diff --git a/backend/src/Taskdeck.Application/Interfaces/IUnitOfWork.cs b/backend/src/Taskdeck.Application/Interfaces/IUnitOfWork.cs
index 9be0965e54..6db10d4b2c 100644
--- a/backend/src/Taskdeck.Application/Interfaces/IUnitOfWork.cs
+++ b/backend/src/Taskdeck.Application/Interfaces/IUnitOfWork.cs
@@ -1,3 +1,5 @@
+using System.Data;
+
 namespace Taskdeck.Application.Interfaces;
 
 public interface IUnitOfWork
@@ -58,6 +60,17 @@ public interface IUnitOfWork
     Task BeginReadTransactionAsync(CancellationToken cancellationToken = default);
 
     Task BeginTransactionAsync(CancellationToken cancellationToken = default);
+
+    /// <summary>
+    /// Begins a transaction at an explicit isolation level. The default implementation keeps
+    /// lightweight test doubles source-compatible; the production unit of work overrides it so
+    /// authorization reads that guard a write can share a serializable snapshot.
+    /// </summary>
+    Task BeginTransactionAsync(
+        IsolationLevel isolationLevel,
+        CancellationToken cancellationToken = default)
+        => BeginTransactionAsync(cancellationToken);
+
     Task CommitTransactionAsync(CancellationToken cancellationToken = default);
     Task RollbackTransactionAsync(CancellationToken cancellationToken = default);
 }
diff --git a/backend/src/Taskdeck.Application/Services/CaptureService.cs b/backend/src/Taskdeck.Application/Services/CaptureService.cs
index 7128c2f64b..58e3141d5d 100644
--- a/backend/src/Taskdeck.Application/Services/CaptureService.cs
+++ b/backend/src/Taskdeck.Application/Services/CaptureService.cs
@@ -1,3 +1,4 @@
+using System.Data;
 using Microsoft.Extensions.Logging;
 using Taskdeck.Application.DTOs;
 using Taskdeck.Application.Interfaces;
