feat: content-address complete PWA shell (Closes #511)

README.md

@@ -73,6 +73,10 @@ restart, **Resume Today** reopens the saved item (or the next surviving item if
 to durable account-bound delivery, then removes the item only from Today and opens the next
 one without closing or merging it. **Reply & next** provides the same one-action continuation
 for the current unread-update conversation. It deliberately leaves the notification unread;
+an open, unassigned issue update also offers **Take ownership & start**, which checks Today capacity
+before assignment, preserves the unread update, adds and syncs the owned issue to Today, checkpoints
+the session, and opens the issue. The adjacent **Take ownership** action remains available for
+claim-only triage, and a local start failure opens the now-owned issue with truthful recovery guidance.
 **Mark read & next** remains the explicit acknowledgement path. Delivery or local-admission
 failure preserves both the reply draft and checkpoint. Finishing or choosing **End session** clears only the checkpoint and leaves the Today plan
 unchanged. Another or unconfirmed account cannot see or resume it. Server revisions prevent delayed

frontend/authored-outbox.js

@@ -315,6 +315,11 @@ function createAuthoredOutbox({ storage, fetchJson, coordinator, backgroundSync,
         error: String(background.error || 'Message needs attention').slice(0, 240),
         ...(background.deliveryState ? { deliveryState: background.deliveryState } : {}),
       }];
+      if (background?.status === 'authorization') return [{
+        ...item,
+        status: 'authorization',
+        error: String(background.error || 'Fresh authorization required').slice(0, 240),
+      }];
       return [item];
     });
     write(items);

frontend/background-issue-sync.js