@@ -183,6 +184,17 @@ public async Task<Result<CaptureItemDto>> CreateAsync(
         if (userId == Guid.Empty)
             return Result.Failure<CaptureItemDto>(ErrorCodes.ValidationError, "UserId cannot be empty");
 
+        var boardTransactionStarted = false;
+
+        async Task RollbackBoardTransactionAsync()
+        {
+            if (!boardTransactionStarted)
+                return;
+
+            await _unitOfWork.RollbackTransactionAsync(cancellationToken);
+            boardTransactionStarted = false;
+        }
+
         try
         {
             var user = await _unitOfWork.Users.GetByIdAsync(userId, cancellationToken);
@@ -191,17 +203,39 @@ public async Task<Result<CaptureItemDto>> CreateAsync(
 
             if (dto.BoardId.HasValue)
             {
-                var permissionResult = await _authorizationService.CanReadBoardAsync(userId, dto.BoardId.Value);
+                // The authorization read and queue insert must share one serializable snapshot.
+                // Otherwise a board owner can demote this caller after CanWriteBoardAsync returns
+                // but before SaveChangesAsync, admitting a capture under stale write authority.
+                await _unitOfWork.BeginTransactionAsync(
+                    IsolationLevel.Serializable,
+                    cancellationToken);
+                boardTransactionStarted = true;
+
+                // A board-scoped capture can enter that board's proposal queue. Keep the
+                // attachment boundary aligned with triage: readable Viewer access is not
+                // authority to inject work into a board only writers can modify (#3291).
+                var permissionResult = await _authorizationService.CanWriteBoardAsync(userId, dto.BoardId.Value);
                 if (!permissionResult.IsSuccess)
+                {
+                    await RollbackBoardTransactionAsync();
                     return Result.Failure<CaptureItemDto>(permissionResult.ErrorCode, permissionResult.ErrorMessage);
+                }
 
                 if (!permissionResult.Value)
-                    return Result.Failure<CaptureItemDto>(ErrorCodes.Forbidden, "You do not have access to this board");
+                {
+                    await RollbackBoardTransactionAsync();
+                    return Result.Failure<CaptureItemDto>(
+                        ErrorCodes.Forbidden,
+                        "You do not have permission to attach captures to this board");
+                }
             }
 
             var sourceResult = ResolveSource(dto.Source);
             if (!sourceResult.IsSuccess)
+            {
+                await RollbackBoardTransactionAsync();
                 return Result.Failure<CaptureItemDto>(sourceResult.ErrorCode, sourceResult.ErrorMessage);
+            }
 
             var payload = new CapturePayloadV1(
                 CaptureRequestContract.CurrentSchemaVersion,
@@ -243,6 +277,12 @@ public async Task<Result<CaptureItemDto>> CreateAsync(
 
             await _unitOfWork.SaveChangesAsync(cancellationToken);
 
+            if (boardTransactionStarted)
+            {
+                await _unitOfWork.CommitTransactionAsync(cancellationToken);
+                boardTransactionStarted = false;
+            }
+
             return Result.Success(MapToDetailDto(
                 request,
                 attributedPayload,
@@ -251,8 +291,14 @@ public async Task<Result<CaptureItemDto>> CreateAsync(
         }
         catch (DomainException ex)
         {
+            await RollbackBoardTransactionAsync();
             return Result.Failure<CaptureItemDto>(ex.ErrorCode, ex.Message);
         }
+        catch
+        {
+            await RollbackBoardTransactionAsync();
+            throw;
+        }
     }
 
     public async Task<Result<IReadOnlyList<CaptureItemSummaryDto>>> ListAsync(
diff --git a/backend/src/Taskdeck.Application/Services/LlmQueueService.cs b/backend/src/Taskdeck.Application/Services/LlmQueueService.cs
index a1ca53643d..a0f49948d4 100644
--- a/backend/src/Taskdeck.Application/Services/LlmQueueService.cs
+++ b/backend/src/Taskdeck.Application/Services/LlmQueueService.cs
@@ -1,3 +1,4 @@
+using System.Data;
 using Taskdeck.Application.DTOs;
 using Taskdeck.Application.Interfaces;
 using Taskdeck.Domain.Common;
@@ -43,33 +44,33 @@ public LlmQueueService(
 
     public async Task<Result<LlmRequestDto>> AddToQueueAsync(Guid userId, CreateLlmRequestDto dto)
     {
+        var boardTransactionStarted = false;
+
+        async Task RollbackBoardTransactionAsync()
+        {
+            if (!boardTransactionStarted)
+                return;
+
+            await _unitOfWork.RollbackTransactionAsync();
+            boardTransactionStarted = false;
+        }
+
         try
         {
             var user = await _unitOfWork.Users.GetByIdAsync(userId);
             if (user == null)
                 return Result.Failure<LlmRequestDto>(ErrorCodes.NotFound, $"User with ID {userId} not found");
 
-            if (dto.BoardId.HasValue)
-            {
-                var permissionResult = await _authorizationService.CanReadBoardAsync(userId, dto.BoardId.Value);
-                if (!permissionResult.IsSuccess)
-                {
-                    return Result.Failure<LlmRequestDto>(permissionResult.ErrorCode, permissionResult.ErrorMessage);
-                }
-
-                if (!permissionResult.Value)
-                {
-                    return Result.Failure<LlmRequestDto>(ErrorCodes.Forbidden, "You do not have access to this board");
-                }
-            }
-
             var requestTypeValidation = CaptureRequestContract.ValidateRequestType(dto.RequestType);
             if (!requestTypeValidation.IsSuccess)
             {
                 return Result.Failure<LlmRequestDto>(requestTypeValidation.ErrorCode, requestTypeValidation.ErrorMessage);
             }
 
-            var requestType = dto.RequestType;
+            // Validation accepts surrounding whitespace, so carry the same normalized value
+            // into capture classification. Otherwise a padded capture type could select the
+            // readable-board gate instead of the write gate below.
+            var requestType = dto.RequestType.Trim();
             var payload = dto.Payload;
             CapturePayloadV1? capturePayload = null;
             if (CaptureRequestContract.IsCaptureRequestType(requestType))
@@ -88,6 +89,37 @@ public async Task<Result<LlmRequestDto>> AddToQueueAsync(Guid userId, CreateLlmR
                 payload = CaptureRequestContract.SerializePayload(capturePayload);
             }
 
+            if (dto.BoardId.HasValue)
+            {
+                // Capture-shaped queue requests are an alternate capture intake path, not merely
+                // readable board metadata. Keep their write gate and transaction boundary aligned
+                // with CaptureService so a Viewer cannot attach new work through this endpoint.
+                if (capturePayload is not null)
+                {
+                    await _unitOfWork.BeginTransactionAsync(
+                        IsolationLevel.Serializable);
+                    boardTransactionStarted = true;
+                }
+
+                var permissionResult = capturePayload is not null
+                    ? await _authorizationService.CanWriteBoardAsync(userId, dto.BoardId.Value)
+                    : await _authorizationService.CanReadBoardAsync(userId, dto.BoardId.Value);
+                if (!permissionResult.IsSuccess)
+                {
+                    await RollbackBoardTransactionAsync();
+                    return Result.Failure<LlmRequestDto>(permissionResult.ErrorCode, permissionResult.ErrorMessage);
+                }
+
+                if (!permissionResult.Value)
+                {
+                    await RollbackBoardTransactionAsync();
+                    var message = capturePayload is not null
+                        ? "You do not have permission to attach captures to this board"
+                        : "You do not have access to this board";
+                    return Result.Failure<LlmRequestDto>(ErrorCodes.Forbidden, message);
+                }
+            }
+
             var request = new LlmRequest(userId, requestType, payload, dto.BoardId);
             await _unitOfWork.LlmQueue.AddAsync(request);
 
@@ -102,12 +134,24 @@ public async Task<Result<LlmRequestDto>> AddToQueueAsync(Guid userId, CreateLlmR
 
             await _unitOfWork.SaveChangesAsync();
 
+            if (boardTransactionStarted)
+            {
+                await _unitOfWork.CommitTransactionAsync();
+                boardTransactionStarted = false;
+            }
+
             return Result.Success(MapToDto(request));
         }
         catch (DomainException ex)
         {
+            await RollbackBoardTransactionAsync();
             return Result.Failure<LlmRequestDto>(ex.ErrorCode, ex.Message);
         }
+        catch
+        {
+            await RollbackBoardTransactionAsync();
+            throw;
+        }
     }
 
     public async Task<Result<IEnumerable<LlmRequestDto>>> GetUserQueueAsync(Guid userId)
diff --git a/backend/src/Taskdeck.Infrastructure/Repositories/BoardAccessRepository.cs b/backend/src/Taskdeck.Infrastructure/Repositories/BoardAccessRepository.cs
index 4429770071..f130e9561b 100644
--- a/backend/src/Taskdeck.Infrastructure/Repositories/BoardAccessRepository.cs
+++ b/backend/src/Taskdeck.Infrastructure/Repositories/BoardAccessRepository.cs
@@ -18,6 +18,7 @@ public BoardAccessRepository(TaskdeckDbContext context) : base(context)
     public async Task<BoardAccess?> GetByBoardAndUserAsync(Guid boardId, Guid userId, CancellationToken cancellationToken = default)
     {
         return await _context.BoardAccesses
+            .AsNoTracking()
             .Include(ba => ba.User)
             .Include(ba => ba.Board)
             .FirstOrDefaultAsync(ba => ba.BoardId == boardId && ba.UserId == userId, cancellationToken);
diff --git a/backend/src/Taskdeck.Infrastructure/Repositories/UnitOfWork.cs b/backend/src/Taskdeck.Infrastructure/Repositories/UnitOfWork.cs
index 1955d6c38d..d967e949ea 100644
--- a/backend/src/Taskdeck.Infrastructure/Repositories/UnitOfWork.cs
+++ b/backend/src/Taskdeck.Infrastructure/Repositories/UnitOfWork.cs
@@ -262,6 +262,15 @@ public async Task BeginTransactionAsync(CancellationToken cancellationToken = de
         _transaction = await _context.Database.BeginTransactionAsync(cancellationToken);
     }
 
+    public async Task BeginTransactionAsync(
+        IsolationLevel isolationLevel,
+        CancellationToken cancellationToken = default)
+    {
+        _transaction = await _context.Database.BeginTransactionAsync(
+            isolationLevel,
+            cancellationToken);
+    }
+
     public async Task CommitTransactionAsync(CancellationToken cancellationToken = default)
     {
         var transaction = _transaction;
diff --git a/backend/tests/Taskdeck.Api.Tests/BoardAccessRepositoryFreshnessTests.cs b/backend/tests/Taskdeck.Api.Tests/BoardAccessRepositoryFreshnessTests.cs
new file mode 100644
index 0000000000..950ae21d56
--- /dev/null
+++ b/backend/tests/Taskdeck.Api.Tests/BoardAccessRepositoryFreshnessTests.cs
@@ -0,0 +1,62 @@
+using FluentAssertions;
+using Microsoft.EntityFrameworkCore;
+using Taskdeck.Domain.Entities;
+using Taskdeck.Domain.Enums;
+using Taskdeck.Infrastructure.Persistence;
+using Taskdeck.Infrastructure.Repositories;
+using Xunit;
+
+namespace Taskdeck.Api.Tests;
+
+public sealed class BoardAccessRepositoryFreshnessTests
+{
+    [Fact]
+    public async Task GetByBoardAndUserAsync_reads_role_changes_after_an_earlier_read()
+    {
+        var dbPath = Path.Combine(Path.GetTempPath(), $"taskdeck-board-access-freshness-{Guid.NewGuid():N}.db");
+        try
+        {
+            var options = new DbContextOptionsBuilder<TaskdeckDbContext>()
+                .UseSqlite(TestSqlite.ConnectionString(dbPath))
+                .Options;
+
+            var owner = new User("access-freshness-owner", $"access-freshness-owner-{Guid.NewGuid():N}@example.com", "hash");
+            var member = new User("access-freshness-member", $"access-freshness-member-{Guid.NewGuid():N}@example.com", "hash");
+            var board = new Board("Access freshness", ownerId: owner.Id);
+            var access = new BoardAccess(board.Id, member.Id, UserRole.Editor, owner.Id);
+
+            await using (var seed = new TaskdeckDbContext(options))
+            {
+                await seed.Database.MigrateAsync();
+                seed.Users.AddRange(owner, member);
+                seed.Boards.Add(board);
+                seed.BoardAccesses.Add(access);
+                await seed.SaveChangesAsync();
+            }
+
+            await using var reader = new TaskdeckDbContext(options);
+            var repository = new BoardAccessRepository(reader);
+            var initial = await repository.GetByBoardAndUserAsync(board.Id, member.Id);
+            initial!.Role.Should().Be(UserRole.Editor);
+
+            await using (var writer = new TaskdeckDbContext(options))
+            {
+                var persisted = await writer.BoardAccesses.SingleAsync(value =>
+                    value.BoardId == board.Id && value.UserId == member.Id);
+                persisted.UpdateRole(UserRole.Viewer, owner.Id);
+                await writer.SaveChangesAsync();
+            }
+
+            var refreshed = await repository.GetByBoardAndUserAsync(board.Id, member.Id);
+            refreshed!.Role.Should().Be(UserRole.Viewer);
+        }
+        finally
+        {
+            foreach (var suffix in new[] { "", "-wal", "-shm", "-journal" })
+            {
+                try { File.Delete(dbPath + suffix); }
+                catch (IOException) { }
+            }
+        }
+    }
+}
diff --git a/backend/tests/Taskdeck.Api.Tests/CaptureApiTests.cs b/backend/tests/Taskdeck.Api.Tests/CaptureApiTests.cs
index 284aaa6a44..126ed39f8a 100644
--- a/backend/tests/Taskdeck.Api.Tests/CaptureApiTests.cs
+++ b/backend/tests/Taskdeck.Api.Tests/CaptureApiTests.cs
@@ -888,8 +888,8 @@ public async Task Triage_ShouldSucceed_WhenTargetBoardMemberIsEditor()
     [Fact]
     public async Task Triage_ShouldReturnForbidden_WhenAlreadyLinkedBoardIsReadOnlyForCaller()
     {
-        // The gate has to sit on the effective board, not only on the triage body: a capture created
-        // with a readable board (create is read-gated) and accepted with no body is the same vector.
+        // Create while the caller is write-capable, then demote the membership before triage. The
+        // already-linked board gate must still reject the read-only caller with no target body.
         var ownerClient = _factory.CreateClient();
         var viewerClient = _factory.CreateClient();
         await ApiTestHarness.AuthenticateAsync(ownerClient, "capture-triage-linked-gate-owner");
@@ -898,8 +898,10 @@ public async Task Triage_ShouldReturnForbidden_WhenAlreadyLinkedBoardIsReadOnlyF
 
         var grantResponse = await ownerClient.PostAsJsonAsync(
             $"/api/boards/{board.Id}/access",
-            new GrantAccessDto(board.Id, viewer.UserId, UserRole.Viewer));
+            new GrantAccessDto(board.Id, viewer.UserId, UserRole.Editor));
         grantResponse.StatusCode.Should().Be(HttpStatusCode.OK);
+        var access = await grantResponse.Content.ReadFromJsonAsync<BoardAccessDto>();
+        access.Should().NotBeNull();
 
         var createResponse = await viewerClient.PostAsJsonAsync(
             "/api/capture/items",
@@ -909,6 +911,11 @@ public async Task Triage_ShouldReturnForbidden_WhenAlreadyLinkedBoardIsReadOnlyF
         created.Should().NotBeNull();
         created!.BoardId.Should().Be(board.Id);
 
+        var demoteResponse = await ownerClient.PutAsJsonAsync(
+            $"/api/boards/{board.Id}/access/{access!.Id}",
+            new UpdateAccessDto(UserRole.Viewer));
+        demoteResponse.StatusCode.Should().Be(HttpStatusCode.OK);
+
         var triageResponse = await viewerClient.PostAsync($"/api/capture/items/{created.Id}/triage", null);
 
         await ApiTestHarness.AssertErrorContractAsync(triageResponse, HttpStatusCode.Forbidden, "Forbidden");
diff --git a/backend/tests/Taskdeck.Api.Tests/CaptureBoardAttachmentAuthorizationApiTests.cs b/backend/tests/Taskdeck.Api.Tests/CaptureBoardAttachmentAuthorizationApiTests.cs
new file mode 100644
index 0000000000..45e90fc64a
--- /dev/null
+++ b/backend/tests/Taskdeck.Api.Tests/CaptureBoardAttachmentAuthorizationApiTests.cs
@@ -0,0 +1,97 @@
+using System.Net;
+using System.Net.Http.Json;
+using FluentAssertions;
+using Microsoft.Extensions.DependencyInjection;
+using Taskdeck.Api.Tests.Support;
+using Taskdeck.Application.DTOs;
+using Taskdeck.Domain.Entities;
+using Taskdeck.Domain.Enums;
+using Taskdeck.Infrastructure.Persistence;
+using Xunit;
+
+namespace Taskdeck.Api.Tests;
+
+public class CaptureBoardAttachmentAuthorizationApiTests : IClassFixture<TestWebApplicationFactory>
+{
+    private readonly TestWebApplicationFactory _factory;
+    private readonly HttpClient _client;
+
+    public CaptureBoardAttachmentAuthorizationApiTests(TestWebApplicationFactory factory)
+    {
+        _factory = factory;
+        _client = factory.CreateClient();
+    }
+
+    [Fact]
+    public async Task Viewer_CannotCreateCaptureAttachedToReadableBoard()
+    {
+        var suffix = Guid.NewGuid().ToString("N")[..8];
+        var owner = await ApiTestHarness.AuthenticateAsync(_client, "cap-owner");
+        var board = await ApiTestHarness.CreateBoardAsync(
+            _client,
+            $"Viewer capture boundary {suffix}");
+        var viewer = await ApiTestHarness.AuthenticateAsync(_client, "cap-viewer");
+
+        using (var scope = _factory.Services.CreateScope())
+        {
+            var db = scope.ServiceProvider.GetRequiredService<TaskdeckDbContext>();
+            db.BoardAccesses.Add(new BoardAccess(
+                board.Id,
+                viewer.UserId,
+                UserRole.Viewer,
+                owner.UserId));
+            await db.SaveChangesAsync();
+        }
+
+        var response = await _client.PostAsJsonAsync(
+            "/api/capture/items",
+            new CreateCaptureItemDto(
+                board.Id,
+                "A Viewer must not attach a capture to this board",
+                "paste"));
+
+        await ApiTestHarness.AssertErrorContractAsync(
+            response,
+            HttpStatusCode.Forbidden,
+            "Forbidden");
+        var captures = await _client.GetFromJsonAsync<List<CaptureItemSummaryDto>>(
+            "/api/capture/items");
+        captures.Should().BeEmpty(
+            "a refused board attachment must not persist a board-scoped capture");
+    }
+
+    [Fact]
+    public async Task Editor_CanCreateCaptureAttachedToWritableBoard()
+    {
+        var suffix = Guid.NewGuid().ToString("N")[..8];
+        var owner = await ApiTestHarness.AuthenticateAsync(_client, "cap-owner");
+        var board = await ApiTestHarness.CreateBoardAsync(
+            _client,
+            $"Editor capture boundary {suffix}");
+        var editor = await ApiTestHarness.AuthenticateAsync(_client, "cap-editor");
+
+        using (var scope = _factory.Services.CreateScope())
+        {
+            var db = scope.ServiceProvider.GetRequiredService<TaskdeckDbContext>();
+            db.BoardAccesses.Add(new BoardAccess(
+                board.Id,
+                editor.UserId,
+                UserRole.Editor,
+                owner.UserId));
+            await db.SaveChangesAsync();
+        }
+
+        var response = await _client.PostAsJsonAsync(
+            "/api/capture/items",
+            new CreateCaptureItemDto(
+                board.Id,
+                "An Editor may attach a capture to this board",
+                "paste"));
+
+        response.StatusCode.Should().Be(HttpStatusCode.Created);
+        var capture = await response.Content.ReadFromJsonAsync<CaptureItemDto>();
+        capture.Should().NotBeNull();
+        capture!.BoardId.Should().Be(board.Id);
+        capture.UserId.Should().Be(editor.UserId);
+    }
+}
diff --git a/backend/tests/Taskdeck.Api.Tests/LlmQueueApiTests.cs b/backend/tests/Taskdeck.Api.Tests/LlmQueueApiTests.cs
index 1a327157c9..fc3fef3b65 100644
--- a/backend/tests/Taskdeck.Api.Tests/LlmQueueApiTests.cs
+++ b/backend/tests/Taskdeck.Api.Tests/LlmQueueApiTests.cs
@@ -2,8 +2,12 @@
 using System.Net.Http.Json;
 using System.Text.Json;
 using FluentAssertions;
+using Microsoft.Extensions.DependencyInjection;
 using Taskdeck.Api.Tests.Support;
 using Taskdeck.Application.DTOs;
+using Taskdeck.Domain.Entities;
+using Taskdeck.Domain.Enums;
+using Taskdeck.Infrastructure.Persistence;
 using Xunit;
 
 namespace Taskdeck.Api.Tests;
@@ -118,6 +122,45 @@ public async Task AddToQueue_ShouldReturnForbidden_WhenBoardBelongsToDifferentUs
         await ApiTestHarness.AssertForbiddenAsync(response);
     }
 
+    [Fact]
+    public async Task AddToQueue_ShouldReturnForbidden_WhenViewerSubmitsCaptureForReadableBoard()
+    {
+        using var ownerClient = _factory.CreateClient();
+        using var viewerClient = _factory.CreateClient();
+
+        var owner = await ApiTestHarness.AuthenticateAsync(ownerClient, "llm-capture-owner");
+        var viewer = await ApiTestHarness.AuthenticateAsync(viewerClient, "llm-capture-viewer");
+        var board = await ApiTestHarness.CreateBoardAsync(ownerClient, "llm-capture-protected-board");
+
+        using (var scope = _factory.Services.CreateScope())
+        {
+            var db = scope.ServiceProvider.GetRequiredService<TaskdeckDbContext>();
+            db.BoardAccesses.Add(new BoardAccess(
+                board.Id,
+                viewer.UserId,
+                UserRole.Viewer,
+                owner.UserId));
+            await db.SaveChangesAsync();
+        }
+
+        var response = await viewerClient.PostAsJsonAsync(
+            "/api/llm-queue",
+            new CreateLlmRequestDto(
+                CaptureRequestContract.RequestTypeV1,
+                "A Viewer must not attach a capture through the queue",
+                board.Id));
+
+        await ApiTestHarness.AssertErrorContractAsync(
+            response,
+            HttpStatusCode.Forbidden,
+            "Forbidden");
+
+        var requests = await viewerClient.GetFromJsonAsync<List<LlmRequestDto>>(
+            "/api/llm-queue/user");
+        requests.Should().BeEmpty(
+            "a refused capture attachment must not persist a queue request");
+    }
+
     [Fact]
     public async Task AddToQueue_ShouldReturnBadRequest_WhenCapturePayloadSpoofsProvenanceAttribution()
     {
diff --git a/backend/tests/Taskdeck.Api.Tests/McpResourcesTests.cs b/backend/tests/Taskdeck.Api.Tests/McpResourcesTests.cs
index cff4e37e03..49aaa54a68 100644
--- a/backend/tests/Taskdeck.Api.Tests/McpResourcesTests.cs
+++ b/backend/tests/Taskdeck.Api.Tests/McpResourcesTests.cs
@@ -314,7 +314,11 @@ private async Task RevokeBoardAccessAsync(IServiceScope scope, Guid boardId, Gui
         var uow = scope.ServiceProvider.GetRequiredService<IUnitOfWork>();
         var access = await uow.BoardAccesses.GetByBoardAndUserAsync(boardId, userId);
         access.Should().NotBeNull();
-        await uow.BoardAccesses.DeleteAsync(access!);
+        // The authorization query is intentionally no-tracking so repeated reads observe
+        // membership changes. Reload the entity through the tracked identity before mutating it.
+        var trackedAccess = await uow.BoardAccesses.GetByIdAsync(access!.Id);
+        trackedAccess.Should().NotBeNull();
+        await uow.BoardAccesses.DeleteAsync(trackedAccess!);
         await uow.SaveChangesAsync();
     }
 
@@ -328,8 +332,12 @@ private async Task DemoteToViewerAsync(IServiceScope scope, Guid boardId, Guid u
         var uow = scope.ServiceProvider.GetRequiredService<IUnitOfWork>();
         var access = await uow.BoardAccesses.GetByBoardAndUserAsync(boardId, userId);
         access.Should().NotBeNull();
-        access!.UpdateRole(UserRole.Viewer, access.GrantedBy);
-        await uow.BoardAccesses.UpdateAsync(access);
+        // The authorization query is intentionally no-tracking so repeated reads observe
+        // membership changes. Reload the entity through the tracked identity before mutating it.
+        var trackedAccess = await uow.BoardAccesses.GetByIdAsync(access!.Id);
+        trackedAccess.Should().NotBeNull();
+        trackedAccess!.UpdateRole(UserRole.Viewer, trackedAccess.GrantedBy);
+        await uow.BoardAccesses.UpdateAsync(trackedAccess);
         await uow.SaveChangesAsync();
     }
 
diff --git a/backend/tests/Taskdeck.Application.Tests/Services/CaptureBoardAttachmentAuthorizationTests.cs b/backend/tests/Taskdeck.Application.Tests/Services/CaptureBoardAttachmentAuthorizationTests.cs
new file mode 100644
index 0000000000..10cc76aace
--- /dev/null
+++ b/backend/tests/Taskdeck.Application.Tests/Services/CaptureBoardAttachmentAuthorizationTests.cs
@@ -0,0 +1,134 @@
+using FluentAssertions;
+using Moq;
+using Taskdeck.Application.DTOs;
+using Taskdeck.Application.Interfaces;
+using Taskdeck.Application.Services;
+using Taskdeck.Domain.Common;
+using Taskdeck.Domain.Entities;
+using Taskdeck.Domain.Exceptions;
+using Xunit;
+
+namespace Taskdeck.Application.Tests.Services;
+
+public class CaptureBoardAttachmentAuthorizationTests
+{
+    private readonly Mock<IUnitOfWork> _unitOfWork = new();
+    private readonly Mock<IAuthorizationService> _authorization = new();
+    private readonly Mock<IUserRepository> _users = new();
+    private readonly Mock<ILlmQueueRepository> _llmQueue = new();
+    private readonly User _user = new("capture-viewer", "capture-viewer@example.com", "Password1!");
+
+    public CaptureBoardAttachmentAuthorizationTests()
+    {
+        _unitOfWork.SetupGet(unit => unit.Users).Returns(_users.Object);
+        _unitOfWork.SetupGet(unit => unit.LlmQueue).Returns(_llmQueue.Object);
+        _users
+            .Setup(repository => repository.GetByIdAsync(
+                _user.Id,
+                It.IsAny<CancellationToken>()))
+            .ReturnsAsync(_user);
+        _llmQueue
+            .Setup(repository => repository.AddAsync(
+                It.IsAny<LlmRequest>(),
+                It.IsAny<CancellationToken>()))
+            .ReturnsAsync((LlmRequest request, CancellationToken _) => request);
+        _unitOfWork
+            .Setup(unit => unit.SaveChangesAsync(It.IsAny<CancellationToken>()))
+            .ReturnsAsync(1);
+    }
+
+    private CaptureService BuildService() => new(
+        _unitOfWork.Object,
+        _authorization.Object);
+
+    [Fact]
+    public async Task CreateAsync_RejectsReadableBoard_WhenCallerCannotWrite()
+    {
+        var boardId = Guid.NewGuid();
+        _authorization
+            .Setup(service => service.CanReadBoardAsync(_user.Id, boardId))
+            .ReturnsAsync(Result.Success(true));
+        _authorization
+            .Setup(service => service.CanWriteBoardAsync(_user.Id, boardId))
+            .ReturnsAsync(Result.Success(false));
+
+        var result = await BuildService().CreateAsync(
+            _user.Id,
+            new CreateCaptureItemDto(boardId, "Viewer must not attach this capture", "paste"));
+
+        result.IsSuccess.Should().BeFalse();
+        result.ErrorCode.Should().Be(ErrorCodes.Forbidden);
+        _authorization.Verify(
+            service => service.CanWriteBoardAsync(_user.Id, boardId),
+            Times.Once);
+        _llmQueue.Verify(
+            repository => repository.AddAsync(
+                It.IsAny<LlmRequest>(),
+                It.IsAny<CancellationToken>()),
+            Times.Never);
+        _unitOfWork.Verify(
+            unit => unit.SaveChangesAsync(It.IsAny<CancellationToken>()),
+            Times.Never);
+    }
+
+    [Fact]
+    public async Task CreateAsync_PropagatesWriteAuthorizationFailure_WithoutPersistence()
+    {
+        var boardId = Guid.NewGuid();
+        _authorization
+            .Setup(service => service.CanReadBoardAsync(_user.Id, boardId))
+            .ReturnsAsync(Result.Success(true));
+        _authorization
+            .Setup(service => service.CanWriteBoardAsync(_user.Id, boardId))
+            .ReturnsAsync(Result.Failure<bool>(
+                ErrorCodes.NotFound,
+                "Board not found"));
+
+        var result = await BuildService().CreateAsync(
+            _user.Id,
+            new CreateCaptureItemDto(boardId, "Missing board", "paste"));
+
+        result.IsSuccess.Should().BeFalse();
+        result.ErrorCode.Should().Be(ErrorCodes.NotFound);
+        result.ErrorMessage.Should().Be("Board not found");
+        _llmQueue.Verify(
+            repository => repository.AddAsync(
+                It.IsAny<LlmRequest>(),
+                It.IsAny<CancellationToken>()),
+            Times.Never);
+        _unitOfWork.Verify(
+            unit => unit.SaveChangesAsync(It.IsAny<CancellationToken>()),
+            Times.Never);
+    }
+
+    [Fact]
+    public async Task CreateAsync_AllowsWritableBoard_WithoutConsultingReadPermission()
+    {
+        var boardId = Guid.NewGuid();
+        _authorization
+            .Setup(service => service.CanWriteBoardAsync(_user.Id, boardId))
+            .ReturnsAsync(Result.Success(true));
+        _authorization
+            .Setup(service => service.CanReadBoardAsync(_user.Id, boardId))
+            .ThrowsAsync(new InvalidOperationException("Read permission is not the attachment contract"));
+
+        var result = await BuildService().CreateAsync(
+            _user.Id,
+            new CreateCaptureItemDto(boardId, "Editor may attach this capture", "paste"));
+
+        result.IsSuccess.Should().BeTrue();
+        result.Value.BoardId.Should().Be(boardId);
+        _authorization.Verify(
+            service => service.CanReadBoardAsync(It.IsAny<Guid>(), It.IsAny<Guid>()),
+            Times.Never);
+        _llmQueue.Verify(
+            repository => repository.AddAsync(
+                It.Is<LlmRequest>(request =>
+                    request.UserId == _user.Id && request.BoardId == boardId),
+                It.IsAny<CancellationToken>()),
+            Times.Once);
+        _unitOfWork.Verify(
+            unit => unit.SaveChangesAsync(It.IsAny<CancellationToken>()),
+            Times.Once);
+    }
+}
diff --git a/backend/tests/Taskdeck.Application.Tests/Services/CaptureServiceDualWriteTests.cs b/backend/tests/Taskdeck.Application.Tests/Services/CaptureServiceDualWriteTests.cs
index 589a64cf0c..4e44b5266e 100644
--- a/backend/tests/Taskdeck.Application.Tests/Services/CaptureServiceDualWriteTests.cs
+++ b/backend/tests/Taskdeck.Application.Tests/Services/CaptureServiceDualWriteTests.cs
@@ -176,7 +176,7 @@ public async Task CreateAsync_WithDualWriteEnabled_ShouldCarryTheBoardAsContextH
         var boardId = Guid.NewGuid();
         Capture? mirrored = null;
         _authorizationServiceMock
-            .Setup(s => s.CanReadBoardAsync(_userId, boardId))
+            .Setup(s => s.CanWriteBoardAsync(_userId, boardId))
             .ReturnsAsync(Result.Success(true));
         _captureStoreMock
             .Setup(s => s.AddAsync(It.IsAny<Capture>(), It.IsAny<CancellationToken>()))
diff --git a/backend/tests/Taskdeck.Application.Tests/Services/CaptureServiceTests.cs b/backend/tests/Taskdeck.Application.Tests/Services/CaptureServiceTests.cs
index fddbdf5dd9..088e700169 100644
--- a/backend/tests/Taskdeck.Application.Tests/Services/CaptureServiceTests.cs
+++ b/backend/tests/Taskdeck.Application.Tests/Services/CaptureServiceTests.cs
@@ -125,7 +125,7 @@ public async Task CreateAsync_ShouldPersistCaptureRequestAndReturnDetail()
             .Setup(r => r.GetByIdAsync(userId, default))
             .ReturnsAsync(user);
         _authorizationServiceMock
-            .Setup(s => s.CanReadBoardAsync(userId, boardId))
+            .Setup(s => s.CanWriteBoardAsync(userId, boardId))
             .ReturnsAsync(Result.Success(true));
         _llmQueueRepositoryMock
             .Setup(r => r.AddAsync(It.IsAny<LlmRequest>(), default))
@@ -177,7 +177,7 @@ public async Task CreateAsync_ShouldAssignTranscriptRequestType_ForTranscriptSou
             .Setup(r => r.GetByIdAsync(userId, default))
             .ReturnsAsync(user);
         _authorizationServiceMock
-            .Setup(s => s.CanReadBoardAsync(userId, boardId))
+            .Setup(s => s.CanWriteBoardAsync(userId, boardId))
             .ReturnsAsync(Result.Success(true));
         _llmQueueRepositoryMock
             .Setup(r => r.AddAsync(It.IsAny<LlmRequest>(), default))
@@ -250,7 +250,7 @@ public async Task CreateAsync_ShouldReturnForbidden_WhenBoardAccessIsDenied()
             .Setup(r => r.GetByIdAsync(userId, default))
             .ReturnsAsync(user);
         _authorizationServiceMock
-            .Setup(s => s.CanReadBoardAsync(userId, boardId))
+            .Setup(s => s.CanWriteBoardAsync(userId, boardId))
             .ReturnsAsync(Result.Success(false));
 
         var result = await _service.CreateAsync(userId, dto);
diff --git a/backend/tests/Taskdeck.Application.Tests/Services/LlmQueueServiceTests.cs b/backend/tests/Taskdeck.Application.Tests/Services/LlmQueueServiceTests.cs
index a1ec21ccdc..7f02fae2cb 100644
--- a/backend/tests/Taskdeck.Application.Tests/Services/LlmQueueServiceTests.cs
+++ b/backend/tests/Taskdeck.Application.Tests/Services/LlmQueueServiceTests.cs
@@ -74,7 +74,7 @@ public async Task AddToQueueAsync_ShouldNormalizeCapturePayload_WhenCaptureReque
 
         _userRepoMock.Setup(r => r.GetByIdAsync(userId, default))
             .ReturnsAsync(user);
-        _authorizationServiceMock.Setup(s => s.CanReadBoardAsync(userId, boardId))
+        _authorizationServiceMock.Setup(s => s.CanWriteBoardAsync(userId, boardId))
             .ReturnsAsync(Result.Success(true));
         _llmQueueRepoMock.Setup(r => r.AddAsync(It.IsAny<LlmRequest>(), default))
             .Callback<LlmRequest, CancellationToken>((request, _) => persistedRequest = request)
@@ -110,7 +110,7 @@ public async Task AddToQueueAsync_ShouldNormalizeToTranscriptRequestType_WhenPay
 
         _userRepoMock.Setup(r => r.GetByIdAsync(userId, default))
             .ReturnsAsync(user);
-        _authorizationServiceMock.Setup(s => s.CanReadBoardAsync(userId, boardId))
+        _authorizationServiceMock.Setup(s => s.CanWriteBoardAsync(userId, boardId))
             .ReturnsAsync(Result.Success(true));
         _llmQueueRepoMock.Setup(r => r.AddAsync(It.IsAny<LlmRequest>(), default))
             .Callback<LlmRequest, CancellationToken>((request, _) => persistedRequest = request)
@@ -225,6 +225,63 @@ public async Task AddToQueueAsync_ShouldReturnForbidden_WhenUserCannotAccessBoar
         _unitOfWorkMock.Verify(u => u.SaveChangesAsync(default), Times.Never);
     }
 
+    [Fact]
+    public async Task AddToQueueAsync_ShouldRejectViewerCaptureAttachment()
+    {
+        var userId = Guid.NewGuid();
+        var boardId = Guid.NewGuid();
+        var user = new User("testuser", "test@example.com", "hashedpassword");
+        var dto = new CreateLlmRequestDto(
+            CaptureRequestContract.RequestTypeV1,
+            "Capture this quick note",
+            boardId);
+
+        _userRepoMock.Setup(r => r.GetByIdAsync(userId, default))
+            .ReturnsAsync(user);
+        _authorizationServiceMock.Setup(s => s.CanWriteBoardAsync(userId, boardId))
+            .ReturnsAsync(Result.Success(false));
+
+        var result = await _service.AddToQueueAsync(userId, dto);
+
+        result.IsSuccess.Should().BeFalse();
+        result.ErrorCode.Should().Be(ErrorCodes.Forbidden);
+        result.ErrorMessage.Should().Contain("attach captures");
+        _llmQueueRepoMock.Verify(r => r.AddAsync(It.IsAny<LlmRequest>(), default), Times.Never);
+        _unitOfWorkMock.Verify(u => u.SaveChangesAsync(default), Times.Never);
+        _unitOfWorkMock.Verify(u => u.RollbackTransactionAsync(default), Times.Once);
+    }
+
+    [Fact]
+    public async Task AddToQueueAsync_ShouldUseWriteGateForWhitespacePaddedCaptureRequestType()
+    {
+        var userId = Guid.NewGuid();
+        var boardId = Guid.NewGuid();
+        var user = new User("testuser", "test@example.com", "hashedpassword");
+        var dto = new CreateLlmRequestDto(
+            $" {CaptureRequestContract.RequestTypeV1} ",
+            "Capture this padded quick note",
+            boardId);
+
+        _userRepoMock.Setup(r => r.GetByIdAsync(userId, default))
+            .ReturnsAsync(user);
+        _authorizationServiceMock.Setup(s => s.CanWriteBoardAsync(userId, boardId))
+            .ReturnsAsync(Result.Success(false));
+        _authorizationServiceMock.Setup(s => s.CanReadBoardAsync(userId, boardId))
+            .ReturnsAsync(Result.Success(true));
+
+        var result = await _service.AddToQueueAsync(userId, dto);
+
+        result.IsSuccess.Should().BeFalse();
+        result.ErrorCode.Should().Be(ErrorCodes.Forbidden);
+        _authorizationServiceMock.Verify(s => s.CanWriteBoardAsync(userId, boardId), Times.Once);
+        _authorizationServiceMock.Verify(s => s.CanReadBoardAsync(userId, boardId), Times.Never);
+        _unitOfWorkMock.Verify(
+            u => u.BeginTransactionAsync(System.Data.IsolationLevel.Serializable, default),
+            Times.Once);
+        _unitOfWorkMock.Verify(u => u.RollbackTransactionAsync(default), Times.Once);
+        _llmQueueRepoMock.Verify(r => r.AddAsync(It.IsAny<LlmRequest>(), default), Times.Never);
+    }
+
     [Fact]
     public async Task AddToQueueAsync_ShouldReturnNotFound_WhenBoardDoesNotExist()
     {
diff --git a/frontend/taskdeck-web/src/components/board/BoardActionRail.vue b/frontend/taskdeck-web/src/components/board/BoardActionRail.vue
index 60e37262d8..19c45c7f88 100644
--- a/frontend/taskdeck-web/src/components/board/BoardActionRail.vue
+++ b/frontend/taskdeck-web/src/components/board/BoardActionRail.vue
@@ -1,4 +1,11 @@
 <script setup lang="ts">
+withDefaults(defineProps<{
+  /** Board-scoped captures require the server-confirmed write capability. */
+  canCapture?: boolean
+}>(), {
+  canCapture: true,
+})
+
 defineEmits<{
   capture: []
   chat: []
@@ -14,7 +21,7 @@ defineEmits<{
     data-board-action-rail
   >
     <span class="td-action-rail__label">Board Actions</span>
-    <button class="td-action-rail__btn" @click="$emit('capture')">
+    <button v-if="canCapture" class="td-action-rail__btn" @click="$emit('capture')">
       Capture here
     </button>
     <button class="td-action-rail__btn" @click="$emit('chat')">
diff --git a/frontend/taskdeck-web/src/components/board/BoardDialogHost.vue b/frontend/taskdeck-web/src/components/board/BoardDialogHost.vue
index 8908144003..74ba95a7e3 100644
--- a/frontend/taskdeck-web/src/components/board/BoardDialogHost.vue
+++ b/frontend/taskdeck-web/src/components/board/BoardDialogHost.vue
@@ -58,6 +58,7 @@ defineEmits<{
     v-if="showCaptureModal && board"
     :board-id="boardId"
     :board-name="board.name"
+    :can-submit="board.canWrite !== false"
     @close="$emit('update:showCaptureModal', false)"
     @created="$emit('update:showCaptureModal', false)"
   />
diff --git a/frontend/taskdeck-web/src/components/common/CaptureModal.vue b/frontend/taskdeck-web/src/components/common/CaptureModal.vue
index 52977ba34f..d39aab6cfd 100644
--- a/frontend/taskdeck-web/src/components/common/CaptureModal.vue
+++ b/frontend/taskdeck-web/src/components/common/CaptureModal.vue
@@ -1,5 +1,5 @@
 <script setup lang="ts">
-import { nextTick, onMounted, onUnmounted, ref } from 'vue'
+import { computed, nextTick, onMounted, onUnmounted, ref } from 'vue'
 import { useCaptureStore } from '../../store/captureStore'
 import { registerEscapeHandler } from '../../composables/useEscapeStack'
 import { usePerformanceMark } from '../../composables/usePerformanceMark'
@@ -7,10 +7,14 @@ import { formatShortcut } from '../../utils/keyboardShortcuts'
 // Shared with the Paper composer so the two capture surfaces cannot drift (GH-2141).
 import { MAX_TRANSCRIPT_FILE_BYTES, MAX_TRANSCRIPT_LENGTH } from '../../constants/capture'
 
-const props = defineProps<{
+const props = withDefaults(defineProps<{
   boardId?: string | null
   boardName?: string | null
-}>()
+  /** Keep the draft mounted when a live board refresh removes write authority. */
+  canSubmit?: boolean
+}>(), {
+  canSubmit: true,
+})
 
 const emit = defineEmits<{
   close: []
@@ -31,6 +35,8 @@ const uploadedFileName = ref<string | null>(null)
 const modalOpenPerf = usePerformanceMark('modal-open')
 let unregisterEscapeHandler: (() => void) | null = null
 
+const canSubmit = computed(() => props.canSubmit !== false)
+
 modalOpenPerf.start()
 
 function requestClose() {
@@ -121,6 +127,11 @@ async function submit() {
     return
   }
 
+  if (!canSubmit.value) {
+    inlineError.value = 'Write access changed while this capture was open. Keep the draft here or close it and try again later.'
+    return
+  }
+
   const normalizedText = text.value.trim()
   if (!normalizedText) {
     inlineError.value = 'Capture text is required.'
@@ -269,12 +280,15 @@ onUnmounted(() => {
       <div v-if="inlineError" class="td-alert td-alert--error" role="alert">
         {{ inlineError }}
       </div>
+      <div v-else-if="!canSubmit" class="td-alert td-alert--error" role="alert">
+        Write access changed while this capture was open. Your draft is preserved until access is restored.
+      </div>
 
       <footer class="td-capture-modal__actions">
         <button class="td-btn td-btn--secondary" :disabled="saving" @click="requestClose">
           Cancel
         </button>
-        <button class="td-btn td-btn--primary" :disabled="saving" @click="submit">
+        <button class="td-btn td-btn--primary" :disabled="saving || !canSubmit" @click="submit">
           {{ saving ? 'Saving...' : 'Save Capture' }}
         </button>
       </footer>
diff --git a/frontend/taskdeck-web/src/composables/useInboxOrchestrator.ts b/frontend/taskdeck-web/src/composables/useInboxOrchestrator.ts
index aadc8e636f..8cdbdc4c9d 100644
--- a/frontend/taskdeck-web/src/composables/useInboxOrchestrator.ts
+++ b/frontend/taskdeck-web/src/composables/useInboxOrchestrator.ts
@@ -105,6 +105,19 @@ export function useInboxOrchestrator(options: {
     const boardId = activeBoardId.value
     return boardId && scopedBoard.value?.id === boardId ? scopedBoard.value.name : boardId ?? ''
   })
+  /**
+   * The scoped Inbox has the same board write boundary as the board page. Keep
+   * older payloads writable once the matching board is loaded, but fail closed
+   * while that metadata is loading or unavailable: the server is still the
+   * authority, and a capture surface must not advertise a board-scoped write
+   * before its capability is known.
+   */
+  const activeBoardCanWrite = computed(() => {
+    const boardId = activeBoardId.value
+    if (!boardId) return true
+    if (scopedBoard.value?.id !== boardId) return false
+    return scopedBoard.value.canWrite !== false
+  })
   const activeColumnName = computed(() => {
     const columnId = activeColumnId.value
     if (!columnId) return ''
@@ -124,7 +137,8 @@ export function useInboxOrchestrator(options: {
       if (requestGeneration !== scopedBoardLoadGeneration || activeBoardId.value !== boardId) return
       scopedBoard.value = board.id === boardId ? board : null
     } catch {
-      // The scoped inbox remains usable when the board metadata is unavailable.
+      // The list remains usable when metadata is unavailable, but capture
+      // surfaces stay disabled until the matching capability is known.
       if (requestGeneration === scopedBoardLoadGeneration && activeBoardId.value === boardId) {
         scopedBoard.value = null
       }
@@ -739,6 +753,7 @@ export function useInboxOrchestrator(options: {
     isArchivedHistory,
     isScopeReplacement,
     activeBoardName,
+    activeBoardCanWrite,
     activeColumnName,
     showCaptureModal,
     selectedIds,
diff --git a/frontend/taskdeck-web/src/tests/components/BoardActionRail.spec.ts b/frontend/taskdeck-web/src/tests/components/BoardActionRail.spec.ts
index 5f1577ea02..5d77c9ca43 100644
--- a/frontend/taskdeck-web/src/tests/components/BoardActionRail.spec.ts
+++ b/frontend/taskdeck-web/src/tests/components/BoardActionRail.spec.ts
@@ -3,8 +3,8 @@ import { mount } from '@vue/test-utils'
 import BoardActionRail from '../../components/board/BoardActionRail.vue'
 
 describe('BoardActionRail', () => {
-  function mountRail() {
-    return mount(BoardActionRail)
+  function mountRail(props: { canCapture?: boolean } = {}) {
+    return mount(BoardActionRail, { props })
   }
 
   it('renders all action buttons', () => {
@@ -29,6 +29,13 @@ describe('BoardActionRail', () => {
     expect(wrapper.emitted('capture')).toHaveLength(1)
   })
 
+  it('hides board capture for a read-only board', () => {
+    const wrapper = mountRail({ canCapture: false })
+
+    expect(wrapper.findAll('button').some((button) => button.text().trim() === 'Capture here')).toBe(false)
+    expect(wrapper.emitted('capture')).toBeUndefined()
+  })
+
   it('emits chat when Ask assistant is clicked', async () => {
     const wrapper = mountRail()
     const btn = wrapper.findAll('button').find(b => b.text().trim() === 'Ask assistant')
diff --git a/frontend/taskdeck-web/src/tests/components/BoardDialogHost.spec.ts b/frontend/taskdeck-web/src/tests/components/BoardDialogHost.spec.ts
index ce78522c66..e4f8bfe74e 100644
--- a/frontend/taskdeck-web/src/tests/components/BoardDialogHost.spec.ts
+++ b/frontend/taskdeck-web/src/tests/components/BoardDialogHost.spec.ts
@@ -104,20 +104,26 @@ describe('BoardDialogHost', () => {
           StarterPackCatalogModal: true,
           LabelManagerModal: true,
           CaptureModal: {
-            props: ['boardId', 'boardName'],
+            props: ['boardId', 'boardName', 'canSubmit'],
             template: `
-              <button data-testid="capture-close" type="button" @click="$emit('close')">{{ boardName }}|{{ boardId }}</button>
+              <button data-testid="capture-close" type="button" @click="$emit('close')">{{ boardName }}|{{ boardId }}|{{ canSubmit }}</button>
             `,
           },
         },
       },
     })
 
-    expect(wrapper.get('[data-testid="capture-close"]').text()).toBe('Ops Board|board-1')
+    expect(wrapper.get('[data-testid="capture-close"]').text()).toBe('Ops Board|board-1|true')
     await wrapper.get('[data-testid="capture-close"]').trigger('click')
     expect(wrapper.emitted('update:showCaptureModal')).toEqual([[false]])
 
     await wrapper.setProps({ board: null })
     expect(wrapper.find('[data-testid="capture-close"]').exists()).toBe(false)
+
+    await wrapper.setProps({
+      board: { ...board, canWrite: false },
+      showCaptureModal: true,
+    })
+    expect(wrapper.get('[data-testid="capture-close"]').text()).toBe('Ops Board|board-1|false')
   })
 })
diff --git a/frontend/taskdeck-web/src/tests/components/CaptureModal.spec.ts b/frontend/taskdeck-web/src/tests/components/CaptureModal.spec.ts
index e0831400e1..8e2037a760 100644
--- a/frontend/taskdeck-web/src/tests/components/CaptureModal.spec.ts
+++ b/frontend/taskdeck-web/src/tests/components/CaptureModal.spec.ts
@@ -34,6 +34,15 @@ async function waitForUi() {
 }
 
 describe('CaptureModal', () => {
+  it('keeps the draft surface mounted but disables submit when board write access is lost', () => {
+    const wrapper = mount(CaptureModal, {
+      props: { boardId: 'board-1', canSubmit: false },
+    })
+
+    expect(wrapper.get('[role="alert"]').text()).toContain('draft is preserved')
+    expect(wrapper.get('button.td-btn--primary').attributes('disabled')).toBeDefined()
+  })
+
   beforeEach(() => {
     vi.clearAllMocks()
     escapeHandlers.splice(0, escapeHandlers.length)
diff --git a/frontend/taskdeck-web/src/tests/composables/useInboxOrchestrator.spec.ts b/frontend/taskdeck-web/src/tests/composables/useInboxOrchestrator.spec.ts
index d3e3626530..5cd3060a95 100644
--- a/frontend/taskdeck-web/src/tests/composables/useInboxOrchestrator.spec.ts
+++ b/frontend/taskdeck-web/src/tests/composables/useInboxOrchestrator.spec.ts
@@ -507,6 +507,42 @@ describe('useInboxOrchestrator', () => {
       expect(orch.activeColumnName.value).toBe('Column B')
     })
 
+    it('exposes the scoped board write capability to Inbox surfaces', async () => {
+      mockRoute.query = { boardId: 'board-viewer' }
+      mockBoardsApi.getBoard.mockResolvedValueOnce({
+        ...makeBoard('board-viewer', 'Viewer board', 'column-1', 'Column 1'),
+        canWrite: false,
+      })
+      const orch = createOrchestrator()
+      mountedCallback!()
+
+      await flushAsyncWork()
+
+      expect(orch.activeBoardCanWrite.value).toBe(false)
+    })
+
+    it('fails closed while scoped board metadata is loading or unavailable', async () => {
+      const pendingBoard = deferred<BoardDetail>()
+      mockRoute.query = { boardId: 'board-pending' }
+      mockBoardsApi.getBoard.mockReturnValueOnce(pendingBoard.promise)
+      const orch = createOrchestrator()
+      mountedCallback!()
+
+      expect(orch.activeBoardCanWrite.value).toBe(false)
+
+      pendingBoard.resolve(makeBoard('board-pending', 'Pending board', 'column-1', 'Column 1'))
+      await flushAsyncWork()
+      expect(orch.activeBoardCanWrite.value).toBe(true)
+
+      mockRoute.query = { boardId: 'board-failed' }
+      mockBoardsApi.getBoard.mockRejectedValueOnce(new Error('metadata unavailable'))
+      watcherForSource(orch.activeBoardId)[1]('board-failed', 'board-pending', () => {})
+      expect(orch.activeBoardCanWrite.value).toBe(false)
+
+      await flushAsyncWork()
+      expect(orch.activeBoardCanWrite.value).toBe(false)
+    })
+
     it('keeps B names after an obsolete A metadata failure resolves last', async () => {
       const boardA = deferred<BoardDetail>()
       const boardB = deferred<BoardDetail>()
diff --git a/frontend/taskdeck-web/src/tests/views/BoardView.spec.ts b/frontend/taskdeck-web/src/tests/views/BoardView.spec.ts
index c7b20d9346..280dc548a9 100644
--- a/frontend/taskdeck-web/src/tests/views/BoardView.spec.ts
+++ b/frontend/taskdeck-web/src/tests/views/BoardView.spec.ts
@@ -77,6 +77,7 @@ const mockBoardStore = reactive({
     id: 'board-1',
     name: 'Ops Board',
     description: 'Primary board',
+    canWrite: true,
     columns: [
       {
         id: 'column-1',
@@ -204,6 +205,7 @@ describe('BoardView', () => {
       id: 'board-1',
       name: 'Ops Board',
       description: 'Primary board',
+      canWrite: true,
       columns: [
         {
           id: 'column-1',
@@ -511,6 +513,18 @@ describe('BoardView', () => {
     expect(wrapper.get('[data-testid="capture-modal"]').text()).toContain('Capture Ops Board board-1')
   })
 
+  it('does not expose board capture for a read-only board', async () => {
+    mockBoardStore.currentBoard = {
+      ...mockBoardStore.currentBoard,
+      canWrite: false,
+    }
+    const wrapper = mountView()
+    await waitForUi()
+
+    expect(wrapper.findAll('button').some((node) => node.text().trim() === 'Capture here')).toBe(false)
+    expect(wrapper.find('[data-testid="capture-modal"]').exists()).toBe(false)
+  })
+
   it('opens the column form when add card is triggered without columns', async () => {
     mockBoardStore.currentBoard = {
       ...mockBoardStore.currentBoard,
diff --git a/frontend/taskdeck-web/src/tests/views/paper/PaperBoardView.spec.ts b/frontend/taskdeck-web/src/tests/views/paper/PaperBoardView.spec.ts
index 1e4b4efe1c..95bdf32a77 100644
--- a/frontend/taskdeck-web/src/tests/views/paper/PaperBoardView.spec.ts
+++ b/frontend/taskdeck-web/src/tests/views/paper/PaperBoardView.spec.ts
@@ -299,6 +299,15 @@ describe('PaperBoardView', () => {
     })
   })
 
+  it('hides board capture for a read-only board', () => {
+    mockBoardStore.currentBoard = { ...board, canWrite: false }
+
+    const wrapper = mountView()
+
+    expect(wrapper.findAll('button').some((button) => button.text().includes('Capture here'))).toBe(false)
+    expect(wrapper.findAll('[data-testid="paper-column-capture"]').length).toBe(0)
+  })
+
   it('does not fetch board data itself because the wrapping BoardView owns loading', () => {
     mountView()
     expect(mockBoardStore.fetchBoard).not.toHaveBeenCalled()
diff --git a/frontend/taskdeck-web/src/tests/views/paper/PaperInboxView.spec.ts b/frontend/taskdeck-web/src/tests/views/paper/PaperInboxView.spec.ts
index a97c828646..3e8537c67b 100644
--- a/frontend/taskdeck-web/src/tests/views/paper/PaperInboxView.spec.ts
+++ b/frontend/taskdeck-web/src/tests/views/paper/PaperInboxView.spec.ts
@@ -45,6 +45,7 @@ const orchestratorState = {
   isArchivedHistory: ref(false),
   isScopeReplacement: ref(false),
   activeBoardName: ref(''),
+  activeBoardCanWrite: ref(true),
   activeColumnName: ref(''),
   selectedItemId: ref<string | null>(null),
   loadInbox: vi.fn<() => Promise<void>>(),
@@ -100,6 +101,7 @@ describe('PaperInboxView', () => {
     orchestratorState.isArchivedHistory.value = false
     orchestratorState.isScopeReplacement.value = false
     orchestratorState.activeBoardName.value = ''
+    orchestratorState.activeBoardCanWrite.value = true
     orchestratorState.activeColumnName.value = ''
     orchestratorState.selectedItemId.value = null
     orchestratorState.loadInbox.mockResolvedValue(undefined)
@@ -157,6 +159,29 @@ describe('PaperInboxView', () => {
     expect(wrapper.attributes('data-variant')).toBe('composer')
   })
 
+  it('preserves the scoped draft while disabling capture for a read-only board', async () => {
+    orchestratorState.activeBoardId.value = 'board-viewer'
+    orchestratorState.activeBoardName.value = 'Viewer board'
+    orchestratorState.activeBoardCanWrite.value = false
+
+    const wrapper = mount(PaperInboxView)
+    const composerBody = wrapper.get<HTMLTextAreaElement>('[data-testid="paper-composer-body"]')
+    await composerBody.setValue('Keep this draft until write access returns')
+    await composerBody.trigger('keydown', { key: 'Enter', metaKey: true })
+
+    const composer = wrapper.findComponent({ name: 'PaperCaptureComposer' })
+    expect(composer.get<HTMLButtonElement>('button.pbtn-ember').element.disabled).toBe(true)
+    expect(composerBody.element.value).toBe('Keep this draft until write access returns')
+    expect(mockCaptureStore.createItem).not.toHaveBeenCalled()
+
+    ;(wrapper.vm as unknown as { setVariant: (next: 'nib' | 'composer') => void }).setVariant('nib')
+    await wrapper.vm.$nextTick()
+    const nib = wrapper.findComponent({ name: 'PaperCaptureNib' })
+    expect(nib.get<HTMLButtonElement>('button.pbtn-ember').element.disabled).toBe(true)
+    expect(nib.get<HTMLTextAreaElement>('textarea').element.value).toBe('')
+    wrapper.unmount()
+  })
+
   it('renders archived capture history read-only and blocks Paper capture and triage mutations', async () => {
     orchestratorState.isArchivedHistory.value = true
     orchestratorState.activeBoardId.value = 'board-archived'
diff --git a/frontend/taskdeck-web/src/tests/views/paper/inbox/PaperCaptureComposer.spec.ts b/frontend/taskdeck-web/src/tests/views/paper/inbox/PaperCaptureComposer.spec.ts
index 394bec2ac3..0e3712de00 100644
--- a/frontend/taskdeck-web/src/tests/views/paper/inbox/PaperCaptureComposer.spec.ts
+++ b/frontend/taskdeck-web/src/tests/views/paper/inbox/PaperCaptureComposer.spec.ts
@@ -528,8 +528,13 @@ describe('PaperCaptureComposer', () => {
   it('blocks capture while a read-only board is the active scope', async () => {
     // defaultBoardId can preselect a board the user only reads; capturing into it
     // would produce an item that 403s the moment it is accepted for triage.
-    mockBoardStore.boards = [{ id: 'board-readonly', name: 'Archive', canWrite: false }]
-    const wrapper = mount(PaperCaptureComposer, { props: { defaultBoardId: 'board-readonly' } })
+    mockBoardStore.boards = [
+      { id: 'board-readonly', name: 'Archive', canWrite: false },
+      { id: 'board-writable', name: 'Working', canWrite: true },
+    ]
+    const wrapper = mount(PaperCaptureComposer, {
+      props: { defaultBoardId: 'board-readonly', canSubmit: false },
+    })
 
     await wrapper.find('textarea').setValue('a thought that has nowhere to land')
     await wrapper.find('textarea').trigger('keydown', { key: 'Enter', metaKey: true })
@@ -538,10 +543,31 @@ describe('PaperCaptureComposer', () => {
     const captureButton = wrapper.findAll('button').find((button) => button.text().includes('Capture'))
     expect(captureButton?.attributes('disabled')).toBeDefined()
 
-    // Switching to "no board" unblocks it — the escape hatch is one click away.
-    await wrapper.setProps({ defaultBoardId: null })
+    // Switching to "no board" unblocks it — the escape hatch is one click away,
+    // even while the parent continues to report the original scoped board as
+    // read-only.
+    await wrapper.get('[data-testid="paper-composer-board"]').setValue('')
+    await wrapper.find('textarea').trigger('keydown', { key: 'Enter', metaKey: true })
+    expect(wrapper.emitted('submit')).toHaveLength(1)
+    expect((wrapper.emitted('submit')?.[0]?.[0] as { boardId: string | null }).boardId).toBeNull()
+  })
+
+  it('unblocks a read-only scoped gate when a writable board is selected', async () => {
+    mockBoardStore.boards = [
+      { id: 'board-readonly', name: 'Archive', canWrite: false },
+      { id: 'board-writable', name: 'Working', canWrite: true },
+    ]
+    const wrapper = mount(PaperCaptureComposer, {
+      props: { defaultBoardId: 'board-readonly', canSubmit: false },
+    })
+
+    await wrapper.find('textarea').setValue('file this on the working board')
+    await wrapper.get('[data-testid="paper-composer-board"]').setValue('board-writable')
     await wrapper.find('textarea').trigger('keydown', { key: 'Enter', metaKey: true })
+
     expect(wrapper.emitted('submit')).toHaveLength(1)
+    expect((wrapper.emitted('submit')?.[0]?.[0] as { boardId: string | null }).boardId)
+      .toBe('board-writable')
   })
 
   it('keeps the draft after submit until the parent confirms success', async () => {
diff --git a/frontend/taskdeck-web/src/views/BoardView.vue b/frontend/taskdeck-web/src/views/BoardView.vue
index f257cf469b..93d13abec6 100644
--- a/frontend/taskdeck-web/src/views/BoardView.vue
+++ b/frontend/taskdeck-web/src/views/BoardView.vue
@@ -623,6 +623,7 @@ useKeyboardShortcuts([
 
         <BoardActionRail
           v-if="routedBoard"
+          :can-capture="routedBoard.canWrite !== false"
           @capture="openBoardCaptureModal"
           @chat="openBoardChat"
           @review="openBoardReview"
@@ -638,7 +639,11 @@ useKeyboardShortcuts([
           description="Boards are where approved work appears. Capture new input, review the proposed changes, then come back here to manage the result."
         >
           <template #actions>
-            <button class="td-btn td-btn--secondary td-btn--sm" @click="openBoardCaptureModal">Capture here</button>
+            <button
+              v-if="routedBoard.canWrite !== false"
+              class="td-btn td-btn--secondary td-btn--sm"
+              @click="openBoardCaptureModal"
+            >Capture here</button>
             <button class="td-btn td-btn--secondary td-btn--sm" @click="openBoardReview">Review proposals</button>
           </template>
         </WorkspaceHelpCallout>
diff --git a/frontend/taskdeck-web/src/views/paper/PaperBoardColumn.vue b/frontend/taskdeck-web/src/views/paper/PaperBoardColumn.vue
index e9dd58d707..46b60f3d0c 100644
--- a/frontend/taskdeck-web/src/views/paper/PaperBoardColumn.vue
+++ b/frontend/taskdeck-web/src/views/paper/PaperBoardColumn.vue
@@ -54,6 +54,8 @@ const props = withDefaults(
     composerOpen?: boolean
     composerBusy?: boolean
     composerError?: string | null
+    /** Hide board-scoped capture when the current viewer cannot write. */
+    canCapture?: boolean
   }>(),
   {
     cardVariant: 'index',
@@ -68,6 +70,7 @@ const props = withDefaults(
     composerOpen: false,
     composerBusy: false,
     composerError: null,
+    canCapture: true,
   },
 )
 
@@ -318,6 +321,7 @@ const proposalMarker = useBoardProposalMarker('column', () => props.column.id)
         />
 
         <button
+          v-if="canCapture"
           type="button"
           class="paper-board-column__capture"
           :aria-label="t('boardDetail.card.captureAria')"
diff --git a/frontend/taskdeck-web/src/views/paper/PaperBoardView.vue b/frontend/taskdeck-web/src/views/paper/PaperBoardView.vue
index 17be746522..9b2278d3e4 100644
--- a/frontend/taskdeck-web/src/views/paper/PaperBoardView.vue
+++ b/frontend/taskdeck-web/src/views/paper/PaperBoardView.vue
@@ -512,6 +512,8 @@ onBeforeRouteUpdate(guardDirtyNavigation)
  * honouring a column end-to-end is the open half of `#1984`.
  */
 function openCapture(_column: Column) {
+  if (routedBoard.value?.canWrite === false) return
+
   void router.push({
     name: 'workspace-inbox',
     query: { boardId: boardId.value },
@@ -526,6 +528,8 @@ function openReview() {
 }
 
 function openCaptureBoard() {
+  if (routedBoard.value?.canWrite === false) return
+
   void router.push({
     name: 'workspace-inbox',
     query: { boardId: boardId.value },
@@ -882,7 +886,11 @@ async function addStarterColumns() {
             data-testid="paper-board-settings"
             @click="openBoardSettings"
           />
-          <PaperHLBtn label="Capture here" @click="openCaptureBoard" />
+          <PaperHLBtn
+            v-if="routedBoard && routedBoard.canWrite !== false"
+            label="Capture here"
+            @click="openCaptureBoard"
+          />
           <PaperHLBtn variant="ember" label="Review" @click="openReview" />
         </div>
       </header>
@@ -1029,6 +1037,7 @@ async function addStarterColumns() {
             :composer-open="composerColumnId === column.id"
             :composer-busy="composerBusy"
             :composer-error="composerError"
+            :can-capture="routedBoard?.canWrite !== false"
             @capture="openCapture"
             @select="emit('column-select', column.id)"
             @toggle-collapse="toggleColumnCollapse"
diff --git a/frontend/taskdeck-web/src/views/paper/PaperInboxView.vue b/frontend/taskdeck-web/src/views/paper/PaperInboxView.vue
index 3a6eaf66ec..eea89d0701 100644
--- a/frontend/taskdeck-web/src/views/paper/PaperInboxView.vue
+++ b/frontend/taskdeck-web/src/views/paper/PaperInboxView.vue
@@ -87,6 +87,7 @@ const {
   isArchivedHistory,
   isScopeReplacement,
   activeBoardName,
+  activeBoardCanWrite,
   loadInbox,
   clearScope,
 } = useInboxOrchestrator({
@@ -609,6 +610,7 @@ defineExpose({ variant, toggleVariant, setVariant })
         :error-id="nibError ? CAPTURE_ERROR_ID : null"
         :active-board-id="activeBoardId"
         :active-board-name="activeBoardName"
+        :can-submit="activeBoardCanWrite"
         @submit="onNibSubmit"
       />
       <PaperCaptureComposer
@@ -618,6 +620,7 @@ defineExpose({ variant, toggleVariant, setVariant })
         :submitting="captureSubmitting"
         :invalid="!!composerError"
         :error-id="composerError ? CAPTURE_ERROR_ID : null"
+        :can-submit="activeBoardCanWrite"
         @submit="onComposerSubmit"
       />
       <p
diff --git a/frontend/taskdeck-web/src/views/paper/inbox/PaperCaptureComposer.vue b/frontend/taskdeck-web/src/views/paper/inbox/PaperCaptureComposer.vue
index b4a654efb1..ce3d2511b2 100644
--- a/frontend/taskdeck-web/src/views/paper/inbox/PaperCaptureComposer.vue
+++ b/frontend/taskdeck-web/src/views/paper/inbox/PaperCaptureComposer.vue
@@ -27,7 +27,7 @@ import type { CaptureSource } from '../../../types/capture'
  * length limit, so the choice is stated plainly next to the control rather
  * than implied.
  */
-const props = defineProps<{
+const props = withDefaults(defineProps<{
   /** Optional board id to default the picker to. */
   defaultBoardId?: string | null
   submitting?: boolean
@@ -35,7 +35,13 @@ const props = defineProps<{
   invalid?: boolean
   /** DOM id of the failure receipt to associate via `aria-describedby`. */
   errorId?: string | null
-}>()
+  /** Server-confirmed write capability for the active Inbox board. */
+  canSubmit?: boolean
+}>(), {
+  // Preserve the pre-capability prop contract for callers that do not pass a
+  // scoped-board decision: only an explicit `false` disables submission.
+  canSubmit: true,
+})
 
 /** The capture sources this composer can file. */
 export type ComposerSource = Extract<CaptureSource, 'Typed' | 'TranscriptPaste' | 'TranscriptFile'>
@@ -56,6 +62,12 @@ const { t } = useI18n()
 
 const body = ref('')
 const boardId = ref<string | null>(props.defaultBoardId ?? null)
+const boardSelection = computed<string | null>({
+  get: () => boardId.value,
+  set: (value) => {
+    boardId.value = value || null
+  },
+})
 const labelInput = ref('')
 const labels = ref<string[]>([])
 const dueAt = ref<string>('')
@@ -114,6 +126,19 @@ const selectedBoardIsWritable = computed(() => {
   return selected ? isBoardWritable(selected) : true
 })
 
+/**
+ * `canSubmit` describes the board that opened a scoped Inbox. It must not
+ * disable the composer's board picker escape hatch after the user changes the
+ * destination to no board or to another board. Known read-only picker options
+ * remain blocked by `selectedBoardIsWritable` above.
+ */
+const scopedBoardSelectionCanSubmit = computed(
+  () =>
+    props.canSubmit !== false ||
+    props.defaultBoardId == null ||
+    boardId.value !== props.defaultBoardId,
+)
+
 /**
  * Transcript bodies carry the server's larger limit; a paste beyond it would
  * 400 on arrival, so it is refused here beside the draft instead. `Typed`
@@ -128,6 +153,7 @@ const canSubmit = computed(
     body.value.trim().length > 0 &&
     !props.submitting &&
     !fileReading.value &&
+    scopedBoardSelectionCanSubmit.value &&
     selectedBoardIsWritable.value &&
     !transcriptTooLong.value,
 )
@@ -449,7 +475,7 @@ defineExpose({ focus: () => bodyRef.value?.focus(), resetDraft, snapshotDraft, r
         <label class="paper-composer__label">
           <span class="tk-eyebrow">{{ t('inbox.boardPicker.label') }}</span>
           <select
-            v-model="boardId"
+            v-model="boardSelection"
             class="paper-composer__select"
             data-testid="paper-composer-board"
             :aria-label="t('inbox.boardPicker.composerAria')"
diff --git a/frontend/taskdeck-web/src/views/paper/inbox/PaperCaptureNib.vue b/frontend/taskdeck-web/src/views/paper/inbox/PaperCaptureNib.vue
index 6a40faec22..de38678e61 100644
--- a/frontend/taskdeck-web/src/views/paper/inbox/PaperCaptureNib.vue
+++ b/frontend/taskdeck-web/src/views/paper/inbox/PaperCaptureNib.vue
@@ -19,7 +19,7 @@ import { formatShortcut } from '../../../utils/keyboardShortcuts'
  * render a static ember placeholder at the same position so the intended
  * structure is reviewable.
  */
-const props = defineProps<{
+const props = withDefaults(defineProps<{
   /**
    * When true, suppress the textarea and render the static ember placeholder
    * for ~1.4s.  The parent owns the timer so it can also reset state.
@@ -39,7 +39,13 @@ const props = defineProps<{
   activeBoardId?: string | null
   /** Human-readable active board name, when the scoped route has one. */
   activeBoardName?: string | null
-}>()
+  /** Server-confirmed write capability for the active Inbox board. */
+  canSubmit?: boolean
+}>(), {
+  // Preserve the pre-capability prop contract for direct callers: only an
+  // explicit `false` disables submission.
+  canSubmit: true,
+})
 
 const emit = defineEmits<{
   (event: 'submit', text: string): void
@@ -48,7 +54,9 @@ const emit = defineEmits<{
 const { t } = useI18n()
 const text = ref('')
 const inputRef = ref<HTMLTextAreaElement | null>(null)
-const canSubmit = computed(() => text.value.trim().length > 0 && !props.submitting)
+const canSubmit = computed(
+  () => text.value.trim().length > 0 && !props.submitting && props.canSubmit !== false,
+)
 const variantShortcut = computed(() => formatShortcut('mod+;'))
 const destination = computed(() => {
   if (!props.activeBoardId) {