@@ -85,7 +85,8 @@ function createIssueSyncStore({
           incoming.set(current.id, replacement);
         }
         if ((current.status === 'sending' && Number(current.claimUntil) > Number(now())) ||
-            (current.status === 'attention' && replacement.status === 'attention') ||
+            (['attention', 'authorization'].includes(current.status) &&
+              replacement.status === current.status) ||
             current.status === 'sent') {
           incoming.set(current.id, current);
         }
@@ -153,7 +154,8 @@ function createIssueSyncStore({
     return transact(async records => {
       const current = (await records.getAll()).find(candidate => candidate.id === item.id);
       if (current && ((current.status === 'sending' && Number(current.claimUntil) > Number(now())) ||
-          (current.status === 'attention' && item.status === 'attention') ||
+          (['attention', 'authorization'].includes(current.status) &&
+            item.status === current.status) ||
           current.status === 'sent')) return current;
       const preservedAttachment = (current?.attachment?.data || current?.attachment?.blob) &&
         item?.attachment?.stored && !item.attachment.data && !item.attachment.blob
@@ -243,6 +245,9 @@ function createIssueSyncStore({
       status: 'attention', error,
       ...(deliveryState ? { deliveryState } : {}),
     })),
+    authorization: (id, claimToken, error) => updateClaim(
+      id, claimToken, item => clearClaim(item, { status: 'authorization', error })
+    ),
     snapshot: () => transact(async records =>
       (await records.getAll()).filter(item => item.recordType !== 'receipt-preference')),
     countBlocked: ownerLogin => transact(async records =>
@@ -271,6 +276,9 @@ function createBackgroundIssueSync({
   const failClaim = (item, error, deliveryState) => store.supportsClaimTokens
     ? store.fail(item.id, item.claimToken, error, deliveryState)
     : store.fail(item.id, error, deliveryState);
+  const requireAuthorization = (item, error) => store.supportsClaimTokens
+    ? store.authorization(item.id, item.claimToken, error)
+    : store.authorization(item.id, error);
   const checkpointClaim = (item, transform) => store.supportsClaimTokens
     ? store.checkpoint(item.id, item.claimToken, transform) : store.update?.(item.id, transform);
 
@@ -560,6 +568,15 @@ function createBackgroundIssueSync({
         await releaseClaim(item);
         throw error;
       }
+      if (status === 428 && item.kind === 'pull-review') {
+        const message = String(error?.message || 'Fresh authorization required').slice(0, 240);
+        await requireAuthorization(item, message);
+        return {
+          authorization: true,
+          error,
+          receipt: receiptFor(item, 'authorization'),
+        };
+      }
       if (status >= 400 && status < 500) {
         await failClaim(
           item,
@@ -590,11 +607,13 @@ function createBackgroundIssueSync({
     const confirmed = [];
     const receipts = [];
     let attention = 0;
-    if (!login) return { confirmed, blocked: 0, attention, login, receipts };
+    let authorization = 0;
+    if (!login) return { confirmed, blocked: 0, attention, authorization, login, receipts };
     const collect = result => {
       if (result.issue) confirmed.push(result.issue);
       if (result.message) confirmed.push(result.message);
       if (result.attention) attention += 1;
+      if (result.authorization) authorization += 1;
       if (result.receipt) receipts.push(result.receipt);
     };
     if (store.planBatch) {
@@ -655,7 +674,7 @@ function createBackgroundIssueSync({
       }
     }
     const blocked = store.countBlocked ? await store.countBlocked(login) : 0;
-    return { confirmed, blocked, attention, login, receipts };
+    return { confirmed, blocked, attention, authorization, login, receipts };
   }
 
   function flush() {

frontend/dashboard.css

@@ -244,6 +244,8 @@ textarea { resize: vertical; min-height: 120px; }
 .update-reply-actions { display:grid; grid-template-columns:repeat(2,minmax(0,1fr)); gap:8px; }
 .update-reply-actions button { min-height:44px; width:100%; }
 .update-sheet-actions { position:sticky; bottom:0; z-index:3; display:grid; gap:8px; margin-top:14px; padding:10px 4px; padding-bottom:calc(10px + env(safe-area-inset-bottom)); background:rgba(11,21,38,.98); border-top:1px solid #2a496e; }
+.update-ownership-actions { display:grid; grid-template-columns:repeat(2,minmax(0,1fr)); gap:8px; }
+.update-ownership-actions button { min-width:0; width:100%; }
 .update-sheet-actions button, .update-sheet-actions a { min-height:44px; display:flex; align-items:center; justify-content:center; }
 .update-sheet-actions a { border:1px solid #60a5fa; border-radius:10px; font-weight:700; }
 .update-retry { min-height:44px; width:100%; margin-top:10px; }
@@ -446,7 +448,7 @@ textarea { resize: vertical; min-height: 120px; }
   .work-filters { width:100%; }
   .work-filter { flex:1 1 calc(50% - 8px); }
   .review-sheet-panel { width:100%; border-left:0; padding:14px; }
-  .update-sheet-panel { width:100%; border-left:0; padding:14px; }
+  .update-sheet-panel { width:100%; border-left:0; padding:14px; overflow-x:hidden; }
   .issue-sheet-panel { width:100%; border-left:0; padding:14px; }
   .search-preview-panel { width:100%; border-left:0; padding:14px; padding-bottom:calc(14px + env(safe-area-inset-bottom)); overflow-x:hidden; }
   #cmd-palette { left:0; top:var(--search-viewport-top,0px); transform:none; width:100%; height:var(--search-viewport-height,100dvh); border:0; border-radius:0; padding:12px; padding-bottom:calc(12px + env(safe-area-inset-bottom)); z-index:46; }

frontend/dashboard.js

@@ -562,6 +562,7 @@
     onStatus: message => { qs('#update-reply-status').textContent = message; },
   });
   const updateOwnership = createUpdateOwnership({
+    available: () => createAndStart.available(),
     claim: item => fetchReviewJson(
       'api/v1/repos/' + item.repository.split('/').map(encodeURIComponent).join('/') +
       '/issues/' + encodeURIComponent(item.number) + '/claim',
@@ -577,6 +578,12 @@
       }
       return result;
     },
+    start: item => {
+      const outcome = createAndStart.complete(item);
+      if (outcome === 'started') openRoutedWork(item, qs('#update-ownership-start'));
+      return outcome;
+    },
+    recover: item => openRoutedWork(item, qs('#update-ownership-start')),
     onClaimed: item => {
       if (!lastContextSnapshot) return;
       const issues = (lastContextSnapshot.issues || []).filter(candidate =>
@@ -592,6 +599,12 @@
       button.textContent = state.action === 'today' ? 'Add to Today' : 'Take ownership';
       if (state.message) qs('#update-sheet-status').textContent = state.message;
     },
+    onStartState: state => {
+      const button = qs('#update-ownership-start');
+      button.hidden = state.action === 'hidden';
+      button.disabled = state.busy;
+      if (state.message) qs('#update-sheet-status').textContent = state.message;
+    },
   });
   const notificationReader = createNotificationReader({
     load: fetchNotificationDetail,
@@ -617,6 +630,7 @@
       qs('#send-update-reply').disabled = false;
       qs('#send-update-reply-read-next').disabled = false;
       qs('#update-ownership-action').hidden = true;
+      qs('#update-ownership-start').hidden = true;
       qs('#retry-update-load').hidden = true;
       setOfflineUpdateControls(false);
       qs('#keep-update-unread').focus();
@@ -1461,6 +1475,7 @@
     qs('#mark-update-read-next').disabled = false;
     qs('#mark-update-read-next').textContent = offline ? 'Queue read & next' : 'Mark read & next';
     qs('#update-ownership-action').disabled = offline;
+    qs('#update-ownership-start').disabled = offline;
     qs('#load-older-update-comments').disabled = offline;
     qs('#update-sheet .detail-defer').inert = offline;
   }
@@ -1642,6 +1657,10 @@
         '<button class="draft-edit" data-draft-index="' + index + '" type="button">Edit</button>' +
         '<button class="draft-send" data-draft-index="' + index + '" type="button">' + sendLabel + '</button>' +
         '<button class="draft-discard" data-draft-index="' + index + '" type="button">Discard</button>' :
+        reviewOutbox && item.status === 'authorization' ?
+        '<button class="draft-resume" data-draft-index="' + index + '" type="button">Open review</button>' +
+        '<button class="draft-authorize" data-draft-index="' + index + '" type="button">Authorize &amp; send review</button>' +
+        '<button class="draft-discard" data-draft-index="' + index + '" type="button">Discard queued review</button>' :
         reviewOutbox && item.status === 'attention' ?
         '<button class="draft-resume" data-draft-index="' + index + '" type="button">Open current review</button>' +
         '<button class="draft-copy" data-draft-index="' + index + '" type="button">Copy feedback</button>' +
@@ -1763,11 +1782,17 @@
         const item = lastDrafts[Number(button.dataset.draftIndex)];
         if (!item?.outbox_id || !activeFlushLogin) return;
         button.disabled = true;
-        qs('#my-work-action-status').textContent = 'Fresh authorization required for this exact issue.';
+        const reviewAuthorization = item.outbox_kind === 'pull-review';
+        qs('#my-work-action-status').textContent = reviewAuthorization ?
+          'Fresh authorization required for this exact review decision and head.' :
+          'Fresh authorization required for this exact issue.';
         const result = await authoredOutbox.retry(item.outbox_id, activeFlushLogin);
         applyAuthoredOutboxResult(result);
         qs('#my-work-action-status').textContent = result.confirmed?.length ?
-          'Issue closed and queued intent cleared.' : 'Issue closure was not confirmed. The queued intent is still safe.';
+          (reviewAuthorization ? 'Review submitted and queued intent cleared.' :
+            'Issue closed and queued intent cleared.') :
+          (reviewAuthorization ? 'Review was not confirmed. The queued review and feedback are still safe.' :
+            'Issue closure was not confirmed. The queued intent is still safe.');
       });
     });
     list.querySelectorAll('.draft-copy').forEach(button => {
@@ -4275,6 +4300,7 @@
   });
   qs('#keep-update-unread').addEventListener('click', () => closeUpdateSheet(true));
   qs('#update-ownership-action').addEventListener('click', () => updateOwnership.act());
+  qs('#update-ownership-start').addEventListener('click', () => updateOwnership.start());
   qs('#retry-update-load').addEventListener('click', () => {
     if (selectedUpdate) notificationReader.open(selectedUpdate, lastMyWork);
   });

frontend/drafts.js

@@ -161,11 +161,12 @@ function createDraftInbox({ storage, getCurrentLogin = () => '', now = () => Dat
             outbox_kind: item.kind,
             kind: 'authored-outbox',
             status: item.status === 'attention' ? 'attention' : (item.status === 'sending' ? 'sending' :
-              (isClosure ? 'authorization' : 'queued')),
+              (item.status === 'authorization' || isClosure ? 'authorization' : 'queued')),
             label: item.deliveryState === 'uncertain' ? 'Verify delivery' :
               (item.status === 'attention' ? (isClosure ? 'Issue closure needs attention' : 'Needs attention') :
-                (isReview ? 'Queued review' : (isClosure ? 'Awaiting authorization' : 'Queued message'))),
-            authorization_required: isClosure,
+                (isReview ? (item.status === 'authorization' ? 'Review awaiting authorization' : 'Queued review') :
+                  (isClosure ? 'Awaiting authorization' : 'Queued message'))),
+            authorization_required: isClosure || (isReview && item.status === 'authorization'),
             delivery_state: item.deliveryState,
             repository: isUpdate ? '' : item.repository,
             title: target,

frontend/index.html

@@ -523,7 +523,10 @@
       <div id="update-reply-status" class="small" aria-live="assertive"></div>
     </section>
     <div class="update-sheet-actions">
-      <button id="update-ownership-action" type="button" hidden aria-describedby="update-sheet-status">Take ownership</button>
+      <div class="update-ownership-actions">
+        <button id="update-ownership-action" type="button" hidden aria-describedby="update-sheet-status">Take ownership</button>
+        <button id="update-ownership-start" type="button" hidden aria-describedby="update-sheet-status">Take ownership &amp; start</button>
+      </div>
       <button class="share-work-route" type="button">Share</button>
       <button id="mark-update-read-next" type="button">Mark read &amp; next</button>
       <a id="open-update-gitea" href="#" target="_blank" rel="noopener noreferrer">Open in Gitea</a>

frontend/service-worker.js

@@ -1,6 +1,6 @@
 const BASE = new URL('./', self.location.href).pathname;
 importScripts(BASE + 'static/background-issue-sync.js');
-const CACHE = 'stackchain-dashboard-shell-v84';
+const CACHE = 'stackchain-dashboard-shell-v85';
 const OFFLINE_LEASE_URL = new URL(BASE + '__offline-session-lease', self.location.origin).href;
 const OUTAGE_STATUSES = new Set([500, 502, 503, 504]);
 const NAVIGATION_TIMEOUT_MS = self.__STACKCHAIN_NAVIGATION_TIMEOUT_MS || 4000;
@@ -205,11 +205,13 @@ async function flushAndNotify() {
       !await issueSync.getReceiptPreference?.(result.login)) return;
   for (const receipt of result.receipts) {
     const needsAttention = receipt.status === 'attention';
-    const title = needsAttention
+    const needsAuthorization = receipt.status === 'authorization';
+    const title = needsAuthorization ? 'Queued review needs authorization' : needsAttention
       ? 'Queued work needs attention'
       : receipt.kind === 'issue' ? 'Queued issue created' : 'Queued message sent';
     await self.registration.showNotification(title, {
-      body: needsAttention ? 'Tap to review it in Drafts.' : 'Tap to open it in Stackchain.',
+      body: needsAuthorization ? 'Tap to authorize it in the Delivery center.' :
+        needsAttention ? 'Tap to review it in Drafts.' : 'Tap to open it in Stackchain.',
       tag: 'stackchain-delivery-' + receipt.id,
       data: { route: receipt.route },
     });

frontend/session.js

@@ -149,6 +149,8 @@
             all_sessions_revoked: 'All device access revoked',
             issue_closed: 'Issue closed',
             pull_merged: 'Pull request merged',
+            pull_review_approved: 'Pull request approved',
+            pull_review_changes_requested: 'Changes requested',
           };
           page.events.forEach(event => {
             const row = root.document.createElement('article');

frontend/update-ownership.js

@@ -1,4 +1,6 @@
-function createUpdateOwnership({ claim, addToday, onClaimed, onState }) {
+function createUpdateOwnership({
+  claim, addToday, available, start, recover, onClaimed, onState, onStartState,
+}) {
   let detail = null;
   let update = null;
   let claimedItem = null;
@@ -8,6 +10,36 @@ function createUpdateOwnership({ claim, addToday, onClaimed, onState }) {
     onState?.(value);
   }
 
+  function startState(value) {
+    onStartState?.(value);
+  }
+
+  function claimed(result) {
+    claimedItem = {
+      ...result,
+      repository: detail.repository,
+      kind: 'issue',
+      notification_id: update?.notification_id,
+      updated_at: update?.updated_at || result.updated_at,
+      has_update: true,
+    };
+    detail.issue.claimable = false;
+    onClaimed?.(claimedItem);
+    startState({ action: 'hidden', busy: false, message: '' });
+    return claimedItem;
+  }
+
+  function recoverStartedItem(item) {
+    recover?.(item);
+    startState({
+      action: 'hidden',
+      busy: false,
+      message: 'Assigned to you, but Today could not start. The update is still unread; the owned issue is open so you can recover.',
+    });
+    state({ action: 'today', busy: false, message: '' });
+    return 'recovery';
+  }
+
   function open(nextDetail, nextUpdate) {
     detail = nextDetail;
     update = nextUpdate;
@@ -18,6 +50,11 @@ function createUpdateOwnership({ claim, addToday, onClaimed, onState }) {
       busy: false,
       message: '',
     });
+    startState({
+      action: nextDetail?.issue?.claimable && available && start ? 'start' : 'hidden',
+      busy: false,
+      message: '',
+    });
   }
 
   function act() {
@@ -40,21 +77,13 @@ function createUpdateOwnership({ claim, addToday, onClaimed, onState }) {
       repository: detail.repository,
       number: detail.issue.number,
     })).then(result => {
-      claimedItem = {
-        ...result,
-        repository: detail.repository,
-        kind: 'issue',
-        notification_id: update?.notification_id,
-        updated_at: update?.updated_at || result.updated_at,
-        has_update: true,
-      };
-      detail.issue.claimable = false;
-      onClaimed?.(claimedItem);
+      claimed(result);
       state({ action: 'today', busy: false, message: 'Assigned to you. The update is still unread.' });
       return claimedItem;
     }).catch(error => {
       if (error?.status === 409) {
         detail.issue.claimable = false;
+        startState({ action: 'hidden', busy: false, message: '' });
         state({
           action: 'hidden',
           busy: false,
@@ -72,7 +101,58 @@ function createUpdateOwnership({ claim, addToday, onClaimed, onState }) {
     return request;
   }
 
-  return { open, act };
+  function startNow() {
+    if (request) return request;
+    if (!detail?.issue?.claimable || !available || !start) return Promise.resolve('hidden');
+    if (!available()) {
+      const message = 'Today is limited to 5 items. Remove one before taking ownership.';
+      startState({ action: 'start', busy: false, message });
+      return Promise.resolve('full');
+    }
+    startState({ action: 'start', busy: true, message: 'Assigning and starting…' });
+    state({ action: 'claim', busy: true, message: '' });
+    request = Promise.resolve(claim({
+      repository: detail.repository,
+      number: detail.issue.number,
+    })).then(result => {
+      const item = claimed(result);
+      const outcome = start(item);
+      if (outcome === 'started') {
+        startState({
+          action: 'hidden',
+          busy: false,
+          message: 'Assigned, added to Today, and ready to work. The update is still unread.',
+        });
+        state({ action: 'today', busy: false, message: '' });
+        return outcome;
+      }
+      return recoverStartedItem(item);
+    }).catch(error => {
+      if (claimedItem) {
+        return recoverStartedItem(claimedItem);
+      }
+      if (error?.status === 409) {
+        detail.issue.claimable = false;
+        state({ action: 'hidden', busy: false, message: '' });
+        startState({
+          action: 'hidden',
+          busy: false,
+          message: 'Someone else claimed or closed this issue. The update is still unread.',
+        });
+        return 'conflict';
+      }
+      state({ action: 'claim', busy: false, message: '' });
+      startState({
+        action: 'start',
+        busy: false,
+        message: (error?.message || 'The issue could not be assigned.') + ' The update and your reply draft are safe; retry.',
+      });
+      return 'retry';
+    }).finally(() => { request = null; });
+    return request;
+  }
+
+  return { open, act, start:startNow };
 }
 
 if (typeof module !== 'undefined' && module.exports) module.exports = createUpdateOwnership;

src/frontend_bundle.py

@@ -13,6 +13,9 @@ import rjsmin
 
 SCRIPT_TAG = re.compile(r'^<script src="(static/[^"?]+\.js)"></script>$', re.MULTILINE)
 WORKER_RUNTIME_SOURCE = "static/background-issue-sync.js"
+CACHE_DECLARATION = re.compile(
+    r"const CACHE = 'stackchain-dashboard-shell-(?:v\d+|[0-9a-f]{16})';"
+)
 
 
 @dataclass(frozen=True)
@@ -22,6 +25,7 @@ class FrontendBuild:
     runtime_gzip_bytes: bytes
     runtime_digest: str
     runtime_name: str
+    shell_digest: str
     page_sources: tuple[str, ...]
     service_worker_source: str
 
@@ -61,11 +65,42 @@ def build_frontend(frontend_dir: Path) -> FrontendBuild:
         "  BASE + 'static/dashboard.css',\n",
         f"  BASE + 'static/dashboard.css',\n  BASE + '{runtime_name}',\n",
     )
-    worker = re.sub(
-        r"const CACHE = 'stackchain-dashboard-shell-v\d+';",
-        f"const CACHE = 'stackchain-dashboard-shell-{digest}';",
-        worker,
-        count=1,
+    worker = CACHE_DECLARATION.sub(
+        "const CACHE = 'stackchain-dashboard-shell-BUILD';", worker, count=1
+    )
+
+    shell_hasher = hashlib.sha256()
+    shell_inputs = (
+        ("dashboard.html", dashboard_html.encode()),
+        (runtime_name, runtime),
+        ("static/dashboard.css", (frontend_dir / "dashboard.css").read_bytes()),
+        ("manifest.webmanifest", (frontend_dir / "manifest.webmanifest").read_bytes()),
+        (
+            "static/icons/stackchain-192.png",
+            (frontend_dir / "icons/stackchain-192.png").read_bytes(),
+        ),
+        (
+            "static/icons/stackchain-512.png",
+            (frontend_dir / "icons/stackchain-512.png").read_bytes(),
+        ),
+        (
+            WORKER_RUNTIME_SOURCE,
+            (
+                frontend_dir / WORKER_RUNTIME_SOURCE.removeprefix("static/")
+            ).read_bytes(),
+        ),
+        ("service-worker.js", worker.encode()),
+    )
+    for name, content in shell_inputs:
+        shell_hasher.update(len(name).to_bytes(4, "big"))
+        shell_hasher.update(name.encode())
+        shell_hasher.update(len(content).to_bytes(8, "big"))
+        shell_hasher.update(content)
+    shell_digest = shell_hasher.hexdigest()[:16]
+    worker = worker.replace(
+        "const CACHE = 'stackchain-dashboard-shell-BUILD';",
+        f"const CACHE = 'stackchain-dashboard-shell-{shell_digest}';",
+        1,
     )
 
     return FrontendBuild(
@@ -74,6 +109,7 @@ def build_frontend(frontend_dir: Path) -> FrontendBuild:
         runtime_gzip_bytes=runtime_gzip,
         runtime_digest=digest,
         runtime_name=runtime_name,
+        shell_digest=shell_digest,
         page_sources=sources,
         service_worker_source=worker,
-    )
+    )

src/main.py

@@ -200,16 +200,20 @@ class DashboardSignIn(BaseModel):
         return normalized
 
 
+StepUpAction = Literal[
+    "merge_pull",
+    "submit_pull_review",
+    "close_issue",
+    "revoke_device",
+    "revoke_all_sessions",
+    "enroll_passkey",
+    "revoke_passkey",
+]
+
+
 class FreshAuthorization(BaseModel):
     access_token: str = Field(min_length=1, max_length=1_024)
-    action: Literal[
-        "merge_pull",
-        "close_issue",
-        "revoke_device",
-        "revoke_all_sessions",
-        "enroll_passkey",
-        "revoke_passkey",
-    ]
+    action: StepUpAction
     target: str = Field(min_length=1, max_length=255)
 
 
@@ -227,9 +231,7 @@ class PasskeyAuthentication(PasskeyCeremony):
 
 
 class PasskeyAuthorizationTarget(BaseModel):
-    action: Literal[
-        "merge_pull", "close_issue", "revoke_device", "revoke_all_sessions", "revoke_passkey"
-    ]
+    action: StepUpAction
     target: str = Field(min_length=1, max_length=255)
 
 
@@ -3793,12 +3795,26 @@ async def merge_assigned_pull(
 @app.post("/api/v1/repos/{owner}/{repo}/pulls/{number}/review", status_code=201)
 async def submit_review(
     submission: PullReviewSubmission,
+    request: Request,
     owner: str,
     repo: str,
     number: int,
     idempotency_key: str | None = Header(default=None, max_length=128),
+    step_up_grant: str | None = Header(
+        default=None, alias="X-Step-Up-Grant", max_length=128
+    ),
 ):
     repository = f"{owner}/{repo}"
+    if submission.decision != "comment":
+        await _require_step_up(
+            request,
+            step_up_grant,
+            action="submit_pull_review",
+            target=(
+                f"{repository}#{number}@{submission.expected_head_sha}:"
+                f"{submission.decision}"
+            ),
+        )
 
     async def submit_requested_review():
         if not await is_requested_review(repository, number):
@@ -3810,12 +3826,50 @@ async def submit_review(
             submission.decision,
             submission.body,
         )
-        if submission.comments:
-            return await gitea_proxy.submit_pull_review(
-                *args,
-                [comment.model_dump() for comment in submission.comments],
-            )
-        return await gitea_proxy.submit_pull_review(*args)
+        journal = None
+        operation_id = None
+        if submission.decision != "comment":
+            journal = _security_event_store()
+            try:
+                operation_id = await asyncio.to_thread(
+                    journal.reserve,
+                    (
+                        "pull_review_approved"
+                        if submission.decision == "approve"
+                        else "pull_review_changes_requested"
+                    ),
+                    target=f"{repository}#{number}",
+                )
+            except SecurityEventStoreError:
+                raise HTTPException(
+                    status_code=503,
+                    detail="Security activity is temporarily unavailable",
+                )
+        try:
+            if submission.comments:
+                result = await gitea_proxy.submit_pull_review(
+                    *args,
+                    [comment.model_dump() for comment in submission.comments],
+                )
+            else:
+                result = await gitea_proxy.submit_pull_review(*args)
+        except (
+            HTTPException,
+            gitea_proxy.StaleReviewError,
+            gitea_proxy.InvalidReviewCommentError,
+        ):
+            if journal is not None and operation_id is not None:
+                try:
+                    await asyncio.to_thread(journal.discard, operation_id)
+                except SecurityEventStoreError:
+                    pass
+            raise
+        if journal is not None and operation_id is not None:
+            try:
+                await asyncio.to_thread(journal.finalize, operation_id)
+            except SecurityEventStoreError:
+                pass
+        return result
 
     try:
         comment_fingerprint = tuple(

tests/test_authored_outbox.py

@@ -480,6 +480,35 @@ outbox.enqueue({{kind:'pull-comment',repository:'o/r',number:2,body:'Review',ope
     assert output["remaining"] == []
 
 
+def test_authorization_hold_can_resume_in_foreground_with_original_review_identity():
+    script = f"""
+const createAuthoredOutbox = require({json.dumps(str(OUTBOX))});
+const values=new Map();const sent=[];
+const storage={{getItem:k=>values.get(k)||null,setItem:(k,v)=>values.set(k,v)}};
+const outbox=createAuthoredOutbox({{
+  storage,getOwnerLogin:()=>'timmy',
+  backgroundSync:{{reconcile:async()=>{{}},requestSync:async()=>{{}},
+    send:async item=>{{sent.push({{operationId:item.operationId,status:item.status,
+      head:item.expectedHeadSha,decision:item.decision}});return{{message:{{id:91}}}};}}}},
+}});
+outbox.enqueue({{kind:'pull-review',repository:'o/r',number:7,operationId:'review-stable',
+  body:'Ship it',decision:'approve',expectedHeadSha:'abc123'}});
+outbox.reconcileBackground([{{id:'review-stable',kind:'pull-review',status:'authorization',
+  error:'Fresh authorization required'}}]);
+(async()=>{{const held=outbox.list()[0];const result=await outbox.retry(held.id,'timmy');
+process.stdout.write(JSON.stringify({{held,sent,result,remaining:outbox.list()}}));}})();
+"""
+    output = run_node(script)
+
+    assert output["held"]["status"] == "authorization"
+    assert output["sent"] == [{
+        "operationId": "review-stable", "status": "authorization",
+        "head": "abc123", "decision": "approve",
+    }]
+    assert output["result"]["confirmed"] == [{"id": 91}]
+    assert output["remaining"] == []
+
+
 @pytest.mark.anyio
 async def test_mobile_dashboard_loads_and_operates_authored_message_outbox():
     html = await dashboard()

tests/test_background_issue_sync.py

@@ -409,6 +409,41 @@ createBackgroundIssueSync({{store,fetchJson}}).flush().then(result=>process.stdo
     }]
 
 
+def test_closed_app_sync_holds_consequential_review_for_foreground_authorization():
+    script = f"""
+const createBackgroundIssueSync = require({json.dumps(str(SYNC))});
+const item={{id:'review-op',operationId:'review-op',ownerLogin:'timmy',status:'queued',
+  kind:'pull-review',repository:'stackchain/web',number:8,body:'Looks good',
+  decision:'approve',expectedHeadSha:'abc123',comments:[]}};
+const state={{authorized:[],failed:[],released:[],completed:[]}};let claimed=false;
+const store={{
+  claimNext:async()=>claimed?null:(claimed=true,item),
+  authorization:async(id,error)=>state.authorized.push({{id,error}}),
+  fail:async(...args)=>state.failed.push(args),release:async id=>state.released.push(id),
+  complete:async id=>state.completed.push(id),countBlocked:async()=>0,
+}};
+const fetchJson=async url=>{{
+  if(url==='api/v1/background-identity')return{{login:'timmy'}};
+  const error=new Error('Fresh authorization required');error.status=428;
+  error.code='step_up_required';throw error;
+}};
+(async()=>{{const result=await createBackgroundIssueSync({{store,fetchJson}}).flush();
+process.stdout.write(JSON.stringify({{state,result}}));}})();
+"""
+    output = run_node(script)
+
+    assert output["state"] == {
+        "authorized": [{"id": "review-op", "error": "Fresh authorization required"}],
+        "failed": [], "released": [], "completed": [],
+    }
+    assert output["result"]["attention"] == 0
+    assert output["result"]["authorization"] == 1
+    assert output["result"]["receipts"] == [{
+        "id": "review-op", "status": "authorization", "kind": "message",
+        "route": "#/my-work/review/stackchain/web/8",
+    }]
+
+
 def test_closed_app_sync_leaves_issue_closure_awaiting_foreground_authorization():
     records = [
         {

tests/test_comment_next.py

@@ -303,4 +303,4 @@ async def test_unread_update_offers_reply_mark_read_and_next_independent_of_toda
     assert '.update-reply-actions { display:grid; grid-template-columns:repeat(2,minmax(0,1fr));' in html
     assert '.update-reply-actions button { min-height:44px;' in html
     worker = (Path(__file__).parents[1] / "frontend" / "service-worker.js").read_text()
-    assert "stackchain-dashboard-shell-v84" in worker
+    assert "stackchain-dashboard-shell-v85" in worker

tests/test_dashboard_auth.py

@@ -201,6 +201,14 @@ async def test_passkey_fresh_authorization_is_exact_target_bound_and_single_use(
             json={"action": "close_issue", "target": "stackchain/api#7"},
             headers=headers,
         )
+        review_options = await client.post(
+            "/api/v1/passkeys/authorization/options",
+            json={
+                "action": "submit_pull_review",
+                "target": "stackchain/api#7@abc123:approve",
+            },
+            headers=headers,
+        )
         ceremony = {
             "challenge": options.json()["challenge"],
             "credential": {"id": "cGhvbmUtY3JlZGVudGlhbA"},
@@ -220,6 +228,8 @@ async def test_passkey_fresh_authorization_is_exact_target_bound_and_single_use(
         )
 
     assert options.status_code == 200
+    assert review_options.status_code == 200
+    assert review_options.json()["challenge"]
     assert authorized.status_code == 201
     assert authorized.json()["grant"]
     assert authorized.json()["expires_in"] == 90
@@ -953,6 +963,91 @@ async def test_other_high_impact_routes_require_fresh_authorization_before_mutat
     assert laptop_still_active.status_code == 200
 
 
+@pytest.mark.anyio
+async def test_consequential_review_requires_decision_and_head_bound_fresh_authorization(
+    access_control, monkeypatch
+):
+    calls = []
+
+    async def requested(repository, number):
+        calls.append(("requested", repository, number))
+        return True
+
+    async def submit(repository, number, head, decision, body):
+        calls.append(("submit", repository, number, head, decision, body))
+        return {"id": 91, "state": "APPROVED"}
+
+    monkeypatch.setattr(main, "is_requested_review", requested)
+    monkeypatch.setattr(main.gitea_proxy, "submit_pull_review", submit)
+    transport = httpx.ASGITransport(app=main.app)
+    payload = {
+        "expected_head_sha": "abc123",
+        "decision": "approve",
+        "body": "Ready to ship.",
+    }
+    async with httpx.AsyncClient(transport=transport, base_url="https://test") as client:
+        await client.post(
+            "/api/v1/session",
+            json={"access_token": "correct horse battery staple"},
+        )
+        headers = {
+            "Origin": "https://test",
+            "X-CSRF-Token": client.cookies["stackchain_csrf"],
+        }
+        missing = await client.post(
+            "/api/v1/repos/stackchain/api/pulls/7/review",
+            json=payload,
+            headers=headers,
+        )
+        wrong_grant = await fresh_grant(
+            client,
+            "submit_pull_review",
+            "stackchain/api#7@different:approve",
+        )
+        mismatched = await client.post(
+            "/api/v1/repos/stackchain/api/pulls/7/review",
+            json=payload,
+            headers={**headers, "X-Step-Up-Grant": wrong_grant},
+        )
+        grant = await fresh_grant(
+            client,
+            "submit_pull_review",
+            "stackchain/api#7@abc123:approve",
+        )
+        approved = await client.post(
+            "/api/v1/repos/stackchain/api/pulls/7/review",
+            json=payload,
+            headers={**headers, "X-Step-Up-Grant": grant},
+        )
+        replayed = await client.post(
+            "/api/v1/repos/stackchain/api/pulls/7/review",
+            json=payload,
+            headers={**headers, "X-Step-Up-Grant": grant},
+        )
+        comment = await client.post(
+            "/api/v1/repos/stackchain/api/pulls/7/review",
+            json={**payload, "decision": "comment"},
+            headers=headers,
+        )
+
+    assert [missing.status_code, mismatched.status_code] == [428, 428]
+    assert missing.json()["detail"] == {
+        "detail": "Fresh authorization required",
+        "code": "step_up_required",
+        "action": "submit_pull_review",
+        "target": "stackchain/api#7@abc123:approve",
+    }
+    assert approved.status_code == 201
+    assert replayed.status_code == 428
+    assert comment.status_code == 201
+    assert calls == [
+        ("requested", "stackchain/api", 7),
+        ("submit", "stackchain/api", 7, "abc123", "approve", "Ready to ship."),
+        ("requested", "stackchain/api", 7),
+        ("submit", "stackchain/api", 7, "abc123", "comment", "Ready to ship."),
+    ]
+
+
 @pytest.mark.anyio
 async def test_operator_can_review_and_revoke_one_remote_device(access_control):
     transport = httpx.ASGITransport(app=main.app)

tests/test_dashboard_session_frontend.py

@@ -655,6 +655,13 @@ def test_security_activity_explains_pending_outcome_confirmation():
     assert "event.status === 'pending'" in source
 
 
+def test_security_activity_labels_consequential_pull_review_decisions():
+    source = SESSION_JS.read_text()
+
+    assert "pull_review_approved: 'Pull request approved'" in source
+    assert "pull_review_changes_requested: 'Changes requested'" in source
+
+
 def test_authenticated_dashboard_load_requests_queued_delivery_resume():
     result = run_session_scenario(
         """

tests/test_drafts.py

@@ -142,6 +142,27 @@ process.stdout.write(JSON.stringify(item));
     assert output["quarantined"] is False
 
 
+def test_draft_inbox_exposes_held_review_as_awaiting_foreground_authorization():
+    script = f"""
+const createDraftInbox = require({json.dumps(str(DRAFTS))});
+const values=new Map([['stackchain.authored-outbox.v1',JSON.stringify({{version:2,items:[{{
+  id:'review-1',kind:'pull-review',repository:'stackchain/web',number:8,body:'Looks good',
+  decision:'approve',expectedHeadSha:'abc',comments:[],ownerLogin:'timmy',
+  status:'authorization',error:'Fresh authorization required',queuedAt:200
+}}]}})]]);
+const storage={{get length(){{return values.size}},key:i=>Array.from(values.keys())[i]||null,getItem:k=>values.get(k)||null,setItem:(k,v)=>values.set(k,v)}};
+const inbox=createDraftInbox({{storage,getCurrentLogin:()=>'timmy'}});
+process.stdout.write(JSON.stringify({{item:inbox.list()[0],partition:inbox.partition()}}));
+"""
+    output = run_node(script)
+
+    assert output["item"]["status"] == "authorization"
+    assert output["item"]["label"] == "Review awaiting authorization"
+    assert output["item"]["authorization_required"] is True
+    assert output["partition"]["counts"]["authorization"] == 1
+    assert output["partition"]["retryable"] == []
+
+
 def test_draft_inbox_exposes_queued_issue_closure_as_awaiting_authorization():
     script = f"""
 const createDraftInbox = require({json.dumps(str(DRAFTS))});

tests/test_frontend_bundle.py

@@ -42,6 +42,64 @@ def test_page_runtime_is_one_deterministic_content_addressed_bundle(tmp_path):
     assert changed.runtime_bytes != first.runtime_bytes
 
 
+def test_css_only_release_gets_a_new_shell_generation(tmp_path):
+    first = build_frontend(FRONTEND)
+    changed_frontend = tmp_path / "frontend"
+    shutil.copytree(FRONTEND, changed_frontend)
+    (changed_frontend / "dashboard.css").write_text(
+        (changed_frontend / "dashboard.css").read_text() + "\n/* release change */\n"
+    )
+
+    changed = build_frontend(changed_frontend)
+
+    assert changed.runtime_name == first.runtime_name
+    assert changed.runtime_bytes == first.runtime_bytes
+    assert changed.shell_digest != first.shell_digest
+    assert f"const CACHE = 'stackchain-dashboard-shell-{changed.shell_digest}';" in (
+        changed.service_worker_source
+    )
+
+
+@pytest.mark.parametrize(
+    "asset",
+    [
+        "manifest.webmanifest",
+        "icons/stackchain-192.png",
+        "icons/stackchain-512.png",
+        "background-issue-sync.js",
+        "service-worker.js",
+    ],
+)
+def test_every_offline_shell_asset_versions_the_shell_generation(tmp_path, asset):
+    first = build_frontend(FRONTEND)
+    changed_frontend = tmp_path / "frontend"
+    shutil.copytree(FRONTEND, changed_frontend)
+    path = changed_frontend / asset
+    path.write_bytes(path.read_bytes() + b"\nrelease-change")
+
+    changed = build_frontend(changed_frontend)
+
+    assert changed.shell_digest != first.shell_digest
+
+
+def test_legacy_cache_marker_is_normalized_out_of_build_identity(tmp_path):
+    first = build_frontend(FRONTEND)
+    changed_frontend = tmp_path / "frontend"
+    shutil.copytree(FRONTEND, changed_frontend)
+    worker = changed_frontend / "service-worker.js"
+    worker.write_text(
+        worker.read_text().replace(
+            "const CACHE = 'stackchain-dashboard-shell-v85';",
+            "const CACHE = 'stackchain-dashboard-shell-v999';",
+        )
+    )
+
+    changed = build_frontend(changed_frontend)
+
+    assert changed.shell_digest == first.shell_digest
+    assert changed.service_worker_source == first.service_worker_source
+
+
 @pytest.mark.anyio
 async def test_runtime_is_transferred_as_gzip_when_the_client_accepts_it():
     transport = httpx.ASGITransport(app=main.app)

tests/test_later_sync.py

@@ -347,5 +347,5 @@ async def test_dashboard_syncs_every_later_change_and_exposes_account_status():
 def test_later_sync_ships_atomically_in_the_offline_shell():
     source = (Path(__file__).parents[1] / "frontend" / "service-worker.js").read_text()
 
-    assert "stackchain-dashboard-shell-v84" in source
+    assert "stackchain-dashboard-shell-v85" in source
     assert "BASE + 'static/later-sync.js'" in source

tests/test_markdown_renderer.py

@@ -137,4 +137,4 @@ def test_markdown_work_bodies_are_mobile_safe_block_containers():
     assert ".markdown-content { min-width:0; max-width:100%; overflow-wrap:anywhere;" in css
     assert ".markdown-content pre { max-width:100%; overflow-x:auto;" in css
     assert ".markdown-content a { min-height:44px;" in css
-    assert "stackchain-dashboard-shell-v84" in worker
+    assert "stackchain-dashboard-shell-v85" in worker

tests/test_mobile_composer_integration.py

@@ -41,7 +41,7 @@ def test_offline_shell_contains_every_local_dashboard_runtime_asset():
     shell_assets = set(re.findall(r"BASE \+ '([^']+)'", worker.split("async function sessionCsrf", 1)[0]))
 
     assert local_assets <= shell_assets, f"Offline shell is missing: {sorted(local_assets - shell_assets)}"
-    assert "stackchain-dashboard-shell-v84" in worker
+    assert "stackchain-dashboard-shell-v85" in worker
 
 
 def test_all_conversation_composers_offer_accessible_mobile_mentions():

tests/test_my_work.py

@@ -176,19 +176,137 @@ controller.open({{repository:'stackchain/api', issue:{{number:7, claimable:true}
     }
 
 
+def test_unread_issue_update_claims_and_starts_once_without_marking_it_read():
+    script = f"""
+const createUpdateOwnership = require({json.dumps(str(UPDATE_OWNERSHIP))});
+let claims = 0;
+let starts = 0;
+let finishClaim;
+const reconciled = [];
+const states = [];
+const controller = createUpdateOwnership({{
+  available: () => true,
+  claim: () => {{ claims += 1; return new Promise(resolve => {{ finishClaim = resolve; }}); }},
+  addToday: () => 'added',
+  start: item => {{ starts += 1; return item.notification_id === 42 ? 'started' : 'broken'; }},
+  recover: () => {{ throw new Error('recovery should not run'); }},
+  onClaimed: item => reconciled.push(item),
+  onStartState: state => states.push(state),
+  onState: () => {{}},
+}});
+controller.open({{
+  repository:'stackchain/api', title:'Retry deploy',
+  issue:{{number:7, assignees:[], claimable:true}},
+}}, {{notification_id:42, updated_at:'2026-08-08T12:00:00Z'}});
+const first = controller.start();
+const second = controller.start();
+if (first !== second || claims !== 1) throw new Error('start was not single-flight');
+finishClaim({{number:7, title:'Retry deploy', assignees:['timmy'], state:'open'}});
+(async () => {{
+  const result = await first;
+  process.stdout.write(JSON.stringify({{result, claims, starts, reconciled, states}}));
+}})().catch(error => {{ console.error(error); process.exit(1); }});
+"""
+    result = subprocess.run(
+        ["node", "-e", script], check=True, capture_output=True, text=True
+    )
+    output = json.loads(result.stdout)
+    assert output["result"] == "started"
+    assert output["claims"] == 1
+    assert output["starts"] == 1
+    assert len(output["reconciled"]) == 1
+    assert output["reconciled"][0]["notification_id"] == 42
+    assert output["reconciled"][0]["has_update"] is True
+    assert output["states"][-1] == {
+        "action": "hidden",
+        "busy": False,
+        "message": "Assigned, added to Today, and ready to work. The update is still unread.",
+    }
+
+
+def test_unread_update_start_checks_today_capacity_before_claiming():
+    script = f"""
+const createUpdateOwnership = require({json.dumps(str(UPDATE_OWNERSHIP))});
+let claims = 0;
+const states = [];
+const controller = createUpdateOwnership({{
+  available: () => false,
+  claim: () => {{ claims += 1; return Promise.resolve({{number:7}}); }},
+  addToday: () => 'added', start: () => 'started',
+  onStartState: state => states.push(state), onState: () => {{}},
+}});
+controller.open({{repository:'stackchain/api', issue:{{number:7, claimable:true}}}}, {{notification_id:42}});
+(async () => {{
+  const result = await controller.start();
+  process.stdout.write(JSON.stringify({{result, claims, states}}));
+}})().catch(error => {{ console.error(error); process.exit(1); }});
+"""
+    result = subprocess.run(
+        ["node", "-e", script], check=True, capture_output=True, text=True
+    )
+    output = json.loads(result.stdout)
+    assert output["result"] == "full"
+    assert output["claims"] == 0
+    assert output["states"][-1] == {
+        "action": "start",
+        "busy": False,
+        "message": "Today is limited to 5 items. Remove one before taking ownership.",
+    }
+
+
+def test_unread_update_opens_owned_issue_when_today_start_throws():
+    script = f"""
+const createUpdateOwnership = require({json.dumps(str(UPDATE_OWNERSHIP))});
+let recovered = null;
+const states = [];
+const controller = createUpdateOwnership({{
+  available: () => true,
+  claim: () => Promise.resolve({{number:7, title:'Retry deploy'}}),
+  addToday: () => 'added',
+  start: () => {{ throw new Error('storage failed'); }},
+  recover: item => {{ recovered = item; }},
+  onStartState: state => states.push(state), onState: () => {{}},
+}});
+controller.open({{repository:'stackchain/api', issue:{{number:7, claimable:true}}}}, {{notification_id:42}});
+(async () => {{
+  const result = await controller.start();
+  process.stdout.write(JSON.stringify({{result, recovered, states}}));
+}})().catch(error => {{ console.error(error); process.exit(1); }});
+"""
+    result = subprocess.run(
+        ["node", "-e", script], check=True, capture_output=True, text=True
+    )
+    output = json.loads(result.stdout)
+    assert output["result"] == "recovery"
+    assert output["recovered"]["number"] == 7
+    assert output["states"][-1] == {
+        "action": "hidden",
+        "busy": False,
+        "message": "Assigned to you, but Today could not start. The update is still unread; the owned issue is open so you can recover.",
+    }
+
+
 @pytest.mark.anyio
 async def test_mobile_update_sheet_wires_phone_safe_ownership_to_my_work_and_today():
     html = await dashboard()
 
     assert '<script src="static/update-ownership.js"></script>' in html
     assert 'id="update-ownership-action"' in html
+    assert 'id="update-ownership-start"' in html
+    assert '>Take ownership &amp; start</button>' in html
     assert 'hidden aria-describedby="update-sheet-status"' in html
     assert 'const updateOwnership = createUpdateOwnership({' in html
+    assert 'available: () => createAndStart.available()' in html
+    assert 'const outcome = createAndStart.complete(item)' in html
+    assert "openRoutedWork(item, qs('#update-ownership-start'))" in html
     assert 'updateOwnership.open(detail, selectedUpdate)' in html
     assert "qs('#update-ownership-action').addEventListener('click'" in html
+    assert "qs('#update-ownership-start').addEventListener('click', () => updateOwnership.start())" in html
     assert "lastContextSnapshot.issues" in html
     assert "todayWork.add(item)" in html
     assert '.update-sheet-actions button, .update-sheet-actions a { min-height:44px;' in html
+    assert '.update-ownership-actions { display:grid; grid-template-columns:repeat(2,minmax(0,1fr));' in html
+    assert '.update-sheet-panel { width:100%; border-left:0; padding:14px; overflow-x:hidden;' in html
 
 
 def test_work_routes_round_trip_all_sheet_kinds_and_reject_unsafe_fragments():
@@ -4682,6 +4800,9 @@ async def test_review_attention_drafts_require_revision_instead_of_resending_sta
     assert "reviewOutbox && item.status === 'attention'" in html
     assert ">Open current review</button>" in html
     assert ">Copy feedback</button>" in html
+    assert "reviewOutbox && item.status === 'authorization'" in html
+    assert ">Authorize &amp; send review</button>" in html
+    assert "Review submitted and queued intent cleared." in html
     assert "item.kind === 'authored-outbox' && !reviewOutbox" in html
 
 

tests/test_plan_today.py

@@ -292,6 +292,6 @@ async def test_plan_today_wires_cancel_back_and_success_through_overlay_history(
 def test_plan_today_controller_is_available_in_the_offline_shell():
     source = SERVICE_WORKER.read_text()
 
-    assert "stackchain-dashboard-shell-v84" in source
+    assert "stackchain-dashboard-shell-v85" in source
     assert "BASE + 'static/plan-today.js'" in source
     assert "BASE + 'static/plan-today-preview.js'" in source

tests/test_security_activity.py

@@ -234,6 +234,117 @@ async def test_successful_protected_actions_record_only_bounded_targets(
     assert b"abc123" not in persisted
 
 
+@pytest.mark.anyio
+async def test_approved_pull_review_records_a_privacy_safe_completed_event(
+    security_access, monkeypatch
+):
+    async def requested(*_args):
+        return True
+
+    async def submit(*_args):
+        return {"id": 91, "state": "APPROVED"}
+
+    monkeypatch.setattr(main, "is_requested_review", requested)
+    monkeypatch.setattr(main.gitea_proxy, "submit_pull_review", submit)
+    transport = httpx.ASGITransport(app=main.app)
+    async with httpx.AsyncClient(transport=transport, base_url="https://test") as client:
+        await client.post(
+            "/api/v1/session",
+            json={"access_token": "correct horse battery staple", "device_label": "Phone"},
+        )
+        headers = {
+            "Origin": "https://test",
+            "X-CSRF-Token": client.cookies["stackchain_csrf"],
+        }
+        grant = await client.post(
+            "/api/v1/fresh-authorization",
+            json={
+                "access_token": "correct horse battery staple",
+                "action": "submit_pull_review",
+                "target": "stackchain/api#7@abc123:approve",
+            },
+            headers=headers,
+        )
+        response = await client.post(
+            "/api/v1/repos/stackchain/api/pulls/7/review",
+            json={
+                "expected_head_sha": "abc123",
+                "decision": "approve",
+                "body": "Ready to ship with private review notes.",
+            },
+            headers={**headers, "X-Step-Up-Grant": grant.json()["grant"]},
+        )
+        events = (await client.get("/api/v1/security-events")).json()["events"]
+
+    assert response.status_code == 201
+    assert events[0] == {
+        "id": events[0]["id"],
+        "kind": "pull_review_approved",
+        "method": None,
+        "device_label": None,
+        "target": "stackchain/api#7",
+        "created_at": events[0]["created_at"],
+        "status": "completed",
+    }
+    persisted = (security_access / "security.sqlite3").read_bytes()
+    assert b"abc123" not in persisted
+    assert b"private review notes" not in persisted
+
+
+@pytest.mark.anyio
+async def test_review_reservation_failure_prevents_the_gitea_mutation(
+    security_access, monkeypatch
+):
+    submit_calls = []
+
+    async def requested(*_args):
+        return True
+
+    async def submit(*args):
+        submit_calls.append(args)
+        return {"id": 91, "state": "APPROVED"}
+
+    class UnavailableJournal:
+        def reserve(self, *_args, **_kwargs):
+            raise SecurityEventStoreError("unavailable")
+
+    monkeypatch.setattr(main, "is_requested_review", requested)
+    monkeypatch.setattr(main.gitea_proxy, "submit_pull_review", submit)
+    transport = httpx.ASGITransport(app=main.app)
+    async with httpx.AsyncClient(transport=transport, base_url="https://test") as client:
+        await client.post(
+            "/api/v1/session",
+            json={"access_token": "correct horse battery staple"},
+        )
+        headers = {
+            "Origin": "https://test",
+            "X-CSRF-Token": client.cookies["stackchain_csrf"],
+        }
+        grant = await client.post(
+            "/api/v1/fresh-authorization",
+            json={
+                "access_token": "correct horse battery staple",
+                "action": "submit_pull_review",
+                "target": "stackchain/api#7@abc123:approve",
+            },
+            headers=headers,
+        )
+        monkeypatch.setattr(main, "_security_event_store", lambda: UnavailableJournal())
+        response = await client.post(
+            "/api/v1/repos/stackchain/api/pulls/7/review",
+            json={
+                "expected_head_sha": "abc123",
+                "decision": "approve",
+                "body": "Ready.",
+            },
+            headers={**headers, "X-Step-Up-Grant": grant.json()["grant"]},
+        )
+
+    assert response.status_code == 503
+    assert response.json()["detail"] == "Security activity is temporarily unavailable"
+    assert submit_calls == []
+
+
 @pytest.mark.anyio
 async def test_issue_close_reservation_failure_prevents_the_gitea_mutation(
     security_access, monkeypatch

tests/test_service_worker.py

@@ -122,7 +122,7 @@ async function dispatchNotificationClick(route) {{
 def test_resumable_today_session_ships_in_a_new_offline_shell():
     source = WORKER.read_text()
 
-    assert "stackchain-dashboard-shell-v84" in source
+    assert "stackchain-dashboard-shell-v85" in source
     assert "BASE + 'static/my-work.js'" in source
     assert "BASE + 'static/dashboard.js'" in source
     assert "BASE + 'static/dashboard.css'" in source
@@ -131,14 +131,14 @@ def test_resumable_today_session_ships_in_a_new_offline_shell():
 def test_ownership_exit_runtime_rolls_the_offline_shell_cache():
     source = WORKER.read_text()
 
-    assert "stackchain-dashboard-shell-v84" in source
+    assert "stackchain-dashboard-shell-v85" in source
     assert "BASE + 'static/dashboard.js'" in source
 
 
 def test_offline_review_next_ships_today_completion_atomically():
     source = WORKER.read_text()
 
-    assert "stackchain-dashboard-shell-v84" in source
+    assert "stackchain-dashboard-shell-v85" in source
     assert "BASE + 'static/today-completion.js'" in source
     assert "BASE + 'static/dashboard.js'" in source
 
@@ -146,7 +146,7 @@ def test_offline_review_next_ships_today_completion_atomically():
 def test_duplicate_aware_capture_ships_in_a_new_offline_shell():
     source = WORKER.read_text()
 
-    assert "stackchain-dashboard-shell-v84" in source
+    assert "stackchain-dashboard-shell-v85" in source
     assert "BASE + 'static/create-issue-sheet.js'" in source
     assert "BASE + 'static/dashboard.js'" in source
 
@@ -154,14 +154,14 @@ def test_duplicate_aware_capture_ships_in_a_new_offline_shell():
 def test_exact_later_picker_ships_atomically_in_a_new_offline_shell():
     source = WORKER.read_text()
 
-    assert "stackchain-dashboard-shell-v84" in source
+    assert "stackchain-dashboard-shell-v85" in source
     assert "BASE + 'static/later-picker.js'" in source
 
 
 def test_navigation_deadline_ships_in_a_new_shell_cache():
     source = WORKER.read_text()
 
-    assert "stackchain-dashboard-shell-v84" in source
+    assert "stackchain-dashboard-shell-v85" in source
     assert "BASE + 'static/dashboard.css'" in source
     assert "BASE + 'static/dashboard.js'" in source
     assert "BASE + 'static/install-app.js'" in source
@@ -170,21 +170,21 @@ def test_navigation_deadline_ships_in_a_new_shell_cache():
 def test_today_convergence_ships_in_a_new_shell_cache():
     source = WORKER.read_text()
 
-    assert "stackchain-dashboard-shell-v84" in source
+    assert "stackchain-dashboard-shell-v85" in source
     assert "BASE + 'static/today-sync.js'" in source
 
 
 def test_mobile_search_viewport_ships_in_a_new_offline_shell():
     source = WORKER.read_text()
 
-    assert "stackchain-dashboard-shell-v84" in source
+    assert "stackchain-dashboard-shell-v85" in source
     assert "BASE + 'static/mobile-search-viewport.js'" in source
 
 
 def test_update_ownership_flow_ships_atomically_in_a_new_offline_shell():
     source = WORKER.read_text()
 
-    assert "stackchain-dashboard-shell-v84" in source
+    assert "stackchain-dashboard-shell-v85" in source
     assert "BASE + 'static/update-ownership.js'" in source
 
 
@@ -328,6 +328,7 @@ def test_opted_in_background_sync_notifies_privately_and_receipt_tap_focuses_rou
   state.flushResult = {login:'timmy', receipts:[
     {id:'capture-1',status:'confirmed',kind:'issue',route:'#/my-work/issue/stackchain/api/44'},
     {id:'bad-1',status:'attention',kind:'message',route:'#/my-work/drafts'},
+    {id:'review-1',status:'authorization',kind:'message',route:'#/my-work/drafts'},
   ]};
   state.clientList = [{url:'https://forge.example/dashboard/', navigate:async function(url){ this.url=url; }, focus:async function(){ state.focused.push(this.url); }}];
   await dispatchSync('stackchain-issue-outbox-v1');
@@ -353,6 +354,14 @@ def test_opted_in_background_sync_notifies_privately_and_receipt_tap_focuses_rou
                 "data": {"route": "#/my-work/drafts"},
             },
         },
+        {
+            "title": "Queued review needs authorization",
+            "options": {
+                "body": "Tap to authorize it in the Delivery center.",
+                "tag": "stackchain-delivery-review-1",
+                "data": {"route": "#/my-work/drafts"},
+            },
+        },
     ]
     assert result["focused"] == [
         "https://forge.example/dashboard/#/my-work/issue/stackchain/api/44"
@@ -385,7 +394,7 @@ def test_one_session_bound_csrf_proof_is_reused_for_a_background_drain():
 def test_queue_today_ships_atomically_in_a_new_offline_shell():
     source = WORKER.read_text()
 
-    assert "stackchain-dashboard-shell-v84" in source
+    assert "stackchain-dashboard-shell-v85" in source
     assert "BASE + 'static/queue-today.js'" in source
 
 

tests/test_today_readiness.py

@@ -221,7 +221,7 @@ async def test_today_blocker_opens_existing_preview_and_preserves_readiness_gate
 def test_readiness_runtime_is_available_in_offline_shell():
     service_worker = SERVICE_WORKER.read_text()
 
-    assert "const CACHE = 'stackchain-dashboard-shell-v84';" in service_worker
+    assert "const CACHE = 'stackchain-dashboard-shell-v85';" in service_worker
     assert "BASE + 'static/today-readiness.js'" in service_worker
 
 

tests/test_today_sync.py

@@ -127,7 +127,7 @@ sync.enqueueConfiguration(120, {{'issue:r:1:':60}});
 def test_inflight_today_drain_ships_in_a_new_offline_shell():
     source = (Path(__file__).parents[1] / "frontend" / "service-worker.js").read_text()
 
-    assert "stackchain-dashboard-shell-v84" in source
+    assert "stackchain-dashboard-shell-v85" in source
     assert "BASE + 'static/today-sync.js'" in source