.gitea/workflows/ci.yml

@@ -7,105 +7,23 @@ on:
     branches: [main]
   workflow_dispatch:
 
-permissions:
-  contents: read
-
 jobs:
   lint:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
-      - uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 # v5.6.0
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
         with: { python-version: "3.11" }
       - run: pip install -r requirements.txt
-      - run: pip install -r requirements-audit.txt
-      - run: python3 -m pip_audit -r requirements.txt --strict
       - run: python3 -m pytest tests/ -q
 
-  build-release:
+  build-frontend:
     runs-on: ubuntu-latest
     needs: lint
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
-      - name: Build deterministic release bundle
-        run: |
-          SOURCE_DATE_EPOCH="$(git show -s --format=%ct "$GITHUB_SHA")"
-          python3 scripts/build_release.py \
-            --root . \
-            --output-dir dist \
-            --commit "$GITHUB_SHA" \
-            --source-date-epoch "$SOURCE_DATE_EPOCH"
-      - name: Upload tested release bundle
-        uses: actions/upload-artifact@a8a3f3ad30e3422c9c7b888a15615d19a852ae32 # v3.1.3
-        with:
-          name: release-bundle
-          path: dist/
-
-  browser-journey:
-    runs-on: ubuntu-latest
-    needs: build-release
-    env:
-      STACKCHAIN_RUN_RELEASE_E2E: "1"
-    steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
-      - uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 # v5.6.0
-        with: { python-version: "3.11" }
-      - name: Download assembled release bundle
-        uses: actions/download-artifact@9bc31d5ccc31df68ecc42ccf4149144866c47d8a # v3.0.2
-        with:
-          name: release-bundle
-          path: dist
-      - name: Install browser test dependencies
-        run: |
-          pip install -r requirements-e2e.txt
-          python3 -m playwright install --with-deps chromium
-      - name: Exercise packaged mobile work journeys
-        run: python3 -m pytest tests/e2e -q
-
-  release-candidate:
-    runs-on: ubuntu-latest
-    needs: [lint, build-release, browser-journey]
-    if: github.event_name == 'push' && github.ref == 'refs/heads/main'
-    permissions:
-      contents: write
-    steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
-      - name: Download tested release bundle
-        uses: actions/download-artifact@9bc31d5ccc31df68ecc42ccf4149144866c47d8a # v3.0.2
-        with:
-          name: release-bundle
-          path: dist
-      - name: Verify and publish release candidate
-        env:
-          TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: |
-          set -euo pipefail
-          TARGET="${{ github.sha }}"
-          TAG="v0.1.0-rc.${{ github.run_number }}"
-          RELEASE_URL="${{ github.server_url }}/api/v1/repos/${{ github.repository }}/releases"
-
-          (cd dist && sha256sum -c ./*.sha256)
-          python3 scripts/verify_release.py --input-dir dist --commit "$TARGET" --repository .
-
-          printf '{"tag_name":"%s","target_commitish":"%s","name":"Release Candidate %s","body":"CI-tested release candidate for commit %s. Verify downloads with the attached SHA-256 checksum.","draft":true,"prerelease":true}\n' \
-            "$TAG" "$TARGET" "$TAG" "$TARGET" > /tmp/release.json
-          curl --fail-with-body -sS -X POST "$RELEASE_URL" \
-            -H "Authorization: token $TOKEN" \
-            -H "Content-Type: application/json" \
-            --data-binary @/tmp/release.json > /tmp/release-response.json
-          RELEASE_ID="$(python3 -c 'import json; print(json.load(open("/tmp/release-response.json"))["id"])')"
-
-          for ASSET in dist/*; do
-            NAME="$(basename "$ASSET")"
-            ENCODED_NAME="$(python3 -c 'import sys,urllib.parse; print(urllib.parse.quote(sys.argv[1]))' "$NAME")"
-            curl --fail-with-body -sS -X POST "$RELEASE_URL/$RELEASE_ID/assets?name=$ENCODED_NAME" \
-              -H "Authorization: token $TOKEN" \
-              -H "Content-Type: application/octet-stream" \
-              --data-binary "@$ASSET"
-          done
-
-          printf '{"draft":false,"prerelease":true}\n' > /tmp/publish.json
-          curl --fail-with-body -sS -X PATCH "$RELEASE_URL/$RELEASE_ID" \
-            -H "Authorization: token $TOKEN" \
-            -H "Content-Type: application/json" \
-            --data-binary @/tmp/publish.json
+      - uses: actions/checkout@v4
+      - name: Pack frontend
+        run: tar -czf frontend.tar.gz frontend
+      - name: Upload artifact
+        uses: actions/upload-artifact@v3
+        with: { name: frontend, path: frontend.tar.gz }

.gitea/workflows/release.yml

@@ -0,0 +1,40 @@
+name: Release
+
+on:
+  push:
+    branches: [main]
+  workflow_dispatch:
+
+jobs:
+  release-candidate:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Create Gitea tag and release candidate
+        env:
+          TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          set -euo pipefail
+          TAG="v0.1.0-rc.${{ github.run_number }}"
+          TARGET="${{ github.sha }}"
+          TAG_URL="${{ github.server_url }}/api/v1/repos/${{ github.repository }}/tags"
+          RELEASE_URL="${{ github.server_url }}/api/v1/repos/${{ github.repository }}/releases"
+
+          printf '{"tag_name":"%s","target":"%s","message":"Automated release candidate %s"}\n' \
+            "$TAG" "$TARGET" "$TAG" > /tmp/tag.json
+          curl --fail-with-body -sS -X POST "$TAG_URL" \
+            -H "Authorization: token $TOKEN" \
+            -H "Content-Type: application/json" \
+            --data-binary @/tmp/tag.json
+
+          printf '{"tag_name":"%s","target_commitish":"%s","name":"Release Candidate %s","body":"Automated release candidate for commit %s.","draft":false,"prerelease":true}\n' \
+            "$TAG" "$TARGET" "$TAG" "$TARGET" > /tmp/release.json
+          curl --fail-with-body -sS -X POST "$RELEASE_URL" \
+            -H "Authorization: token $TOKEN" \
+            -H "Content-Type: application/json" \
+            --data-binary @/tmp/release.json

README.md

@@ -18,332 +18,22 @@ token that can read dashboard data, update the authenticated user's notification
 threads, create and self-assign issues, discover, claim, and release issue assignments,
 list repository labels and open milestones, set or clear due dates on assigned issues, create issue comments, close assigned issues,
 inspect/comment on assigned pull
-requests, merge assigned pull requests, and submit pull-request reviews. For authored
-pulls, up to eight non-overlapping one-line reviewer suggestions across bounded UTF-8
-files can be staged during the mobile feedback pass, reviewed in a path-grouped manifest,
-and committed as one atomic branch update. The batch preserves every original blob
-identity, applies same-file replacements from the bottom up, rejects overlapping or stale
-lines, and verifies the advanced pull head and every final file before reporting success.
-The server uses Gitea's multi-file contents mutation so a cross-file implementation-and-test
-fix cannot be partially committed.
-After an exact merged commit fails release checks, its mobile release receipt can load the
-failed job evidence and prepare a draft rollback pull request. The server revalidates the
-operator's participation and push access, reverses only bounded UTF-8 files whose current
-default-branch content still matches the failed merge, and creates one atomic commit on a
-stable operator-owned branch. Conflicts, renames, binary files, and oversized changes fail
-closed; retrying converges on the same draft PR, which opens in the existing review workspace.
-Assigned-issue, assigned-pull-request, and unread-update conversation composers accept an ordered bundle of up to five PNG, JPEG, or WebP photos. Repeated camera captures append to the bundle, the gallery picker accepts multiple images, and each composer automatically optimizes oversized screenshots on-device to fit the 2 MB upload boundary. Before sending, the selected conversation photo can use the same touch editor as New issue evidence to crop, privacy-redact, highlight, or add an arrow; Apply replaces only that flattened derivative while preserving its caption and bundle position, and Cancel leaves the original unchanged.
-For online delivery, every photo uploads before the comment is posted to the exact conversation target, producing one ordered Markdown comment or reply; validation or upload failures keep the typed text and removable preview available for retry. Offline photo conversations admit every image Blob to IndexedDB before confirmation, keep only bounded metadata in localStorage, and checkpoint each upload separately so reconnect resumes at the first unconfirmed photo without duplicating an upload, comment, reply, or reply-and-read transition. The mobile **New issue** capture-first stage accepts an ordered evidence bundle of up to
-five PNG, JPEG, or WebP screenshots before a repository is chosen, optimizing each image independently
-to the 2 MB boundary. **Save to Drafts** durably writes every optimized Blob to IndexedDB before
-confirmation, keeps only account-bound attachment metadata in localStorage, and restores the ordered
-bundle when the operator later chooses a repository. A scrollable thumbnail tray lets the operator
-review every restored image before filing; **Move earlier**, **Move later**, and **Remove selected**
-change the durable evidence order without changing the issue title or note. The active screenshot's
-optional **Evidence note** stays paired with that image through reorder, Draft restore, offline delivery,
-and retry, then appears as a Markdown-safe caption immediately before its uploaded image. The selected screenshot can be cropped, privacy-redacted, highlighted, and marked with touch-drawn arrows before a flattened derivative replaces it; undo, reset, and cancel keep editing reversible without changing its note or bundle position. The source Draft remains
-available until its evidence has safely transferred to the issue outbox; discard and bounded pruning remove every Blob.
-Repository-aware durable admission likewise stores the evidence bundle with its account-bound outbox
-capture, avoiding base64 quota pressure and synchronous multi-megabyte writes. Online and background
-delivery send the original bytes as multipart form data, avoiding the roughly 33% base64 wire
-expansion. Existing queued base64 screenshot payloads remain readable and are converted only at
-delivery time.
-Delivery creates the issue exactly once, then uploads each image under a checkpointed per-image
-identity and posts one ordered Markdown evidence comment. After a partial failure, retry resumes with the confirmed issue and from
-the first unconfirmed image instead of duplicating the issue or earlier uploads. The installed PWA
-Share Target accepts the same bounded multi-image bundle through sign-in continuation.
+requests, merge assigned pull requests, and submit pull-request reviews.
 Pull-request replies and mobile My Work issue and PR comments use Gitea's
-issue-comment API. In issue, pull-request, unread-update, and active Today progress
-conversations, typing at least two characters after `@` offers repository-scoped
-teammate suggestions; touch or keyboard selection inserts the login without leaving
-the draft. Mention lookup failure never blocks literal text or comment delivery. Mobile issue capture requires issue
-creation and assignment permission. A fresh capture never silently targets the first repository:
-the operator must explicitly choose one, either from the paginated browser or through the bounded
-authenticated repository search. Search results include only visible repository identities, stale
-responses cannot replace a newer query, and search failure leaves the draft and browse fallback
-intact. Saved drafts restore their exact repository even when it is outside the first page. Once a
-repository and meaningful title are selected,
-the New issue sheet checks for similar open issues in that repository. Candidate links keep
-the draft intact; the first create attempt pauses until the operator reviews them or explicitly
-chooses **Create anyway**. This check is advisory and never blocks offline capture or capture
-when search is unavailable. The sheet can also optionally select an open
+issue-comment API; mobile issue capture requires issue
+creation and assignment permission. The New issue sheet can optionally select an open
 repository milestone and due date; the dashboard validates both and sends them with
 self-assignment in the single create request, so planned work appears in its release
-lane immediately. On a cold offline launch, **Save for filing** stores up to 20
-account-bound title/description captures without selecting a repository or entering the
-mutation outbox. Drafts marks them **Needs filing** and saves locally first. After a fresh
-reconnect confirms the same Gitea login, a bounded, revisioned collection synchronizes the title,
-description, blockers, and ordered screenshot evidence; another signed-in device can then use
-**Choose repository** to continue the normal planning and durable delivery flow. Draft cards report
-whether they are synced or still pending locally. Concurrent changes surface a conflict, and
-successful discard or outbox admission propagates deletion so a stale device cannot resurrect the
-draft. Synchronization is limited to 20 drafts and 12 MiB of decoded evidence per account; failure
-never blocks local capture. A different or unconfirmed account can only copy or discard
-the private content. Issue capture and authored mobile actions (issue
+lane immediately. Issue capture and authored mobile actions (issue
 comments, pull-request comments, notification replies, and reviews) persist per-draft
 idempotency keys, so retrying after a timeout, reload, process restart, or handoff to
-another worker replays a confirmed result instead of posting duplicate content. Mobile Search previews
-let operators assign an eligible issue directly into Later at an exact local return time without filling
-Today or interrupting active work. Cancel and browser Back preserve the Search preview without assigning;
-confirmation claims only when needed, syncs the Later plan across devices, and returns to the preserved
-query, filters, results, and scroll position. If assignment succeeds but Later storage fails, the issue
-remains recoverable in My Work and the dashboard reports the partial outcome instead of claiming success.
-Eligible open issue previews also expose **Plan ahead**: choose one of the next seven local dates, review
-that day's current load and capacity, and enter a required estimate without leaving Search. Existing Week
-Ahead placement is moved only after an explicit day change, never duplicated; full days are blocked and
-over-capacity admission requires a second confirmation. The action claims unassigned work only after these
-checks, stages the canonical issue through the account-bound Week Ahead outbox, and preserves the Search
-preview through cancel or browser Back. Offline saves report **sync pending**; if assignment succeeds but
-local planning fails, the dashboard reports **Assigned, not planned** and leaves the issue recoverable in My Work.
-The live mobile Week Ahead overview also offers **Remove from week** for active planned work. It removes only the
-private planning placement—not assignment, issue state, or Gitea content—and immediately recalculates the day's
-load. A 10-second **Undo** receipt restores the exact day, list position, and estimate. Both transitions use the
-account-bound Week Ahead outbox, remain **sync pending** after delivery failure, and stay unavailable in a read-only
-offline snapshot.
-Search selection mode extends that flow across several open issues with **Plan Week Ahead**. One phone-safe
-review assigns each issue a future day and estimate, validates five-item limits and daily capacity before any
-claim, and requires a second confirmation for overload. Confirmed rows are staged into one canonical Week
-Ahead update and flushed together; partial assignment or offline sync is reported without discarding the
-selection, so claimed work remains recoverable from My Work.
-Commentable mobile Search previews support camera capture and gallery selection for up to five ordered
-photos, including captions, crop/annotation/redaction review, and metadata-stripping re-encoding. Operators
-can queue photo-only, text-only, or mixed replies without leaving their Search pass, including while offline.
-Durable admission account-binds the exact issue/pull kind and stores image bytes in IndexedDB before the UI
-clears or advances. Reconnect revalidates the visible Search target through the narrower preview attachment
-and comment routes instead of assigned-work routes. Existing per-photo upload operation IDs and confirmed
-Markdown checkpoints survive handoff, so retry resumes from the first unfinished photo and the final comment
-posts once. **Send & next** advances only after durable admission; a storage failure keeps the current result,
-text, evidence, and Search position unchanged.
-Named mobile Search views preserve the query, type, status, and optional repository scope. They are
-bounded to 20 per confirmed account and synchronize through a revisioned SQLite collection, so another
-device can reopen the exact Search with one tap while stale writes surface a conflict instead of silently
-overwriting newer views. Rename and delete affect only the saved view, never Gitea work; an unavailable
-sync service leaves ad-hoc Search usable. Set `STACKCHAIN_SAVED_SEARCH_DB` to override the default
-`.stackchain-state/saved-searches.sqlite3` path.
-
-The mobile **Customize routine order** control is also portable across authenticated devices. Reordering
-remains immediate when offline and is marked **Sync pending** until connectivity returns. Rapid taps are
-coalesced into one latest-order write; transient network or server failures retry automatically with bounded
-backoff, and a clean phone refreshes the account order when it returns to the foreground. The complete
-routine order is stored as an encrypted, revisioned collection scoped to the confirmed Gitea login; a
-concurrent edit shows explicit **Keep this device** and **Use other device** actions instead of silently
-losing either order. Account changes discard stale responses and retry work. Resetting publishes the
-canonical default order. Delivery, Human Gates, and active Prepare Today precedence are not customizable.
-Set `STACKCHAIN_QUEUE_PRIORITY_DB` to override the default `.stackchain-state/queue-priority.sqlite3` path.
-
-Mobile **Recent work** is also portable across signed-in devices. Opening an issue, pull request,
-review, Filed item, or update records its canonical detail route locally before navigation and marks
-the entry **Sync pending** until the authenticated API confirms it. Reconnect and foreground checks
-merge the server list without duplicate routes, while each confirmed account remains bounded to its
-five most recent items. A separate **Pin** action keeps up to 20 frequently revisited items above
-Recent work even after that five-item window advances; **Unpin** removes only the pin, and both actions
-apply offline-first before account-scoped synchronization. Open and Pin/Unpin remain separate touch and
-keyboard targets. Titles, repositories, routes, and pins are encrypted at rest with the shared
-private-state key; stale responses from a prior account are discarded. Set
-`STACKCHAIN_RECENT_WORK_DB` to override `.stackchain-state/recent-work.sqlite3`.
-
-Confirmed **Watch issue** and **Watch pull request** actions on open Search results and assigned My Work
-issue/pull-request details feed the mobile **Following** queue, including work already assigned to you or a teammate.
-The detail control loads authoritative Gitea state, remains single-flight while changing it, and refreshes Following only
-after the account-scoped collection confirms the same mutation. This completes the read → watch → revisit flow without
-changing ownership, review assignment, or scheduling work.
-Following is a read-first, account-scoped collection: it is encrypted at rest, revisioned, bounded to
-50 typed items, and synchronized across signed-in devices. Opening a row reuses the correct issue or
-pull-request Search Preview; confirmed **Stop watching** removes an open item. When watched work
-closes or merges, the sequential review exposes **Stop watching & next** so the completed item can be
-retired without leaving the preview; the next captured change opens immediately, and retiring the
-final item completes the Following phase. Changed cards explain whether work closed, reopened, changed title, or
-received other activity. During review, conversation messages newer than the prior reviewed revision are highlighted,
-and the revision is acknowledged only after both detail and conversation context load; a failed conversation load keeps
-that exact change unseen for Retry or **Keep for later & next**. For open work that still needs thought, **Keep for later & next**
-restores only the loaded revision to the unseen queue and continues the captured pass without changing
-Gitea state, ownership, planning, or watch status. Failed or unconfirmed Gitea mutations leave the collection
-and current review position unchanged. Following counts never influence the recommended Work queue. Set
-`STACKCHAIN_FOLLOWING_DB` to override `.stackchain-state/following.sqlite3`.
-
-Each device can explicitly opt in to **Notify me when Following changes**. Stackchain polls that
-channel independently, validates the device session immediately before delivery, and checkpoints
-the exact unseen revision set so unchanged work stays silent across workers. Lock-screen payloads
-contain only a bounded count and the `#/my-work/following` route—never repository names, titles,
-bodies, or comments. Disabling Following alerts leaves Updates, deadlines, and start-day reminders
-unchanged.
-
-Completed delegated issues remain in the mobile **Filed** queue until their latest outcome is acknowledged.
-The mobile queue sheet begins with **Prepare Today**, a live briefing that totals Agenda, Attention, Updates, Filed,
-and unseen Following activity, then opens the highest-priority non-empty review queue. Following refreshes only when
-Prepare Today is opened; selecting that phase starts its changed-first sequential review directly. Starting the pass
-saves a confirmed-account, local-day checkpoint: finishing Agenda, Updates, the final Filed review, or the final
-Following revision returns to a focused handoff using fresh queue counts, while reopening the queue sheet resumes the
-next live phase. **Finish for now** removes only that local
-checkpoint. Once urgent review is clear the pass continues the existing Today plan, or opens Find Work when Today
-is empty; the briefing and checkpoint never change Gitea state.
-Filed separates actionable **Needs review** from a browsable **Reviewed** history, so acknowledgement clears the
-queue without erasing the delegated-work record. Reviewed cards reopen the existing read-only issue detail and
-conversation, while the Filed badge continues to count actionable outcomes only. A later Gitea update moves that
-issue back to Needs review automatically. Acknowledgements synchronize the exact Gitea `updated_at` revision in
-bounded batches to the confirmed account and preserve the same Reviewed state on other signed-in devices. Offline
-or failed synchronization keeps the local acknowledgement and retries on the next healthy dashboard refresh
-without blocking **Acknowledge & next**. Set
-`STACKCHAIN_COMPLETED_FILED_REVIEW_DB` to override the default
-`.stackchain-state/completed-filed-reviews.sqlite3` path.
-Search previews also
-let operators assign an eligible issue and add it to Today without starting or replacing active work.
-The queue action keeps the Search query, filters, results, and scroll position available for continued
-planning, reports an existing Today item without duplicating it, and uses the same capacity, sync, and
-offline-warm path as other Today admission flows. The ordered,
-five-item Today plan syncs across the operator's devices. **Plan Today** also stores available minutes
-and a per-item estimate with the account-scoped plan, continuously showing planned/free or over-capacity
-time. An over-capacity plan requires a second explicit save, legacy plans migrate with unestimated work,
-and an active Today session shows the current estimate plus estimated remaining runway. Adding an issue through **Plan Today**
-first previews its Gitea dependencies: unresolved blockers are listed with links and require the
-explicit **Add blocked item anyway** override, while an unavailable dependency lookup is reported
-as unknown rather than unblocked. Completing any Today item now exposes a 10-second, touch-safe
-**Undo** receipt. Undo restores the item's original order and estimate, queues the inverse cross-device
-plan changes, and leaves the already-advanced work session on its current item; expiry, capacity, or a
-concurrently changed plan is reported without overwriting newer work. Rescheduling Today work into
-Week Ahead uses a bounded account-scoped FIFO on the device: multiple offline moves survive reload,
-deliver oldest-first with stable operation IDs, and rebase each later move on the confirmed plan revisions
-without concurrent requests. Starting a Today work session also
-stores an account-bound checkpoint on the current device and starts an account-bound actual-time timer for the exact item. The sticky mobile session controls show elapsed time beside the estimate and let the operator pause or resume it. An opt-in, privacy-safe lock-screen notification mirrors the current pause/resume control and adds **Finish current**: its opaque one-shot action is bound to the exact active item, reuses **Done & next** or recap, and never changes the underlying Gitea issue or pull request. Switching items preserves each item's elapsed value, while wall-clock checkpoints keep a running timer accurate through app backgrounding, reloads, and installed-app restarts without double counting. Cross-device **Continue here** handoff transfers the bounded per-item timing ledger—not only the active item—so the receiving phone keeps the complete recap and optional time-log durations; legacy single-item sessions migrate automatically. **End session** stops accumulation but retains measured time with the private device data. The recap identifies each item by title and repository, reports per-item estimate variance, and **Save recap & adjust plan** continues into the current ordered Today plan without changing Gitea time entries. Eligible non-zero rows also offer an unchecked **Log Xm to Gitea** control. **Log selected time to Gitea** saves the recap and sends only those corrected durations to each canonical issue or pull request; confirmed account-scoped receipts prevent a completed row from being posted again, while definite failures retain the draft for an explicit retry. If the upstream response is lost after sending, Stackchain marks the row for verification in Gitea instead of risking an automatic duplicate. Actual time appears in planning as an explicit estimate recommendation; it changes only the planning draft until the operator chooses **Save plan** or **Save & start**. After the recap is confirmed, this recommendation handoff remains account-bound on the device through reloads, app restarts, planner cancellation, and failed plan admission. Opening **Plan Today** resumes it without reposting the recap; a successful plan save clears it, while **Discard recap feedback** removes only the handoff and leaves recap history unchanged. The recap and any corrected actual minutes are also saved as an account-bound device draft: an offline save failure can survive a reload and retry with the same idempotent session ID, while another account cannot view it. The draft and timer are cleared only after the account confirms the recap.
-After wrap-up, **Share day summary** opens a private review of the exact worked-on and tomorrow selections. Every row is opt-in adjustable, actual time is excluded by default, and an optional bounded note is previewed before the native share sheet or clipboard fallback. Canceling or closing keeps the account-scoped device draft; successful sharing or **Discard draft** removes it.
-
-A running issue or pull request also exposes **Add update** without advancing Today. The operator can type or dictate a progress note, review and explicitly append, replace, or discard the transcript, add up to five photo-evidence items, then save privately or admit the exact comment to durable delivery. When work is blocked, **Post blocker & move on** requires a future return time, admits the comment before any planning change, defers the item to Later, and continues the existing Today session. An admitted planning transition remains checkpointed for retry, so a storage or Today-removal failure cannot post the blocker twice. Final transcripts—not audio—are bounded to 2,000 characters and isolated by confirmed account and Today item; closing the sheet aborts listening while leaving text and photos usable.
-After a reload or installed-app
-restart, **Resume Today** reopens the saved item (or the next surviving item if work changed). In an open
-assigned issue, the mobile detail sheet renders Markdown checklist items as touch-safe controls and keeps
-**Add step** directly beside the plan. A new step is normalized, checked for duplicates, and appended without
-exposing or replacing the full issue description. Offline additions enter the same account-bound durable
-issue-content queue as checklist toggles; reconnect conflict review applies unique local additions to the
-latest remote body while preserving remote prose and task-state changes.
-**Comment & next** on that current issue or pull request posts the handoff online or admits it
-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. During an online Updates pass,
-Stackchain preloads at most the next surviving conversation from the fixed snapshot while the
-current one is being read. Advancing consumes that account-bound result without another detail
-request; failures fall back to the normal foreground retry path, and offline triage never speculates.
-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
-responses from replacing a newer plan; same-account browser tabs exchange fresh snapshots,
-and reconnecting or returning to the dashboard refreshes server truth after replaying queued
-offline operations. **Plan Tomorrow** remains independent from active Today work and durably admits the exact
-ordered plan, capacity, estimates, next local date, timezone, and server revision to account-bound browser
-storage before closing on a phone. The Queues summary marks it **sync pending** while offline; reconnect,
-foreground, and midnight lifecycle checks share one delivery flight. A successful account receipt removes
-the pending copy, while a revision conflict preserves both the phone plan and fresh server snapshot for
-review. Unsynced Tomorrow work is never promoted into Today.
-**Week Ahead** opens as a read-first seven-day mobile overview, so operators can inspect the next planned day,
-work titles and references, load versus capacity, overloads, and pending sync without staging a change. When Today
-is empty and no work session is active, **Start this day early** confirms the next planned date, item count, minutes,
-and capacity before atomically moving only that day into Today; offline, pending, stale, or non-empty plans remain
-unchanged. **Edit day** enters one date and returns to the refreshed overview; **Edit week** starts the continuous
-planning pass. Closing an issue from its Week Ahead detail retires that identity and estimate from every future
-week day in one durable update while preserving sibling order and daily capacity. The open overview recalculates
-immediately; an unavailable save remains visibly **sync pending** and retries through the existing lifecycle.
-**Plan Week Ahead** continues through seven local dates and now finishes on a mobile review step instead of
-closing after the seventh save. The review shows planned minutes against each day’s capacity, marks overloads,
-and flags work assigned to more than one date. Operators can move an item to another date without copying it;
-the estimate follows the item and the server rejects duplicate cross-day assignments without advancing the
-week revision. When capacity changes create overload, **Reflow remaining week** previews a deterministic,
-order-preserving redistribution across the seven visible dates. No day exceeds its capacity or five-item limit;
-work that cannot fit is named and remains in My Work, while missing estimates block apply. Cancel performs no
-write, and apply stages one durable whole-week transition through the existing conflict-safe sync path.
-Confirmation remains disabled while duplicates exist or the account-bound week is still syncing.
-Rapid saves and review moves use one network flight plus a coalesced latest-state delivery, so later staged days
-are not stranded behind an earlier request. From the same review, **Refresh from calendar** reads a local
-`.ics` file on-device, unions overlapping busy periods within chosen working hours, and compares every current
-capacity with refreshed availability and planned load. If refreshed availability creates an overload, the review
-previews the deterministic destination of moved work and reports anything that cannot fit. One explicit
-**Apply capacities & reflow** action stages the complete seven-day plan once—there is no transient overloaded
-save—and preserves consented free windows alongside the redistributed work. A refresh that already fits keeps
-the direct one-write capacity path. IANA `TZID` values from Google and Outlook calendars are converted
-to the device's local workday, including daylight-saving transitions. Daily and weekly recurrence (`COUNT`,
-`UNTIL`, `INTERVAL`, and weekly `BYDAY`), `RDATE`/`EXDATE`, and all-day events are evaluated with work bounded
-to the seven review dates; cancelled and transparent events do not consume capacity. If a time zone is unknown,
-or a recurring event that could affect the week uses another frequency or unsupported rule part, the review
-reports only an affected-event count and disables apply rather than understating busy time. Export a simpler
-seven-day calendar to proceed. Raw calendar data and event
-metadata are never persisted, rendered in diagnostics, or sent; only the reviewed capacity-minute totals use
-the existing encrypted, account-bound Week Ahead sync.
-Planning edits can remain offline for up to 30 days. After that, the
-expired edit is discarded visibly and the account plan is kept rather than replaying stale
-intent. The server retains no more than 4,096 operation receipts per account and removes
-receipts older than the same 30-day window; client base revisions keep a pruned replay from
-changing a newer Today or Later plan. After a healthy, fully paginated
-My Work refresh proves that an item is complete or otherwise no longer eligible, Stackchain
-queues an idempotent retirement before removing it locally; partial and degraded refreshes
-leave the plan unchanged, and offline retirements replay after reconnect. When
-**Keep My Work available offline** is enabled, every issue or pull request in the bounded
-Today queue is warmed automatically after a healthy authenticated refresh and as soon as
-it is added. The readiness indicator reports saved, pending, and retryable items; unchanged
-`updated_at` revisions make no detail request, transient failures retain the prior copy,
-and pull-request diffs remain online-only. Saved unread-update conversations remain
-triageable offline: **Queue read & next** writes an account-bound, notification-ID-
-deduplicated acknowledgement to the durable background delivery system, removes the
-update from the local queue immediately, and opens the next saved conversation. A cold
-offline reload suppresses acknowledgements still waiting to sync; reconnect uses the
-authenticated notification-read endpoint and keeps transient failures queued. Every foreground
-same-origin dashboard API request also has a 15-second browser deadline, including fresh-
-authorization and step-up retries. Read timeouts settle with retry guidance even if the browser's
-fetch ignores abort; mutation timeouts instead tell the operator to refresh and verify the server
-outcome before retrying. Caller cancellation still takes precedence, and cross-origin fetches are
-not changed by this session boundary. Installed-app
-navigations are also deadline-bounded: after four seconds without a network response,
-Stackchain aborts the request and opens the cached dashboard shell. If the shell has not
-been installed yet, it returns explicit HTTP 504 reconnect guidance instead of hanging.
-Live dashboard refreshes use the server's per-section freshness windows: healthy sections
-refresh at their earliest deadline while a fully degraded snapshot waits for its reported
-cooldown. HTTP `Retry-After` delays are honored up to five minutes, and transport failures
-back off from eight seconds to a one-minute cap. Reconnect, foreground return, and explicit
-refresh still run immediately; a successful response resets transport backoff.
-Closed-app
-delivery requests are deadline-bounded: a stalled identity, CSRF, or mutation request is
-aborted after 15 seconds, its durable claim returns to the queue, and the next sync retries
-with the unchanged idempotency key. Each finite, lane-fair drain admits at most 70 records
-and runs up to three deliveries concurrently, but claims a record only when a delivery slot
-is ready. Claims have unique fencing tokens and are renewed before every network stage;
-completion, release, failure, and delivery checkpoints are token-fenced so an expired worker
-cannot alter a newer crash-recovery claim. Device purge cancels an active drain before closing
-private outbox storage. Results are coordinated through a bounded SQLite ledger. All private SQLite stores enforce a
-filesystem boundary independently of the service umask: the database directory is repaired to
-owner-only `0700`, database and SQLite sidecar files are owner-only `0600`, and symlinked database
-paths are rejected before access. Worker-shared live and Find Work snapshots add AES-256-GCM
-envelopes authenticated to their store identity (and live generation), so copied databases do not
-expose issue bodies, titles, notification metadata, or repository context. The authored-action
-idempotency ledger encrypts both request fingerprints and confirmed upstream responses, authenticating
-each envelope to its operation key and field purpose so rows and fields cannot be substituted.
-Existing plaintext snapshot and ledger rows migrate atomically on their first read without changing
-freshness, revisions, ordering, replay, or conflict semantics. Synchronized unfiled Draft collections
-use a separate AES-256-GCM key and authenticate the account and revision; existing plaintext rows
-likewise migrate on first read. Synchronized Saved Search collections, mobile Recent work, and completed Filed review
-receipts use the private-state key and authenticate each envelope to its normalized account, preventing
-rows from being substituted between operators. Existing plaintext Saved Searches migrate atomically on
-first read without advancing their revision; existing completed Filed receipts migrate transactionally at
-startup without changing order or acknowledgement state. Missing, wrong, or modified key material
-returns no saved-view or receipt content. Other private stores
-are not encrypted at the application layer. Web
-Push subscriptions use a third, independent
-AES-256-GCM key authenticated to the device session, with keyed endpoint indexes preserving
-single-device enrollment without retaining capability URLs. Existing plaintext subscriptions
-migrate atomically at startup without resetting delivery checkpoints or reminder schedules. Secure
-host access, encrypted volumes, and private backups are still required.
-Set `STACKCHAIN_STATE_DIR` to a
+another worker replays a confirmed result instead of posting duplicate content. Results
+are coordinated through a bounded SQLite ledger. Set `STACKCHAIN_STATE_DIR` to a
 persistent, writable service directory (or set `STACKCHAIN_IDEMPOTENCY_DB` to an explicit
 SQLite path); the local default is `.stackchain-state/idempotency.sqlite3`. Ledger reads and
 writes run outside the request event loop, and lock admission is bounded to 100 ms by
 default. Tune it with `STACKCHAIN_IDEMPOTENCY_LOCK_TIMEOUT_SECONDS`; keep the value below
-route deadlines. During a controlled shutdown, the server gives in-flight authored mutations
-five seconds to finish and persist their ledger result before it closes the Gitea transport.
-Set `STACKCHAIN_AUTHORED_ACTION_SHUTDOWN_GRACE_SECONDS` to match the service manager's
-shutdown budget; when that deadline expires, remaining operations are cancelled and their
-pending reservations continue to fail closed rather than being retried automatically.
-Reservation contention returns retryable HTTP 503 with `Retry-After: 1`.
+route deadlines. Reservation contention returns retryable HTTP 503 with `Retry-After: 1`.
 If contention occurs after the upstream mutation, the dashboard fails closed with
 `Retry-After: 5` and asks the caller to verify the result before retrying. Direct API callers
 should preserve the `Idempotency-Key` header with the unchanged route and payload until a
@@ -352,12 +42,7 @@ Approve, and Request changes reviews, and assigned-PR merge require repository
 write permission. Native Comment, Approve, and Request changes reviews support
 head-scoped draft comments anchored to changed lines; the dashboard validates each
 comment path and submits the summary, decision, and inline comments in one review
-request. On phone-width review sheets, changed lines wrap inside a stable old/new
-line-number gutter by default so long source lines remain readable and commentable
-without horizontal panning. **Lines wrapped** toggles back to whitespace-preserving
-horizontal inspection, and an explicit choice persists on the device across files,
-review-sheet reopen, and reload. Desktop review diffs remain horizontally scrollable
-until wrapping is explicitly enabled. The dashboard rechecks the current pull-request head, CI success, draft
+request. The dashboard rechecks the current pull-request head, CI success, draft
 state, and mergeability immediately before every merge.
 Serve the dashboard only to trusted users on its own origin; cross-origin API
 access is intentionally disabled. Authentication defaults to fail-closed
@@ -374,241 +59,40 @@ export GITEA_TOKEN='<read-notification-and-issue-write-token>'
 export STACKCHAIN_DASHBOARD_AUTH_MODE='operator'
 export STACKCHAIN_DASHBOARD_ACCESS_TOKEN='<operator-sign-in-secret>'
 export STACKCHAIN_DASHBOARD_SESSION_SECRET='<independent-cookie-signing-secret>'
-export STACKCHAIN_DASHBOARD_PUBLIC_ORIGIN='https://forge.example.com'
 # Optional; defaults to STACKCHAIN_STATE_DIR/sessions.sqlite3.
 export STACKCHAIN_SESSION_DB='/var/lib/stackchain-dashboard/sessions.sqlite3'
-# Optional; defaults to STACKCHAIN_STATE_DIR/security-events.sqlite3.
-export STACKCHAIN_SECURITY_EVENT_DB='/var/lib/stackchain-dashboard/security-events.sqlite3'
-# Optional compatibility overrides; defaults derive from the required public origin.
-export STACKCHAIN_PASSKEY_RP_ID='forge.example.com'
-export STACKCHAIN_PASSKEY_ORIGIN='https://forge.example.com'
 # Optional; defaults to eight hours.
 export STACKCHAIN_DASHBOARD_SESSION_TTL_SECONDS=28800
-# Optional; explicit pointer, keyboard, or touch activity renews this idle window.
-# Background polling and queued delivery do not. Defaults to 15 minutes.
-export STACKCHAIN_DASHBOARD_IDLE_TIMEOUT_SECONDS=900
 # Optional sign-in throttle: five failures per five minutes, up to 10,000 sources.
 export STACKCHAIN_LOGIN_MAX_FAILURES=5
 export STACKCHAIN_LOGIN_WINDOW_SECONDS=300
 export STACKCHAIN_LOGIN_MAX_ENTRIES=10000
-# Public passkey ceremonies share the same window and durable source ledger.
-export STACKCHAIN_PASSKEY_OPTIONS_MAX_ATTEMPTS=10
-# Bound live one-time challenges even if anonymous clients rotate addresses.
-export STACKCHAIN_PASSKEY_MAX_CHALLENGES_PER_SOURCE=10
-export STACKCHAIN_PASSKEY_MAX_CHALLENGES=10000
 # Optional; defaults to STACKCHAIN_STATE_DIR/login-attempts.sqlite3.
 export STACKCHAIN_LOGIN_ATTEMPT_DB='/var/lib/stackchain-dashboard/login-attempts.sqlite3'
-# Required for worker-shared live/Find Work snapshots, synchronized Today/Later
-# planning, Saved Search state, completed Filed review receipts, and the Security activity journal. Keep this key independent
-# from the Draft key and inject the
-# base64 encoding of exactly 32 random bytes from a secret manager. Never commit
-# it. Missing, malformed, wrong-key, or modified state fails closed without
-# returning content. Legacy Today/Later, Saved Search, and Security activity rows
-# migrate atomically on first use without changing logical revisions or journal IDs.
-# The single-key setting remains the compatible first deployment and writes v1 envelopes.
-export STACKCHAIN_PRIVATE_STATE_ENCRYPTION_KEY='<base64-encoded-32-byte-key>'
-# After all workers run keyring-capable code, configure at most four named keys and
-# select the active write key. Keep the old key present during the rolling deployment.
-# Key IDs use 1-32 letters, digits, underscores, or hyphens.
-export STACKCHAIN_PRIVATE_STATE_ENCRYPTION_KEYS='{"legacy":"<old-base64-key>","2026-08":"<new-base64-key>"}'
-export STACKCHAIN_PRIVATE_STATE_ACTIVE_KEY_ID='2026-08'
-# New writes use authenticated v2 envelopes carrying the active key ID. Rewrap every
-# shared store with the restart-safe command; output contains store-level counts only.
-# Run it again until every store reports failed=0, migrated=0, and current=total,
-# then remove the old key from every worker. Retain all keys and investigate if it exits 1.
-python3 scripts/rotate_private_state.py
-# Required for cross-device unfiled Draft sync. The single-key setting remains
-# supported for the first deployment of keyring-capable code and writes v1 envelopes.
-# Inject the base64 encoding of exactly 32 random bytes from a secret manager.
-export STACKCHAIN_UNFILED_DRAFT_ENCRYPTION_KEY='<base64-encoded-32-byte-key>'
-# After every worker runs keyring-capable code, replace the single-key setting with
-# a bounded JSON object (at most eight keys) and name one active write key. During
-# the first rotation, preserve the original single key under the reserved `legacy`
-# ID so existing v1 envelopes remain readable. Key IDs use 1-32 letters, digits,
-# underscores, or hyphens. Never commit either setting.
-export STACKCHAIN_UNFILED_DRAFT_ENCRYPTION_KEYS='{"legacy":"<old-base64-key>","2026-08":"<new-base64-key>"}'
-export STACKCHAIN_UNFILED_DRAFT_ACTIVE_KEY_ID='2026-08'
-# New writes use authenticated v2 envelopes carrying the active key ID. Reads
-# atomically rewrap plaintext, v1, and inactive-key rows without advancing their
-# logical revision. Run the content-free, restart-safe migration until it exits 0:
-python3 scripts/rotate_unfiled_drafts.py
-# A result such as {"current":42,"failed":0,"migrated":0,"total":42} proves the
-# old key has no remaining row dependencies. Only then remove `legacy`/old keys and
-# restart. A nonzero exit reports unreadable row counts but never account or Draft
-# content. Roll back only to a keyring-capable build and retain every configured key.
 # Trust forwarding headers only from these immediate reverse-proxy networks.
 export STACKCHAIN_TRUSTED_PROXY_CIDRS='127.0.0.0/8'
-# Optional Web Push. Generate a VAPID key pair outside the repo and inject it.
-# The feature stays disabled unless all three values are present. Privacy-safe update
-# alerts offer Mark read and Tomorrow; Tomorrow syncs the unread item to Later at
-# 09:00 in the device's local timezone without opening the dashboard. Bursts send
-# three individual alerts followed by one private digest that opens Updates. A later
-# comment on an already-delivered thread triggers a fresh alert when Gitea advances
-# that thread's updated_at revision; unchanged and older snapshots remain silent. Opt-in
-# Following alerts use generic copy and deep-link to the changed-first Following review.
-# Browser push services must resolve exclusively to public IP addresses. Stackchain
-# validates endpoints at enrollment and again before delivery, rejects redirects,
-# and removes legacy subscriptions that resolve to private or reserved networks.
-export STACKCHAIN_VAPID_PUBLIC_KEY='<url-safe-public-key>'
-export STACKCHAIN_VAPID_PRIVATE_KEY='<private-key-from-secret-manager>'
-export STACKCHAIN_VAPID_SUBJECT='mailto:ops@example.com'
-# Required whenever all three VAPID settings enable Web Push. Keep this key
-# independent from the snapshot and Draft keys. Startup authenticates every retained
-# subscription and fails closed for a missing, malformed, wrong, or modified key.
-# Back up the key separately: losing it makes existing device enrollments unrecoverable.
-export STACKCHAIN_PUSH_STATE_ENCRYPTION_KEY='<base64-encoded-32-byte-key>'
-# Optional; defaults to a 30-second poll, 10-second endpoint deadline,
-# 8 concurrently dispatched devices, 60-second renewable cross-worker lease,
-# and STACKCHAIN_STATE_DIR/push-subscriptions.sqlite3. Threads stay ordered
-# within each device; one slow device does not delay healthy devices behind it.
-export STACKCHAIN_PUSH_POLL_SECONDS=30
-# Unread updates and deadline reminders run on independent, fixed-cadence
-# workers, so a slow channel cannot delay the other or add drift to its ticks.
-# On each phone, Device Setup can enable deadline reminders and choose any local
-# reminder hour from 00:00 through 23:00; the server-confirmed choice is restored.
-export STACKCHAIN_PUSH_SEND_TIMEOUT_SECONDS=10
-export STACKCHAIN_PUSH_MAX_CONCURRENCY=8
-# Maximum individual alerts per device and poll before one digest covers the rest.
-export STACKCHAIN_PUSH_MAX_INDIVIDUAL_NOTIFICATIONS=3
-export STACKCHAIN_PUSH_LEASE_SECONDS=60
-export STACKCHAIN_PUSH_DB='/var/lib/stackchain-dashboard/push-subscriptions.sqlite3'
 uvicorn src.main:app --host 127.0.0.1 --port 8000
 ```
 
-`GITEA_URL` is also the trust boundary for every Gitea resource link returned
-to the browser. Configure the externally reachable scheme, host, and subpath
-(for example `https://forge.example.com/git`); cross-origin, downgraded, and
-same-host links outside that subpath are discarded.
-
-For a systemd deployment, keep those values in a root-readable environment file
-(`chmod 600`), reference it with `EnvironmentFile=`, and keep secrets out of the unit
-command line and repository. Liveness alone does not prove that operators can use the
-service: `/healthz` intentionally remains healthy when authentication is missing. After
-each restart or proxy change, run the complete public-subpath smoke journey with the
-operator secret supplied only through the process environment:
-
-```bash
-STACKCHAIN_DASHBOARD_ACCESS_TOKEN='<operator-sign-in-secret>' \
-  python3 scripts/verify_deployment.py \
-  https://forge.example.com/dashboard/
-```
-
-The verifier requires readiness, rendered sign-in, a manifest whose `scope` and
-`start_url` remain inside the supplied subpath, and an authenticated mobile Home with
-its New-issue entry. It emits only a small JSON result and never includes the operator
-secret in success or failure output.
-
-Token and passkey sign-in failures are scoped to a hashed canonical client address and
-persisted across workers and restarts. Public passkey option issuance has a separate
-fixed-window admission budget in the same ledger, and live challenges are bounded per
-source and globally in the session registry. Once either sign-in budget is exhausted,
-the server returns `429` with `Retry-After`; a successful sign-in clears that source's
-failure state. Expired source records and challenges are pruned, and both ledgers are
-size-bounded. Keep their SQLite files on shared writable storage. `X-Forwarded-For` is
-ignored unless the immediate peer is inside `STACKCHAIN_TRUSTED_PROXY_CIDRS`; list only
-networks you operate. Without that setting, a reverse proxy is safely treated as one
-shared source.
-
-Inbound API mutations are admitted through a body-size boundary before FastAPI
-parses JSON: sign-in is capped at 16 KiB and other `POST`, `PUT`, and `PATCH`
-requests under `/api/v1/` are capped at 64 KiB. Both declared and streamed bodies
-are counted. Oversized requests receive a compact, non-cacheable HTTP 413 response;
-validation errors expose field locations and messages but never echo submitted
-values or validation context. Preserve these limits at the reverse proxy or enforce
-equal or tighter upstream limits.
+Sign-in failures are scoped to a hashed canonical client address and persisted across
+workers and restarts. Once the budget is exhausted, the server returns `429` with
+`Retry-After`; the mobile login form disables retries for that interval. Expired
+source records are pruned and the ledger is size-bounded. Keep its SQLite file on
+shared writable storage. `X-Forwarded-For` is ignored unless the immediate peer is
+inside `STACKCHAIN_TRUSTED_PROXY_CIDRS`; list only networks you operate. Without
+that setting, a reverse proxy is safely treated as one shared source.
 
 Each signed cookie includes an opaque session identifier whose hash and expiry are
 kept in the SQLite session registry. Keep that registry on persistent, writable
-storage shared by all dashboard workers. Operators name a device at sign-in and can
-open **Active devices** to review creation/expiry times, identify the current device,
-and revoke one remote session without interrupting other trusted devices. The API
-exposes only independent management IDs and bounded labels—never cookie values,
-session hashes, CSRF proofs, or source addresses. The registry also stores each
-session's last explicit activity. Existing two-column registries are migrated in
-place, their live sessions remain valid, and their idle clock starts at migration.
-
-The same sheet includes **Security activity**, a reverse-chronological journal of
-successful token/passkey sign-ins, passkey enrollments, sign-outs, remote device
-revocations, issue closures, and pull-request merges. The separate SQLite journal
-retains at most 10,000 events for 90 days. Its bounded event kind, authentication
-method, device label, and action target are sealed at rest with the private-state
-encryption key and authenticated against the immutable event ID. Legacy plaintext
-journals migrate atomically without changing IDs, timestamps, order, or pending
-operations. Missing or wrong key material and modified ciphertext fail closed with
-no partial activity response. The journal never stores access tokens, cookies,
-session/CSRF values,
-credential IDs, public keys, challenges, attestation data, raw network addresses,
-request bodies, or comment content. Keep its database on the same class of persistent,
-writable storage as the session registry. Before passkey credential creation, session
-revocation, or issue closure, the journal durably reserves a pending event; if that
-reservation fails, the consequential action does not begin. A successful action
-remains truthfully reported even if its event cannot immediately be finalized, and
-the activity sheet marks that durable record as **Outcome confirmation pending**.
-
-After token bootstrap, **Active devices → Add a passkey for this device** enrolls a
-WebAuthn credential with required user verification. That device can then sign in
-and authorize high-impact actions with its biometric/PIN gesture. The access token
-remains the recovery fallback for browsers without WebAuthn or devices without an
-enrolled credential. Registration and authentication challenges are exact-purpose,
-single-use, and short-lived. **Enrolled passkeys** lists every durable credential,
-including those whose original session has expired or signed out, using only its
-bounded label, enrollment time, and active/current status. Removing one requires a
-single-use fresh authorization bound to that exact management ID. A remote active
-session linked to the credential is revoked atomically; unrelated credentials and
-sessions remain valid. Removing the current device's passkey keeps its current
-session active, so the sheet warns that the recovery token will be required after
-sign-out. Remotely revoking an enrolled device also deletes its passkey; signing out
-normally keeps the passkey available for the next sign-in. Passkey assertion counters
-advance with an atomic compare-and-swap across workers: stale or equal nonzero counters
-fail before a session or authorization grant is issued, while counterless authenticators
-remain compatible. The bounded **Passkey counter anomaly** Security activity entry names
-only the device label and attempted action; repeated alerts should prompt removal and
-re-enrollment of that passkey.
-
-High-impact actions—merging a pull request, closing an assigned issue, permanently
-deleting an authored comment, revoking a remote device, or signing out every device—
-require a passkey assertion or the
-operator access token again.
-The server issues a random 90-second grant bound to the active session, exact action,
-and exact target. Only its digest is stored, and the grant is consumed atomically on
-first use. Expired, replayed, cross-session, and target-substituted grants fail before
-Gitea or session state is changed. The browser preserves the pending request and
-retries it once after the built-in mobile/keyboard-accessible authorization prompt.
-
-After 15 minutes without pointer, keyboard, or touch activity (configurable through
-`STACKCHAIN_DASHBOARD_IDLE_TIMEOUT_SECONDS`), the server rejects the session even if
-polling or background delivery continued. The dashboard locks and background outbox
-delivery pauses, but drafts, Today/Later state, queued mutations, and caches remain on
-the device; signing in resumes the existing account-bound work. If an active session
-expires, the first authenticated API rejection replaces the
-dashboard with sign-in and explains that private drafts remain on the device; signing
-in again resumes account-bound queued delivery. Expiry recovery does not clear offline
-state. A selectively or globally revoked device instead receives a bounded revocation
-reason: on its next server contact, Stackchain clears its owned local/session storage,
-private outbox database, and dashboard caches before enabling sign-in. Revocation
-blocks server access immediately, but no web application can erase a device that
-remains offline forever. **Sign out & clear this device** revokes only the current
-session before clearing browser state, so a copied cookie cannot be replayed
-afterward; other signed-in devices remain active. **Sign out all devices** is a
-separately confirmed lost-device safety action that atomically revokes every existing
-operator session before clearing the current browser and returning to sign-in.
-Registry read or write failures return a sanitized HTTP 503 before Gitea is contacted.
+storage shared by all dashboard workers. Sign-out revokes only the current session
+before clearing browser state, so a copied cookie cannot be replayed afterward;
+other signed-in devices remain active. Deploying this version invalidates older
+cookies that do not contain a registered identifier, so operators must sign in once
+again. Registry read or write failures return a sanitized HTTP 503 before Gitea is
+contacted.
 
 Terminate TLS at the trusted reverse proxy: session cookies are deliberately
 `Secure`, `HttpOnly`, `SameSite=Strict`, and scoped to the deployment subpath.
-Every response also defines the browser execution boundary with a Content Security
-Policy that allows scripts only from the dashboard origin, denies framing and
-plugins, and blocks unused browser capabilities. Keep these response headers when
-proxying; do not add inline scripts or broaden `script-src`. The dashboard bootstrap
-is assembled in source order into one content-addressed JavaScript response. Dashboard
-HTML and the offline worker reference that exact fingerprint, while the runtime receives
-immutable caching and HTML/worker responses remain revalidated. The stylesheet and
-fingerprinted runtime are same-origin assets included atomically in the offline PWA shell.
-Device Setup also checks whether the browser has granted persistent storage without prompting.
-Choose **Protect offline work** to request protection from automatic storage-pressure eviction;
-Stackchain reports **Protected**, **Best effort**, **Denied**, or an unavailable/retryable state
-truthfully. Offline work continues when protection is unavailable or denied, but the browser may
-remove best-effort data, so persistence does not replace backups or device security.
 Use **Sign out & clear this device** on shared devices; it clears Stackchain's
 offline snapshots, drafts, outboxes, background IndexedDB, and PWA caches without
 removing unrelated forge preferences. Rotate either dashboard secret by replacing
@@ -626,14 +110,12 @@ successful response is JSON containing
 to search commands plus issues and pull requests across every repository visible to
 the configured Gitea token. Remote search starts after two characters, is debounced,
 and keeps local commands usable if Gitea search is unavailable. Selecting a remote
-result opens a mobile-safe preview without discarding the search query. Open
-unassigned issues can be claimed in place and handed into My Work after Gitea
-confirms the assignment. A closed issue can be reopened, self-assigned, added to
-Today, and resumed through the same capacity-guarded flow; pull requests remain
-read-only with a safe canonical Gitea link. The bounded APIs are available at
-`GET /api/v1/search?q=<query>&limit=<1-25>`,
-`GET /api/v1/repos/<owner>/<repo>/issues/<number>/preview?kind=issue|pull`, and
-`PATCH /api/v1/repos/<owner>/<repo>/issues/<number>/reopen`. Never commit the token
+result opens a mobile-safe, read-only preview without discarding the search query;
+open unassigned issues can be claimed in place and handed into My Work after Gitea
+confirms the assignment. Closed work and pull requests remain read-only with a safe
+canonical Gitea link. The bounded APIs are available at
+`GET /api/v1/search?q=<query>&limit=<1-25>` and
+`GET /api/v1/repos/<owner>/<repo>/issues/<number>/preview?kind=issue|pull`. Never commit the token
 or place it in a tracked configuration file.
 
 For service monitoring, GET `/healthz` is a liveness check that confirms the
@@ -651,36 +133,6 @@ other writes. Requests that cannot enter within 250 ms fail as retryable HTTP
 below the route deadlines. Streaming diff reads share the same read capacity,
 while POST, PATCH, PUT, and DELETE requests are never coalesced.
 
-Live snapshots expose independent `context`, `events`, and `notifications`
-revision tokens. Snapshot content, freshness/backoff metadata, and revisions are published
-atomically through a private SQLite store shared by all application workers. An expiring
-refresh lease ensures only one worker loads currently due sections; other workers serve the
-same stale snapshot while that refresh runs, and can recover an abandoned lease after expiry.
-Set `STACKCHAIN_LIVE_SNAPSHOT_DB` to override the default
-`STACKCHAIN_STATE_DIR/live-snapshot.sqlite3`; keep the containing directory on private,
-worker-shared writable storage. The database and directory are restricted to the service
-account and never contain the Gitea token. Find Work uses the same worker-shared pattern:
-`STACKCHAIN_AVAILABLE_ISSUE_SNAPSHOT_DB` overrides
-`STACKCHAIN_STATE_DIR/available-issue-snapshot.sqlite3`. One expiring lease bounds each
-catalog scan across the deployment, shared retry metadata prevents worker-by-worker retry
-bursts, and confirmed claims are removed from every worker's retained catalog. On a cold
-catalog, non-owner workers wait within the bounded foreground deadline for the lease owner
-to publish; if that owner releases or abandons the lease, a waiter can take over the scan
-within its remaining request budget. Releasing
-an assignment invalidates the shared catalog so the newly available issue can be discovered
-by the next authoritative scan. Each bounded opaque revision token includes the
-store generation, so a token from a different deployment or before replacement of the store
-cannot suppress different content. The browser sends its known tokens on later polls, so
-`/api/v1/live` can omit unchanged section bodies while still returning current freshness and
-retry metadata. The client retains omitted data and only rebuilds or persists the sections
-that changed. Malformed or oversized tokens are rejected before any upstream work.
-Confirmed notification acknowledgements update this worker's live view immediately, then
-maintain the shared snapshot outside the async request loop. Bulk acknowledgements remove
-all successful notification IDs in one SQLite transaction and advance the notification
-revision once. If shared-store lock admission fails after Gitea confirms the mutation, the
-API keeps the confirmed result and process-local filtering rather than falsely reporting the
-upstream write as failed; a later shared refresh reconciles the cache.
-
 ## Offline mobile shell
 
 At phone widths, a persistent bottom task dock keeps **Work**, **Find**, **New**,
@@ -689,31 +141,13 @@ filter, preserves the selected release lane, shows the current draft count, resp
 the device safe area, and moves out of the way while a full-screen task is open.
 Desktop layout is unchanged.
 
-Mobile **Search** provides touch-sized **Repository**, **Type**, and **Status** controls.
-Operators can find and select a repository visible to their Gitea account, then scope results
-to that exact repository, issues, pull requests, open work, closed work, or all accessible work;
-the server applies every scope before pagination. Clearing Repository returns to organization-wide
-Search. The selected scope is bounded and addressable, survives preview/back, reload, sharing,
-and sign-in continuation, and a scope change cancels obsolete requests before restarting at the
-first page. Repository lookup failure leaves organization-wide Search usable.
-
-My Work also has an account-synced **Later** queue. **Later today** defers an item for four
-hours, while **Tomorrow** returns it at 09:00 in the device's local timezone. **Choose date & time**
-accepts a valid future local date and time and returns the item at that exact instant; the picker
-shows the device timezone and rejects empty, normalized, invalid, or past values before saving.
+My Work also has a local **Later** queue. **Later today** defers an item for four
+hours, while **Tomorrow** returns it at 09:00 in the device's local timezone.
 Deferred items leave normal and Attention queues without marking notifications read
 or changing any Gitea issue or pull request. They automatically return to their
-existing priority position at the wake time. **Start now** atomically admits a deferred
-item to Today, removes its Later record, and opens that exact item in a resumable Today
-session; full or unavailable Today storage leaves the deferral intact for retry. Items
-already in Today are opened without duplication. **Bring back now** still restores an
-item early without starting it. Later wake times are scoped to the confirmed Gitea login and synchronize
-across signed-in tabs and devices. Offline changes apply immediately, survive reload,
-and replay after reconnect. Each queued edit carries the account revision it was based
-on; if another device has since changed the same item, Stackchain keeps the newer
-account plan and reports the conflict instead of silently overwriting it. Unrelated
-items continue syncing in the same batch. `STACKCHAIN_LATER_DB` can override the
-default durable store at `.stackchain-state/later.sqlite3`.
+existing priority position at the wake time, and **Bring back now** restores them
+early. Later state is stored only in this browser, scoped to the confirmed Gitea
+login, and removed when fully loaded work confirms that an item no longer exists.
 
 After one successful online load, the installed dashboard precaches a versioned,
 subpath-scoped application shell. During a network outage or a dashboard HTTP
@@ -726,40 +160,18 @@ dashboard keeps polling until it can restore its live snapshot automatically.
 Users can explicitly enable **Keep My Work available offline**. Each healthy live
 refresh then stores a seven-day, versioned snapshot containing only the signed-in
 user identity and queue-card metadata for issues, pull requests, unread updates,
-and pagination totals. For each opened Today issue or pull request, Stackchain additionally retains an allowlisted detail record with its body and
-newest 20 comments. Requested-review records also retain the head SHA, CI state,
-newest 20 prior reviews, and at most 50 sanitized file previews with 400 diff lines
-per file. A previously opened unread update is retained by notification
-identity with allowlisted subject context and its newest 20 conversation messages.
-The snapshot and each account-bound detail are committed as separate IndexedDB records,
-so large review previews do not consume the small synchronous localStorage quota or require
-rewriting the whole cache. Only the opt-in preference remains in localStorage. Existing v1
-localStorage payloads migrate after a successful IndexedDB commit. The detail cache remains
-limited to ten records across all detail kinds; credentials, repository catalogs, events, raw
-patches, and complete API responses are excluded.
-A cold offline launch labels the saved time. Cached Today details open in the existing
-phone sheet, where comments can enter the account-bound durable outbox. For issue and
-non-review pull details, planning, assignment, review, merge, and close controls remain disabled
-until reconnection. Cached requested reviews open in the existing review sheet so file progress, notes,
-summary, decision, and inline-comment drafts remain usable under the saved head SHA.
-**Queue review for reconnect** durably stores that complete SHA-bound review with one
-idempotency key. Reconnect or Background Sync submits it exactly once; transient failures
-retain the queue entry, while stale-head and invalid-inline-comment responses move it to
-Drafts as **Needs attention** without deleting feedback. Confirmed delivery removes the
-queued operation and its matching SHA-scoped draft and progress.
-Cached unread updates use the same phone conversation sheet and replies enter the
-account-bound durable outbox, while mark read, ownership, deferral, and older-message loading remain disabled until reconnection.
-Cards without a saved detail explain that reconnection is required. **Clear offline
-work data**, opt-out, sign-out, remote revocation, and absolute session expiry delete the
-IndexedDB records; seven-day expiry removes stale records automatically.
+and pagination totals. Bodies, comments, diffs, credentials, repository catalogs,
+events, and complete API responses are excluded. A cold offline launch labels the
+saved time and renders this snapshot read-only; opening live details, pagination,
+and server mutations remain disabled until reconnection. **Clear offline work
+data** deletes the snapshot, and opting out deletes it automatically.
 
 API responses and mutations are never cached by the service worker. New issue captures,
 issue comments, pull-request comments, and unread-update replies use bounded local
 outboxes when connectivity or a retryable server failure prevents delivery. Issue
 captures and authored messages are also mirrored into account-bound IndexedDB lanes
 and registered with Background Sync, so a supporting installed browser can deliver
-new issues, issue comments, pull-request comments, unread-update replies, and completed
-pull-request reviews after
+new issues, issue comments, pull-request comments, and unread-update replies after
 every dashboard client has closed. The worker verifies the current Gitea login, shares
 an atomic delivery claim with the foreground path, and preserves the original
 idempotency key. Installed browsers can explicitly enable **Notify me when queued
@@ -821,10 +233,6 @@ python3 -m src.release_engine \
   --repo stackchain/stackchain-dashboard \
   --agent timmy \
   --issue 19 \
-  --agent-timeout 1800 \
-  --test-timeout 900 \
-  --termination-grace 5 \
-  --agent-env AGENT_CONFIG_HOME \
   --test-command 'python3 -m pytest tests/ -q'
 ```
 
@@ -833,62 +241,6 @@ claim, reruns the test command, pushes the branch, and opens a PR containing
 `Closes #19` plus test evidence. Replace `19` with the selected issue number;
 do not run without `--issue` when processing a preselected ticket.
 
-Agent and test commands use POSIX argument quoting and run as argument vectors,
-not through a shell. Issue context is available to the agent only through
-`RELEASE_ISSUE_NUMBER`, `RELEASE_ISSUE_TITLE`, `RELEASE_ISSUE_BODY`,
-`RELEASE_REPO`, and `RELEASE_BRANCH`; do not put issue placeholders in command
-text. Shell substitutions, redirects, and pipelines are intentionally not
-interpreted. Put any trusted shell workflow in a reviewed wrapper script and
-configure that script as `RELEASE_AGENT_COMMAND` instead.
-
-Every child process receives an explicit least-privilege environment rather
-than inheriting the worker's credentials. Coding agents receive a minimal
-runtime environment plus the five `RELEASE_*` context values above. Tests and
-Git receive only the minimal runtime environment, so `GITEA_TOKEN` and
-unrelated parent secrets remain in the release-engine process. If an agent
-runtime needs another non-secret setting, allow it explicitly with a repeated
-`--agent-env NAME` option or the comma-separated `RELEASE_AGENT_ENV` variable.
-`GITEA_TOKEN`, reserved `RELEASE_*` names, and malformed names are rejected
-before the issue is claimed. Secret-bearing values must not be allowlisted.
-
-Agent and test deadlines are independent. On expiry, the engine terminates the
-command's entire process group, escalates from `SIGTERM` to `SIGKILL` after the
-configured grace period, and records `agent_timed_out` or `tests_timed_out`
-without advancing the release. The equivalent environment variables are
-`RELEASE_AGENT_TIMEOUT`, `RELEASE_TEST_TIMEOUT`, and
-`RELEASE_TERMINATION_GRACE`; every value must be positive.
-
-Durable state defaults to `.release-engine/state.json`. Successful checkpoints
-record the repository, issue branch, and exact commit SHA. A restart resumes at
-tests, push, or PR creation only after validating that identity and a clean
-worktree; a pushed checkpoint also verifies the remote branch SHA. Invocations
-are serialized by an OS-backed, non-blocking lease at
-`.release-engine/run.lock` under the canonical repository path. If an hourly
-run overlaps a manual or slow prior run, the contender exits with `release run
-already active` and owner diagnostics before Gitea discovery or any Git/agent
-work. The kernel releases ownership when the process exits, so never delete a
-lock file to recover from a crash; stale file metadata cannot retain the lease.
-Checkpoint replacement uses writer-unique, flushed temporary files and an
-atomic rename, preventing concurrent writers from colliding or exposing partial
-JSON. Full behavior and safety gates are documented in
+Durable state defaults to `.release-engine/state.json`. Full behavior and
+safety gates are documented in
 [`docs/release-engine-spec.md`](docs/release-engine-spec.md).
-
-## Human Gates inbox
-
-Authenticated release producers use `POST /api/v1/human-gates/intake` with an
-`Idempotency-Key` and an immutable `"candidate_hash"`; durable account-bound
-SQLite storage is configured by `STACKCHAIN_HUMAN_GATE_DB`. Account isolation
-binds each queue to the upstream principal ID and login, including its offline
-browser cache. Review decisions carry `expected_revision`, a stable idempotency
-key across network retries and mobile app restarts, and return durable receipts.
-An interrupted decision response is restored as **Decision outcome unknown**;
-the operator verifies the exact persisted operation instead of creating a second
-decision. The client clears that operation only after recovering a receipt. If producer evidence
-changes after a release or hold, the update reopens the exact hash for a new
-revision-checked decision instead of silently retaining the old outcome.
-New hashes mark older pending candidates `superseded` without removing their audit
-history. See [`docs/human-gates.md`](docs/human-gates.md) for the complete
-producer body, decision API, and **Telegram coalescing contract**. Lock-screen
-and Telegram notifications expose count and route only, using
-`#/my-work/human-gates`; they never expose project, title, candidate hash,
-artifacts, checks, provenance, reasons, or receipts.

conftest.py

@@ -6,5 +6,4 @@ def explicit_local_dashboard_auth_mode(monkeypatch):
     """Keep tests intentional now that deployed authentication fails closed."""
     monkeypatch.setenv("STACKCHAIN_DASHBOARD_AUTH_MODE", "insecure-local")
     monkeypatch.delenv("STACKCHAIN_DASHBOARD_ACCESS_TOKEN", raising=False)
-    monkeypatch.delenv("STACKCHAIN_DASHBOARD_SESSION_SECRET", raising=False)
-    monkeypatch.setenv("STACKCHAIN_DASHBOARD_PUBLIC_ORIGIN", "https://test")
+    monkeypatch.delenv("STACKCHAIN_DASHBOARD_SESSION_SECRET", raising=False)

docs/human-gates.md

@@ -1,45 +0,0 @@
-# Human Gates producer and notification contract
-
-Human Gates is an account-bound release-candidate inbox. The canonical mobile route is `#/my-work/human-gates`. Reads may use the last account-scoped browser cache, but Release/Hold decisions require a live authenticated identity and an online server round trip.
-
-A cold open of the canonical route confirms the account and opens Human Gates from the core browser runtime while optional Today and Planning bundles continue hydrating or recovering. The full workspace adopts that controller and fixed review snapshot without a second queue request or duplicate decision handlers.
-
-## Producer intake
-
-Authenticated producers submit `POST /api/v1/human-gates/intake` with a unique `Idempotency-Key` header and JSON such as:
-
-```json
-{
-  "source": "release-bot",
-  "project": "stackchain/dashboard",
-  "candidate_hash": "abc123",
-  "title": "Dashboard candidate",
-  "priority": 7,
-  "artifacts": [{"name": "manifest", "url": "https://forge.example/artifacts/manifest.json"}],
-  "links": [{"label": "change", "url": "https://forge.example/pulls/1415"}],
-  "checks": [{"name": "browser", "state": "success", "required": true}],
-  "score": {"value": 92, "provenance": "release-evaluator/v2"},
-  "provenance": {"producer": "release-bot", "run_id": "run-9"}
-}
-```
-
-The immutable identity is authenticated account + `source` + `project` + `candidate_hash`. Retrying the same key and body returns the same gate. Reusing a key for different facts, or redefining an existing candidate hash, returns 409. A newer hash from the same source/project atomically marks older pending candidates `superseded`; detail history remains available for audit. Configure durable storage with `STACKCHAIN_HUMAN_GATE_DB` (default: `$STACKCHAIN_STATE_DIR/human-gates.sqlite3`).
-
-Consumers list `GET /api/v1/human-gates`, inspect `GET /api/v1/human-gates/{id}`, and submit `POST /api/v1/human-gates/{id}/decision` with a new `Idempotency-Key`, `expected_revision`, and either `release` or `hold`. Hold requires a reason. Release requires all three checklist confirmations; if any required check is not successful it also requires an explicit override reason. Durable receipts are available at `GET /api/v1/human-gate-receipts/{receipt_id}`. All endpoints are authenticated, account-bound, and `Cache-Control: no-store`.
-
-Before a mobile client submits Release or Hold, it stores one account-, gate-, and revision-bound pending operation with the exact payload and idempotency key. A transport interruption changes the decision tray to **Decision outcome unknown** and blocks replacement decisions. **Verify decision** replays that exact operation; server-side idempotency returns the original receipt if the decision committed, or executes it once if the first request never arrived. The pending operation and saved review progress are removed only after a receipt is confirmed. Reloading or restarting the installed app restores this verification flow even when the committed gate is no longer present in the live pending queue. Pending decision data never crosses the immutable account cache boundary.
-
-## Privacy-safe notification contract
-
-Web Push is opt-in per authenticated device under **My Work → Settings → Notify me when release decisions are waiting**. The preference is stored with that device's push subscription; revoked sessions are removed before delivery. The poller honors the device's routine-alert quiet hours, coalesces unchanged pending counts, and routes a notification tap to `#/my-work/human-gates`.
-
-Web Push, Telegram, and other lock-screen adapters MUST expose **count and route only**:
-
-```json
-{
-  "pending_count": 3,
-  "route": "#/my-work/human-gates"
-}
-```
-
-The notification text may say “3 Human Gates pending” and provide the route. It MUST NOT include project names, candidate hash values, titles, artifact/link URLs, checks, scores, provenance, decision history, superseded candidate facts, reasons, or receipts. Multiple intake/supersession events before delivery replace the pending notification with the latest count rather than emitting one message per candidate. A transition to zero clears the outstanding notification; it does not send candidate detail. Producers and adapters must fetch current state after authenticated route open rather than treating notification delivery as an action authorization.

docs/ops-fundamentals.md

@@ -23,20 +23,3 @@
 - API contracts + versioning
 - independent deployability
 - observability: metrics, traces, structured logs
-
-# Disk capacity incident
-
-Root filesystem usage at or above 85% is an operations incident.
-
-1. Capture the initial state with `df -h / /var/lib/gitea`.
-2. Inspect directory sizes and active processes before cleanup. Reclaim only
-   disposable caches and abandoned temporary environments. Responders must not
-   delete Gitea data, repositories, databases, secrets, or active release
-   artifacts.
-3. Re-run `df -h / /var/lib/gitea`; usage must be below 85%.
-4. Confirm the release path with `systemctl is-active gitea act_runner`, then run
-   the repository test suite.
-
-Record the before and after usage in the incident ticket. If safe cleanup cannot
-restore capacity below 85%, keep the incident open and escalate storage
-expansion rather than removing durable data.

docs/release-engine-spec.md

@@ -12,29 +12,15 @@ Convert one eligible Gitea issue into a tested, traceable pull request without d
 - Repository key (`owner/repo`).
 - Agent username.
 - Optional explicit issue number; otherwise deterministic queue selection.
-- Coding-agent command, parsed into an argument vector.
-- Test command, parsed into an argument vector.
-- Positive, independent coding-agent and test deadlines plus a termination grace period.
-- Optional explicit allowlist of non-secret parent environment variables needed by the coding-agent runtime.
+- Coding-agent command template.
+- Test command.
 - Local repository path and durable state-file path.
 
 ## State machine
 
 `discovered → claimed → agent_complete → tests_passed → pushed → pr_opened`
 
-Terminal failure states include `claim_failed`, `agent_failed`, `agent_timed_out`, `tests_failed`, `tests_timed_out`, and `push_failed`. A rerun resumes from persisted state and never opens a duplicate PR.
-
-Successful checkpoints are schema-versioned and bind the repository, issue,
-deterministic branch, and exact commit SHA. On restart, the engine:
-
-- resumes `agent_complete` at tests;
-- resumes `tests_passed` at push; and
-- resumes `pushed` at PR creation after verifying the remote branch SHA.
-
-Before skipping any stage, it checks out the recorded branch, verifies its
-local `HEAD`, and requires a clean worktree. Missing identity, an unsupported
-schema, or any repository/issue/branch/SHA mismatch fails closed instead of
-repeating or advancing delivery.
+Terminal failure states are `claim_failed`, `agent_failed`, `tests_failed`, and `push_failed`. A rerun resumes from persisted state and never opens a duplicate PR.
 
 ## Queue selection
 
@@ -44,19 +30,6 @@ repeating or advancing delivery.
 4. Otherwise sort by priority label (`P0`, `P1`, `P2`, unlabeled) then issue number.
 5. Select exactly one issue per invocation.
 
-## Single-active-run lease
-
-- Before issue discovery, every invocation acquires a non-blocking advisory lock
-  at `.release-engine/run.lock` under the canonical repository path.
-- The lease is held through the final checkpoint and pull-request request. A
-  contended invocation fails immediately with `release run already active`
-  before contacting Gitea or running Git, agent, or test commands.
-- The lock file records bounded owner PID and acquisition-time diagnostics.
-  These are informational only: kernel lock ownership is authoritative, so a
-  killed or crashed process releases the lease automatically and stale metadata
-  cannot block the next run.
-- Different canonical repository paths use independent leases.
-
 ## Claiming
 
 - PATCH the issue with the configured assignee.
@@ -66,18 +39,9 @@ repeating or advancing delivery.
 ## Execution
 
 - Branch format: `<agent>/<issue>-<slug>`.
-- Coding and test commands are parsed with POSIX argument quoting and executed directly without a shell.
-- Issue number, title, body, repo, and branch are supplied to the coding agent only through `RELEASE_ISSUE_NUMBER`, `RELEASE_ISSUE_TITLE`, `RELEASE_ISSUE_BODY`, `RELEASE_REPO`, and `RELEASE_BRANCH` environment variables. Gitea-controlled content is never interpolated into executable syntax.
-- Child processes never inherit the complete parent environment. Coding receives a minimal runtime environment, explicitly allowlisted non-secret agent variables, and the five issue-context values. Tests and Git receive only the minimal runtime environment; `GITEA_TOKEN` remains parent-process-only.
-- Agent variables are allowlisted with repeated `--agent-env NAME` options or comma-separated `RELEASE_AGENT_ENV`. `GITEA_TOKEN`, `RELEASE_*`, and malformed names fail validation before claim.
-- Shell operators, substitutions, and pipelines are not interpreted. Operators that are intentionally required must live in a separately reviewed wrapper script configured as the command.
-- Empty or malformed commands abort before the issue claim.
+- Coding command receives issue number, title, body, repo, and branch through template fields and environment variables.
 - Non-zero coding-agent exit blocks tests and PR creation.
 - Tests run using the configured command; stdout/stderr and exit code become evidence.
-- Coding-agent and test commands each run in a new process session. Their deadlines default to 1800 and 900 seconds, respectively.
-- On expiry, the engine sends `SIGTERM` to the command's entire process group, waits for the termination grace period (5 seconds by default), then sends `SIGKILL` to the group and reaps the command. This prevents descendants from keeping the worker wedged.
-- Deadlines are configured with `--agent-timeout`, `--test-timeout`, and `--termination-grace`, or `RELEASE_AGENT_TIMEOUT`, `RELEASE_TEST_TIMEOUT`, and `RELEASE_TERMINATION_GRACE`. Non-positive values abort before issue discovery or claim.
-- Timeout evidence is bounded in durable state. An agent timeout blocks tests; a test timeout blocks push and PR creation.
 
 ## PR and release gate
 
@@ -91,12 +55,6 @@ repeating or advancing delivery.
 
 - `--dry-run` performs discovery and planning only: no claim, git mutation, agent command, push, or PR.
 - State is written atomically after each successful transition.
-- Each checkpoint write uses a writer-unique temporary file, flushes file data,
-  atomically replaces the checkpoint, and flushes its parent directory. A
-  failed or concurrent writer therefore cannot collide on a shared temp path or
-  expose partial JSON.
-- Resumable state carries repository and commit identity; successful stages are
-  skipped only after local (and, after push, remote) Git verification.
 - One invocation handles at most one issue.
 - Missing token, dirty worktree, failed claim verification, failed tests, or missing evidence blocks PR creation.
 
@@ -110,13 +68,3 @@ repeating or advancing delivery.
 6. Passing tests produce a linked PR request with evidence.
 7. Existing state/PR prevents duplicate work.
 8. Dry-run against live Gitea returns a plan and performs no mutation.
-9. A timed-out command terminates its descendants and returns within its deadline plus grace period.
-10. Agent and test timeouts persist distinct terminal states and block every later delivery stage.
-11. Non-positive deadline configuration aborts before issue claim.
-12. Restarts from `agent_complete`, `tests_passed`, and `pushed` skip only the
-    completed stages and open exactly one linked PR.
-13. Dirty or identity-mismatched checkpoints stop before push or PR creation.
-14. Parent credentials are absent from coding-agent, test, and Git subprocesses while explicit agent variables and issue context reach only the coding stage.
-15. Reserved or malformed agent environment allowlist entries abort before claim.
-16. An overlapping invocation fails before Gitea discovery or local command execution and reports bounded owner diagnostics.
-17. Concurrent checkpoint-save stress completes without temp-file collisions or partial state.

frontend/agenda-calendar.js

@@ -1,180 +0,0 @@
-(function (root) {
-  'use strict';
-
-  function escapeText(value) {
-    return String(value || '')
-      .replace(/\\/g, '\\\\')
-      .replace(/\r?\n/g, '\\n')
-      .replace(/,/g, '\\,')
-      .replace(/;/g, '\\;');
-  }
-
-  function calendarDay(value) {
-    const match = String(value || '').match(/^(\d{4})-(\d{2})-(\d{2})/);
-    return match ? match.slice(1).join('') : '';
-  }
-
-  function nextDay(day) {
-    const date = new Date(Date.UTC(
-      Number(day.slice(0, 4)), Number(day.slice(4, 6)) - 1, Number(day.slice(6, 8)) + 1
-    ));
-    return date.toISOString().slice(0, 10).replace(/-/g, '');
-  }
-
-  function uid(item) {
-    const repository = String(item.repository || '').replace(/[^a-z0-9]+/gi, '-').replace(/^-|-$/g, '').toLowerCase();
-    return `issue-${Number(item.number)}@${repository}`;
-  }
-
-  function foldLine(line) {
-    const encoder = new TextEncoder();
-    const chunks = [];
-    let chunk = '';
-    let bytes = 0;
-    let limit = 75;
-    for (const character of String(line)) {
-      const width = encoder.encode(character).length;
-      if (chunk && bytes + width > limit) {
-        chunks.push(chunk);
-        chunk = character;
-        bytes = width;
-        limit = 74;
-      } else {
-        chunk += character;
-        bytes += width;
-      }
-    }
-    chunks.push(chunk);
-    return chunks.join('\r\n ');
-  }
-
-  function serializeAgendaCalendar(items, { generatedOn } = {}) {
-    const stampDay = String(generatedOn || new Date().toISOString().slice(0, 10).replace(/-/g, ''));
-    const lines = ['BEGIN:VCALENDAR', 'VERSION:2.0', 'PRODID:-//Stackchain//Agenda Snapshot//EN',
-      'CALSCALE:GREGORIAN', 'METHOD:PUBLISH', 'X-WR-CALNAME:Stackchain Agenda'];
-    (items || []).forEach(item => {
-      const day = calendarDay(item.due_date);
-      if (!day || !Number.isInteger(Number(item.number)) || !item.repository) return;
-      lines.push(
-        'BEGIN:VEVENT',
-        `UID:${uid(item)}`,
-        `DTSTAMP:${stampDay}T000000Z`,
-        `DTSTART;VALUE=DATE:${day}`,
-        `DTEND;VALUE=DATE:${nextDay(day)}`,
-        `SUMMARY:${escapeText(item.title)}`,
-        `DESCRIPTION:${escapeText(`${item.repository}#${item.number} · Stackchain Agenda snapshot`)}`,
-        `URL:${String(item.url || '')}`,
-        'TRANSP:TRANSPARENT',
-        'END:VEVENT',
-      );
-    });
-    lines.push('END:VCALENDAR');
-    return lines.map(foldLine).join('\r\n') + '\r\n';
-  }
-
-  async function deliverCalendarSnapshot({
-    text,
-    filename,
-    navigator,
-    document,
-    urlApi,
-    FileCtor,
-  }) {
-    const file = new FileCtor([text], filename, { type: 'text/calendar;charset=utf-8' });
-    const sharePayload = { files: [file], title: 'Stackchain Agenda', text: 'Agenda calendar snapshot' };
-    if (typeof navigator?.share === 'function' && typeof navigator?.canShare === 'function' &&
-        navigator.canShare(sharePayload)) {
-      await navigator.share(sharePayload);
-      return 'shared';
-    }
-    const href = urlApi.createObjectURL(file);
-    try {
-      const anchor = document.createElement('a');
-      anchor.href = href;
-      anchor.download = filename;
-      anchor.click();
-    } finally {
-      urlApi.revokeObjectURL(href);
-    }
-    return 'downloaded';
-  }
-
-  function mountAgendaCalendarExport({
-    qs,
-    getItems,
-    escapeHtml,
-    onDone,
-    windowObject = root,
-    navigatorObject = root.navigator,
-    documentObject = root.document,
-    urlApi = root.URL,
-    FileCtor = root.File,
-  }) {
-    const sheet = qs('#agenda-export-sheet');
-    let items = [];
-    let scrollY = 0;
-    let trigger = null;
-    const selectedItems = () => Array.from(qs('#agenda-export-items').querySelectorAll('input[type="checkbox"]'))
-      .filter(checkbox => checkbox.checked)
-      .map(checkbox => items[Number(checkbox.value)])
-      .filter(Boolean);
-    const updateSelection = () => {
-      const selected = selectedItems();
-      qs('#share-agenda-export').disabled = selected.length === 0;
-      qs('#agenda-export-status').textContent = selected.length + ' of ' + items.length +
-        (items.length === 1 ? ' deadline selected.' : ' deadlines selected.');
-    };
-    const close = () => {
-      sheet.close();
-      windowObject.scrollTo({ top:scrollY, behavior:'instant' });
-      trigger?.focus();
-    };
-    qs('#open-agenda-export').addEventListener('click', event => {
-      items = getItems();
-      scrollY = windowObject.scrollY;
-      trigger = event.currentTarget;
-      qs('#agenda-export-items').innerHTML = items.map((item, index) =>
-        '<label class="agenda-export-item"><input type="checkbox" value="' + index + '" checked> ' +
-        '<span><strong>' + escapeHtml(item.title) + '</strong><small>' +
-        escapeHtml(item.repository + '#' + item.number + ' · ' + item.due_date.slice(0, 10)) +
-        '</small></span></label>'
-      ).join('');
-      qs('#agenda-export-items').querySelectorAll('input[type="checkbox"]').forEach(checkbox =>
-        checkbox.addEventListener('change', updateSelection)
-      );
-      updateSelection();
-      sheet.showModal();
-      qs('#cancel-agenda-export').focus();
-    });
-    qs('#cancel-agenda-export').addEventListener('click', close);
-    sheet.addEventListener('cancel', event => {
-      event.preventDefault();
-      close();
-    });
-    qs('#share-agenda-export').addEventListener('click', async () => {
-      const selected = selectedItems();
-      if (!selected.length) return;
-      const button = qs('#share-agenda-export');
-      button.disabled = true;
-      qs('#agenda-export-status').textContent = 'Preparing calendar snapshot…';
-      const day = new Date().toISOString().slice(0, 10);
-      try {
-        const text = serializeAgendaCalendar(selected, { generatedOn:day.replace(/-/g, '') });
-        const result = await deliverCalendarSnapshot({
-          text, filename:'stackchain-agenda-' + day + '.ics',
-          navigator:navigatorObject, document:documentObject, urlApi, FileCtor,
-        });
-        onDone(result);
-        close();
-      } catch (error) {
-        qs('#agenda-export-status').textContent = error?.name === 'AbortError' ?
-          'Share cancelled. Nothing was exported.' : 'Calendar export failed. Retry without leaving Agenda.';
-        button.disabled = false;
-      }
-    });
-  }
-
-  const api = { calendarDay, deliverCalendarSnapshot, escapeText, foldLine, mountAgendaCalendarExport, serializeAgendaCalendar };
-  if (typeof module !== 'undefined' && module.exports) module.exports = api;
-  else root.StackchainAgendaCalendar = api;
-})(typeof window !== 'undefined' ? window : globalThis);

frontend/agenda-replan.js

@@ -1,83 +0,0 @@
-function createAgendaReplan({ now = () => new Date(), update }) {
-  let items = [];
-  let index = 0;
-  let pending = false;
-  let active = false;
-
-  const dayKey = date => [
-    date.getFullYear(),
-    String(date.getMonth() + 1).padStart(2, '0'),
-    String(date.getDate()).padStart(2, '0'),
-  ].join('-');
-  const dueDay = value => {
-    const match = String(value || '').match(/^(\d{4}-\d{2}-\d{2})(?:$|T)/);
-    return match ? match[1] : '';
-  };
-  const current = () => active ? items[index] || null : null;
-  const snapshot = () => ({
-    active,
-    index,
-    total: items.length,
-    current: current()?.key || null,
-    pending,
-  });
-  const advance = () => {
-    index += 1;
-    if (index >= items.length) active = false;
-    return { ok:true, done:!active };
-  };
-  const change = async dueDate => {
-    const item = current();
-    if (!item) return { ok:false, error:'No overdue deadline selected.' };
-    if (pending) return { ok:false, error:'Deadline update already in progress.' };
-    pending = true;
-    try {
-      await update(item, dueDate);
-      return advance();
-    } catch (error) {
-      return { ok:false, error:error?.message || 'Deadline could not be updated.' };
-    } finally {
-      pending = false;
-    }
-  };
-
-  return {
-    start(overdue) {
-      items = (overdue || []).slice().sort((left, right) =>
-        dueDay(left.due_date).localeCompare(dueDay(right.due_date)) ||
-        String(left.repository || '').localeCompare(String(right.repository || '')) ||
-        Number(left.number || 0) - Number(right.number || 0)
-      );
-      index = 0;
-      pending = false;
-      active = items.length > 0;
-      return snapshot();
-    },
-    snapshot,
-    current,
-    keep() {
-      if (pending) return Promise.resolve({ ok:false, error:'Deadline update already in progress.' });
-      if (!current()) return Promise.resolve({ ok:false, error:'No overdue deadline selected.' });
-      return Promise.resolve(advance());
-    },
-    tomorrow() {
-      const date = new Date(now());
-      date.setDate(date.getDate() + 1);
-      return change(dayKey(date) + 'T23:59:59Z');
-    },
-    choose(value) {
-      const chosen = String(value || '');
-      if (!/^\d{4}-\d{2}-\d{2}$/.test(chosen) || chosen <= dayKey(now())) {
-        return Promise.resolve({ ok:false, error:'Choose a future date.' });
-      }
-      return change(chosen + 'T23:59:59Z');
-    },
-    cancel() {
-      active = false;
-      pending = false;
-      return snapshot();
-    },
-  };
-}
-
-if (typeof module !== 'undefined' && module.exports) module.exports = createAgendaReplan;

frontend/agenda-session-launcher.js

@@ -1,33 +0,0 @@
-(function (root, factory) {
-  if (typeof module === 'object' && module.exports) module.exports = factory;
-  else root.createAgendaSessionLauncher = factory;
-})(typeof self !== 'undefined' ? self : this, function createAgendaSessionLauncher(options) {
-  let pending = null;
-
-  function open() {
-    if (pending) return pending;
-    options.selectAgenda();
-    pending = Promise.resolve()
-      .then(() => options.discover())
-      .then(complete => {
-        if (!options.isAgendaSelected()) return 'cancelled';
-        if (complete === false || options.hasMore()) {
-          options.announce('Agenda check paused. Retry to check older assigned deadlines.');
-          return 'incomplete';
-        }
-        const opened = options.hasCheckpoint() ? options.resume() : options.start();
-        if (!opened) options.announce('No deadlines are ready in Agenda.');
-        return opened ? 'opened' : 'empty';
-      })
-      .catch(() => {
-        if (options.isAgendaSelected()) {
-          options.announce('Agenda check paused. Retry to check older assigned deadlines.');
-        }
-        return 'incomplete';
-      })
-      .finally(() => { pending = null; });
-    return pending;
-  }
-
-  return {open};
-});

frontend/assign-and-start.js

@@ -1,49 +0,0 @@
-function createAssignAndStart({ available, claim, start, queue, recover, announce }) {
-  let request = null;
-
-  function run(item, { alreadyOwned = false, destination = 'start' } = {}) {
-    if (request) return request;
-    if (!available()) {
-      announce('Today is full—remove an item before assigning this issue.');
-      return Promise.resolve('full');
-    }
-    request = Promise.resolve()
-      .then(() => alreadyOwned ? item : claim(item))
-      .then(confirmed => {
-        const outcome = destination === 'queue' ? queue(confirmed) : start(confirmed);
-        if (outcome === 'queued') {
-          announce(alreadyOwned ? 'Queued in Today. Keep finding work when ready.' :
-            'Assigned and queued in Today. Keep finding work when ready.');
-          return outcome;
-        }
-        if (outcome === 'started') {
-          announce(alreadyOwned ? 'Added to Today and ready to work.' :
-            'Assigned, added to Today, and ready to work.');
-          return outcome;
-        }
-        if (destination === 'queue') {
-          if (outcome === 'sync-unavailable') {
-            announce(alreadyOwned ?
-              'Saved in Today on this device, but account sync is unavailable. The issue is open so you can recover.' :
-              'Assigned and saved in Today on this device, but account sync is unavailable. The issue is open so you can recover.');
-          } else {
-            announce(alreadyOwned ?
-              'Today could not be queued. The issue is open so you can recover.' :
-              'Assigned to you, but Today could not be queued. The issue is open so you can recover.');
-          }
-        } else {
-          announce(alreadyOwned ?
-            'Today could not start. The issue is open so you can recover.' :
-            'Assigned to you, but Today could not start. The issue is open so you can recover.');
-        }
-        recover(confirmed);
-        return 'recovery';
-      })
-      .finally(() => { request = null; });
-    return request;
-  }
-
-  return { run };
-}
-
-if (typeof module !== 'undefined' && module.exports) module.exports = createAssignAndStart;

frontend/authored-outbox.js

@@ -1,83 +1,10 @@
-function createAuthoredOutbox({ storage, fetchJson, coordinator, backgroundSync, getOwnerLogin = () => '', createOperationId, mergeChecklistConflict, now = () => Date.now(), maxItems = 50 }) {
+function createAuthoredOutbox({ storage, fetchJson, coordinator, backgroundSync, getOwnerLogin = () => '', createOperationId, now = () => Date.now(), maxItems = 50 }) {
   const storageKey = 'stackchain.authored-outbox.v1';
   const makeId = createOperationId || (() =>
     globalThis.crypto?.randomUUID?.() || String(Date.now()) + '-' + Math.random().toString(16).slice(2)
   );
   const pending = new Map();
-  const supportedKinds = new Set(['issue-comment', 'pull-comment', 'search-reply', 'update-reply', 'update-reply-read', 'pull-review', 'issue-close', 'issue-blocker', 'issue-content']);
-
-  function messageAttachments(message) {
-    const values = Array.isArray(message?.attachments) ? message.attachments :
-      (Array.isArray(message?.attachment) ? message.attachment : (message?.attachment ? [message.attachment] : []));
-    return values.filter(Boolean).slice(0, 5);
-  }
-
-  function attachmentMetadata(value) {
-    const note = String(value.note || '').replace(/\s+/g, ' ').trim().slice(0, 240);
-    return {
-      filename: String(value.filename || ''),
-      contentType: String(value.contentType || ''),
-      stored: true,
-      ...(note ? { note } : {}),
-      ...(value.operationId ? { operationId:String(value.operationId).slice(0, 128) } : {}),
-      ...(value.confirmed?.markdown ? { confirmed:{ markdown:String(value.confirmed.markdown) } } : {}),
-    };
-  }
-
-  function durableAttachment(value) {
-    const note = String(value.note || '').replace(/\s+/g, ' ').trim().slice(0, 240);
-    return {
-      filename: String(value.filename || ''),
-      contentType: String(value.contentType || ''),
-      ...(note ? { note } : {}),
-      ...(value.operationId ? { operationId:String(value.operationId).slice(0, 128) } : {}),
-      ...(value.confirmed?.markdown ? { confirmed:{ markdown:String(value.confirmed.markdown) } } : {}),
-      ...(value.blob ? { blob:value.blob } : { data:String(value.data || '') }),
-    };
-  }
-
-  function checklistOperation(value) {
-    const action = String(value?.action || '');
-    if (!['rename', 'remove', 'move-earlier', 'move-later'].includes(action)) return null;
-    return {
-      action,
-      index:Number(value.index),
-      ...(action === 'rename' ? { label:String(value.label || '') } : {}),
-    };
-  }
-
-  function reviewFingerprint(message) {
-    return JSON.stringify({
-      body: String(message.body || ''),
-      decision: String(message.decision || 'comment'),
-      expectedHeadSha: String(message.expectedHeadSha || ''),
-      comments: Array.isArray(message.comments) ? message.comments : [],
-    });
-  }
-
-  function operationFingerprint(message) {
-    return JSON.stringify({
-      kind:String(message.kind || ''), repository:String(message.repository || ''),
-      number:Number(message.number || 0), notificationId:Number(message.notificationId || 0),
-      body:String(message.body || ''), targetKind:String(message.targetKind || ''),
-      decision:String(message.decision || 'comment'), expectedHeadSha:String(message.expectedHeadSha || ''),
-      comments:Array.isArray(message.comments) ? message.comments : [],
-      blockerRepository:String(message.blockerRepository || ''), blockerNumber:Number(message.blockerNumber || 0),
-      present:message.present === true, title:String(message.title || ''),
-      expectedUpdatedAt:String(message.expectedUpdatedAt || ''),
-      attachments:messageAttachments(message).map(attachmentMetadata),
-    });
-  }
-
-  function clearConfirmedReviewState(item) {
-    if (item.kind !== 'pull-review') return;
-    try {
-      if (item.draftKey && item.draftFingerprint &&
-          storage?.getItem(item.draftKey) === item.draftFingerprint) storage.removeItem(item.draftKey);
-      if (item.progressKey && item.progressFingerprint &&
-          storage?.getItem(item.progressKey) === item.progressFingerprint) storage.removeItem(item.progressKey);
-    } catch (_error) { /* Delivery is confirmed even when local cleanup is unavailable. */ }
-  }
+  const supportedKinds = new Set(['issue-comment', 'pull-comment', 'update-reply']);
 
   function read() {
     try {
@@ -99,50 +26,14 @@ function createAuthoredOutbox({ storage, fetchJson, coordinator, backgroundSync,
 
   function enqueue(message, mirror = true) {
     if (!supportedKinds.has(message?.kind)) throw new Error('This action cannot be queued.');
-    if (message.kind === 'search-reply' && !['issue', 'pull'].includes(message.targetKind)) {
-      throw new Error('Choose an exact Search result before queueing a reply.');
-    }
     const ownerLogin = String(getOwnerLogin() || '').trim();
     if (!ownerLogin) throw new Error('Confirm your Gitea account before queueing a message.');
     const items = read();
     const requestedOperationId = String(message.operationId || '').slice(0, 128);
     const existing = requestedOperationId && items.find(item => item.operationId === requestedOperationId);
-    if (existing) {
-      if (operationFingerprint(existing) !== operationFingerprint(message)) {
-        throw new Error('This operation ID is already bound to a different queued action.');
-      }
-      return { ...existing };
-    }
-    if (message.kind === 'pull-review') {
-      const queuedReview = items.find(item => item.kind === 'pull-review' &&
-        item.repository === String(message.repository || '') &&
-        item.number === Number(message.number || 0) &&
-        item.expectedHeadSha === String(message.expectedHeadSha || ''));
-      if (queuedReview) {
-        if (reviewFingerprint(queuedReview) === reviewFingerprint(message)) return { ...queuedReview };
-        throw new Error('A review for this saved head is already queued. Open Drafts to inspect or discard it first.');
-      }
-    }
-    if (message.kind === 'issue-content') {
-      const queuedContent = items.find(item => item.kind === 'issue-content' && item.status === 'queued' &&
-        item.ownerLogin === ownerLogin && item.repository === String(message.repository || '') &&
-        item.number === Number(message.number || 0));
-      if (queuedContent) {
-        const operation = checklistOperation(message.checklistOperation);
-        const replacement = {
-          ...queuedContent,
-          operationId: String(requestedOperationId || makeId()).slice(0, 128),
-          title: String(message.title || ''),
-          body: String(message.body || ''),
-          ...(operation ? { checklistOperations:[...(queuedContent.checklistOperations || []), operation] } : {}),
-        };
-        write(items.map(item => item.id === queuedContent.id ? replacement : item), mirror);
-        return replacement;
-      }
-    }
+    if (existing) return { ...existing };
     if (items.length >= maxItems) throw new Error('Message outbox is full. Send or discard a queued message first.');
     const id = String(requestedOperationId || makeId()).slice(0, 128);
-    const attachments = messageAttachments(message);
     const item = {
       id,
       operationId: requestedOperationId || id,
@@ -154,33 +45,6 @@ function createAuthoredOutbox({ storage, fetchJson, coordinator, backgroundSync,
       ownerLogin,
       status: 'queued',
       queuedAt: Number(now()),
-      ...(message.kind === 'search-reply' ? { targetKind:String(message.targetKind) } : {}),
-      ...(message.kind === 'update-reply-read' ? { replyConfirmed: message.replyConfirmed === true } : {}),
-      ...(['issue-comment', 'pull-comment', 'search-reply', 'update-reply', 'update-reply-read'].includes(message.kind) && attachments.length ?
-        (attachments.length === 1 ? { attachment:attachmentMetadata(attachments[0]) } :
-          { attachments:attachments.map(attachmentMetadata) }) : {}),
-      ...(message.kind === 'pull-review' ? {
-        decision: String(message.decision || 'comment'),
-        expectedHeadSha: String(message.expectedHeadSha || ''),
-        comments: Array.isArray(message.comments) ? message.comments.map(comment => ({ ...comment })) : [],
-        draftKey: String(message.draftKey || ''),
-        progressKey: String(message.progressKey || ''),
-        draftFingerprint: String(message.draftFingerprint || ''),
-        progressFingerprint: String(message.progressFingerprint || ''),
-      } : {}),
-      ...(message.kind === 'issue-blocker' ? {
-        blockerRepository: String(message.blockerRepository || ''),
-        blockerNumber: Number(message.blockerNumber || 0),
-        present: message.present === true,
-      } : {}),
-      ...(message.kind === 'issue-content' ? {
-        title: String(message.title || ''),
-        baseBody: String(message.baseBody ?? message.body ?? ''),
-        expectedUpdatedAt: String(message.expectedUpdatedAt || ''),
-        ...(checklistOperation(message.checklistOperation) ? {
-          checklistOperations:[checklistOperation(message.checklistOperation)],
-        } : {}),
-      } : {}),
     };
     items.push(item);
     write(items, mirror);
@@ -188,29 +52,12 @@ function createAuthoredOutbox({ storage, fetchJson, coordinator, backgroundSync,
   }
 
   async function enqueueDurably(message) {
-    const previousItems = read();
     const item = enqueue(message, false);
-    const attachments = messageAttachments(message);
-    if (attachments.length && ['search-reply', 'update-reply', 'update-reply-read'].includes(message.kind) &&
-        (!backgroundSync?.reconcile || !backgroundSync?.requestSync)) {
-      write(read().filter(candidate => candidate.id !== item.id), false);
-      throw new Error('Screenshot delivery needs IndexedDB. Your reply and screenshot are still here; retry.');
-    }
     if (!backgroundSync?.reconcile || !backgroundSync?.requestSync) {
       return { item, background: false, durability: 'foreground-only' };
     }
-    const durableItems = read().map(candidate => candidate.id === item.id && attachments.length ? {
-      ...candidate,
-      ...(attachments.length === 1 ? { attachment:durableAttachment(attachments[0]) } :
-        { attachments:attachments.map(durableAttachment) }),
-    } : candidate);
-    try {
-      await backgroundSync.reconcile(durableItems, 'authored');
-    } catch (error) {
-      write(previousItems, false);
-      throw error;
-    }
     try {
+      await backgroundSync.reconcile(read(), 'authored');
       await backgroundSync.requestSync();
       return { item, background: true, durability: 'background' };
     } catch (error) {
@@ -230,7 +77,6 @@ function createAuthoredOutbox({ storage, fetchJson, coordinator, backgroundSync,
         status: 'queued',
       };
       delete updated.error;
-      delete updated.deliveryState;
       return updated;
     }));
     return updated;
@@ -248,22 +94,6 @@ function createAuthoredOutbox({ storage, fetchJson, coordinator, backgroundSync,
       return 'api/v1/notifications/' + encodeURIComponent(item.notificationId) + '/reply';
     }
     const repository = item.repository.split('/').map(encodeURIComponent).join('/');
-    if (item.kind === 'issue-close') {
-      return 'api/v1/repos/' + repository + '/issues/' + encodeURIComponent(item.number) + '/close';
-    }
-    if (item.kind === 'issue-blocker') {
-      return 'api/v1/repos/' + repository + '/issues/' + encodeURIComponent(item.number) + '/blockers';
-    }
-    if (item.kind === 'issue-content') {
-      return 'api/v1/repos/' + repository + '/issues/' + encodeURIComponent(item.number) + '/content';
-    }
-    if (item.kind === 'pull-review') {
-      return 'api/v1/repos/' + repository + '/pulls/' + encodeURIComponent(item.number) + '/review';
-    }
-    if (item.kind === 'search-reply') {
-      return 'api/v1/repos/' + repository + '/issues/' + encodeURIComponent(item.number) +
-        '/preview/comments?kind=' + encodeURIComponent(item.targetKind);
-    }
     const resource = item.kind === 'pull-comment' ? 'pulls' : 'issues';
     return 'api/v1/repos/' + repository + '/' + resource + '/' + encodeURIComponent(item.number) + '/comments';
   }
@@ -271,10 +101,6 @@ function createAuthoredOutbox({ storage, fetchJson, coordinator, backgroundSync,
   async function sendItem(item, currentLogin) {
     if (!currentLogin || item.ownerLogin !== currentLogin) return { blocked: true };
     if (pending.has(item.id)) return pending.get(item.id);
-    const attemptAt = Number(now());
-    write(read().map(candidate => candidate.id === item.id ? {
-      ...candidate, status:'sending', lastAttemptAt:attemptAt,
-    } : candidate), false);
     const request = (async () => {
       try {
         let result;
@@ -287,93 +113,27 @@ function createAuthoredOutbox({ storage, fetchJson, coordinator, backgroundSync,
           }
           result = delivery.message;
         } else {
-          if (item.kind === 'update-reply-read') {
-            if (!item.replyConfirmed) {
-              await fetchJson('api/v1/notifications/' + encodeURIComponent(item.notificationId) + '/reply', {
-                method: 'POST',
-                headers: {
-                  Accept: 'application/json', 'Content-Type': 'application/json',
-                  'Idempotency-Key': item.operationId,
-                },
-                body: JSON.stringify({ body: item.body }),
-              });
-              write(read().map(candidate => candidate.id === item.id ? {
-                ...candidate, replyConfirmed: true, status: 'sending', lastAttemptAt: attemptAt,
-              } : candidate), false);
-            }
-            result = await fetchJson('api/v1/notifications/' + encodeURIComponent(item.notificationId) + '/read', {
-              method: 'PATCH', headers: { Accept: 'application/json' },
-            });
-          } else if (item.kind === 'issue-close') {
-            result = await fetchJson(endpoint(item), {
-              method: 'PATCH',
-              headers: { Accept: 'application/json', 'Idempotency-Key': item.operationId },
-            });
-            if (result?.state !== 'closed') throw new Error('Issue closure was not confirmed.');
-          } else if (item.kind === 'issue-blocker') {
-            result = await fetchJson(endpoint(item), {
-              method: 'PATCH',
-              headers: {
-                Accept: 'application/json',
-                'Content-Type': 'application/json',
-                'Idempotency-Key': item.operationId,
-              },
-              body: JSON.stringify({
-                repository: item.blockerRepository,
-                number: item.blockerNumber,
-                present: item.present,
-              }),
-            });
-            const dependencies = Array.isArray(result?.dependencies) ? result.dependencies : [];
-            const present = dependencies.some(candidate => candidate?.repository === item.blockerRepository &&
-              Number(candidate?.number) === item.blockerNumber);
-            if (result?.number !== item.number || result?.dependencies_available !== true || present !== item.present) {
-              throw new Error('Blocker change was not confirmed.');
-            }
-          } else {
-            const body = item.kind === 'pull-review' ? {
-              body: item.body,
-              decision: item.decision,
-              expected_head_sha: item.expectedHeadSha,
-              comments: item.comments,
-            } : item.kind === 'issue-content' ? {
-              title:item.title, body:item.body, expected_updated_at:item.expectedUpdatedAt,
-            } : { body: item.body };
-            result = await fetchJson(endpoint(item), {
-              method: item.kind === 'issue-content' ? 'PATCH' : 'POST',
-              headers: {
-                Accept: 'application/json',
-                'Content-Type': 'application/json',
-                'Idempotency-Key': item.operationId,
-              },
-              body: JSON.stringify(body),
-            });
-            if (item.kind === 'issue-content' &&
-                (result?.number !== item.number || result?.title !== item.title || result?.body !== item.body)) {
-              throw new Error('Checklist update was not confirmed.');
-            }
-          }
+          result = await fetchJson(endpoint(item), {
+            method: 'POST',
+            headers: {
+              Accept: 'application/json',
+              'Content-Type': 'application/json',
+              'Idempotency-Key': item.operationId,
+            },
+            body: JSON.stringify({ body: item.body }),
+          });
         }
         if (!result) return { blocked: true };
-        clearConfirmedReviewState(item);
         discard(item.id);
         return { result };
       } catch (error) {
         const status = Number(error?.status || 0);
         const permanent = status >= 400 && status < 500;
-        const attemptError = String(error.message || 'Delivery failed').slice(0, 240);
         if (permanent) {
           write(read().map(candidate => candidate.id === item.id ? {
             ...candidate,
             status: 'attention',
             error: String(error.message || 'Message needs attention').slice(0, 240),
-            lastAttemptAt: attemptAt,
-            lastAttemptError: attemptError,
-            ...(error.code === 'delivery_uncertain' ? { deliveryState: 'uncertain' } : {}),
-          } : candidate));
-        } else {
-          write(read().map(candidate => candidate.id === item.id ? {
-            ...candidate, status:'queued', lastAttemptAt:attemptAt, lastAttemptError:attemptError,
           } : candidate));
         }
         return { error, transient: !permanent };
@@ -389,7 +149,7 @@ function createAuthoredOutbox({ storage, fetchJson, coordinator, backgroundSync,
     let blocked = 0;
     currentLogin = String(currentLogin || '').trim();
     for (const item of read()) {
-      if (item.status === 'attention' || item.kind === 'issue-close') continue;
+      if (item.status === 'attention') continue;
       if (!currentLogin || item.ownerLogin !== currentLogin) { blocked += 1; continue; }
       const outcome = await sendItem(item, currentLogin);
       if (outcome.result) confirmed.push(outcome.result);
@@ -410,17 +170,7 @@ function createAuthoredOutbox({ storage, fetchJson, coordinator, backgroundSync,
     if (!currentLogin || item.ownerLogin !== currentLogin) {
       return { confirmed: [], remaining: read(), blocked: 1 };
     }
-    let queued = item;
-    if (item.status === 'attention') {
-      queued = {
-        ...item,
-        operationId: String(makeId()).slice(0, 128),
-        status: 'queued',
-      };
-      delete queued.error;
-      delete queued.deliveryState;
-      write(read().map(candidate => candidate.id === id ? queued : candidate));
-    }
+    const queued = item.status === 'attention' ? update(id, item) : item;
     const outcome = await sendItem(queued, currentLogin);
     return { confirmed: outcome.result ? [outcome.result] : [], remaining: read(), blocked: 0 };
   }
@@ -430,69 +180,15 @@ function createAuthoredOutbox({ storage, fetchJson, coordinator, backgroundSync,
     return retryItem(id, currentLogin);
   }
 
-  async function resolveIssueContentConflict(id, latest, currentLogin) {
-    const previousItems = read();
-    const item = previousItems.find(candidate => candidate.id === id);
-    currentLogin = String(currentLogin || '').trim();
-    if (!item || item.kind !== 'issue-content' || item.status !== 'attention') {
-      throw new Error('This checklist conflict is no longer available.');
-    }
-    if (!currentLogin || item.ownerLogin !== currentLogin) {
-      throw new Error('Confirm the account that queued this checklist update.');
-    }
-    if (typeof mergeChecklistConflict !== 'function') {
-      throw new Error('Checklist conflict review is unavailable.');
-    }
-    const merged = mergeChecklistConflict({
-      baseBody: String(item.baseBody ?? item.body ?? ''),
-      localBody: String(item.body || ''),
-      remoteBody: String(latest?.body || ''),
-    });
-    if (merged.conflicts?.length) return merged;
-    if (!String(latest?.updated_at || '')) throw new Error('Latest issue revision is unavailable.');
-    const rebased = {
-      ...item,
-      operationId: String(makeId()).slice(0, 128),
-      title: String(latest?.title || ''),
-      baseBody: String(latest?.body || ''),
-      body: merged.body,
-      expectedUpdatedAt: String(latest.updated_at),
-      status: 'queued',
-    };
-    delete rebased.error;
-    delete rebased.deliveryState;
-    const nextItems = previousItems.map(candidate => candidate.id === id ? rebased : candidate);
-    write(nextItems, false);
-    if (backgroundSync?.reconcile) {
-      try { await backgroundSync.reconcile(nextItems, 'authored'); }
-      catch (error) {
-        write(previousItems, false);
-        throw error;
-      }
-      try { await backgroundSync.requestSync?.(); }
-      catch (_error) { /* Foreground retry remains available. */ }
-    }
-    return { ...merged, item: rebased };
-  }
-
   function reconcileBackground(records) {
     const statuses = new Map((records || []).map(item => [item.id, item]));
     const items = read().flatMap(item => {
       const background = statuses.get(item.id);
-      if (background?.status === 'sent') {
-        clearConfirmedReviewState(item);
-        return [];
-      }
+      if (background?.status === 'sent') return [];
       if (background?.status === 'attention') return [{
         ...item,
         status: 'attention',
         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];
     });
@@ -500,8 +196,7 @@ function createAuthoredOutbox({ storage, fetchJson, coordinator, backgroundSync,
     return items;
   }
 
-  return { enqueue, enqueueDurably, update, discard, flush, retry, resolveIssueContentConflict,
-    reconcileBackground, list: () => read().map(item => ({ ...item })) };
+  return { enqueue, enqueueDurably, update, discard, flush, retry, reconcileBackground, list: () => read().map(item => ({ ...item })) };
 }
 
 if (typeof module !== 'undefined' && module.exports) module.exports = createAuthoredOutbox;

frontend/background-issue-sync.js

@@ -8,14 +8,7 @@ function createIndexedDbTransaction(indexedDB, dbName = 'stackchain-background-o
           request.result.createObjectStore('issues', { keyPath: 'id' });
         }
       };
-      request.onsuccess = () => {
-        const db = request.result;
-        db.onversionchange = () => {
-          db.close();
-          databasePromise = undefined;
-        };
-        resolve(db);
-      };
+      request.onsuccess = () => resolve(request.result);
       request.onerror = () => reject(request.error);
     });
     return databasePromise;
@@ -24,7 +17,7 @@ function createIndexedDbTransaction(indexedDB, dbName = 'stackchain-background-o
     request.onsuccess = () => resolve(request.result);
     request.onerror = () => reject(request.error);
   });
-  const transact = async work => {
+  return async work => {
     const db = await database();
     return new Promise((resolve, reject) => {
       const transaction = db.transaction('issues', 'readwrite');
@@ -35,7 +28,6 @@ function createIndexedDbTransaction(indexedDB, dbName = 'stackchain-background-o
       transaction.onerror = () => reject(transaction.error);
       transaction.onabort = () => reject(transaction.error || new Error('Issue outbox transaction aborted'));
       Promise.resolve(work({
-        get: id => requested(objectStore.get(id)),
         getAll: () => requested(objectStore.getAll()),
         put: value => requested(objectStore.put(value)),
         delete: id => requested(objectStore.delete(id)),
@@ -46,34 +38,9 @@ function createIndexedDbTransaction(indexedDB, dbName = 'stackchain-background-o
       });
     });
   };
-  transact.close = async () => {
-    if (!databasePromise) return;
-    const db = await databasePromise;
-    db.close();
-    databasePromise = undefined;
-  };
-  return transact;
 }
 
-function createUnfiledAttachmentStore(indexedDB = globalThis.indexedDB) {
-  const transact = createIndexedDbTransaction(indexedDB, 'stackchain-unfiled-captures-v1');
-  return {
-    put: (id, value) => transact(records => records.put({id, ...value})),
-    get: id => transact(async records => {
-      const value = await records.get(id);
-      if (!value) return null;
-      const {id: _id, ...attachment} = value;
-      return attachment;
-    }),
-    delete: id => transact(records => records.delete(id)),
-  };
-}
-
-function createIssueSyncStore({
-  transaction, indexedDB = globalThis.indexedDB, now = () => Date.now(), claimMs = 30000,
-  createToken = () => globalThis.crypto?.randomUUID?.() ||
-    (Date.now().toString(36) + '-' + Math.random().toString(36).slice(2)),
-} = {}) {
+function createIssueSyncStore({ transaction, indexedDB = globalThis.indexedDB, now = () => Date.now(), claimMs = 30000 } = {}) {
   const transact = transaction || createIndexedDbTransaction(indexedDB);
 
   async function reconcile(items, outboxLane = 'issue') {
@@ -84,35 +51,15 @@ function createIssueSyncStore({
         if (current.recordType === 'receipt-preference') continue;
         const currentLane = current.outboxLane || 'issue';
         if (currentLane !== outboxLane) continue;
-        let replacement = incoming.get(current.id);
+        const replacement = incoming.get(current.id);
         if (!replacement) {
           if (current.status !== 'sending' || Number(current.claimUntil) <= Number(now())) {
             await records.delete(current.id);
           }
           continue;
         }
-        const preservedBundle = current.operationId === replacement.operationId &&
-          current.attachments?.every(value => value?.data || value?.blob) &&
-          replacement.attachments?.every(value => value?.stored && !value.data && !value.blob)
-          ? current.attachments : null;
-        if (current.operationId === replacement.operationId &&
-            (current.attachment?.data || current.attachment?.blob) &&
-            replacement.attachment?.stored &&
-            !replacement.attachment.data && !replacement.attachment.blob || preservedBundle) {
-          replacement = {
-            ...replacement,
-            ...(preservedBundle ? {attachments:preservedBundle} : {attachment:current.attachment}),
-          };
-          incoming.set(current.id, replacement);
-        }
-        if (current.kind === 'issue-content' && replacement.kind === 'issue-content' &&
-            current.operationId !== replacement.operationId && current.status === 'sending' &&
-            Number(current.claimUntil) > Number(now())) {
-          throw new Error('Checklist sync is already delivering. Retry this change.');
-        }
         if ((current.status === 'sending' && Number(current.claimUntil) > Number(now())) ||
-            (['attention', 'authorization'].includes(current.status) &&
-              replacement.status === current.status) ||
+            (current.status === 'attention' && replacement.status === 'attention') ||
             current.status === 'sent') {
           incoming.set(current.id, current);
         }
@@ -126,41 +73,15 @@ function createIssueSyncStore({
       const timestamp = Number(now());
       const items = await records.getAll();
       const item = items.find(candidate => candidate.ownerLogin === ownerLogin &&
-        candidate.kind !== 'issue-close' &&
         (candidate.status === 'queued' || candidate.status === 'sending') &&
         (candidate.status !== 'sending' || Number(candidate.claimUntil) <= timestamp));
       if (!item) return null;
-      const claimed = {
-        ...item, status: 'sending', claimUntil: timestamp + claimMs, claimToken: createToken(),
-      };
+      const claimed = { ...item, status: 'sending', claimUntil: timestamp + claimMs };
       await records.put(claimed);
       return claimed;
     });
   }
 
-  async function planBatch(ownerLogin, limit = 70) {
-    return transact(async records => {
-      const timestamp = Number(now());
-      const eligible = (await records.getAll()).filter(candidate =>
-        candidate.recordType !== 'receipt-preference' &&
-        candidate.ownerLogin === ownerLogin &&
-        candidate.kind !== 'issue-close' &&
-        (candidate.status === 'queued' || candidate.status === 'sending') &&
-        (candidate.status !== 'sending' || Number(candidate.claimUntil) <= timestamp));
-      const lanes = {
-        issue: eligible.filter(item => (item.outboxLane || 'issue') !== 'authored'),
-        authored: eligible.filter(item => item.outboxLane === 'authored'),
-      };
-      const selected = [];
-      const maximum = Math.max(0, Number(limit) || 0);
-      while (selected.length < maximum && (lanes.issue.length || lanes.authored.length)) {
-        if (lanes.issue.length) selected.push(lanes.issue.shift().id);
-        if (selected.length < maximum && lanes.authored.length) selected.push(lanes.authored.shift().id);
-      }
-      return selected;
-    });
-  }
-
   async function claim(id, ownerLogin) {
     return transact(async records => {
       const timestamp = Number(now());
@@ -168,9 +89,7 @@ function createIssueSyncStore({
       if (!item || item.ownerLogin !== ownerLogin ||
           !['queued', 'sending'].includes(item.status) ||
           (item.status === 'sending' && Number(item.claimUntil) > timestamp)) return null;
-      const claimed = {
-        ...item, status: 'sending', claimUntil: timestamp + claimMs, claimToken: createToken(),
-      };
+      const claimed = { ...item, status: 'sending', claimUntil: timestamp + claimMs };
       await records.put(claimed);
       return claimed;
     });
@@ -180,24 +99,10 @@ 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())) ||
-          (['attention', 'authorization'].includes(current.status) &&
-            item.status === current.status) ||
+          (current.status === 'attention' && item.status === 'attention') ||
           current.status === 'sent')) return current;
-      const preservedAttachment = (current?.attachment?.data || current?.attachment?.blob) &&
-        item?.attachment?.stored && !item.attachment.data && !item.attachment.blob
-        ? { attachment: current.attachment } : {};
-      const preservedAttachments = current?.operationId === item?.operationId &&
-        current?.attachments?.every(value => value?.data || value?.blob) &&
-        item?.attachments?.every(value => value?.stored && !value.data && !value.blob)
-        ? { attachments:current.attachments } : {};
-      const next = current && current.operationId === item.operationId ? {
-        ...item, ...preservedAttachment, ...preservedAttachments,
-        ...(current.deliveredIssue ? { deliveredIssue: current.deliveredIssue } : {}),
-        ...(current.attachmentMarkdown ? { attachmentMarkdown: current.attachmentMarkdown } : {}),
-        ...(current.attachmentMarkdowns ? { attachmentMarkdowns:current.attachmentMarkdowns } : {}),
-      } : { ...item };
-      await records.put(next);
-      return next;
+      await records.put({ ...item });
+      return item;
     });
   }
 
@@ -208,32 +113,6 @@ function createIssueSyncStore({
     });
   }
 
-  async function updateClaim(id, claimToken, transform) {
-    return transact(async records => {
-      const item = records.get ? await records.get(id) :
-        (await records.getAll()).find(candidate => candidate.id === id);
-      if (!item || item.status !== 'sending' || !claimToken || item.claimToken !== claimToken) {
-        return false;
-      }
-      await records.put(transform(item));
-      return true;
-    });
-  }
-
-  function clearClaim(item, changes) {
-    const { claimToken: _claimToken, ...unclaimed } = item;
-    return { ...unclaimed, ...changes, claimUntil: 0 };
-  }
-
-  async function renew(id, claimToken) {
-    let renewed = null;
-    await updateClaim(id, claimToken, item => {
-      renewed = { ...item, claimUntil: Number(now()) + claimMs };
-      return renewed;
-    });
-    return renewed;
-  }
-
   function preferenceId(ownerLogin) {
     return 'receipt-preference:' + String(ownerLogin || '').trim();
   }
@@ -256,29 +135,13 @@ function createIssueSyncStore({
   }
 
   return {
-    get: id => transact(records => records.get(id)),
     reconcile,
     upsert,
-    update,
     claim,
     claimNext,
-    planBatch,
-    supportsClaimTokens: true,
-    renew,
-    checkpoint: updateClaim,
-    complete: (id, claimToken, deliveredIssue) => updateClaim(id, claimToken, item => clearClaim(item, {
-      status: 'sent',
-      ...(item.completionIntent === 'create-and-start' && deliveredIssue ? { deliveredIssue } : {}),
-    })),
-    release: (id, claimToken) => updateClaim(id, claimToken,
-      item => clearClaim(item, { status: 'queued' })),
-    fail: (id, claimToken, error, deliveryState) => updateClaim(id, claimToken, item => clearClaim(item, {
-      status: 'attention', error,
-      ...(deliveryState ? { deliveryState } : {}),
-    })),
-    authorization: (id, claimToken, error) => updateClaim(
-      id, claimToken, item => clearClaim(item, { status: 'authorization', error })
-    ),
+    complete: id => update(id, item => ({ ...item, status: 'sent', claimUntil: 0 })),
+    release: id => update(id, item => ({ ...item, status: 'queued', claimUntil: 0 })),
+    fail: (id, error) => update(id, item => ({ ...item, status: 'attention', claimUntil: 0, error })),
     snapshot: () => transact(async records =>
       (await records.getAll()).filter(item => item.recordType !== 'receipt-preference')),
     countBlocked: ownerLogin => transact(async records =>
@@ -286,177 +149,30 @@ function createIssueSyncStore({
         item.status !== 'sent' && item.ownerLogin !== ownerLogin).length),
     setReceiptPreference,
     getReceiptPreference,
-    close: () => transact.close?.(),
   };
 }
 
-function createBackgroundIssueSync({
-  store, fetchJson, base = '', maxConcurrency = 3, batchSize = 70,
-  batch = work => work(), requestTimeoutMs = 15000,
-}) {
-  let purgeRequested = false;
-  let activePurge = null;
-  let activeFlush = null;
-  const activeRequests = new Set();
-  const timeoutMs = Math.max(1, Number(requestTimeoutMs) || 15000);
-
-  const completeClaim = (item, delivered) => store.supportsClaimTokens
-    ? store.complete(item.id, item.claimToken, delivered) : store.complete(item.id, delivered);
-  const releaseClaim = item => store.supportsClaimTokens
-    ? store.release(item.id, item.claimToken) : store.release(item.id);
-  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);
-
-  async function requestStage(item, url, options) {
-    if (store.renew) {
-      const renewed = await store.renew(item.id, item.claimToken);
-      if (!renewed) throw new Error('Background delivery claim was lost.');
-    }
-    return requestJson(url, options);
-  }
-
-  async function requestJson(url, options = {}) {
-    const controller = new AbortController();
-    activeRequests.add(controller);
-    let timer;
-    const interrupted = new Promise((resolve, reject) => {
-      controller.signal.addEventListener('abort', () => {
-        reject(new Error(purgeRequested
-          ? 'Background request canceled.'
-          : 'Background request timed out.'));
-      }, { once: true });
-      timer = setTimeout(() => controller.abort(), timeoutMs);
-    });
-    try {
-      return await Promise.race([
-        Promise.resolve().then(() => fetchJson(url, { ...options, signal: controller.signal })),
-        interrupted,
-      ]);
-    } finally {
-      clearTimeout(timer);
-      activeRequests.delete(controller);
-    }
-  }
+function createBackgroundIssueSync({ store, fetchJson, base = '' }) {
   function receiptFor(item, status, delivered = {}) {
     if (status === 'attention') {
       return { id: item.id, status, kind: item.kind ? 'message' : 'issue', route: '#/my-work/drafts' };
     }
-    if (item.kind === 'notification-read') {
-      return { id: item.id, status, kind: 'notification-read', route: '#/my-work/updates' };
-    }
-    if (item.kind === 'update-reply' || item.kind === 'update-reply-read') {
+    if (item.kind === 'update-reply') {
       return { id: item.id, status, kind: 'message', route: '#/my-work/update/' + encodeURIComponent(item.notificationId) };
     }
     const repository = String(item.repository || '').split('/').map(encodeURIComponent).join('/');
-    if (item.kind === 'pull-review') {
-      return {
-        id: item.id, status, kind: 'message',
-        route: '#/my-work/review/' + repository + '/' + encodeURIComponent(item.number),
-      };
-    }
-    if (item.kind === 'issue-close') {
-      return {
-        id: item.id, status, kind: 'message',
-        route: '#/my-work/issue/' + repository + '/' + encodeURIComponent(item.number),
-      };
-    }
     if (item.kind === 'issue-comment' || item.kind === 'pull-comment') {
       const resource = item.kind === 'pull-comment' ? 'pull' : 'issue';
       return { id: item.id, status, kind: 'message', route: '#/my-work/' + resource + '/' + repository + '/' + encodeURIComponent(item.number) };
     }
-    if (typeof delivered.url === 'string' && /^https?:\/\//.test(delivered.url)) {
-      return { id: item.id, status, kind: 'issue', url: delivered.url };
-    }
     return { id: item.id, status, kind: 'issue', route: '#/my-work/issue/' + repository + '/' + encodeURIComponent(delivered.number) };
   }
 
   function deliveryRequest(item) {
-    if (item.kind === 'notification-read') {
-      return {
-        url: base + 'api/v1/notifications/' + encodeURIComponent(item.notificationId) + '/read',
-        options: { method: 'PATCH', headers: { Accept: 'application/json' } },
-      };
-    }
     if (item.kind === 'update-reply') {
       return authoredRequest('api/v1/notifications/' + encodeURIComponent(item.notificationId) + '/reply', item);
     }
-    if (item.kind === 'update-reply-read') {
-      return {
-        url: base + 'api/v1/notifications/' + encodeURIComponent(item.notificationId) + '/read',
-        options: { method: 'PATCH', headers: { Accept: 'application/json' } },
-      };
-    }
     const repository = String(item.repository || '').split('/').map(encodeURIComponent).join('/');
-    if (item.kind === 'issue-close') {
-      return {
-        url: base + 'api/v1/repos/' + repository + '/issues/' + encodeURIComponent(item.number) + '/close',
-        options: {
-          method: 'PATCH',
-          headers: { Accept: 'application/json', 'Idempotency-Key': item.operationId },
-        },
-      };
-    }
-    if (item.kind === 'issue-blocker') {
-      return {
-        url: base + 'api/v1/repos/' + repository + '/issues/' + encodeURIComponent(item.number) + '/blockers',
-        options: {
-          method: 'PATCH',
-          headers: {
-            Accept: 'application/json',
-            'Content-Type': 'application/json',
-            'Idempotency-Key': item.operationId,
-          },
-          body: JSON.stringify({
-            repository: item.blockerRepository,
-            number: item.blockerNumber,
-            present: item.present === true,
-          }),
-        },
-      };
-    }
-    if (item.kind === 'issue-content') {
-      return {
-        url: base + 'api/v1/repos/' + repository + '/issues/' + encodeURIComponent(item.number) + '/content',
-        options: {
-          method: 'PATCH',
-          headers: {
-            Accept: 'application/json',
-            'Content-Type': 'application/json',
-            'Idempotency-Key': item.operationId,
-          },
-          body: JSON.stringify({
-            title: item.title,
-            body: item.body,
-            expected_updated_at: item.expectedUpdatedAt,
-          }),
-        },
-      };
-    }
-    if (item.kind === 'pull-review') {
-      return {
-        url: base + 'api/v1/repos/' + repository + '/pulls/' + encodeURIComponent(item.number) + '/review',
-        options: {
-          method: 'POST',
-          headers: {
-            Accept: 'application/json',
-            'Content-Type': 'application/json',
-            'Idempotency-Key': item.operationId,
-          },
-          body: JSON.stringify({
-            body: item.body,
-            decision: item.decision,
-            expected_head_sha: item.expectedHeadSha,
-            comments: item.comments || [],
-          }),
-        },
-      };
-    }
     if (item.kind === 'issue-comment' || item.kind === 'pull-comment') {
       const resource = item.kind === 'pull-comment' ? 'pulls' : 'issues';
       return authoredRequest(
@@ -464,13 +180,6 @@ function createBackgroundIssueSync({
         item,
       );
     }
-    if (item.kind === 'search-reply') {
-      return authoredRequest(
-        'api/v1/repos/' + repository + '/issues/' + encodeURIComponent(item.number) +
-          '/preview/comments?kind=' + encodeURIComponent(item.targetKind),
-        item,
-      );
-    }
     return {
       url: base + 'api/v1/repos/' + repository + '/issues',
       options: {
@@ -484,8 +193,6 @@ function createBackgroundIssueSync({
           title: item.title,
           body: item.body,
           label_ids: item.labelIds,
-          ...(item.unassigned ? { unassigned: true } : {}),
-          ...(item.assignee ? { assignee: item.assignee } : {}),
           ...(item.milestoneId ? { milestone_id: item.milestoneId } : {}),
           ...(item.dueDate ? { due_date: item.dueDate + 'T23:59:59Z' } : {}),
         }),
@@ -508,306 +215,29 @@ function createBackgroundIssueSync({
     };
   }
 
-  function stageOperationId(operationId, stage) {
-    const suffix = ':' + stage;
-    return String(operationId || '').slice(0, 128 - suffix.length) + suffix;
-  }
-
-  function evidenceMarkdown(attachment, markdown, index) {
-    const note = String(attachment?.note || '').replace(/\s+/g, ' ').trim().slice(0, 240);
-    if (!note) return markdown;
-    const escaped = note.replace(/([\\`*_[\]{}()<>#+\-.!|])/g, '\\$1');
-    return '**Screenshot ' + (index + 1) + ' — ' + escaped + '**\n\n' + markdown;
-  }
-
-  function conversationAttachments(item) {
-    return (Array.isArray(item?.attachments) ? item.attachments : [item?.attachment]).filter(Boolean);
-  }
-
-  async function uploadConversationAttachments(item, url) {
-    let current = item;
-    const attachments = conversationAttachments(current);
-    const confirmedMarkdowns = attachments.map(value => String(value?.confirmed?.markdown || ''));
-    const firstMissing = confirmedMarkdowns.findIndex(value => !value);
-    const leadingConfirmed = confirmedMarkdowns.slice(0, firstMissing < 0 ? confirmedMarkdowns.length : firstMissing);
-    const markdowns = Array.isArray(current.attachmentMarkdowns) ?
-      current.attachmentMarkdowns.slice(0, attachments.length) :
-      (current.attachmentMarkdown ? [current.attachmentMarkdown] : leadingConfirmed);
-    for (let index = markdowns.length; index < attachments.length; index += 1) {
-      const uploaded = await requestStage(current, url, {
-        method:'POST',
-        headers:{
-          Accept:'application/json',
-          'Idempotency-Key':String(attachments[index]?.operationId || stageOperationId(
-            current.operationId, attachments.length === 1 ? 'attachment' : 'attachment-' + index,
-          )).slice(0, 128),
-        },
-        body:attachmentMultipart(attachments[index]),
-      });
-      const markdown = String(uploaded?.markdown || '');
-      if (!markdown) {
-        const error = new Error('The server did not confirm the screenshot upload.');
-        error.status = 422;
-        throw error;
-      }
-      markdowns.push(markdown);
-      await checkpointClaim(current, stored => ({
-        ...stored, attachmentMarkdowns:markdowns.slice(),
-        ...(attachments.length === 1 ? {attachmentMarkdown:markdown} : {}),
-      }));
-      current = {
-        ...current, attachmentMarkdowns:markdowns.slice(),
-        ...(attachments.length === 1 ? {attachmentMarkdown:markdown} : {}),
-      };
-    }
-    return {
-      current,
-      markdown:markdowns.map((value, index) =>
-        evidenceMarkdown(attachments[index], value, index)).join('\n\n'),
-    };
-  }
-
-  async function deliverReplyRead(item) {
-    let current = item;
-    if (!current.replyConfirmed) {
-      let attachmentMarkdown = '';
-      if (conversationAttachments(current).length) {
-        const uploaded = await uploadConversationAttachments(current,
-          base + 'api/v1/notifications/' + encodeURIComponent(current.notificationId) + '/attachments');
-        current = uploaded.current;
-        attachmentMarkdown = uploaded.markdown;
-      }
-      const text = String(current.body || '').trim();
-      const replyBody = attachmentMarkdown ?
-        (text ? text + '\n\n' + attachmentMarkdown : attachmentMarkdown) : text;
-      const options = authoredRequest('', { ...current, body:replyBody }).options;
-      if (conversationAttachments(current).length) options.headers['Idempotency-Key'] = stageOperationId(current.operationId, 'reply');
-      await requestStage(
-        current,
-        base + 'api/v1/notifications/' + encodeURIComponent(current.notificationId) + '/reply',
-        options,
-      );
-      const checkpointed = await checkpointClaim(current, stored => ({ ...stored, replyConfirmed: true }));
-      if (checkpointed === false) throw new Error('Background delivery claim was lost.');
-      current = { ...current, replyConfirmed: true };
-    }
-    const request = deliveryRequest(current);
-    return requestStage(current, request.url, request.options);
-  }
-
-  function attachmentMultipart(attachment) {
-    let blob = attachment?.blob;
-    if (!blob && attachment?.data) {
-      const binary = atob(String(attachment.data));
-      const bytes = Uint8Array.from(binary, character => character.charCodeAt(0));
-      blob = new Blob([bytes], { type: String(attachment.contentType || '') });
-    }
-    if (!blob) throw new Error('The saved screenshot is unavailable. Retry before sending.');
-    const form = new FormData();
-    form.append('file', blob, String(attachment.filename || 'screenshot'));
-    return form;
-  }
-
-  async function deliverIssueCapture(item) {
-    const repository = String(item.repository || '').split('/').map(encodeURIComponent).join('/');
-    let deliveredIssue = item.deliveredIssue;
-    if (!deliveredIssue) {
-      const request = deliveryRequest(item);
-      deliveredIssue = await requestStage(item, request.url, request.options);
-      await checkpointClaim(item, current => ({ ...current, deliveredIssue }));
-    }
-    const blockers = Array.isArray(item.blockers) ? item.blockers : [];
-    let deliveredBlockers = Math.min(Number(item.deliveredBlockers) || 0, blockers.length);
-    for (let index = deliveredBlockers; index < blockers.length; index += 1) {
-      const blocker = blockers[index];
-      await requestStage(
-        item,
-        base + 'api/v1/repos/' + repository + '/issues/' + encodeURIComponent(deliveredIssue.number) + '/blockers',
-        {
-          method:'PATCH',
-          headers:{
-            Accept:'application/json', 'Content-Type':'application/json',
-            'Idempotency-Key':stageOperationId(item.operationId, 'blocker-' + index),
-          },
-          body:JSON.stringify({repository:blocker.repository, number:blocker.number, present:true}),
-        },
-      );
-      deliveredBlockers = index + 1;
-      await checkpointClaim(item, current => ({ ...current, deliveredIssue, deliveredBlockers }));
-    }
-    const attachments = (Array.isArray(item.attachments) ? item.attachments : [item.attachment]).filter(Boolean);
-    if (!attachments.length) return deliveredIssue;
-    const attachmentMarkdowns = Array.isArray(item.attachmentMarkdowns)
-      ? item.attachmentMarkdowns.slice(0, attachments.length)
-      : (item.attachmentMarkdown ? [item.attachmentMarkdown] : []);
-    for (let index = attachmentMarkdowns.length; index < attachments.length; index += 1) {
-      const uploaded = await requestStage(
-        item,
-        base + 'api/v1/repos/' + repository + '/issues/' + encodeURIComponent(deliveredIssue.number) + '/attachments',
-        {
-          method: 'POST',
-          headers: {
-            Accept: 'application/json',
-            'Idempotency-Key': stageOperationId(
-              item.operationId, attachments.length === 1 ? 'attachment' : 'attachment-' + index,
-            ),
-          },
-          body: attachmentMultipart(attachments[index]),
-        },
-      );
-      const markdown = String(uploaded?.markdown || '');
-      if (!markdown) {
-        const error = new Error('The server did not confirm the screenshot upload.');
-        error.status = 422;
-        throw error;
-      }
-      attachmentMarkdowns.push(markdown);
-      await checkpointClaim(item, current => ({
-        ...current, deliveredIssue, attachmentMarkdowns:attachmentMarkdowns.slice(),
-        ...(attachments.length === 1 ? {attachmentMarkdown:markdown} : {}),
-      }));
-    }
-    const attachmentMarkdown = attachmentMarkdowns.map((markdown, index) =>
-      evidenceMarkdown(attachments[index], markdown, index)).join('\n\n');
-    await requestStage(
-      item,
-      base + 'api/v1/repos/' + repository + '/issues/' + encodeURIComponent(deliveredIssue.number) + '/comments',
-      {
-        method: 'POST',
-        headers: {
-          Accept: 'application/json', 'Content-Type': 'application/json',
-          'Idempotency-Key': stageOperationId(item.operationId, 'attachment-comment'),
-        },
-        body: JSON.stringify({ body: attachmentMarkdown }),
-      },
-    );
-    return deliveredIssue;
-  }
-
-  async function deliverScreenshotComment(item) {
-    const repository = String(item.repository || '').split('/').map(encodeURIComponent).join('/');
-    const resource = item.kind === 'pull-comment' ? 'pulls' : 'issues';
-    const uploaded = await uploadConversationAttachments(item,
-      base + 'api/v1/repos/' + repository + '/' + resource + '/' + encodeURIComponent(item.number) + '/attachments');
-    const attachmentMarkdown = uploaded.markdown;
-    const text = String(item.body || '').trim();
-    return requestStage(
-      item,
-      base + 'api/v1/repos/' + repository + '/' + resource + '/' + encodeURIComponent(item.number) + '/comments',
-      {
-        method: 'POST',
-        headers: {
-          Accept: 'application/json', 'Content-Type': 'application/json',
-          'Idempotency-Key': stageOperationId(item.operationId, 'comment'),
-        },
-        body: JSON.stringify({ body: text ? text + '\n\n' + attachmentMarkdown : attachmentMarkdown }),
-      },
-    );
-  }
-
-  async function deliverSearchReply(item) {
-    const repository = String(item.repository || '').split('/').map(encodeURIComponent).join('/');
-    let current = item;
-    let attachmentMarkdown = '';
-    if (conversationAttachments(current).length) {
-      const uploaded = await uploadConversationAttachments(current,
-        base + 'api/v1/repos/' + repository + '/issues/' + encodeURIComponent(current.number) +
-          '/preview/attachments?kind=' + encodeURIComponent(current.targetKind));
-      current = uploaded.current;
-      attachmentMarkdown = uploaded.markdown;
-    }
-    const text = String(current.body || '').trim();
-    return requestStage(current,
-      base + 'api/v1/repos/' + repository + '/issues/' + encodeURIComponent(current.number) +
-        '/preview/comments?kind=' + encodeURIComponent(current.targetKind), {
-        method:'POST',
-        headers:{Accept:'application/json','Content-Type':'application/json',
-          'Idempotency-Key':stageOperationId(current.operationId, 'comment')},
-        body:JSON.stringify({body:attachmentMarkdown ?
-          (text ? text + '\n\n' + attachmentMarkdown : attachmentMarkdown) : text}),
-      });
-  }
-
-  async function deliverUpdateScreenshotReply(item) {
-    const uploaded = await uploadConversationAttachments(item,
-      base + 'api/v1/notifications/' + encodeURIComponent(item.notificationId) + '/attachments');
-    const current = uploaded.current;
-    const attachmentMarkdown = uploaded.markdown;
-    const text = String(current.body || '').trim();
-    return requestStage(current,
-      base + 'api/v1/notifications/' + encodeURIComponent(current.notificationId) + '/reply', {
-        method:'POST',
-        headers:{ Accept:'application/json', 'Content-Type':'application/json',
-          'Idempotency-Key':stageOperationId(current.operationId, 'reply') },
-        body:JSON.stringify({ body:text ? text + '\n\n' + attachmentMarkdown : attachmentMarkdown }),
-      });
-  }
-
   async function deliver(item) {
     const request = deliveryRequest(item);
     try {
-      const delivered = item.kind === 'update-reply-read' ? await deliverReplyRead(item) :
-        item.kind === 'search-reply' ? await deliverSearchReply(item) :
-        item.kind === 'update-reply' && conversationAttachments(item).length ? await deliverUpdateScreenshotReply(item) :
-        conversationAttachments(item).length && ['issue-comment', 'pull-comment'].includes(item.kind) ?
-        await deliverScreenshotComment(item) : item.attachment && !item.kind ?
-          await deliverIssueCapture(item) : item.attachments?.length && !item.kind ?
-            await deliverIssueCapture(item) : item.blockers?.length && !item.kind ?
-              await deliverIssueCapture(item) : await requestStage(item, request.url, request.options);
-      if (item.kind === 'issue-close' && delivered?.state !== 'closed') {
-        const error = new Error('Issue closure was not confirmed.');
-        error.status = 422;
-        throw error;
-      }
-      if (item.kind === 'issue-blocker') {
-        const dependencies = Array.isArray(delivered?.dependencies) ? delivered.dependencies : [];
-        const present = dependencies.some(candidate => candidate?.repository === item.blockerRepository &&
-          Number(candidate?.number) === item.blockerNumber);
-        if (delivered?.number !== item.number || delivered?.dependencies_available !== true || present !== item.present) {
-          const error = new Error('Blocker change was not confirmed.');
-          error.status = 422;
-          throw error;
-        }
-      }
-      if (item.kind === 'issue-content' &&
-          (delivered?.number !== item.number || delivered?.title !== item.title || delivered?.body !== item.body)) {
-        const error = new Error('Checklist update was not confirmed.');
-        error.status = 422;
-        throw error;
-      }
-      await completeClaim(item, delivered);
+      const delivered = await fetchJson(request.url, request.options);
+      await store.complete(item.id);
       const receipt = receiptFor(item, 'confirmed', delivered);
       return item.kind ? { message: delivered, receipt } : { issue: delivered, receipt };
     } catch (error) {
       const status = Number(error?.status || 0);
       if (status === 401) {
-        await releaseClaim(item);
+        await store.release(item.id);
         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,
-          String(error?.message || 'Issue needs attention').slice(0, 240),
-          error?.code === 'delivery_uncertain' ? 'uncertain' : undefined,
-        );
+        await store.fail(item.id, String(error?.message || 'Issue needs attention').slice(0, 240));
         return { attention: true, error, receipt: receiptFor(item, 'attention') };
       }
-      await releaseClaim(item);
+      await store.release(item.id);
       throw error;
     }
   }
 
   async function send(item, currentLogin) {
-    if (purgeRequested) return { blocked: true };
     if (!currentLogin || item.ownerLogin !== currentLogin) return { blocked: true };
     await store.upsert(item);
     const claimed = await store.claim(item.id, currentLogin);
@@ -815,112 +245,30 @@ function createBackgroundIssueSync({
     return deliver(claimed);
   }
 
-  async function runFlush() {
-    const identity = await requestJson(base + 'api/v1/background-identity', {
+  async function flush() {
+    const identity = await fetchJson(base + 'api/v1/background-identity', {
       headers: { Accept: 'application/json' }, cache: 'no-store',
     });
     const login = String(identity?.login || '').trim();
     const confirmed = [];
     const receipts = [];
     let attention = 0;
-    let authorization = 0;
-    if (!login) return { confirmed, blocked: 0, attention, authorization, login, receipts };
-    const collect = result => {
+    if (!login) return { confirmed, blocked: 0, attention, login, receipts };
+    while (true) {
+      const item = await store.claimNext(login);
+      if (!item) break;
+      const result = await deliver(item);
       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) {
-      const planned = await store.planBatch(login, batchSize);
-      let next = 0;
-      let authenticationError = null;
-      let transientError = null;
-      const worker = async () => {
-        while (!purgeRequested && !authenticationError && next < planned.length) {
-          const id = planned[next++];
-          const item = await store.claim(id, login);
-          if (!item) continue;
-          try {
-            collect(await deliver(item));
-          } catch (error) {
-            if (Number(error?.status || 0) === 401) authenticationError = error;
-            else if (!transientError) transientError = error;
-          }
-        }
-      };
-      const concurrency = Math.max(1, Math.min(Number(maxConcurrency) || 1, planned.length));
-      await Promise.all(Array.from({ length: concurrency }, worker));
-      if (purgeRequested) throw new Error('Background delivery canceled.');
-      if (authenticationError) throw authenticationError;
-      if (transientError) throw transientError;
-    } else if (store.claimBatch) {
-      const claimed = await store.claimBatch(login, batchSize);
-      let next = 0;
-      let authenticationError = null;
-      let transientError = null;
-      const worker = async () => {
-        while (!purgeRequested && !authenticationError && next < claimed.length) {
-          const item = claimed[next++];
-          try {
-            collect(await deliver(item));
-          } catch (error) {
-            if (Number(error?.status || 0) === 401) authenticationError = error;
-            else if (!transientError) transientError = error;
-          }
-        }
-      };
-      const concurrency = Math.max(1, Math.min(Number(maxConcurrency) || 1, claimed.length));
-      await Promise.all(Array.from({ length: concurrency }, worker));
-      if (purgeRequested) {
-        await Promise.all(claimed.slice(next).map(item => store.release(item.id)));
-        throw new Error('Background delivery canceled.');
-      }
-      if (authenticationError) {
-        await Promise.all(claimed.slice(next).map(item => store.release(item.id)));
-        throw authenticationError;
-      }
-      if (transientError) throw transientError;
-    } else {
-      while (!purgeRequested) {
-        const item = await store.claimNext(login);
-        if (!item) break;
-        collect(await deliver(item));
-      }
     }
     const blocked = store.countBlocked ? await store.countBlocked(login) : 0;
-    return { confirmed, blocked, attention, authorization, login, receipts };
-  }
-
-  function flush() {
-    if (purgeRequested) return Promise.resolve({ confirmed: [], blocked: 0, attention: 0, login: '', receipts: [] });
-    if (activeFlush) return activeFlush;
-    activeFlush = Promise.resolve().then(() => batch(runFlush)).finally(() => { activeFlush = null; });
-    return activeFlush;
-  }
-
-  function purge() {
-    if (activePurge) return activePurge;
-    purgeRequested = true;
-    activeRequests.forEach(controller => controller.abort());
-    activePurge = (async () => {
-      if (activeFlush) await activeFlush.catch(() => {});
-      await store.close?.();
-    })();
-    return activePurge;
-  }
-
-  async function resume() {
-    const pendingPurge = activePurge;
-    if (pendingPurge) await pendingPurge;
-    if (activePurge === pendingPurge) activePurge = null;
-    purgeRequested = false;
+    return { confirmed, blocked, attention, login, receipts };
   }
 
   return {
-    flush, send, purge, resume,
-    get: id => store.get(id),
+    flush, send,
     reconcile: (items, outboxLane) => store.reconcile(items, outboxLane),
     snapshot: () => store.snapshot(),
     setReceiptPreference: (ownerLogin, enabled) => store.setReceiptPreference(ownerLogin, enabled),
@@ -933,5 +281,4 @@ if (typeof module !== 'undefined' && module.exports) module.exports = createBack
 if (typeof globalThis !== 'undefined') {
   globalThis.createBackgroundIssueSync = createBackgroundIssueSync;
   globalThis.createIssueSyncStore = createIssueSyncStore;
-  globalThis.createUnfiledAttachmentStore = createUnfiledAttachmentStore;
 }

frontend/batch-find-work.js

@@ -1,162 +0,0 @@
-function createBatchFindWork({
-  capacity,
-  claim,
-  queue,
-  timeBudget = () => ({ capacity_minutes: null, planned_minutes: 0 }),
-  persistEstimate = () => {},
-  onProgress = () => {},
-  storage = typeof localStorage === 'undefined' ? null : localStorage,
-  owner = () => '',
-  journalName = 'find-work-batch',
-  queueFailureReason = 'assigned but Today sync is unavailable',
-  autoMount = true,
-}) {
-  let request = null;
-  const journalKey = () => 'stackchain.' + journalName + '.v1.' +
-    encodeURIComponent(String(owner() || ''));
-
-  function readJournal() {
-    if (!storage || !String(owner() || '')) return null;
-    try {
-      const value = JSON.parse(storage.getItem(journalKey()) || 'null');
-      return value?.owner === String(owner()) && Array.isArray(value.items) ? value : null;
-    } catch (_error) { return null; }
-  }
-
-  function writeJournal(value) {
-    if (!storage || !String(owner() || '')) return;
-    storage.setItem(journalKey(), JSON.stringify(value));
-  }
-
-  function clearJournal() {
-    if (storage && String(owner() || '')) storage.removeItem(journalKey());
-  }
-
-  function result(status, selected, available, queued = [], failed = []) {
-    return { status, selected, available, queued, failed };
-  }
-
-  function key(item) {
-    return String(item.repository || '') + '#' + String(item.number || '');
-  }
-
-  async function processJournal(journal) {
-    const selected = journal.items;
-    const queued = [];
-    const failed = [];
-    for (let index = 0; index < selected.length; index += 1) {
-      const entry = selected[index];
-      const item = entry.item;
-      if (entry.state === 'queued') {
-        queued.push(key(item));
-        onProgress({ status: 'running', processed: index + 1, selected: selected.length });
-        continue;
-      }
-      try {
-        const confirmed = entry.confirmed || await claim(item);
-        if (!entry.confirmed) {
-          entry.confirmed = confirmed;
-          entry.state = 'assigned';
-          writeJournal(journal);
-        }
-        const queueResult = await queue(confirmed, journal.context);
-        if (queueResult === 'queued' || queueResult === 'exists') {
-          queued.push(key(item));
-          entry.state = 'queued';
-          if (Number.isInteger(entry.estimate) && entry.estimate > 0) {
-            persistEstimate(confirmed, entry.estimate);
-          }
-          writeJournal(journal);
-        } else {
-          failed.push({ key: key(item), reason: queueFailureReason, assigned: true });
-        }
-      } catch (error) {
-        failed.push({ key: key(item), reason: error?.message || 'assignment failed' });
-      }
-      onProgress({ status: 'running', processed: index + 1, selected: selected.length });
-    }
-    const outcome = result('complete', selected.length, journal.available, queued, failed);
-    if (!failed.length) clearJournal();
-    else writeJournal(journal);
-    onProgress({ ...outcome, processed: selected.length });
-    return outcome;
-  }
-
-  function run(items, estimates = {}, context = null) {
-    if (request) return request;
-    const selected = Array.isArray(items) ? items.slice() : [];
-    const available = Math.max(0, Number(capacity()) || 0);
-    if (selected.length > available) {
-      const outcome = result('full', selected.length, available);
-      onProgress(outcome);
-      return Promise.resolve(outcome);
-    }
-    const budget = timeBudget() || {};
-    if (Number.isInteger(budget.capacity_minutes) && budget.capacity_minutes > 0) {
-      const remaining = Math.max(0, budget.capacity_minutes - (Number(budget.planned_minutes) || 0));
-      const invalid = selected.map(key).filter(id =>
-        !Number.isInteger(estimates[id]) || estimates[id] <= 0
-      );
-      const requested = selected.reduce((sum, item) => sum +
-        (Number.isInteger(estimates[key(item)]) && estimates[key(item)] > 0 ? estimates[key(item)] : 0), 0);
-      if (invalid.length) {
-        const outcome = { ...result('estimates-required', selected.length, available),
-          remaining_minutes: remaining, requested_minutes: requested, invalid };
-        onProgress(outcome);
-        return Promise.resolve(outcome);
-      }
-      if (requested > remaining) {
-        const outcome = { ...result('over-budget', selected.length, available),
-          remaining_minutes: remaining, requested_minutes: requested, over_minutes: requested - remaining };
-        onProgress(outcome);
-        return Promise.resolve(outcome);
-      }
-    }
-    const journal = {
-      owner: String(owner() || ''), available, context,
-      items: selected.map(item => ({ item, estimate: estimates[key(item)] || null, state: 'pending' })),
-    };
-    writeJournal(journal);
-    request = processJournal(journal).finally(() => { request = null; });
-    return request;
-  }
-
-  function resume() {
-    if (request) return request;
-    const journal = readJournal();
-    if (!journal) return Promise.resolve(null);
-    request = processJournal(journal).finally(() => { request = null; });
-    return request;
-  }
-
-  function pending() {
-    const journal = readJournal();
-    return journal ? journal.items.filter(item => item.state !== 'queued').length : 0;
-  }
-
-  function mountRecovery(button, opener) {
-    const show = () => {
-      const journal = readJournal();
-      button.hidden = !journal;
-      if (journal) button.textContent = 'Resume ' + journal.items.filter(item => item.state !== 'queued').length + ' interrupted';
-    };
-    button.addEventListener('click', async () => {
-      button.disabled = true;
-      const outcome = await resume();
-      button.disabled = false;
-      show();
-      if (outcome) {
-        button.previousElementSibling.textContent = outcome.failed.length ?
-          outcome.failed.length + ' still need recovery.' : outcome.queued.length + ' queued · batch recovered.';
-      }
-    });
-    opener.addEventListener('click', show);
-  }
-
-  if (autoMount && typeof document !== 'undefined') mountRecovery(
-    document.getElementById('resume-find-work-batch'), document.getElementById('find-work')
-  );
-  return { run, resume, pending, mountRecovery };
-}
-
-if (typeof module !== 'undefined' && module.exports) module.exports = createBatchFindWork;

frontend/card-planning.js

@@ -1,39 +0,0 @@
-(function (root, factory) {
-  if (typeof module !== 'undefined' && module.exports) module.exports = factory;
-  else root.createCardPlanning = factory;
-})(typeof self !== 'undefined' ? self : this, function createCardPlanning(root) {
-  function sync(disclosure) {
-    disclosure.querySelector('summary')?.setAttribute(
-      'aria-expanded', String(disclosure.open)
-    );
-  }
-
-  function wire() {
-    const disclosures = Array.from(root.querySelectorAll('[data-card-planning]'));
-    disclosures.forEach(disclosure => {
-      if (disclosure.dataset.cardPlanningBound === 'true') return;
-      disclosure.dataset.cardPlanningBound = 'true';
-      sync(disclosure);
-      disclosure.addEventListener('toggle', () => {
-        if (disclosure.open) {
-          disclosures.forEach(other => {
-            if (other === disclosure || !other.open) return;
-            other.open = false;
-            sync(other);
-          });
-        }
-        sync(disclosure);
-      });
-      disclosure.addEventListener('keydown', event => {
-        if (event.key !== 'Escape' || !disclosure.open) return;
-        disclosure.open = false;
-        sync(disclosure);
-        disclosure.querySelector('summary')?.focus();
-        event.preventDefault();
-        event.stopPropagation();
-      });
-    });
-  }
-
-  return { wire };
-});

frontend/checklist-conflict.js

@@ -1,141 +0,0 @@
-function mergeChecklistConflict({ baseBody, localBody, remoteBody, operations = [] }) {
-  const taskPattern = /^(\s*[-*+]\s+\[)([ xX])(\]\s+)(.*)$/;
-
-  function tasks(body) {
-    const entries = [];
-    String(body || '').split('\n').forEach((line, lineIndex) => {
-      const match = line.match(taskPattern);
-      if (!match) return;
-      const label = match[4].trim();
-      const key = label.replace(/\s+/g, ' ').toLocaleLowerCase();
-      if (!key) return;
-      entries.push({ key, label, checked: match[2].toLowerCase() === 'x', lineIndex, match });
-    });
-    return entries;
-  }
-
-  function grouped(entries) {
-    const result = new Map();
-    entries.forEach(entry => result.set(entry.key, [...(result.get(entry.key) || []), entry]));
-    return result;
-  }
-
-  function replayOperations(body, requested, reportChanges) {
-    let lines = String(body || '').split('\n');
-    const visibleTasks = value => tasks(value).filter(entry => /^[-*+]/.test(entry.match[1]));
-    const logical = visibleTasks(baseBody).map(entry => ({ key:entry.key, label:entry.label }));
-    const replayed = [];
-    for (const operation of requested) {
-      const index = Number(operation?.index);
-      const target = logical[index];
-      if (!target) return { body:null, changes:replayed, conflict:{ label:'Checklist step', reason:'missing' } };
-      let entries = visibleTasks(lines.join('\n'));
-      const matches = entries.filter(entry => entry.key === target.key);
-      if (matches.length !== 1) {
-        return { body:null, changes:replayed, conflict:{
-          label:target.label, reason:matches.length ? 'ambiguous' : 'missing',
-        } };
-      }
-      const match = matches[0];
-      if (operation.action === 'rename') {
-        const label = String(operation.label || '').trim().replace(/\s+/g, ' ');
-        const key = label.toLocaleLowerCase();
-        if (!label || entries.some(entry => entry.key === key && entry.lineIndex !== match.lineIndex)) {
-          return { body:null, changes:replayed, conflict:{ label:target.label, reason:'ambiguous' } };
-        }
-        lines[match.lineIndex] = match.match[1] + match.match[2] + match.match[3] + label;
-        if (reportChanges) replayed.push({ label:target.label, renamed:label });
-        target.label = label;
-        target.key = key;
-      } else if (operation.action === 'remove') {
-        lines.splice(match.lineIndex, 1);
-        logical.splice(index, 1);
-        if (reportChanges) replayed.push({ label:target.label, removed:true });
-      } else if (operation.action === 'move-earlier' || operation.action === 'move-later') {
-        const neighborIndex = operation.action === 'move-earlier' ? index - 1 : index + 1;
-        const neighbor = logical[neighborIndex];
-        const neighborMatches = neighbor ? entries.filter(entry => entry.key === neighbor.key) : [];
-        if (neighborMatches.length !== 1 || Math.abs(neighborMatches[0].lineIndex - match.lineIndex) !== 1) {
-          return { body:null, changes:replayed, conflict:{ label:target.label, reason:'order-changed' } };
-        }
-        const neighborLine = neighborMatches[0].lineIndex;
-        [lines[match.lineIndex], lines[neighborLine]] = [lines[neighborLine], lines[match.lineIndex]];
-        [logical[index], logical[neighborIndex]] = [logical[neighborIndex], logical[index]];
-        if (reportChanges) replayed.push({
-          label:target.label, moved:operation.action === 'move-earlier' ? 'earlier' : 'later',
-        });
-      }
-    }
-    return { body:lines.join('\n'), changes:replayed, conflict:null };
-  }
-
-  if (Array.isArray(operations) && operations.length) {
-    const baseReplay = replayOperations(baseBody, operations, false);
-    const remoteReplay = replayOperations(remoteBody, operations, true);
-    const conflict = baseReplay.conflict || remoteReplay.conflict;
-    if (conflict) return { body:null, changes:remoteReplay.changes || [], conflicts:[conflict] };
-    const residual = mergeChecklistConflict({
-      baseBody:baseReplay.body, localBody, remoteBody:remoteReplay.body,
-    });
-    return {
-      body:residual.body,
-      changes:[...remoteReplay.changes, ...residual.changes],
-      conflicts:residual.conflicts,
-    };
-  }
-
-  const base = grouped(tasks(baseBody));
-  const local = grouped(tasks(localBody));
-  const remoteEntries = tasks(remoteBody);
-  const remote = grouped(remoteEntries);
-  const changes = [];
-  const conflicts = [];
-
-  for (const [key, baseMatches] of base) {
-    const localMatches = local.get(key) || [];
-    if (baseMatches.length !== 1 || localMatches.length !== 1) continue;
-    if (baseMatches[0].checked === localMatches[0].checked) continue;
-    const remoteMatches = remote.get(key) || [];
-    if (remoteMatches.length !== 1) {
-      conflicts.push({
-        label: baseMatches[0].label,
-        reason: remoteMatches.length ? 'ambiguous' : 'missing',
-      });
-      continue;
-    }
-    changes.push({ label: remoteMatches[0].label, checked: localMatches[0].checked });
-  }
-
-  for (const [key, localMatches] of local) {
-    if (base.has(key)) continue;
-    if (localMatches.length !== 1) {
-      conflicts.push({ label:localMatches[0].label, reason:'ambiguous' });
-      continue;
-    }
-    const remoteMatches = remote.get(key) || [];
-    if (remoteMatches.length > 1) {
-      conflicts.push({ label: localMatches[0].label, reason: 'ambiguous' });
-      continue;
-    }
-    if (remoteMatches.length === 0) {
-      changes.push({ label: localMatches[0].label, checked:localMatches[0].checked, added:true });
-    }
-  }
-
-  if (conflicts.length) return { body: null, changes, conflicts };
-  const desired = new Map(changes.map(change => [
-    change.label.replace(/\s+/g, ' ').toLocaleLowerCase(), change.checked,
-  ]));
-  const lines = String(remoteBody || '').split('\n');
-  remoteEntries.forEach(entry => {
-    if (!desired.has(entry.key)) return;
-    const marker = desired.get(entry.key) ? 'x' : ' ';
-    lines[entry.lineIndex] = entry.match[1] + marker + entry.match[3] + entry.match[4];
-  });
-  changes.filter(change => change.added).forEach(change => {
-    lines.push('- [' + (change.checked ? 'x' : ' ') + '] ' + change.label);
-  });
-  return { body: lines.join('\n'), changes, conflicts: [] };
-}
-
-if (typeof module !== 'undefined') module.exports = mergeChecklistConflict;

frontend/commands.js

@@ -15,15 +15,6 @@
     return current;
   };
 
-  filterCommands.searchUrl = function searchUrl(query, page, scope, continuation) {
-    const streamPages = continuation ?
-      (continuation.issues ? '&issues_page=' + encodeURIComponent(continuation.issues) : '') +
-      (continuation.pulls ? '&pulls_page=' + encodeURIComponent(continuation.pulls) : '') : '';
-    return 'api/v1/search?q=' + encodeURIComponent(query) + '&limit=10&page=' + page +
-      '&kind=' + encodeURIComponent(scope.kind) + '&state=' + encodeURIComponent(scope.state) +
-      (scope.repository ? '&repository=' + encodeURIComponent(scope.repository) : '') + streamPages;
-  };
-
   filterCommands.createGlobalSearchController = function createGlobalSearchController(options) {
     const search = options.search;
     const onState = options.onState;
@@ -31,46 +22,6 @@
     let timer = null;
     let generation = 0;
     let activeController = null;
-    let scope = { kind:'all', state:'all' };
-    let state = { status: 'idle', query: '', items: [], more: false, next: 1, scope };
-
-    function publish(next) {
-      state = next;
-      onState(next);
-      return state;
-    }
-
-    async function requestPage(query, page, current, append, continuation) {
-      const requestController = new AbortController();
-      activeController = requestController;
-      try {
-        const requestScope = { ...scope };
-        const result = await search(
-          query, requestController.signal, page, requestScope, continuation
-        );
-        const partial = result.partial === true;
-        const incoming = result.items || result;
-        const combined = append ? state.items.concat(incoming) : incoming;
-        const items = [...new Map((combined || []).map(item =>
-          [`${item.kind}:${item.repository}:${item.number}`, item]
-        )).values()];
-        if (current === generation) return publish({
-          status: 'ready', query, items, partial,
-          more: !!result.has_more,
-          next: result.next_page,
-          continuation:result.continuation,
-          failedStreams:result.failed_streams || [],
-          scope:requestScope,
-        });
-      } catch (error) {
-        if (error && error.name === 'AbortError') return;
-        if (current === generation) return publish(append
-          ? { ...state, status: 'ready' }
-          : { status: 'error', query, items: [], error, scope:{ ...scope } });
-      } finally {
-        if (activeController === requestController) activeController = null;
-      }
-    }
 
     return {
       setQuery(value) {
@@ -81,32 +32,25 @@
         if (activeController !== null) activeController.abort();
         activeController = null;
         if (query.length < 2) {
-          publish({ status: 'idle', query, items: [], more: false, next: 1, scope:{ ...scope } });
+          onState({ status: 'idle', query, items: [] });
           return;
         }
-        publish({ status: 'loading', query, items: [], more: false, next: 1, scope:{ ...scope } });
-        timer = setTimeout(() => requestPage(query, 1, current, false), delay);
-      },
-      setScope(value) {
-        const repository = typeof value?.repository === 'string' &&
-          /^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/.test(value.repository.trim())
-          ? value.repository.trim() : '';
-        const next = {
-          kind:['all', 'issue', 'pull'].includes(value?.kind) ? value.kind : 'all',
-          state:['all', 'open', 'closed'].includes(value?.state) ? value.state : 'all',
-          ...(repository ? { repository } : {}),
-        };
-        if (next.kind === scope.kind && next.state === scope.state &&
-            (next.repository || '') === (scope.repository || '')) return;
-        const query = state.query;
-        scope = next;
-        this.setQuery(query);
-      },
-      loadMore() {
-        if (state.status !== 'ready' || !state.more || activeController) return Promise.resolve(state);
-        const current = generation;
-        const page = state.next;
-        return requestPage(state.query, page, current, true, state.continuation);
+        onState({ status: 'loading', query, items: [] });
+        timer = setTimeout(async () => {
+          const requestController = new AbortController();
+          activeController = requestController;
+          try {
+            const result = await search(query, requestController.signal);
+            const items = Array.isArray(result) ? result : result.items;
+            const partial = !Array.isArray(result) && result.partial === true;
+            if (current === generation) onState({ status: 'ready', query, items, partial });
+          } catch (error) {
+            if (error && error.name === 'AbortError') return;
+            if (current === generation) onState({ status: 'error', query, items: [], error });
+          } finally {
+            if (activeController === requestController) activeController = null;
+          }
+        }, delay);
       },
     };
   };

frontend/comment-actions.js

@@ -1,196 +0,0 @@
-function createCommentActions({ fetchJson, getLogin, confirmDelete = () => false }) {
-  const reactionLabels = {
-    '+1': 'Thumbs up', '-1': 'Thumbs down', laugh: 'Laugh', hooray: 'Hooray',
-    confused: 'Confused', heart: 'Heart', rocket: 'Rocket', eyes: 'Eyes',
-  };
-  const encodedRepository = repository => String(repository || '').split('/')
-    .map(encodeURIComponent).join('/');
-
-  function pathFor(context, commentId) {
-    const item = context?.item || {};
-    if (context?.kind === 'update') {
-      return 'api/v1/notifications/' + encodeURIComponent(item.notification_id) +
-        '/comments/' + encodeURIComponent(commentId);
-    }
-    if (!['issue', 'pull'].includes(context?.kind)) throw new Error('Comment conversation is unavailable.');
-    return 'api/v1/repos/' + encodedRepository(item.repository) + '/' +
-      (context.kind === 'pull' ? 'pulls/' : 'issues/') + encodeURIComponent(item.number) +
-      '/comments/' + encodeURIComponent(commentId);
-  }
-
-  function reactionPath(context, commentId, content = '') {
-    return pathFor(context, commentId) + '/reactions' +
-      (content ? '/' + encodeURIComponent(content) : '');
-  }
-
-  const pendingReactions = new Set();
-  const controller = {
-    isOwned(comment) {
-      const login = String(getLogin() || '').trim();
-      return Boolean(login && comment && comment.author === login);
-    },
-    async edit(context, pager, commentId, body) {
-      const draft = String(body || '').trim();
-      if (!draft) throw new Error('Comment must not be blank.');
-      const comment = await fetchJson(pathFor(context, commentId), {
-        method: 'PATCH',
-        headers: { Accept: 'application/json', 'Content-Type': 'application/json' },
-        body: JSON.stringify({ body: draft }),
-      });
-      pager.replace(comment);
-      return pager.snapshot();
-    },
-    async remove(context, pager, commentId) {
-      if (!confirmDelete('Delete this comment permanently?')) return null;
-      const result = await fetchJson(pathFor(context, commentId), {
-        method: 'DELETE', headers: { Accept: 'application/json' },
-      });
-      if (!result?.deleted || Number(result.id) !== Number(commentId)) {
-        throw new Error('Comment deletion was not confirmed.');
-      }
-      pager.remove(commentId);
-      return pager.snapshot();
-    },
-    async loadReactions(context, commentId) {
-      return fetchJson(reactionPath(context, commentId), {
-        headers: { Accept: 'application/json' },
-      });
-    },
-    async setReaction(context, commentId, content, active) {
-      return fetchJson(reactionPath(context, commentId, content), {
-        method: 'PUT',
-        headers: { Accept: 'application/json', 'Content-Type': 'application/json' },
-        body: JSON.stringify({ active: Boolean(active) }),
-      });
-    },
-    reactionHtml(state) {
-      const current = new Map((state?.reactions || []).map(item => [item.content, item]));
-      return Object.entries(reactionLabels).map(([content, label]) => {
-        const item = current.get(content) || {};
-        const count = Number.isInteger(item.count) && item.count > 0 ? item.count : 0;
-        const selected = item.selected === true;
-        return '<button type="button" data-comment-reaction="' + content + '" ' +
-          'aria-pressed="' + selected + '" aria-label="' + label + ' ' + count + '">' +
-          label + ' ' + count + '</button>';
-      }).join('') + '<button type="button" data-comment-reactions-close>Cancel</button>';
-    },
-    actionHtml(comment) {
-      const owned = controller.isOwned(comment) ?
-        '<div class="comment-owned-actions" aria-label="Your comment actions">' +
-        '<button type="button" data-comment-action="edit">Edit</button>' +
-        '<button type="button" data-comment-action="delete">Delete</button></div>' : '';
-      return owned + '<div class="comment-reactions" aria-label="Comment reactions">' +
-        '<button type="button" data-comment-reactions-open aria-expanded="false" ' +
-        'aria-label="React to this comment">React</button>' +
-        '<div class="comment-reaction-menu" data-comment-reaction-menu hidden></div></div>';
-    },
-    wire({ root, getSurface, isOffline, escapeHtml }) {
-      root.addEventListener('click', async event => {
-        const actionButton = event.target.closest('[data-comment-action]');
-        const reactionClose = actionButton ? null : event.target.closest('[data-comment-reactions-close]');
-        const reactionButton = actionButton ? null : event.target.closest('[data-comment-reaction]');
-        const reactionTrigger = actionButton ? null : event.target.closest('[data-comment-reactions-open]');
-        if (reactionClose) {
-          const card = reactionClose.closest('.issue-comment');
-          const menu = card?.querySelector('[data-comment-reaction-menu]');
-          const trigger = card?.querySelector('[data-comment-reactions-open]');
-          if (menu && trigger) {
-            menu.hidden = true;
-            trigger.setAttribute('aria-expanded', 'false');
-            trigger.focus();
-          }
-          return;
-        }
-        if (reactionButton || reactionTrigger) {
-          const control = reactionButton || reactionTrigger;
-          const card = control.closest('.issue-comment');
-          const commentId = Number(card?.dataset.commentId);
-          const surface = getSurface();
-          const menu = card?.querySelector('[data-comment-reaction-menu]');
-          const trigger = card?.querySelector('[data-comment-reactions-open]');
-          if (!commentId || !menu || !trigger) return;
-          if (isOffline()) {
-            surface.status.textContent = 'Reconnect to react.';
-            return;
-          }
-          if (pendingReactions.has(commentId)) return;
-          pendingReactions.add(commentId);
-          control.disabled = true;
-          try {
-            if (reactionButton) {
-              const content = reactionButton.dataset.commentReaction;
-              const active = reactionButton.getAttribute('aria-pressed') !== 'true';
-              const state = await controller.setReaction(surface.context, commentId, content, active);
-              menu.innerHTML = controller.reactionHtml(state);
-              menu.hidden = true;
-              trigger.setAttribute('aria-expanded', 'false');
-              trigger.focus();
-              surface.status.textContent = 'Reaction updated.';
-            } else {
-              surface.status.textContent = 'Loading reactions…';
-              const state = await controller.loadReactions(surface.context, commentId);
-              menu.innerHTML = controller.reactionHtml(state);
-              menu.hidden = false;
-              trigger.setAttribute('aria-expanded', 'true');
-              surface.status.textContent = '';
-            }
-          } catch (error) {
-            surface.status.textContent = error.message || 'Reactions are unavailable. Please retry.';
-          } finally {
-            pendingReactions.delete(commentId);
-            control.disabled = false;
-          }
-          return;
-        }
-        const button = actionButton;
-        if (!button) return;
-        const card = button.closest('.issue-comment');
-        const commentId = Number(card?.dataset.commentId);
-        const surface = getSurface();
-        const comment = surface.pager?.snapshot().comments.find(item => item.id === commentId);
-        if (!comment || !controller.isOwned(comment)) return;
-        if (isOffline()) {
-          surface.status.textContent = 'Reconnect to edit or delete this comment.';
-          return;
-        }
-        if (button.dataset.commentAction === 'delete') {
-          try {
-            const state = await controller.remove(surface.context, surface.pager, commentId);
-            if (state) {
-              surface.render(state);
-              surface.status.textContent = 'Comment deleted.';
-            }
-          } catch (error) {
-            surface.status.textContent = error.message || 'Comment deletion failed. Retry or open it in Gitea.';
-          }
-          return;
-        }
-        card.innerHTML = '<div class="small">Editing your comment</div>' +
-          '<textarea class="comment-edit-textarea" maxlength="10000" aria-label="Edit comment">' +
-          escapeHtml(comment.body || '') + '</textarea>' +
-          '<div class="comment-owned-actions"><button type="button" data-comment-edit-save>Save</button>' +
-          '<button type="button" data-comment-edit-cancel>Cancel</button></div>';
-        const textarea = card.querySelector('.comment-edit-textarea');
-        textarea.focus();
-        card.querySelector('[data-comment-edit-cancel]').addEventListener('click', () => surface.render(surface.pager.snapshot()));
-        card.querySelector('[data-comment-edit-save]').addEventListener('click', async saveEvent => {
-          const save = saveEvent.currentTarget;
-          save.disabled = true;
-          surface.status.textContent = 'Saving comment…';
-          try {
-            const state = await controller.edit(surface.context, surface.pager, commentId, textarea.value);
-            surface.render(state);
-            surface.status.textContent = 'Comment updated.';
-          } catch (error) {
-            save.disabled = false;
-            surface.status.textContent = error.message || 'Comment update failed. Your edit is safe; retry or open it in Gitea.';
-            textarea.focus();
-          }
-        });
-      });
-    },
-  };
-  return controller;
-}
-
-if (typeof module !== 'undefined' && module.exports) module.exports = createCommentActions;

frontend/comment-next.js

@@ -1,61 +0,0 @@
-function createCommentNext({ post, queue, queueKind = '', canQueue, accept = () => undefined, complete }) {
-  let inFlight = null;
-
-  async function admitQueued(item, message) {
-    const admission = await queue(message);
-    if (!admission || (!admission.item && admission.durable !== true)) {
-      throw new Error('Comment was not saved for delivery.');
-    }
-    accept(item, { delivery: admission.background ? 'queued' : 'saved' });
-    return {
-      accepted: true,
-      delivery: admission.background ? 'queued' : 'saved',
-      background: Boolean(admission.background),
-      completed: Boolean(complete(item)),
-    };
-  }
-
-  function submit(item, body, operationId = '') {
-    if (inFlight) return inFlight;
-    inFlight = (async () => {
-      try {
-        let comment;
-        try {
-          comment = await post(item, body, typeof operationId === 'function' ? operationId() : operationId);
-        } catch (error) {
-          if (!canQueue(error)) throw error;
-          const identity = queueKind === 'update-reply' ? {
-            kind: 'update-reply', notificationId: item.notification_id,
-          } : {
-            kind: item.kind === 'pull' ? 'pull-comment' : 'issue-comment',
-            repository: item.repository, number: item.number,
-          };
-          return admitQueued(item, {
-            ...identity, body,
-            operationId: typeof operationId === 'function' ? operationId() : operationId,
-          });
-        }
-        accept(item, { delivery: 'posted', comment });
-        return {
-          accepted: true,
-          delivery: 'posted',
-          comment,
-          completed: Boolean(complete(item)),
-        };
-      } finally {
-        inFlight = null;
-      }
-    })();
-    return inFlight;
-  }
-
-  function admit(item, message) {
-    if (inFlight) return inFlight;
-    inFlight = admitQueued(item, message).finally(() => { inFlight = null; });
-    return inFlight;
-  }
-
-  return { submit, admit, busy: () => Boolean(inFlight) };
-}
-
-if (typeof module !== 'undefined' && module.exports) module.exports = createCommentNext;

frontend/context-poller.js

@@ -1,22 +1,3 @@
-function buildLiveRevisionQuery(revisions = {}) {
-  const params = new URLSearchParams();
-  const tokenPattern = /^[0-9a-f]{16}\.[0-9]{1,20}$/;
-  ['context', 'events', 'notifications'].forEach((section) => {
-    const revision = revisions[section];
-    if (typeof revision === 'string' && tokenPattern.test(revision)) {
-      params.set(section + '_revision', revision);
-    }
-  });
-  return params.toString();
-}
-
-function retryAfterMs(value) {
-  if (typeof value !== 'string' || !/^\d+$/.test(value)) return null;
-  const seconds = Number(value);
-  if (!Number.isFinite(seconds) || seconds <= 0) return null;
-  return Math.min(seconds * 1000, 300000);
-}
-
 function createContextPoller({
   fetchContext,
   onSnapshot,
@@ -24,218 +5,69 @@ function createContextPoller({
   isHidden = () => false,
   setTimer = setTimeout,
   clearTimer = clearTimeout,
-  setDeadlineTimer = setTimeout,
-  clearDeadlineTimer = clearTimeout,
   intervalMs = 8000,
-  timeoutMs = 12000,
-  maxBackoffMs = 60000,
 }) {
-  let activeRequest = null;
+  let inFlight = null;
   let timer = null;
   let stopped = false;
-  let revisions = {};
-  let retainedSnapshot = null;
-  let nextDelayMs = intervalMs;
-  let failureStreak = 0;
-  let nextRetryAt = null;
-  let lastSuccessAt = null;
-
-  function snapshotDelay(snapshot) {
-    const freshness = snapshot && snapshot.freshness;
-    const sections = freshness && freshness.sections;
-    const sectionValues = sections && Object.values(sections);
-    const degradedRetrySeconds = (sectionValues || [])
-      .filter(section => section.degraded)
-      .map(section => Number(section.retry_in_seconds ?? freshness.retry_in_seconds))
-      .filter(seconds => Number.isFinite(seconds) && seconds > 0);
-    const failedSectionDelay = degradedRetrySeconds.length ?
-      Math.min(...degradedRetrySeconds) * 1000 : null;
-    if (sectionValues && sectionValues.length && sectionValues.every(section => section.degraded)) {
-      return failedSectionDelay || intervalMs;
-    }
-    const freshForSeconds = Number(freshness && freshness.fresh_for_seconds);
-    const healthyDeadlines = (sectionValues || [])
-      .filter(section => !section.degraded)
-      .map(section => freshForSeconds - Number(section.age_seconds))
-      .filter(seconds => Number.isFinite(seconds));
-    if (Number.isFinite(freshForSeconds) && freshForSeconds > 0 && healthyDeadlines.length) {
-      const earliestDeadline = Math.min(...healthyDeadlines);
-      const healthyDelay = earliestDeadline <= 0 &&
-        sectionValues.some(section => !section.degraded && section.revalidating) ?
-        intervalMs : Math.max(0, earliestDeadline) * 1000;
-      return failedSectionDelay === null ? healthyDelay : Math.min(healthyDelay, failedSectionDelay);
-    }
-    return intervalMs;
-  }
 
   function cancelTimer() {
     if (timer !== null) clearTimer(timer);
     timer = null;
   }
 
-  function schedule(delayMs = intervalMs) {
+  function schedule() {
     cancelTimer();
     if (stopped || isHidden()) return;
-    nextRetryAt = Date.now() + delayMs;
     timer = setTimer(() => {
       timer = null;
-      nextRetryAt = null;
       refresh();
-    }, delayMs);
+    }, intervalMs);
   }
 
-  function abortError() {
-    const error = new Error('Live update superseded.');
-    error.name = 'AbortError';
-    return error;
-  }
-
-  function supersede(request) {
-    if (!request || request.settled) return;
-    request.superseded = true;
-    request.controller.abort();
-    request.rejectDeadline(abortError());
-  }
-
-  function refresh(options = {}) {
+  function refresh() {
     if (stopped || isHidden()) return Promise.resolve(null);
-    if (activeRequest && !options.force) return activeRequest.promise;
-    if (activeRequest) supersede(activeRequest);
-
-    const controller = new AbortController();
-    let rejectDeadline;
-    const deadlinePromise = new Promise((resolve, reject) => {
-      rejectDeadline = reject;
-    });
-    const requestState = {
-      controller,
-      deadline: null,
-      promise: null,
-      rejectDeadline,
-      settled: false,
-      superseded: false,
-    };
-    activeRequest = requestState;
-    requestState.deadline = setDeadlineTimer(() => {
-      if (requestState.settled || requestState.superseded) return;
-      controller.abort();
-      const error = new Error(`Live update timed out after ${timeoutMs}ms.`);
-      error.name = 'TimeoutError';
-      rejectDeadline(error);
-    }, timeoutMs);
+    if (inFlight) return inFlight;
 
     let request;
     try {
-      request = fetchContext(options.full ? {} : { ...revisions }, { signal: controller.signal });
+      request = fetchContext();
     } catch (error) {
       request = Promise.reject(error);
     }
-    requestState.promise = Promise.race([Promise.resolve(request), deadlinePromise])
+    inFlight = Promise.resolve(request)
       .then((snapshot) => {
-        if (activeRequest !== requestState) return retainedSnapshot;
-        failureStreak = 0;
-        lastSuccessAt = Date.now();
-        nextDelayMs = snapshotDelay(snapshot);
-        const changedSections = ['context', 'events', 'notifications'].filter(
-          (section) => Object.prototype.hasOwnProperty.call(snapshot, section)
-        );
-        retainedSnapshot = retainedSnapshot ? { ...retainedSnapshot, ...snapshot } : { ...snapshot };
-        revisions = { ...revisions, ...(snapshot.revisions || {}) };
-        onSnapshot(retainedSnapshot, changedSections);
-        return retainedSnapshot;
+        onSnapshot(snapshot);
+        return snapshot;
       })
       .catch((error) => {
-        if (activeRequest === requestState && !stopped) {
-          const retryAfterMs = Number(error && error.retryAfterMs);
-          failureStreak += 1;
-          nextDelayMs = Number.isFinite(retryAfterMs) && retryAfterMs > 0
-            ? retryAfterMs
-            : Math.min(intervalMs * (2 ** (failureStreak - 1)), maxBackoffMs);
-          onError(error);
-        }
+        onError(error);
         return null;
       })
       .finally(() => {
-        requestState.settled = true;
-        clearDeadlineTimer(requestState.deadline);
-        if (activeRequest !== requestState) return;
-        activeRequest = null;
-        schedule(nextDelayMs);
+        inFlight = null;
+        schedule();
       });
-    return requestState.promise;
+    return inFlight;
   }
 
   function setVisible(visible) {
     cancelTimer();
     if (!visible) return Promise.resolve(null);
-    return refresh({ force: true });
-  }
-
-  function adopt(snapshot) {
-    if (
-      stopped || activeRequest || retainedSnapshot || !snapshot ||
-      typeof snapshot !== 'object' ||
-      !Object.prototype.hasOwnProperty.call(snapshot, 'context')
-    ) return false;
-    retainedSnapshot = { ...snapshot };
-    revisions = { ...(snapshot.revisions || {}) };
-    failureStreak = 0;
-    lastSuccessAt = Date.now();
-    nextDelayMs = snapshotDelay(snapshot);
-    const changedSections = ['context', 'events', 'notifications'].filter(
-      section => Object.prototype.hasOwnProperty.call(snapshot, section)
-    );
-    onSnapshot(retainedSnapshot, changedSections);
-    schedule(nextDelayMs);
-    return true;
-  }
-
-  async function adoptPending(snapshotPromise) {
-    if (!snapshotPromise || typeof snapshotPromise.then !== 'function') return false;
-    let deadline = null;
-    const timeout = new Promise(resolve => {
-      deadline = setDeadlineTimer(() => resolve(null), timeoutMs);
-    });
-    try {
-      const snapshot = await Promise.race([
-        Promise.resolve(snapshotPromise).catch(() => null),
-        timeout,
-      ]);
-      return adopt(snapshot);
-    } finally {
-      clearDeadlineTimer(deadline);
-    }
+    return refresh();
   }
 
   return {
     start: refresh,
     refresh,
-    adopt,
-    adoptPending,
     setVisible,
-    getState() {
-      return {
-        refreshing: Boolean(activeRequest),
-        nextRetryAt,
-        lastSuccessAt,
-        failureStreak,
-      };
-    },
     stop() {
       stopped = true;
       cancelTimer();
-      if (activeRequest) {
-        const request = activeRequest;
-        activeRequest = null;
-        supersede(request);
-      }
     },
   };
 }
 
-createContextPoller.buildRevisionQuery = buildLiveRevisionQuery;
-createContextPoller.retryAfterMs = retryAfterMs;
-
 if (typeof module !== 'undefined' && module.exports) {
   module.exports = createContextPoller;
 }

frontend/conversation-action-hydrator.js

@@ -1,44 +0,0 @@
-function createConversationActionHydrator({ load, activate }) {
-  let actions = null;
-  let pending = null;
-  const wired = new WeakSet();
-
-  async function ensure() {
-    if (actions) return actions;
-    if (!pending) pending = load().then(() => actions = activate()).catch(error => {
-      pending = null;
-      throw error;
-    });
-    return pending;
-  }
-
-  function show({ root, state, paint, wire, retry }) {
-    if (actions) {
-      retry.hidden = true;
-      if (!wired.has(root)) {
-        wire(actions);
-        wired.add(root);
-      }
-      paint(state, actions);
-      return Promise.resolve(true);
-    }
-
-    paint(state, null);
-    retry.hidden = true;
-    return ensure().then(controller => {
-      if (!wired.has(root)) {
-        wire(controller);
-        wired.add(root);
-      }
-      paint(state, controller);
-      return true;
-    }).catch(() => {
-      retry.hidden = false;
-      return false;
-    });
-  }
-
-  return {show,get:ensure};
-}
-
-if (typeof module !== 'undefined' && module.exports) module.exports = createConversationActionHydrator;

frontend/conversation-photo-drafts.js

@@ -1,93 +0,0 @@
-(function (root, factory) {
-  const createConversationPhotoDrafts = factory();
-  if (typeof module === 'object' && module.exports) module.exports = createConversationPhotoDrafts;
-  else root.createConversationPhotoDrafts = createConversationPhotoDrafts;
-})(typeof globalThis !== 'undefined' ? globalThis : this, function () {
-  'use strict';
-
-  return function createConversationPhotoDrafts({ store, lanes, onChange = () => {} }) {
-    const states = {};
-    Object.entries(lanes || {}).forEach(([kind, lane]) => {
-      states[kind] = { ...lane, target:null, generation:0, restoring:false, pending:Promise.resolve() };
-    });
-
-    function state(kind) {
-      const value = states[kind];
-      if (!value) throw new Error('Unknown conversation photo draft lane.');
-      return value;
-    }
-
-    async function checkpoint(kind) {
-      const current = state(kind);
-      if (!current.target || current.restoring) return null;
-      const target = { ...current.target };
-      const attachments = await current.controller.serialize();
-      const save = current.pending.then(() => store.save(target, attachments));
-      current.pending = save.catch(() => null);
-      try {
-        const saved = await save;
-        onChange();
-        return saved;
-      }
-      catch (error) { current.onError?.(error); throw error; }
-    }
-
-    async function open(kind, target) {
-      const current = state(kind);
-      const generation = ++current.generation;
-      current.target = { ...target };
-      await current.pending;
-      const attachments = await store.load(target);
-      if (generation !== current.generation) return false;
-      current.restoring = true;
-      try {
-        current.controller.clear();
-        if (attachments?.length) current.controller.restore(attachments);
-      } finally { current.restoring = false; }
-      return Boolean(attachments?.length);
-    }
-
-    async function leave(kind) {
-      const current = state(kind);
-      const generation = current.generation;
-      if (!current.target) return true;
-      try { await checkpoint(kind); }
-      catch (_error) { return false; }
-      if (generation === current.generation) {
-        current.restoring = true;
-        try { current.controller.clear(); }
-        finally {
-          current.restoring = false;
-          current.target = null;
-          current.generation += 1;
-        }
-      }
-      return true;
-    }
-
-    async function complete(kind) {
-      const current = state(kind);
-      if (!current.target) return false;
-      const target = { ...current.target };
-      await current.pending;
-      await store.remove(target);
-      onChange();
-      current.restoring = true;
-      try { current.controller.clear(); }
-      finally {
-        current.restoring = false;
-        current.target = null;
-        current.generation += 1;
-      }
-      return true;
-    }
-
-    async function switchTo(kind, target, isCurrent = () => true) {
-      if (!await leave(kind) || !isCurrent()) return false;
-      return open(kind, target);
-    }
-
-    function hasTarget(kind) { return Boolean(state(kind).target); }
-    return { checkpoint, open, switchTo, leave, complete, hasTarget };
-  };
-});

frontend/conversation-reply-draft-store.js

@@ -1,163 +0,0 @@
-(function (root, factory) {
-  const createConversationReplyDraftStore = factory();
-  if (typeof module === 'object' && module.exports) module.exports = createConversationReplyDraftStore;
-  else root.createConversationReplyDraftStore = createConversationReplyDraftStore;
-})(typeof globalThis !== 'undefined' ? globalThis : this, function () {
-  'use strict';
-
-  const dbName = 'stackchain-conversation-reply-drafts-v1';
-  const storeName = 'drafts';
-
-  function requestResult(request) {
-    return new Promise((resolve, reject) => {
-      request.onsuccess = () => resolve(request.result ?? null);
-      request.onerror = () => reject(request.error || new Error('Conversation photo draft storage failed.'));
-    });
-  }
-
-  function createTransaction(indexedDB) {
-    if (!indexedDB) return null;
-    let databasePromise;
-    function database() {
-      if (!databasePromise) databasePromise = new Promise((resolve, reject) => {
-        const request = indexedDB.open(dbName, 1);
-        request.onupgradeneeded = () => {
-          if (!request.result.objectStoreNames.contains(storeName)) {
-            request.result.createObjectStore(storeName, { keyPath:'id' });
-          }
-        };
-        request.onsuccess = () => resolve(request.result);
-        request.onerror = () => reject(request.error || new Error('Conversation photo draft storage is unavailable.'));
-      });
-      return databasePromise;
-    }
-    return async (operation, key, value) => {
-      const db = await database();
-      const transaction = db.transaction(storeName, ['get', 'list'].includes(operation) ? 'readonly' : 'readwrite');
-      const records = transaction.objectStore(storeName);
-      if (operation === 'put') return requestResult(records.put(value));
-      if (operation === 'delete') return requestResult(records.delete(key));
-      if (operation === 'list') return requestResult(records.getAll());
-      return requestResult(records.get(key));
-    };
-  }
-
-  function normalizedTarget(target) {
-    const kind = String(target?.kind || '');
-    if (kind === 'update') {
-      const notificationId = Number(target?.notificationId || target?.notification_id || 0);
-      if (!Number.isInteger(notificationId) || notificationId < 1) {
-        throw new Error('Open an unread update before saving photo evidence.');
-      }
-      return { kind, notificationId };
-    }
-    const repository = String(target?.repository || '');
-    const number = Number(target?.number || 0);
-    if (!['issue', 'pull'].includes(kind) || !repository || !Number.isInteger(number) || number < 1) {
-      throw new Error('Open a conversation before saving photo evidence.');
-    }
-    return { kind, repository, number };
-  }
-
-  function attachment(value) {
-    const blob = value?.blob;
-    const data = String(value?.data || '');
-    if (!blob && !data) throw new Error('A saved conversation photo is unavailable.');
-    const note = String(value?.note || '').replace(/\s+/g, ' ').trim().slice(0, 240);
-    const operationId = String(value?.operationId || '').slice(0, 128);
-    const markdown = String(value?.confirmed?.markdown || '');
-    return {
-      filename:String(value?.filename || ''), contentType:String(value?.contentType || ''),
-      ...(blob ? { blob } : { data }), ...(note ? { note } : {}),
-      ...(operationId ? { operationId } : {}), ...(markdown ? { confirmed:{ markdown } } : {}),
-    };
-  }
-
-  return function createConversationReplyDraftStore({
-    indexedDB = globalThis.indexedDB, transaction, getOwnerLogin = () => '', scope = 'conversation',
-  } = {}) {
-    const transact = transaction || createTransaction(indexedDB);
-    const draftScope = String(scope || 'conversation').trim().slice(0, 64) || 'conversation';
-
-    function identity(target) {
-      const ownerLogin = String(getOwnerLogin() || '').trim();
-      if (!ownerLogin) throw new Error('Confirm your Gitea account before saving conversation photos.');
-      const normalized = normalizedTarget(target);
-      const targetKey = normalized.kind === 'update' ? normalized.notificationId :
-        normalized.repository + ':' + normalized.number;
-      const identityParts = draftScope === 'conversation' ? [ownerLogin, normalized.kind, targetKey] :
-        [ownerLogin, draftScope, normalized.kind, targetKey];
-      return {
-        ownerLogin, scope:draftScope, target:normalized,
-        id:identityParts.map(value => encodeURIComponent(String(value))).join(':'),
-      };
-    }
-
-    async function save(target, values) {
-      if (!transact) throw new Error('Photo draft storage needs IndexedDB. Your current photos are still here.');
-      const { id, ownerLogin, scope:recordScope, target:normalized } = identity(target);
-      const list = (Array.isArray(values) ? values : [values]).filter(Boolean).slice(0, 5).map(attachment);
-      if (!list.length) { await transact('delete', id); return null; }
-      await transact('put', id, {
-        id, version:1, ownerLogin, scope:recordScope, ...normalized,
-        updatedAt:Date.now(), attachments:list,
-      });
-      return list;
-    }
-
-    async function load(target) {
-      if (!transact) return null;
-      const { id, ownerLogin, scope:recordScope, target:normalized } = identity(target);
-      const record = await transact('get', id);
-      const scopeMatches = recordScope === 'conversation' ? (!record?.scope || record.scope === recordScope) :
-        record?.scope === recordScope;
-      const same = record?.version === 1 && record.ownerLogin === ownerLogin && scopeMatches &&
-        record.kind === normalized.kind && (normalized.kind === 'update' ?
-          Number(record.notificationId) === normalized.notificationId :
-          record.repository === normalized.repository && Number(record.number) === normalized.number);
-      if (!same || !Array.isArray(record.attachments) || !record.attachments.length) return null;
-      return record.attachments.slice(0, 5).map(attachment);
-    }
-
-    async function remove(target) {
-      if (!transact) return false;
-      const { id } = identity(target);
-      await transact('delete', id);
-      return true;
-    }
-
-    async function list() {
-      if (!transact || draftScope !== 'conversation') return [];
-      const ownerLogin = String(getOwnerLogin() || '').trim();
-      if (!ownerLogin) return [];
-      const records = await transact('list');
-      return (Array.isArray(records) ? records : []).flatMap(record => {
-        if (record?.version !== 1 || record.ownerLogin !== ownerLogin ||
-            (record.scope && record.scope !== 'conversation') ||
-            !Array.isArray(record.attachments) || !record.attachments.length) return [];
-        const updatedAt = Number(record.updatedAt || 0);
-        if (record.kind === 'update') {
-          const notificationId = Number(record.notificationId || 0);
-          if (!Number.isInteger(notificationId) || notificationId < 1) return [];
-          return [{
-            id:record.id, kind:'photo-reply', label:'Update photos', title:'Update #' + notificationId,
-            photo_count:record.attachments.length, updated_at:updatedAt,
-            route:{ kind:'update', notification_id:notificationId }, photo_store:'conversation',
-          }];
-        }
-        const repository = String(record.repository || '');
-        const number = Number(record.number || 0);
-        if (!['issue', 'pull'].includes(record.kind) || !repository ||
-            !Number.isInteger(number) || number < 1) return [];
-        const label = record.kind === 'issue' ? 'Issue photos' : 'PR photos';
-        return [{
-          id:record.id, kind:'photo-reply', label, repository, number,
-          title:repository + '#' + number, photo_count:record.attachments.length, updated_at:updatedAt,
-          route:{ kind:record.kind, repository, number }, photo_store:'conversation',
-        }];
-      }).sort((left, right) => Number(right.updated_at) - Number(left.updated_at) || left.id.localeCompare(right.id));
-    }
-
-    return { save, load, remove, list };
-  };
-});

frontend/conversation.js

@@ -63,54 +63,6 @@ function createConversationPager({ loadPage }) {
       }
       return snapshot();
     },
-    replace(comment) {
-      if (!comment || !Number.isInteger(comment.id)) return snapshot();
-      state = {
-        ...state,
-        comments: state.comments.map(existing => existing.id === comment.id ? { ...comment } : existing),
-      };
-      return snapshot();
-    },
-    remove(commentId) {
-      const comments = state.comments.filter(comment => comment.id !== commentId);
-      if (comments.length !== state.comments.length) {
-        state = { ...state, comments, total: Math.max(0, state.total - 1) };
-      }
-      return snapshot();
-    },
-  };
-}
-
-function renderConversationComment(comment, controller, escapeHtml, formatTime, renderMarkdown) {
-  const actions = controller?.actionHtml?.(comment) || '';
-  return '<div class="issue-comment" data-comment-id="' + Number(comment.id || 0) + '"><div class="small">' +
-    escapeHtml(comment.author || 'Unknown author') +
-    (comment.created_at ? ' · ' + escapeHtml(formatTime(comment.created_at)) : '') +
-    '</div>' + actions + '<div class="issue-sheet-content markdown-content">' +
-    renderMarkdown(comment.body || 'No comment body provided.') + '</div></div>';
-}
-
-function createConversationRenderers({qs,renderComment,updateReadPosition,getSelectedUpdate}) {
-  function status(kind, comments, total) {
-    qs('#' + kind + '-conversation-status').textContent = comments.length ?
-      comments.length + ' of ' + Math.max(total || 0, comments.length) + ' messages loaded.' : 'No comments yet.';
-  }
-  function paint(kind, state, controller) {
-    const comments = state?.comments || [];
-    qs('#' + kind + '-comments').innerHTML = comments.length ? comments.map(comment =>
-      kind === 'pull' ? '<div class="pull-comment-card">' + renderComment(comment,controller) + '</div>' :
-        renderComment(comment,controller)).join('') : '<div class="muted">No comments yet.</div>';
-    qs('#load-older-' + kind + '-comments').hidden = !Number.isInteger(state?.older_page);
-    status(kind,comments,state?.total);
-    if (kind === 'update') {
-      const newest = qs('#update-comments .issue-comment:last-child');
-      updateReadPosition.ready(String(getSelectedUpdate()?.notification_id || ''),newest);
-    }
-  }
-  return {
-    paintIssueConversation:(state,controller)=>paint('issue',state,controller),
-    paintPullConversation:(state,controller)=>paint('pull',state,controller),
-    paintUpdateConversation:(state,controller)=>paint('update',state,controller),
   };
 }
 

frontend/create-and-start.js

@@ -1,84 +0,0 @@
-function createCreateAndStart({ todayWork, todaySync, refresh, warm, start, announce }) {
-  const completed = new Set();
-
-  function available() {
-    return todayWork.read().length < todayWork.limit;
-  }
-
-  function capacity(value) {
-    if (String(value ?? '').trim() === '') return { valid: false, reason: 'required' };
-    const minutes = Number(value);
-    if (!Number.isInteger(minutes) || minutes < 5 || minutes > 1440) {
-      return { valid: false, reason: 'range' };
-    }
-    const plan = todayWork.planning();
-    const capacityMinutes = plan.capacity_minutes;
-    if (!Number.isInteger(capacityMinutes)) {
-      return { valid: true, minutes, capacityMinutes: null, plannedMinutes: null,
-        remainingMinutes: null, projectedMinutes: null, fits: true };
-    }
-    const plannedMinutes = todayWork.read().reduce(
-      (total, identity) => total + (Number.isInteger(plan.estimates[identity]) ? plan.estimates[identity] : 0), 0
-    );
-    const remainingMinutes = capacityMinutes - plannedMinutes;
-    const projectedMinutes = remainingMinutes - minutes;
-    return { valid: true, minutes, capacityMinutes, plannedMinutes, remainingMinutes,
-      projectedMinutes, fits: projectedMinutes >= 0 };
-  }
-
-  function capacityMessage(result) {
-    if (!result.valid) return result.reason === 'required'
-      ? 'Required only for Create & start.'
-      : 'Use a whole number from 5 to 1440 minutes.';
-    if (result.capacityMinutes === null) {
-      return result.minutes + ' min · Set a Today budget to see remaining time.';
-    }
-    return result.fits
-      ? result.minutes + ' min · ' + result.projectedMinutes + ' min will remain in Today.'
-      : result.minutes + ' min · ' + Math.abs(result.projectedMinutes) + ' min over Today capacity.';
-  }
-
-  function complete(issue, estimateMinutes) {
-    const identity = todayWork.identity(issue);
-    if (!identity || completed.has(identity)) return 'exists';
-    const added = todayWork.add(issue);
-    if (added === 'full') {
-      announce('Created, but Today changed—remove an item, then add this issue.');
-      return 'full';
-    }
-    if (added !== 'added' && added !== 'exists') {
-      announce('Created, but Today could not be saved on this device.');
-      return 'unavailable';
-    }
-    let estimatedPlan = null;
-    if (Number.isInteger(estimateMinutes)) {
-      estimatedPlan = todayWork.planning();
-      estimatedPlan.estimates[identity] = estimateMinutes;
-      if (!todayWork.replacePlanning(estimatedPlan)) {
-        announce('Created and added to Today, but its estimate could not be saved on this device.');
-        return 'estimate-unavailable';
-      }
-    }
-    if (!todaySync.enqueue('add', identity)) {
-      announce('Created and saved to Today on this device, but account sync is unavailable.');
-      return 'sync-unavailable';
-    }
-    if (estimatedPlan) {
-      if (!todaySync.enqueueConfiguration(estimatedPlan.capacity_minutes, estimatedPlan.estimates)) {
-        announce('Created and estimated on this device, but Today plan sync is unavailable.');
-        return 'sync-unavailable';
-      }
-    }
-    completed.add(identity);
-    refresh();
-    todaySync.flush();
-    warm();
-    start(issue);
-    announce('Created, added to Today, and ready to work.');
-    return 'started';
-  }
-
-  return { available, capacity, capacityMessage, complete };
-}
-
-if (typeof module !== 'undefined' && module.exports) module.exports = createCreateAndStart;

frontend/create-issue-sheet.js

@@ -8,59 +8,6 @@ function newIssueOperationId() {
   return String(Date.now()) + '-' + Math.random().toString(16).slice(2);
 }
 
-function createIssueModalLifecycle({ root, background = [], document, requestClose }) {
-  let launcher = null;
-  let active = false;
-  let backgroundState = [];
-  const focusableSelector = [
-    'a[href]', 'button:not([disabled])', 'input:not([disabled])',
-    'select:not([disabled])', 'textarea:not([disabled])',
-    '[tabindex]:not([tabindex="-1"])',
-  ].join(',');
-  const focusable = () => Array.from(root.querySelectorAll(focusableSelector)).filter(element =>
-    !element.hidden && !element.disabled && element.getClientRects().length > 0
-  );
-  function keydown(event) {
-    if (!active) return;
-    if (event.key === 'Escape') {
-      event.preventDefault();
-      requestClose();
-      return;
-    }
-    if (event.key !== 'Tab') return;
-    const controls = focusable();
-    if (!controls.length) return;
-    const first = controls[0];
-    const last = controls[controls.length - 1];
-    if (event.shiftKey && document.activeElement === first) {
-      event.preventDefault();
-      last.focus();
-    } else if (!event.shiftKey && document.activeElement === last) {
-      event.preventDefault();
-      first.focus();
-    }
-  }
-  root.addEventListener('keydown', keydown);
-  return {
-    open(trigger = null) {
-      launcher = trigger?.isConnected ? trigger : document.activeElement;
-      backgroundState = background.map(element => [element, element.inert]);
-      backgroundState.forEach(([element]) => { element.inert = true; });
-      active = true;
-      (root.querySelector('#cancel-new-issue') || focusable()[0])?.focus();
-    },
-    close({ restore = true } = {}) {
-      active = false;
-      backgroundState.forEach(([element, inert]) => { element.inert = inert; });
-      backgroundState = [];
-      const panel = root.querySelector('.create-issue-panel');
-      if (panel) panel.scrollTop = 0;
-      if (restore && launcher?.isConnected) launcher.focus();
-      launcher = null;
-    },
-  };
-}
-
 function normalizeSharedContent(value = {}) {
   const clean = input => String(input || '').replace(/\s+/g, ' ').trim();
   const text = String(value.text || '').trim().slice(0, 9500);
@@ -72,244 +19,16 @@ function normalizeSharedContent(value = {}) {
   return { title, body };
 }
 
-function buildRelatedDraft(value = {}, template = null) {
-  const repository = /^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/.test(String(value.repository || ''))
-    ? String(value.repository) : '';
-  const labelIds = Array.from(new Set((Array.isArray(value.labelIds) ? value.labelIds : [])
-    .filter(id => Number.isInteger(id) && id > 0))).slice(0, 20);
-  const draft = {repository, title:'', body:'', labelIds};
-  const milestoneId = Number(value.milestoneId);
-  if (Number.isInteger(milestoneId) && milestoneId > 0) draft.milestoneId = milestoneId;
-  if (/^\d{4}-\d{2}-\d{2}$/.test(String(value.dueDate || ''))) draft.dueDate = String(value.dueDate);
-  if (value.unassigned === true) draft.unassigned = true;
-  else if (/^[A-Za-z0-9_.-]+$/.test(String(value.assignee || ''))) {
-    draft.assignee = String(value.assignee);
-    draft.assigneeName = String(value.assigneeName || value.assignee).replace(/\s+/g, ' ').trim().slice(0, 255);
-  }
-  const templateId = String(value.templateId || '').slice(0, 80);
-  if (templateId && template && String(template.id || '') === templateId) {
-    draft.templateId = templateId;
-    draft.templateName = String(value.templateName || template.name || 'Issue template').trim().slice(0, 80);
-    draft.capturedBody = '';
-    draft.body = String(template.body || '').trim().slice(0, 9000);
-  }
-  return draft;
-}
-
-function relatedChecklistDraft(item, label) {
-  const title = String(label || '').trim().replace(/\s+/g, ' ').slice(0, 240);
-  if (!title) throw new Error('Choose a checklist step to file.');
-  const repository = String(item?.repository || '');
-  const number = Number(item?.number);
-  const url = String(item?.url || '');
-  if (!/^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/.test(repository) ||
-      !Number.isInteger(number) || number < 1 || !/^https:\/\//.test(url)) {
-    throw new Error('The parent issue link is unavailable.');
-  }
-  return {repository, title,
-    body:'Related to [' + repository + '#' + number + '](' + url + ').', labelIds:[]};
-}
-
-function linkChecklistTask(raw, targetIndex, child) {
-  const url = String(child?.url || '');
-  if (!/^https:\/\//.test(url)) throw new Error('The related issue link is unavailable.');
-  const parts = String(raw || '').split(/(\r\n|\n|\r)/);
-  let fenced = false;
-  let taskIndex = 0;
-  for (let index = 0; index < parts.length; index += 2) {
-    const line = parts[index];
-    if (/^\s*```/.test(line)) { fenced = !fenced; continue; }
-    if (fenced) continue;
-    const task = line.match(/^(\s*[-*+]\s+\[[ xX]\]\s+)(.*)$/);
-    if (!task) continue;
-    if (taskIndex === Number(targetIndex)) {
-      if (/^\s*\[[^\]]+\]\([^)]+\)\s*$/.test(task[2])) throw new Error('That checklist step is already linked.');
-      const label = task[2].trim().replace(/\s+/g, ' ');
-      parts[index] = task[1] + '[' + label + '](' + url + ')';
-      return parts.join('');
-    }
-    taskIndex += 1;
-  }
-  throw new Error('The checklist step is no longer available.');
-}
-
-function createChecklistPromotion({ issueController, issueCapture, clearAttachments, onLinked, onStatus }) {
-  let pending = null;
-  const persistedPromotion = value => ({
-    item:{repository:value.repository, number:value.number, url:value.url},
-    detail:{title:value.title, body:value.body, updated_at:value.updatedAt}, taskIndex:value.taskIndex,
-  });
-  return {
-    pending:() => Boolean(pending),
-    start(context) {
-      pending = {item:{...context.item}, detail:{...context.detail}, taskIndex:Number(context.taskIndex)};
-      const draft = issueController.relatedTaskDraft(context.item, context.detail, context.taskIndex, context.label);
-      issueCapture.saveDraft(draft);
-      clearAttachments();
-      return draft;
-    },
-    cancel() { if (!pending) return false; pending = null; issueCapture.clearDraft(); return true; },
-    deliveryContext() {
-      if (!pending) return null;
-      return {repository:pending.item.repository, number:pending.item.number, url:pending.item.url,
-        title:pending.detail.title, body:pending.detail.body, updatedAt:pending.detail.updated_at,
-        taskIndex:pending.taskIndex};
-    },
-    async finish(child, persisted = null) {
-      const promotion = pending || (persisted ? persistedPromotion(persisted) : null);
-      if (!promotion || !child) return false;
-      pending = null;
-      try {
-        const confirmed = await issueController.linkRelatedTask(
-          promotion.item, promotion.detail, promotion.taskIndex, child
-        );
-        onLinked(promotion, confirmed);
-        onStatus('Related issue created and linked from its parent checklist.');
-        return true;
-      } catch (error) {
-        onStatus('Related issue created, but the parent link needs attention.' +
-          (child.url ? ' ' + child.url : '') + ' ' + error.message);
-        return false;
-      }
-    },
-  };
-}
-
-function createIssueOwnerPicker(issueCapture, documentRef, onChange) {
-  const NO_OWNER = '__unassigned__';
-  const select = documentRef.querySelector('#create-issue-assignee');
-  const status = documentRef.querySelector('#create-issue-assignee-status');
-  const getRepository = () => documentRef.querySelector('#create-issue-repository').value;
-  const loadOwners = repository => issueCapture.loadOwners(repository);
-  let ownerRequest = 0;
-  function reset(repository, selected = {}) {
-    select.replaceChildren();
-    const me = documentRef.createElement('option');
-    me.value = '';
-    me.textContent = 'Me';
-    select.appendChild(me);
-    const noOwner = documentRef.createElement('option');
-    noOwner.value = NO_OWNER;
-    noOwner.textContent = 'No owner';
-    select.appendChild(noOwner);
-    if (selected.unassigned === true) select.value = NO_OWNER;
-    if (selected.assignee) {
-      const option = documentRef.createElement('option');
-      option.value = selected.assignee;
-      option.textContent = (selected.assigneeName || selected.assignee) + ' (@' + selected.assignee + ')';
-      option.dataset.name = selected.assigneeName || selected.assignee;
-      select.appendChild(option);
-      select.value = selected.assignee;
-    }
-    select.dataset.repository = '';
-    status.textContent = repository ? 'Open the owner picker to load eligible teammates.' : 'Choose a repository first.';
-  }
-
-  async function load(repository) {
-    if (!repository || select.dataset.repository === repository) return;
-    const request = ++ownerRequest;
-    const selected = select.value;
-    const selectedName = select.selectedOptions?.[0]?.dataset.name || '';
-    status.textContent = 'Loading eligible teammates…';
-    try {
-      const owners = await loadOwners(repository);
-      if (request !== ownerRequest || getRepository() !== repository) return;
-      const selectedStillEligible = owners.some(owner => owner?.login === selected);
-      reset(repository, selected === NO_OWNER ? {unassigned:true} :
-        (selectedStillEligible ? {assignee:selected, assigneeName:selectedName} : {}));
-      owners.forEach(owner => {
-        if (!owner?.login || owner.login === selected) return;
-        const option = documentRef.createElement('option');
-        option.value = owner.login;
-        option.textContent = (owner.name || owner.login) + ' (@' + owner.login + ')';
-        option.dataset.name = owner.name || owner.login;
-        select.appendChild(option);
-      });
-      select.dataset.repository = repository;
-      status.textContent = owners.length ? 'Choose yourself, no owner, or an eligible teammate.' :
-        'Choose yourself or no owner; no eligible teammates are available.';
-    } catch (_error) {
-      if (request !== ownerRequest || getRepository() !== repository) return;
-      status.textContent = 'Teammates could not be loaded. The issue will stay assigned to you.';
-    }
-  }
-  function updateActions(hasRepository, hasBlockers, canStart) {
-    const submit = documentRef.querySelector('#submit-new-issue');
-    const start = documentRef.querySelector('#create-and-start-issue');
-    const hasNoOwner = select.value === NO_OWNER;
-    const hasTeammateOwner = Boolean(select.value) && !hasNoOwner;
-    submit.disabled = !hasRepository;
-    submit.textContent = hasNoOwner ? 'Create unassigned' :
-      (hasTeammateOwner ? 'Create & assign' : 'Create & assign to me');
-    start.disabled = !hasRepository || hasBlockers || hasTeammateOwner || hasNoOwner || !canStart;
-    start.title = hasBlockers ? 'Blocked work cannot start until its blockers are complete.' :
-      (hasNoOwner ? 'No owner work cannot be added to your Today queue.' :
-        (hasTeammateOwner ? 'Work assigned to a teammate cannot be added to your Today queue.' : ''));
-  }
-  function fields() {
-    return {
-      assignee: select.value === NO_OWNER ? '' : select.value,
-      assigneeName: select.value === NO_OWNER ? '' : (select.selectedOptions?.[0]?.dataset.name || ''),
-      unassigned: select.value === NO_OWNER,
-    };
-  }
-  function draft(labelIds, blockers, trim = false) {
-    const value = id => documentRef.querySelector(id).value;
-    const clean = input => trim ? input.trim() : input;
-    return {
-      repository:value('#create-issue-repository'),
-      title:clean(value('#create-issue-title')), body:clean(value('#create-issue-body')),
-      labelIds, milestoneId:Number(value('#create-issue-milestone')) || null,
-      dueDate:value('#create-issue-due-date'), ...fields(), blockers,
-    };
-  }
-  select.addEventListener('focus', () => {
-    const repository = getRepository();
-    if (repository) load(repository);
-  });
-  select.addEventListener('change', onChange);
-  return { reset, load, updateActions, fields, draft };
-}
-
 function createIssueCapture({ fetchJson, storage, createOperationId = newIssueOperationId }) {
   const storageKey = 'stackchain.issue-capture.v1';
   const sharedStorageKey = 'stackchain.issue-share.v1';
-  const followUpStorageKey = 'stackchain.issue-follow-up.v1';
   let pending = null;
-  let issueTemplates = [];
-  let activeTemplate = null;
-  let templateRequest = 0;
-  let duplicateRequest = 0;
-  let repositorySearchRequest = 0;
-  let filingMetadataRequest = 0;
-  let blockerSearchRequest = 0;
-  let duplicateState = {status: 'idle', key: '', candidates: []};
-  let acknowledgedDuplicateKey = '';
-  const repositoryPageRequests = new Map();
   const safeLabelIds = value => Array.from(new Set(
     (Array.isArray(value) ? value : []).filter(id => Number.isInteger(id) && id > 0)
   )).slice(0, 20);
-  const safeBlockers = value => {
-    const seen = new Set();
-    return (Array.isArray(value) ? value : []).reduce((items, blocker) => {
-      const repository = String(blocker?.repository || '').trim();
-      const number = Number(blocker?.number);
-      const key = repository + '#' + number;
-      if (items.length >= 5 || seen.has(key) ||
-          !/^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/.test(repository) ||
-          !Number.isInteger(number) || number < 1) return items;
-      seen.add(key);
-      items.push({repository, number,
-        title:String(blocker?.title || '').replace(/\s+/g, ' ').trim().slice(0, 255)});
-      return items;
-    }, []);
-  };
   const emptyDraft = () => ({ repository: '', title: '', body: '', labelIds: [] });
   const safeMilestoneId = value => Number.isInteger(Number(value)) && Number(value) > 0 ? Number(value) : null;
   const safeDueDate = value => /^\d{4}-\d{2}-\d{2}$/.test(String(value || '')) ? String(value) : '';
-  const safeAssignee = value => /^[A-Za-z0-9_.-]+$/.test(String(value || '')) ? String(value) : '';
-  const safeEstimate = value => Number.isInteger(Number(value)) && Number(value) >= 5 && Number(value) <= 1440 ?
-    Number(value) : null;
 
   function loadStored() {
     try {
@@ -322,28 +41,10 @@ function createIssueCapture({ fetchJson, storage, createOperationId = newIssueOp
         labelIds: safeLabelIds(parsed.labelIds),
         operationId: String(parsed.operationId || '').slice(0, 128),
       };
-      if (parsed.unassigned === true) draft.unassigned = true;
-      if (typeof parsed.templateName === 'string' && parsed.templateName.trim()) {
-        draft.templateName = parsed.templateName.trim().slice(0, 80);
-        draft.templateId = String(parsed.templateId || '').slice(0, 80);
-        draft.capturedBody = String(parsed.capturedBody || '').slice(0, 10000);
-      }
-      const assignee = safeAssignee(parsed.assignee);
-      if (assignee) {
-        draft.assignee = assignee;
-        draft.assigneeName = String(parsed.assigneeName || assignee).replace(/\s+/g, ' ').trim().slice(0, 255);
-      }
       const milestoneId = safeMilestoneId(parsed.milestoneId);
       const dueDate = safeDueDate(parsed.dueDate);
       if (milestoneId !== null) draft.milestoneId = milestoneId;
       if (dueDate) draft.dueDate = dueDate;
-      const estimateMinutes = safeEstimate(parsed.estimateMinutes);
-      if (estimateMinutes !== null) draft.estimateMinutes = estimateMinutes;
-      if (['create', 'create-and-start'].includes(parsed.completionIntent)) {
-        draft.completionIntent = parsed.completionIntent;
-      }
-      const blockers = safeBlockers(parsed.blockers);
-      if (blockers.length) draft.blockers = blockers;
       return draft;
     } catch (_error) {
       return {...emptyDraft(), operationId: ''};
@@ -363,33 +64,13 @@ function createIssueCapture({ fetchJson, storage, createOperationId = newIssueOp
       body: String(draft?.body || ''),
       labelIds: safeLabelIds(draft?.labelIds),
     };
-    if (draft?.unassigned === true) safe.unassigned = true;
-    if (typeof draft?.templateName === 'string' && draft.templateName.trim()) {
-      safe.templateName = draft.templateName.trim().slice(0, 80);
-      safe.templateId = String(draft.templateId || '').slice(0, 80);
-      safe.capturedBody = String(draft.capturedBody || '').slice(0, 10000);
-    }
-    const assignee = safe.unassigned ? '' : safeAssignee(draft?.assignee);
-    if (assignee) {
-      safe.assignee = assignee;
-      safe.assigneeName = String(draft?.assigneeName || assignee).replace(/\s+/g, ' ').trim().slice(0, 255);
-    }
     const milestoneId = safeMilestoneId(draft?.milestoneId);
     const dueDate = safeDueDate(draft?.dueDate);
     if (milestoneId !== null) safe.milestoneId = milestoneId;
     if (dueDate) safe.dueDate = dueDate;
-    const estimateMinutes = safeEstimate(draft?.estimateMinutes);
-    if (estimateMinutes !== null) safe.estimateMinutes = estimateMinutes;
-    if (['create', 'create-and-start'].includes(draft?.completionIntent)) {
-      safe.completionIntent = draft.completionIntent;
-    }
-    const blockers = safeBlockers(draft?.blockers);
-    if (blockers.length) safe.blockers = blockers;
-    const unchanged = ['repository', 'title', 'body', 'milestoneId', 'dueDate', 'assignee', 'assigneeName', 'unassigned',
-      'templateName', 'templateId', 'capturedBody', 'estimateMinutes', 'completionIntent']
+    const unchanged = ['repository', 'title', 'body', 'milestoneId', 'dueDate']
       .every(key => (previous[key] || '') === (safe[key] || '')) &&
-      JSON.stringify(previous.labelIds) === JSON.stringify(safe.labelIds) &&
-      JSON.stringify(previous.blockers || []) === JSON.stringify(safe.blockers || []);
+      JSON.stringify(previous.labelIds) === JSON.stringify(safe.labelIds);
     writeStored({...safe, operationId: unchanged ? previous.operationId : ''});
     return safe;
   }
@@ -440,42 +121,6 @@ function createIssueCapture({ fetchJson, storage, createOperationId = newIssueOp
     return {status: 'ready'};
   }
 
-  function pendingFollowUp() {
-    try {
-      const parsed = JSON.parse(storage.getItem(followUpStorageKey) || 'null');
-      if (!parsed || typeof parsed !== 'object') return null;
-      const repository = /^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/.test(String(parsed.repository || '')) ? String(parsed.repository) : '';
-      const title = String(parsed.title || '').trim().slice(0, 240);
-      const body = String(parsed.body || '').trim().slice(0, 9500);
-      return title || body ? {repository, title, body, labelIds: []} : null;
-    } catch (_error) { return null; }
-  }
-
-  function acceptFollowUp() {
-    const followUp = pendingFollowUp();
-    if (!followUp) return loadDraft();
-    const accepted = saveDraft(followUp);
-    try { storage.removeItem(followUpStorageKey); }
-    catch (_error) { /* Accepted content is already persisted as the issue draft. */ }
-    return accepted;
-  }
-
-  function discardFollowUp() {
-    try { storage.removeItem(followUpStorageKey); }
-    catch (_error) { /* The existing capture remains authoritative. */ }
-  }
-
-  function stageFollowUp(value) {
-    const followUp = {repository: String(value?.repository || ''), title: String(value?.title || ''), body: String(value?.body || '')};
-    if (!followUp.title && !followUp.body) return {status: 'empty'};
-    try { storage.setItem(followUpStorageKey, JSON.stringify(followUp)); }
-    catch (_error) { /* The in-page flow can still continue. */ }
-    const existing = loadDraft();
-    if (existing.title || existing.body) return {status: 'conflict'};
-    acceptFollowUp();
-    return {status: 'ready'};
-  }
-
   function loadLabels(repository) {
     const encoded = String(repository || '').split('/').map(encodeURIComponent).join('/');
     const priorities = new Set(['p0', 'priority-high', 'critical']);
@@ -495,360 +140,6 @@ function createIssueCapture({ fetchJson, storage, createOperationId = newIssueOp
     );
   }
 
-  function loadOwners(repository) {
-    const encoded = String(repository || '').split('/').map(encodeURIComponent).join('/');
-    return fetchJson('api/v1/repos/' + encoded + '/issue-assignees').then(owners =>
-      Array.isArray(owners) ? owners : []
-    );
-  }
-
-  function loadTemplates(repository) {
-    const encoded = String(repository || '').split('/').map(encodeURIComponent).join('/');
-    return fetchJson('api/v1/repos/' + encoded + '/issue-templates').then(templates =>
-      Array.isArray(templates) ? templates.slice(0, 20) : []
-    );
-  }
-
-  async function loadFilingMetadata(repository) {
-    const selectedRepository = String(repository || '');
-    const encoded = selectedRepository.split('/').map(encodeURIComponent).join('/');
-    const request = ++filingMetadataRequest;
-    const payload = await fetchJson(
-      'api/v1/repos/' + encoded + '/issue-filing-metadata'
-    );
-    if (request !== filingMetadataRequest) {
-      return {status:'stale', repository:selectedRepository};
-    }
-    const section = name => {
-      const value = payload?.[name];
-      const available = value?.available === true;
-      return {
-        available,
-        items:available && Array.isArray(value?.items) ? value.items : [],
-        ...(!available && typeof value?.error === 'string' ? {error:value.error} : {}),
-      };
-    };
-    return {
-      status:'ready', repository:selectedRepository,
-      labels:section('labels'), milestones:section('milestones'),
-      templates:section('templates'),
-    };
-  }
-
-  function applyTemplate(draft, template, availableLabels = []) {
-    const source = {...(draft || {})};
-    const capturedBody = source.templateName ? String(source.capturedBody || '') : String(source.body || '');
-    if (!template) {
-      delete source.templateName;
-      delete source.templateId;
-      delete source.capturedBody;
-      return {...source, body: capturedBody};
-    }
-    const scaffold = String(template.body || '').trim().slice(0, 9000);
-    const body = [capturedBody.trim(), scaffold].filter(Boolean).join('\n\n---\n\n').slice(0, 10000);
-    const validByName = new Map((Array.isArray(availableLabels) ? availableLabels : [])
-      .filter(label => Number.isInteger(label?.id) && typeof label?.name === 'string')
-      .map(label => [label.name.toLowerCase(), label.id]));
-    const templateLabelIds = (Array.isArray(template.labels) ? template.labels : [])
-      .map(name => validByName.get(String(name).toLowerCase())).filter(Boolean);
-    return {
-      ...source,
-      title: source.title || String(template.title || '').trim().slice(0, 255),
-      body,
-      labelIds: safeLabelIds([...(source.labelIds || []), ...templateLabelIds]),
-      templateId: String(template.id || '').slice(0, 80),
-      templateName: String(template.name || 'Issue template').trim().slice(0, 80),
-      capturedBody,
-    };
-  }
-
-  function setTemplateState(draft) {
-    activeTemplate = draft?.templateName ? {
-      templateName:draft.templateName, templateId:draft.templateId,
-      capturedBody:draft.capturedBody || '',
-    } : null;
-  }
-
-  function templateFields(draft) {
-    return activeTemplate ? {...draft, ...activeTemplate} : draft;
-  }
-
-  function restoreTemplate(draft, availableLabels) {
-    const restored = applyTemplate(templateFields(draft), null, availableLabels);
-    activeTemplate = null;
-    return restored;
-  }
-
-  async function loadTemplateOptions(repository, elements, selectedId = '') {
-    const request = ++templateRequest;
-    issueTemplates = [];
-    elements.select.innerHTML = '<option value="">Blank issue</option>';
-    elements.field.hidden = true;
-    if (!repository) return;
-    elements.status.textContent = 'Loading issue types…';
-    try {
-      const templates = await loadTemplates(repository);
-      if (request !== templateRequest || elements.getRepository() !== repository) return;
-      issueTemplates = templates;
-      templates.forEach(template => {
-        const option = elements.document.createElement('option');
-        option.value = template.id;
-        option.textContent = template.name;
-        elements.select.appendChild(option);
-      });
-      elements.field.hidden = templates.length === 0;
-      elements.select.value = templates.some(template => template.id === selectedId) ? selectedId : '';
-      elements.status.textContent = templates.length ?
-        'Choose a repository guide or keep a blank issue.' : 'Blank issue selected.';
-    } catch (_error) {
-      if (request !== templateRequest || elements.getRepository() !== repository) return;
-      elements.status.textContent = 'Issue types could not be loaded. Blank issue filing is still available.';
-    }
-  }
-
-  function selectTemplate(identifier, draft, availableLabels) {
-    const template = issueTemplates.find(item => item.id === identifier) || null;
-    const applied = applyTemplate(templateFields(draft), template, availableLabels);
-    activeTemplate = template ? {
-      templateId:applied.templateId, templateName:applied.templateName,
-      capturedBody:applied.capturedBody,
-    } : null;
-    return {draft: applied, template};
-  }
-
-  function relatedDraft(draft) {
-    const template = issueTemplates.find(item => String(item?.id || '') === String(draft?.templateId || '')) || null;
-    return buildRelatedDraft(draft, template);
-  }
-
-  function bindTemplatePicker(elements, callbacks) {
-    let labels = [];
-    elements.select.addEventListener('change', event => {
-      const {draft, template} = selectTemplate(event.target.value, callbacks.getDraft(), labels);
-      callbacks.setDraft(draft);
-      const selected = new Set(draft.labelIds || []);
-      elements.labelInputs().forEach(input => { input.checked = selected.has(Number(input.value)); });
-      elements.status.textContent = template ?
-        template.name + (template.about ? ' — ' + template.about : '') : 'Blank issue selected.';
-      callbacks.changed();
-    });
-    return {
-      fields:templateFields,
-      reset:setTemplateState,
-      setLabels(value) { labels = Array.isArray(value) ? value : []; },
-      load(repository, selectedId) {
-        return loadTemplateOptions(repository, elements, selectedId);
-      },
-      render(repository, section, selectedId = '') {
-        ++templateRequest;
-        issueTemplates = [];
-        elements.select.innerHTML = '<option value="">Blank issue</option>';
-        elements.field.hidden = true;
-        if (!repository || elements.getRepository() !== repository) return;
-        if (section?.available !== true) {
-          elements.status.textContent = 'Issue types could not be loaded. Blank issue filing is still available.';
-          return;
-        }
-        issueTemplates = Array.isArray(section.items) ? section.items.slice(0, 20) : [];
-        issueTemplates.forEach(template => {
-          const option = elements.document.createElement('option');
-          option.value = template.id;
-          option.textContent = template.name;
-          elements.select.appendChild(option);
-        });
-        elements.field.hidden = issueTemplates.length === 0;
-        elements.select.value = issueTemplates.some(template => template.id === selectedId) ? selectedId : '';
-        elements.status.textContent = issueTemplates.length ?
-          'Choose a repository guide or keep a blank issue.' : 'Blank issue selected.';
-      },
-      changeRepository(draft) {
-        const restored = restoreTemplate(draft, labels);
-        callbacks.setDraft(restored);
-        return restored;
-      },
-    };
-  }
-
-  function bindFilingMetadata(elements, templatePicker) {
-    function renderLabels(repository, section, selectedIds = []) {
-      elements.labelList.replaceChildren();
-      if (!repository) {
-        elements.labelStatus.textContent = 'Choose a repository to load labels.';
-        return;
-      }
-      if (section?.available !== true) {
-        templatePicker.setLabels([]);
-        elements.labelStatus.textContent = 'Labels could not be loaded. You can still create the issue without labels.';
-        return;
-      }
-      const priorities = new Set(['p0', 'priority-high', 'critical']);
-      const labels = (Array.isArray(section.items) ? section.items : []).slice().sort((left, right) =>
-        Number(priorities.has(String(right?.name || '').toLowerCase())) -
-        Number(priorities.has(String(left?.name || '').toLowerCase()))
-      );
-      templatePicker.setLabels(labels);
-      const selected = new Set(selectedIds.map(Number));
-      labels.forEach(label => {
-        const option = elements.document.createElement('label');
-        option.className = 'create-issue-label-option';
-        const input = elements.document.createElement('input');
-        input.type = 'checkbox';
-        input.name = 'create-issue-label';
-        input.value = String(Number(label.id));
-        input.checked = selected.has(Number(label.id));
-        const name = elements.document.createElement('span');
-        name.textContent = label.name;
-        option.append(input, name);
-        elements.labelList.appendChild(option);
-      });
-      elements.labelStatus.textContent = labels.length ?
-        'Select labels to triage this issue.' : 'This repository has no labels.';
-    }
-
-    function renderMilestones(repository, section, selectedId = null) {
-      elements.milestoneSelect.replaceChildren();
-      const blank = elements.document.createElement('option');
-      blank.value = '';
-      blank.textContent = 'No milestone';
-      elements.milestoneSelect.appendChild(blank);
-      if (!repository) {
-        elements.milestoneStatus.textContent = 'Choose a repository to load milestones.';
-        return;
-      }
-      if (section?.available !== true) {
-        elements.milestoneStatus.textContent = 'Milestones could not be loaded. You can still create an unplanned issue.';
-        return;
-      }
-      const milestones = Array.isArray(section.items) ? section.items : [];
-      milestones.forEach(milestone => {
-        const option = elements.document.createElement('option');
-        option.value = String(Number(milestone.id));
-        option.textContent = milestone.title;
-        elements.milestoneSelect.appendChild(option);
-      });
-      if (selectedId) elements.milestoneSelect.value = String(selectedId);
-      elements.milestoneStatus.textContent = milestones.length ?
-        'Choose the release lane for this issue.' : 'This repository has no open milestones.';
-    }
-
-    async function load(repository, selected = {}) {
-      renderLabels(repository, null, selected.labelIds || []);
-      renderMilestones(repository, null, selected.milestoneId);
-      templatePicker.render(repository, null, selected.templateId);
-      if (!repository) return;
-      elements.labelStatus.textContent = 'Loading labels…';
-      elements.milestoneStatus.textContent = 'Loading milestones…';
-      elements.templateStatus.textContent = 'Loading issue types…';
-      try {
-        const metadata = await loadFilingMetadata(repository);
-        if (metadata.status !== 'ready' || elements.getRepository() !== repository) return;
-        renderLabels(repository, metadata.labels, selected.labelIds || []);
-        renderMilestones(repository, metadata.milestones, selected.milestoneId);
-        templatePicker.render(repository, metadata.templates, selected.templateId);
-      } catch (_error) {
-        if (elements.getRepository() !== repository) return;
-        renderLabels(repository, {available:false}, selected.labelIds || []);
-        renderMilestones(repository, {available:false}, selected.milestoneId);
-        templatePicker.render(repository, {available:false}, selected.templateId);
-      }
-    }
-    return {load};
-  }
-
-  function loadRepositoryPage(page) {
-    const safePage = Math.max(1, Math.floor(Number(page) || 1));
-    if (repositoryPageRequests.has(safePage)) return repositoryPageRequests.get(safePage);
-    const request = fetchJson('api/v1/repositories?page=' + safePage + '&limit=50')
-      .then(payload => ({
-        items: Array.isArray(payload?.items) ? payload.items : [],
-        page: Number(payload?.page) || safePage,
-        total: Math.max(0, Number(payload?.total) || 0),
-        has_more: payload?.has_more === true,
-      }))
-      .finally(() => repositoryPageRequests.delete(safePage));
-    repositoryPageRequests.set(safePage, request);
-    return request;
-  }
-
-  async function searchRepositories(value) {
-    const query = String(value || '').trim().slice(0, 80);
-    const request = ++repositorySearchRequest;
-    if (query.length < 2) return {status: 'idle', items: []};
-    try {
-      const payload = await fetchJson(
-        'api/v1/repositories/search?q=' + encodeURIComponent(query) + '&limit=20'
-      );
-      if (request !== repositorySearchRequest) return {status: 'stale', items: []};
-      return {
-        status: 'ready',
-        items: Array.isArray(payload?.items) ? payload.items : [],
-      };
-    } catch (error) {
-      if (request !== repositorySearchRequest) return {status: 'stale', items: []};
-      return {status: 'failed', items: [], error};
-    }
-  }
-
-  async function searchBlockers(value) {
-    const query = String(value || '').trim().slice(0, 80);
-    const request = ++blockerSearchRequest;
-    if (query.length < 2) return {status:'idle', items:[]};
-    try {
-      const payload = await fetchJson('api/v1/search?q=' + encodeURIComponent(query) + '&limit=20');
-      if (request !== blockerSearchRequest) return {status:'stale', items:[]};
-      return {status:'ready', items:(Array.isArray(payload?.items) ? payload.items : [])
-        .filter(item => item?.kind === 'issue' && item?.state === 'open').slice(0, 20)};
-    } catch (error) {
-      if (request !== blockerSearchRequest) return {status:'stale', items:[]};
-      return {status:'failed', items:[], error};
-    }
-  }
-
-  function duplicateKey(draft) {
-    const repository = String(draft?.repository || '').trim();
-    const title = String(draft?.title || '').replace(/\s+/g, ' ').trim();
-    return { repository, title, key: repository + '\n' + title.toLowerCase() };
-  }
-
-  async function findDuplicates(draft) {
-    const input = duplicateKey(draft);
-    const request = ++duplicateRequest;
-    if (!input.repository || input.title.length < 4) {
-      duplicateState = {status: 'idle', key: input.key, candidates: []};
-      return duplicateState;
-    }
-    try {
-      const payload = await fetchJson('api/v1/search?q=' + encodeURIComponent(input.title) + '&limit=10');
-      if (request !== duplicateRequest) return {status: 'stale', key: input.key, candidates: []};
-      duplicateState = {
-        status: 'ready',
-        key: input.key,
-        partial: payload?.partial === true,
-        candidates: (Array.isArray(payload?.items) ? payload.items : []).filter(item =>
-          item?.kind === 'issue' && item?.state === 'open' && item?.repository === input.repository
-        ).slice(0, 3),
-      };
-      return duplicateState;
-    } catch (error) {
-      if (request !== duplicateRequest) return {status: 'stale', key: input.key, candidates: []};
-      duplicateState = {status: 'failed', key: input.key, candidates: [], error};
-      return duplicateState;
-    }
-  }
-
-  function needsDuplicateAcknowledgement(draft) {
-    const {key} = duplicateKey(draft);
-    return duplicateState.status === 'ready' && duplicateState.partial !== true && duplicateState.key === key &&
-      duplicateState.candidates.length > 0 && acknowledgedDuplicateKey !== key;
-  }
-
-  function acknowledgeDuplicates(draft) {
-    const {key} = duplicateKey(draft);
-    if (duplicateState.status === 'ready' && duplicateState.key === key && duplicateState.candidates.length) {
-      acknowledgedDuplicateKey = key;
-    }
-  }
-
   function submit(draft) {
     if (pending) return pending;
     const saved = saveDraft(draft);
@@ -864,8 +155,6 @@ function createIssueCapture({ fetchJson, storage, createOperationId = newIssueOp
       },
       body: JSON.stringify({
         title: saved.title, body: saved.body, label_ids: saved.labelIds,
-        ...(saved.unassigned ? {unassigned:true} : {}),
-        ...(saved.assignee ? {assignee: saved.assignee} : {}),
         ...(saved.milestoneId ? {milestone_id: saved.milestoneId} : {}),
         ...(saved.dueDate ? {due_date: saved.dueDate + 'T23:59:59Z'} : {}),
       }),
@@ -877,22 +166,11 @@ function createIssueCapture({ fetchJson, storage, createOperationId = newIssueOp
   }
 
   return {
-    saveDraft, loadDraft, clearDraft, loadLabels, loadMilestones, loadOwners, loadTemplates,
-    loadFilingMetadata, applyTemplate, setTemplateState, templateFields, restoreTemplate, loadTemplateOptions,
-    selectTemplate, buildRelatedDraft:relatedDraft, bindTemplatePicker, bindFilingMetadata, loadRepositoryPage,
-    searchRepositories, searchBlockers, findDuplicates,
-    needsDuplicateAcknowledgement, acknowledgeDuplicates, submit,
+    saveDraft, loadDraft, clearDraft, loadLabels, loadMilestones, submit,
     stageSharedContent, pendingSharedContent, acceptSharedContent, discardSharedContent,
-    stageFollowUp, pendingFollowUp, acceptFollowUp, discardFollowUp,
   };
 }
 
 createIssueCapture.normalizeSharedContent = normalizeSharedContent;
-createIssueCapture.createOwnerPicker = createIssueOwnerPicker;
-createIssueCapture.buildRelatedDraft = buildRelatedDraft;
-createIssueCapture.relatedChecklistDraft = relatedChecklistDraft;
-createIssueCapture.linkChecklistTask = linkChecklistTask;
-createIssueCapture.createChecklistPromotion = createChecklistPromotion;
-createIssueCapture.createModalLifecycle = createIssueModalLifecycle;
 
 if (typeof module !== 'undefined' && module.exports) module.exports = createIssueCapture;

frontend/create-pull-sheet.js

@@ -1,203 +0,0 @@
-function createController({request, storage, login, createId = () => globalThis.crypto?.randomUUID?.() || String(Date.now())}) {
-  const storageKey = 'stackchain.create-pull.v1.' + String(login || '').toLowerCase();
-  let operationId = createId();
-  let current = {
-    repository:'', branches:[], head:'', base:'', expected_head_sha:'',
-    title:'', body:'', draft:true,
-  };
-  try {
-    const saved = JSON.parse(storage?.getItem?.(storageKey) || 'null');
-    if (saved && typeof saved === 'object') {
-      for (const field of ['repository', 'head', 'base', 'title', 'body']) {
-        if (typeof saved[field] === 'string') current[field] = saved[field];
-      }
-      if (typeof saved.draft === 'boolean') current.draft = saved.draft;
-    }
-  } catch (_) {}
-
-  function snapshot() {
-    return JSON.parse(JSON.stringify(current));
-  }
-
-  function persist() {
-    storage?.setItem?.(storageKey, JSON.stringify({
-      repository:current.repository, head:current.head, base:current.base,
-      title:current.title, body:current.body, draft:current.draft,
-    }));
-  }
-
-  async function selectRepository(repository) {
-    const options = await request('api/v1/repos/' + repository + '/pull-creation-options');
-    const branches = Array.isArray(options?.branches) ? options.branches : [];
-    const base = branches.some(branch => branch.name === options.default_branch) ? options.default_branch : (branches[0]?.name || '');
-    const headBranch = branches.find(branch => branch.name !== base) || branches[0] || {};
-    current = {
-      ...current, repository, branches, base,
-      head:headBranch.name || '', expected_head_sha:headBranch.sha || '',
-    };
-    persist();
-    return snapshot();
-  }
-
-  function update(values) {
-    current = {...current, ...values};
-    if (Object.prototype.hasOwnProperty.call(values, 'head')) {
-      current.expected_head_sha = current.branches.find(branch => branch.name === values.head)?.sha || '';
-    }
-    persist();
-    return snapshot();
-  }
-
-  async function submit() {
-    const result = await request('api/v1/repos/' + current.repository + '/pulls', {
-      method:'POST',
-      headers:{'Idempotency-Key':operationId},
-      body:{
-        head:current.head, base:current.base, title:current.title, body:current.body,
-        draft:current.draft, expected_head_sha:current.expected_head_sha,
-      },
-    });
-    operationId = createId();
-    return result;
-  }
-
-  return {
-    state:snapshot,
-    selectRepository,
-    update,
-    submit,
-  };
-}
-
-function createBinding({controller, render, status, onCreated}) {
-  return {
-    async repositoryChanged(repository) {
-      status('Loading branches…');
-      try {
-        const state = await controller.selectRepository(repository);
-        render(state);
-        status(state.branches.length ? 'Choose the source and base branches.' : 'No branches are available.');
-        return state;
-      } catch (error) {
-        status(error.message || 'Branches could not be loaded.');
-        throw error;
-      }
-    },
-    changed(values) {
-      const state = controller.update(values);
-      render(state);
-      return state;
-    },
-    async submit() {
-      status('Creating pull request…');
-      try {
-        const result = await controller.submit();
-        status(result.existing ? `Pull request #${result.number} is already open.` : `Pull request #${result.number} created.`);
-        onCreated(result);
-        return result;
-      } catch (error) {
-        status(error.message || 'The pull request could not be created. Your draft is safe.');
-        throw error;
-      }
-    },
-  };
-}
-
-async function bindDashboard() {
-  const qs = selector => document.querySelector(selector);
-  const switchButton = qs('#switch-to-create-pull');
-  switchButton.disabled = true;
-  const identityResponse = await fetch('api/v1/background-identity').catch(()=>null);
-  const identity = await identityResponse?.json().catch(()=>({}));
-  if (!identityResponse?.ok || !identity?.login) {
-    switchButton.title = 'Account identity is unavailable.';
-    return null;
-  }
-  const login = identity.login;
-  const root = qs('#create-pull-sheet');
-  const repository = qs('#create-pull-repository');
-  const head = qs('#create-pull-head');
-  const base = qs('#create-pull-base');
-  const title = qs('#create-pull-title');
-  const body = qs('#create-pull-body');
-  const submit = qs('#submit-create-pull');
-  const request = async (url, options) => {
-    const response = await fetch(url, options ? {
-      method:options.method,
-      headers:{'Content-Type':'application/json', ...options.headers},
-      body:JSON.stringify(options.body),
-    } : undefined);
-    const payload = await response.json().catch(()=>({}));
-    if (!response.ok) throw new Error(payload.error || payload.detail || 'Request failed.');
-    return payload;
-  };
-  const controller = createController({request, storage:localStorage, login});
-  const setOptions = (select, branches) => {
-    select.replaceChildren(...branches.map(branch => {
-      const option = document.createElement('option');
-      option.value = option.textContent = branch.name;
-      return option;
-    }));
-  };
-  const render = state => {
-    setOptions(head, state.branches);
-    setOptions(base, state.branches);
-    head.value = state.head;
-    base.value = state.base;
-    head.disabled = base.disabled = !state.branches.length;
-    qs('#create-pull-head-receipt').textContent = state.expected_head_sha ? 'Source at ' + state.expected_head_sha.slice(0, 12) : '';
-    submit.disabled = !(state.repository && state.head && state.base && state.head !== state.base && title.value.trim());
-  };
-  const binding = createBinding({
-    controller, render,
-    status:message=>{ qs('#create-pull-status').textContent = message; },
-    onCreated:result=>{
-      root.hidden = true;
-      qs('main').inert = false;
-      location.hash = '#/my-work/pull/' + result.repository + '/' + result.number;
-      location.reload();
-    },
-  });
-  const update = () => binding.changed({
-    head:head.value, base:base.value, title:title.value, body:body.value,
-    draft:document.querySelector('input[name="create-pull-mode"]:checked')?.value !== 'ready',
-  });
-  repository.addEventListener('change', () => binding.repositoryChanged(repository.value).catch(()=>{}));
-  [head,base,title,body].forEach(field => field.addEventListener('input', update));
-  document.querySelectorAll('input[name="create-pull-mode"]').forEach(field => field.addEventListener('change', () => {
-    update();
-    submit.textContent = field.value === 'ready' && field.checked ? 'Create ready pull request' : 'Create draft pull request';
-  }));
-  qs('#create-pull-form').addEventListener('submit', event => {
-    event.preventDefault();
-    update();
-    binding.submit().catch(()=>{});
-  });
-  const close = () => {
-    root.hidden = true;
-    qs('main').inert = false;
-    qs('#new-issue').focus();
-  };
-  qs('#cancel-create-pull').addEventListener('click', close);
-  switchButton.addEventListener('click', () => {
-    qs('#cancel-new-issue').click();
-    repository.replaceChildren(...Array.from(qs('#create-issue-repository').options).map(source => {
-      const option = document.createElement('option');
-      option.value = source.value;
-      option.textContent = source.textContent;
-      return option;
-    }));
-    root.hidden = false;
-    qs('main').inert = true;
-    qs('#cancel-create-pull').focus();
-  });
-  root.addEventListener('keydown', event => {
-    if (event.key === 'Escape') { event.preventDefault(); close(); }
-  });
-  switchButton.disabled = false;
-  return binding;
-}
-
-const cp = {createController, createBinding, b:bindDashboard};
-if (typeof module !== 'undefined') module.exports = cp;
-else cp.b();

frontend/detail-defer.js

@@ -1,7 +1,6 @@
 function createDetailDefer({
   laterWork,
   session,
-  continueSession = null,
   close,
   refresh,
   focus,
@@ -9,30 +8,17 @@ function createDetailDefer({
   formatTime = value => new Date(value).toLocaleString(),
 }) {
   return {
-    deferUntil(item, until, { closeSheet = true, restoreFocus = true } = {}) {
+    defer(item, preset) {
       if (!item) return false;
-      const result = laterWork.defer(item, until);
-      if (result !== 'deferred') {
-        announce(result === 'invalid' ? 'Choose a valid future time.' : 'Could not save Later on this device.');
-        return false;
-      }
+      const until = laterWork.presetUntil(preset);
+      if (!laterWork.defer(item, until)) return false;
       const inSession = session.active();
-      if (continueSession && session.checkpointed?.(item)) {
-        if (continueSession(item) === true) return true;
-        laterWork.restore(item);
-        refresh();
-        announce('Could not remove this item from Today, so it was restored from Later.');
-        return false;
-      }
-      if (!inSession && closeSheet) close();
+      if (!inSession) close();
       refresh();
       announce('Deferred until ' + formatTime(until) + '. It stays unread and unchanged in Gitea.');
-      if (!inSession && restoreFocus) focus();
+      if (!inSession) focus();
       return true;
     },
-    defer(item, preset) {
-      return this.deferUntil(item, laterWork.presetUntil(preset));
-    },
   };
 }
 

frontend/device-storage.js

@@ -1,142 +0,0 @@
-(function (root, factory) {
-  if (typeof module === 'object' && module.exports) module.exports = factory;
-  else {
-    root.createDeviceStorage = factory;
-    root.createDeviceStorage.mount = document => factory({
-      summary:document.querySelector('#device-storage-summary'),
-      detail:document.querySelector('#device-storage-detail'),
-      clearCachesButton:document.querySelector('#clear-device-caches'),
-      clearAllButton:document.querySelector('#clear-private-device-data'),
-      localStorage:root.localStorage,
-      sessionStorage:root.sessionStorage,
-      caches:root.caches,
-      storageManager:root.navigator?.storage,
-      privateDatabases:root.stackchainPrivateDatabases,
-      inspectPrivateDatabases:root.inspectStackchainPrivateDatabases,
-      clearPrivateDeviceData:root.stackchainPrivateDeviceData,
-    });
-  }
-})(typeof self !== 'undefined' ? self : this, function createDeviceStorage(options) {
-  let privateItemCount = 0;
-  let privateRecordCount = 0;
-  let inventoryUnavailable = false;
-  let fullClearArmed = false;
-  let persistence = { state:'unavailable', detail:'Storage protection is unavailable in this browser.', label:'Unavailable' };
-  const ownedCaches = async () => (await options.caches?.keys?.() || [])
-    .filter(name => name.startsWith('stackchain-dashboard-'));
-
-  function ownedStorageCount(storage) {
-    if (!storage) return 0;
-    let count = 0;
-    for (let index = 0; index < storage.length; index += 1) {
-      if (storage.key(index)?.startsWith('stackchain.')) count += 1;
-    }
-    return count;
-  }
-
-  function megabytes(value) {
-    return Math.round((Number(value) || 0) / (1024 * 1024));
-  }
-
-  async function inspectPersistence() {
-    if (typeof options.storageManager?.persisted !== 'function' || typeof options.storageManager?.persist !== 'function') {
-      persistence = {state:'unavailable', detail:'Storage protection is unavailable in this browser.', label:'Unavailable'};
-      return persistence;
-    }
-    try {
-      const protectedStorage = await options.storageManager.persisted();
-      persistence = protectedStorage
-        ? {state:'complete', detail:'Offline work is protected from automatic browser storage cleanup.', label:'Protected'}
-        : {state:'incomplete', detail:'Offline work uses best-effort browser storage and may be removed under storage pressure.', label:'Best effort'};
-    } catch (_error) {
-      persistence = {state:'incomplete', detail:'Storage protection could not be checked. Retry to protect offline work.', label:'Check failed'};
-    }
-    return persistence;
-  }
-
-  function persistenceReadiness() {
-    return {state:persistence.state, detail:persistence.detail};
-  }
-
-  async function requestPersistence() {
-    if (typeof options.storageManager?.persist !== 'function') return persistenceReadiness();
-    let granted = false;
-    try { granted = await options.storageManager.persist(); }
-    catch (_error) {
-      persistence = {state:'incomplete', detail:'Storage protection request failed. Offline work still uses best-effort storage; retry when ready.', label:'Request failed'};
-      options.detail.textContent = options.detail.textContent.replace(/Storage protection: [^·]+/, 'Storage protection: Request failed ');
-      return persistenceReadiness();
-    }
-    await refresh();
-    if (!granted && persistence.state !== 'complete') {
-      persistence = {state:'incomplete', detail:'The browser did not grant storage protection. Offline work still works but may be removed under storage pressure.', label:'Denied'};
-      options.detail.textContent = options.detail.textContent.replace(/Storage protection: [^·]+/, 'Storage protection: Denied ');
-    }
-    return persistenceReadiness();
-  }
-
-  async function refresh() {
-    let estimate = null;
-    try { estimate = await options.storageManager?.estimate?.(); }
-    catch (_error) { /* Storage estimates are optional. */ }
-    await inspectPersistence();
-    options.summary.textContent = estimate?.quota
-      ? `${megabytes(estimate.usage)} MB of ${megabytes(estimate.quota)} MB browser storage used.`
-      : 'Browser storage usage is unavailable.';
-    const itemCount = ownedStorageCount(options.localStorage)
-      + (options.sessionStorage === options.localStorage ? 0 : ownedStorageCount(options.sessionStorage));
-    privateItemCount = itemCount;
-    const inventory = await options.inspectPrivateDatabases?.(options.privateDatabases)
-      || { recordCount: 0, unavailable: true };
-    privateRecordCount = inventory.recordCount;
-    inventoryUnavailable = inventory.unavailable;
-    const cacheCount = (await ownedCaches()).length;
-    options.detail.textContent = `Storage protection: ${persistence.label} · ${itemCount} private browser item${itemCount === 1 ? '' : 's'} · `
-      + `${inventoryUnavailable ? 'private work status unknown' : `${privateRecordCount} private work record${privateRecordCount === 1 ? '' : 's'}`} · `
-      + `${cacheCount} cached app cop${cacheCount === 1 ? 'y' : 'ies'}`;
-    return { itemCount, privateRecordCount, inventoryUnavailable, cacheCount };
-  }
-
-  async function clearCaches() {
-    options.clearCachesButton.disabled = true;
-    try {
-      await Promise.all((await ownedCaches()).map(name => options.caches.delete(name)));
-      await refresh();
-      options.summary.textContent = 'Cached app copies cleared. Private work was kept.';
-    } catch (error) {
-      options.summary.textContent = `Cached copies could not be cleared: ${error.message}`;
-    } finally {
-      options.clearCachesButton.disabled = false;
-    }
-  }
-
-  async function clearAll() {
-    if ((privateItemCount > 0 || privateRecordCount > 0 || inventoryUnavailable) && !fullClearArmed) {
-      fullClearArmed = true;
-      options.clearAllButton.textContent = 'Confirm: clear private work';
-      options.summary.textContent = 'Private drafts or queued work may not be synced. Press confirm to clear them from this device.';
-      return;
-    }
-    options.clearAllButton.disabled = true;
-    try {
-      await options.clearPrivateDeviceData();
-      privateItemCount = 0;
-      fullClearArmed = false;
-      options.clearAllButton.textContent = 'Clear all private data';
-      options.detail.textContent = `Storage protection: ${persistence.label} · 0 private browser items · 0 private work records · 0 cached app copies`;
-      options.summary.textContent = 'All Stackchain private data was cleared from this device.';
-    } catch (error) {
-      options.summary.textContent = `Private data was not fully cleared: ${error.message}`;
-    } finally {
-      options.clearAllButton.disabled = false;
-    }
-  }
-
-  async function start() {
-    options.clearCachesButton.addEventListener('click', clearCaches);
-    options.clearAllButton.addEventListener('click', clearAll);
-    return refresh();
-  }
-
-  return { refresh, start, persistenceReadiness, requestPersistence };
-});

frontend/draft-capacity-dialog.js

@@ -1,68 +0,0 @@
-function showDraftCapacityDialog(captures, qs) {
-  const state = captures.capacity();
-  if (!state.full) return false;
-  const oldest = state.oldest;
-  qs('#draft-capacity-oldest').innerHTML = '<strong>' + escapeHtml(oldest.title) + '</strong><div class="small">' +
-    escapeHtml(oldest.body || 'No note') + (oldest.hasAttachment ? ' · Screenshot attached' : '') + '</div>';
-  qs('#draft-capacity-sheet').dataset.oldestId = oldest.id;
-  qs('#draft-capacity-status').textContent = '';
-  qs('#draft-capacity-sheet').hidden = false;
-  qs('#keep-editing-draft').focus();
-  return true;
-}
-
-function bindDraftCapacityDialog({
-  qs, saveIssueCaptureDraft, closeCreateIssueSheet, mobileTaskDock, refreshMyWorkView,
-  unfiledCaptures, currentIssueCaptureDraft, createIssueAttachmentController, issueCapture,
-}) {
-  qs('#keep-editing-draft').addEventListener('click', () => {
-    qs('#draft-capacity-sheet').hidden = true;
-    qs('#save-unfiled-issue').focus();
-  });
-  qs('#review-full-drafts').addEventListener('click', () => {
-    const oldestId = qs('#draft-capacity-sheet').dataset.oldestId;
-    saveIssueCaptureDraft();
-    qs('#draft-capacity-sheet').hidden = true;
-    closeCreateIssueSheet(true, false);
-    qs('[data-work-filter="draft"]').click();
-    mobileTaskDock.select('queues');
-    refreshMyWorkView();
-    requestAnimationFrame(() => {
-      const card = qs('[data-capture-id="' + CSS.escape(oldestId) + '"]');
-      card?.scrollIntoView({block:'nearest'});
-      card?.focus({preventScroll:true});
-    });
-  });
-  qs('#replace-oldest-draft').addEventListener('click', async () => {
-    const oldest = unfiledCaptures.capacity().oldest;
-    if (!oldest || oldest.id !== qs('#draft-capacity-sheet').dataset.oldestId) {
-      qs('#draft-capacity-status').textContent = 'Drafts changed. Review them before replacing anything.';
-      return;
-    }
-    if (!window.confirm('Replace “' + oldest.title + '” and permanently delete its saved contents?')) return;
-    const button = qs('#replace-oldest-draft');
-    button.disabled = true;
-    try {
-      const draft = currentIssueCaptureDraft();
-      const evidence = await createIssueAttachmentController.serialize();
-      Object.assign(draft,
-        Array.isArray(evidence) ? {attachments:evidence} : {attachment:evidence});
-      const saved = await unfiledCaptures.replaceOldest(draft, oldest.id);
-      qs('#draft-capacity-sheet').hidden = true;
-      issueCapture.clearDraft();
-      qs('#create-issue-title').value = '';
-      qs('#create-issue-body').value = '';
-      createIssueAttachmentController.clear();
-      closeCreateIssueSheet(true, false);
-      qs('[data-work-filter="draft"]').click();
-      mobileTaskDock.select('queues');
-      refreshMyWorkView();
-      requestAnimationFrame(() => qs('[data-capture-id="' + CSS.escape(saved.id) + '"]')?.focus());
-      qs('#my-work-action-status').textContent = 'Oldest Draft replaced. New work saved to Drafts.';
-    } catch (error) {
-      qs('#draft-capacity-status').textContent = error.message + ' Nothing was replaced.';
-    } finally { button.disabled = false; }
-  });
-}
-
-if (typeof module !== 'undefined' && module.exports) module.exports = {showDraftCapacityDialog, bindDraftCapacityDialog};

frontend/draft-filing-session.js

@@ -1,118 +0,0 @@
-function createDraftFilingSession({list}) {
-  let orderedIds = [];
-  let currentId = '';
-  let reviewTrigger = null;
-
-  function visibleIds() {
-    const available = new Set(list().map(item => item.id));
-    orderedIds = orderedIds.filter(id => available.has(id));
-    for (const item of list()) {
-      if (!orderedIds.includes(item.id)) orderedIds.push(item.id);
-    }
-    return orderedIds;
-  }
-
-  function state() {
-    const ids = visibleIds();
-    if (!ids.length) {
-      currentId = '';
-      return null;
-    }
-    if (!ids.includes(currentId)) currentId = ids[0];
-    const index = ids.indexOf(currentId);
-    return {id:currentId, position:index + 1, total:ids.length, remaining:ids.length - index - 1};
-  }
-
-  function start(id) {
-    orderedIds = list().map(item => item.id);
-    if (!orderedIds.includes(id)) throw new Error('This capture is no longer available.');
-    currentId = id;
-    return state();
-  }
-
-  function move(offset) {
-    const ids = visibleIds();
-    if (!ids.length) return state();
-    const index = Math.max(0, ids.indexOf(currentId));
-    currentId = ids[(index + offset + ids.length) % ids.length];
-    return state();
-  }
-
-  function removeCurrentAndNext(removedId) {
-    const previousIds = orderedIds.slice();
-    const removedIndex = Math.max(0, previousIds.indexOf(removedId));
-    orderedIds = previousIds.filter(id => id !== removedId);
-    const ids = visibleIds();
-    if (!ids.length) return state();
-    currentId = ids[Math.min(removedIndex, ids.length - 1)];
-    return state();
-  }
-
-  const session = {start, current:state, next:()=>move(1), previous:()=>move(-1), removeCurrentAndNext};
-  session.attach = (qs, dependencies) => {
-    const openCapture = async (captureId, trigger = null) => {
-      const resumed = await dependencies.captures.resume(captureId, dependencies.getLogin());
-      const issueCapture = dependencies.capture?.() || dependencies.issueCapture;
-      issueCapture.saveDraft(resumed);
-      dependencies.setResumedId(captureId);
-      await dependencies.openSheet(false);
-      const evidence = resumed.attachments || resumed.attachment;
-      dependencies.attachment[evidence ? 'restore' : 'clear'](evidence);
-      dependencies.setFilingMode(true);
-      session.render();
-      if (trigger) {
-        await dependencies.review(resumed);
-        reviewTrigger = trigger;
-        const submitter = resumed.completionIntent === 'create-and-start' ?
-          qs('#create-and-start-issue') : qs('#submit-new-issue');
-        const disabled = submitter.disabled;
-        submitter.disabled = false;
-        qs('#create-issue-form').requestSubmit(submitter);
-        submitter.disabled = disabled;
-      }
-    };
-    return Object.assign(session, {
-    nextCapture() { const state = session.current(); return state ? openCapture(state.id) : null; },
-    reviewCapture(captureId, trigger) {
-      session.start(captureId);
-      return openCapture(captureId, trigger);
-    },
-    open(captureId, trigger = null) {
-      session.start(captureId);
-      return openCapture(captureId, trigger);
-    },
-    takeTrigger() {
-      const trigger = reviewTrigger;
-      reviewTrigger = null;
-      return trigger;
-    },
-    render() {
-      const state = session.current();
-      qs('#draft-filing-session').hidden = !state;
-      if (!state) return;
-      qs('#draft-filing-progress').textContent = `Draft ${state.position} of ${state.total}`;
-      qs('#draft-filing-remaining').textContent = state.remaining ? `${state.remaining} remaining` : 'Last Draft';
-      qs('#previous-draft').disabled = qs('#skip-draft').disabled = state.total < 2;
-      qs('#submit-new-issue').textContent = state.remaining ? 'File & next' : 'File final Draft';
-    },
-    bind() {
-      [['#previous-draft','previous'],['#skip-draft','next']].forEach(([selector, method]) =>
-        qs(selector).addEventListener('click', async () => {
-          const state = session[method]();
-          if (state) await openCapture(state.id);
-        })
-      );
-    },
-    async advance(completedId) {
-      const state = session.removeCurrentAndNext(completedId);
-      if (state) { await openCapture(state.id); return true; }
-      qs('#draft-filing-session').hidden = true;
-      qs('#submit-new-issue').textContent = 'Create & assign to me';
-      return false;
-    },
-  });
-  };
-  return session;
-}
-
-if (typeof module !== 'undefined' && module.exports) module.exports = createDraftFilingSession;

frontend/drafts.js

@@ -101,7 +101,7 @@ function createDraftInbox({ storage, getCurrentLogin = () => '', now = () => Dat
   function parseOutbox(raw) {
     try {
       const record = JSON.parse(raw);
-      if (![1, 2, 3].includes(record?.version) || !Array.isArray(record.items)) return [];
+      if (![1, 2].includes(record?.version) || !Array.isArray(record.items)) return [];
       const currentLogin = String(getCurrentLogin() || '').trim();
       return record.items.filter(item =>
         item && typeof item.id === 'string' && typeof item.repository === 'string' && typeof item.title === 'string'
@@ -112,13 +112,8 @@ function createDraftInbox({ storage, getCurrentLogin = () => '', now = () => Dat
         id: 'stackchain.issue-outbox.v1:' + item.id,
         outbox_id: item.id,
         kind: 'issue-outbox',
-        status: item.status === 'completion' ? 'completion' :
-          (item.status === 'attention' ? 'attention' : (item.status === 'sending' ? 'sending' : 'queued')),
-        label: item.deliveryState === 'uncertain' ? 'Verify delivery' :
-          (item.status === 'completion' ? 'Created · ready to start' :
-            (item.status === 'attention' ? 'Needs attention' : 'Queued issue')),
-        continuation: item.status === 'completion' && item.completionIntent === 'create-and-start',
-        delivery_state: item.deliveryState,
+        status: item.status === 'attention' ? 'attention' : 'queued',
+        label: item.status === 'attention' ? 'Needs attention' : 'Queued issue',
         repository: item.repository,
         title: textPreview(item.title) || 'Untitled queued issue',
         preview: textPreview([item.title, item.error || item.body].filter(Boolean).join(' — ')),
@@ -126,8 +121,6 @@ function createDraftInbox({ storage, getCurrentLogin = () => '', now = () => Dat
         quarantined,
         ownership: quarantined ? 'Queued by ' + (ownerLogin || 'an unknown account') +
           (currentLogin ? ' — current account is ' + currentLogin : ' — account confirmation unavailable') : '',
-        last_attempt_at: Number(item.lastAttemptAt || 0),
-        last_attempt_error: textPreview(item.lastAttemptError),
         updated_at: Number(item.queuedAt || 0),
         };
       });
@@ -141,46 +134,24 @@ function createDraftInbox({ storage, getCurrentLogin = () => '', now = () => Dat
       const currentLogin = String(getCurrentLogin() || '').trim();
       return record.items.filter(item => item && typeof item.id === 'string' && typeof item.body === 'string')
         .map(item => {
-          const isUpdate = item.kind === 'update-reply' || item.kind === 'update-reply-read';
-          const isReview = item.kind === 'pull-review';
-          const isClosure = item.kind === 'issue-close';
-          const routeKind = isReview ? 'review' : (item.kind === 'pull-comment' ? 'pull' : 'issue');
+          const isUpdate = item.kind === 'update-reply';
+          const routeKind = item.kind === 'pull-comment' ? 'pull' : 'issue';
           const target = isUpdate ? 'Update #' + item.notificationId : item.repository + '#' + item.number;
-          const inlineFeedback = isReview && Array.isArray(item.comments) ? item.comments.map(comment =>
-            String(comment.path || 'File') + ' · ' +
-              (comment.new_position ? 'new line ' + comment.new_position : 'old line ' + comment.old_position) +
-              ': ' + String(comment.body || '')
-          ).filter(Boolean) : [];
-          const copyText = [item.body, inlineFeedback.length ? 'Inline feedback\n' + inlineFeedback.join('\n') : '']
-            .filter(Boolean).join('\n\n');
           const ownerLogin = String(item.ownerLogin || '').trim();
           const quarantined = !ownerLogin || !currentLogin || ownerLogin !== currentLogin;
-          const checklistConflict = !quarantined && item.kind === 'issue-content' &&
-            item.status === 'attention' && typeof item.baseBody === 'string';
           return {
             id: 'stackchain.authored-outbox.v1:' + item.id,
             outbox_id: item.id,
-            outbox_kind: item.kind,
             kind: 'authored-outbox',
-            status: item.status === 'attention' ? 'attention' : (item.status === 'sending' ? 'sending' :
-              (item.status === 'authorization' || isClosure ? 'authorization' : 'queued')),
-            label: checklistConflict ? 'Checklist conflict' : item.deliveryState === 'uncertain' ? 'Verify delivery' :
-              (item.status === 'attention' ? (isClosure ? 'Issue closure needs attention' : 'Needs attention') :
-                (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,
+            status: item.status === 'attention' ? 'attention' : 'queued',
+            label: item.status === 'attention' ? 'Needs attention' : 'Queued message',
             repository: isUpdate ? '' : item.repository,
             title: target,
             preview: textPreview([item.error, item.body].filter(Boolean).join(' — ')),
-            copy_text: copyText,
-            checklist_conflict: checklistConflict,
-            ...(isReview ? { head_sha: item.expectedHeadSha } : {}),
+            copy_text: item.body,
             quarantined,
             ownership: quarantined ? 'Queued by ' + (ownerLogin || 'an unknown account') +
               (currentLogin ? ' — current account is ' + currentLogin : ' — account confirmation unavailable') : '',
-            last_attempt_at: Number(item.lastAttemptAt || 0),
-            last_attempt_error: textPreview(item.lastAttemptError),
             updated_at: Number(item.queuedAt || 0),
             route: isUpdate ? { kind:'update', notification_id:item.notificationId } :
               { kind:routeKind, repository:item.repository, number:item.number },
@@ -239,38 +210,7 @@ function createDraftInbox({ storage, getCurrentLogin = () => '', now = () => Dat
     } catch (_error) { return false; }
   }
 
-  function partition(items = list()) {
-    const isDelivery = item => item.kind === 'issue-outbox' || item.kind === 'authored-outbox';
-    const needsAction = item => isDelivery(item) && (
-      item.status === 'attention' || item.status === 'authorization' || item.status === 'completion' ||
-      item.delivery_state === 'uncertain' || item.quarantined
-    );
-    const deliveries = items.filter(isDelivery).sort((left, right) =>
-      Number(needsAction(right)) - Number(needsAction(left))
-    );
-    const drafts = items.filter(item => item.kind !== 'issue-outbox' && item.kind !== 'authored-outbox');
-    const counts = deliveries.reduce((summary, item) => {
-      const state = item.status === 'sending' ? 'sending' : (item.status === 'attention' ? 'attention' :
-        (item.status === 'authorization' ? 'authorization' : 'waiting'));
-      summary[state] += 1;
-      return summary;
-    }, { waiting:0, sending:0, attention:0, authorization:0 });
-    const retryable = deliveries.filter(item =>
-      item.status === 'queued' && !item.authorization_required && !item.quarantined && item.delivery_state !== 'uncertain'
-    );
-    return { drafts, deliveries, counts, retryable, actionable:deliveries.filter(needsAction).length };
-  }
-
-  function deliveryLabel(item) {
-    if (item.quarantined) return 'Identity protected';
-    if (item.status === 'completion') return 'Created · ready to start';
-    if (item.status === 'attention') return 'Needs attention';
-    if (item.status === 'sending') return 'Sending';
-    if (item.status === 'authorization') return 'Awaiting authorization';
-    return 'Queued for sync';
-  }
-
-  return { list, discard, partition, deliveryLabel };
+  return { list, discard };
 }
 
 if (typeof module !== 'undefined' && module.exports) module.exports = createDraftInbox;

frontend/feature-loader.js

@@ -1,63 +0,0 @@
-function createFeatureLoader({ document, urls, timeoutMs = 10000 }) {
-  const pending = new Map();
-  const loaded = new Set();
-
-  function load(name) {
-    if (loaded.has(name)) return Promise.resolve();
-    if (pending.has(name)) return pending.get(name);
-    const url = urls[name];
-    if (!url) return Promise.reject(new Error('Unknown feature: ' + name));
-
-    const request = new Promise((resolve, reject) => {
-      const script = document.createElement('script');
-      let timeout;
-      const fail = () => {
-        clearTimeout(timeout);
-        script.remove();
-        pending.delete(name);
-        reject(new Error('Could not load ' + name.replace(/-/g, ' ') + '.'));
-      };
-      script.src = url;
-      script.async = true;
-      script.onload = () => {
-        clearTimeout(timeout);
-        pending.delete(name);
-        loaded.add(name);
-        resolve();
-      };
-      script.onerror = fail;
-      timeout = setTimeout(fail, timeoutMs);
-      document.head.appendChild(script);
-    });
-    pending.set(name, request);
-    return request;
-  }
-
-  async function run(name, elements, callback) {
-    const trigger = elements?.trigger;
-    const status = elements?.status;
-    const retryLabel = elements?.retryLabel || 'Tap New issue to retry.';
-    if (trigger) trigger.disabled = true;
-    if (status) status.textContent = 'Loading ' + name.replace(/-/g, ' ') + '…';
-    try {
-      await load(name);
-      callback();
-      if (status) status.textContent = '';
-      return true;
-    } catch (_error) {
-      if (status) {
-        const label = name === 'issue-capture' ? 'Issue capture' :
-          name === 'pull-workflow' ? 'Pull workspace' :
-          name === 'security-center' ? 'Security center' : name.replace(/-/g, ' ');
-        status.textContent = label + ' could not load. ' + retryLabel;
-      }
-      return false;
-    } finally {
-      if (trigger) trigger.disabled = false;
-    }
-  }
-
-  return { load, run, ready: name => loaded.has(name) };
-}
-
-if (typeof module !== 'undefined' && module.exports) module.exports = createFeatureLoader;

frontend/filed-claim.js

@@ -1,9 +0,0 @@
-function filedClaimEligible(item, detail) {
-  return Boolean(
-    item?.is_filed && !item?.is_assigned && !item?.is_completed &&
-    item?.state === 'open' && detail?.state === 'open' &&
-    Array.isArray(detail?.assignees) && detail.assignees.length === 0
-  );
-}
-
-if (typeof module !== 'undefined' && module.exports) module.exports = filedClaimEligible;

frontend/following.js

@@ -1,292 +0,0 @@
-(function (root, factory) {
-  const exports = factory();
-  if (typeof module === 'object' && module.exports) {
-    module.exports = exports.createFollowing;
-    module.exports.attachFollowing = exports.attachFollowing;
-    module.exports.planningDisposition = exports.planningDisposition;
-  } else {
-    root.createFollowing = exports.createFollowing;
-    root.attachFollowing = exports.attachFollowing;
-    root.followingPlanningDisposition = exports.planningDisposition;
-  }
-})(typeof self !== 'undefined' ? self : this, function () {
-  function planningDisposition(detail, controls) {
-    const active = detail?.following === true && detail.kind === 'issue' && detail.state === 'open' &&
-      Boolean(detail.claimable || detail.assigned_to_me);
-    const result = active ? {active:true,today:'Add to Today & next',later:'Later & next',week:'Week Ahead & next'} : {active:false};
-    if (!controls && globalThis.document) {
-      const query = selector => globalThis.document.querySelector(selector);
-      controls = {root:query('.search-preview-primary-actions'),claim:query('#claim-search-result'),
-        today:query('#queue-search-result'),later:query('#defer-search-result'),week:query('#plan-search-result'),
-        start:query('#start-search-result'),watch:query('#watch-search-result')};
-    }
-    controls?.root?.classList.toggle('following-disposition-mode', active);
-    if (active && controls) {
-      controls.claim.hidden = controls.start.hidden = controls.watch.hidden = true;
-      controls.today.textContent = result.today;
-      controls.later.textContent = result.later;
-      controls.week.textContent = result.week;
-    }
-    return result;
-  }
-
-  function createFollowing(options) {
-    let generation = 0;
-    let snapshot = {revision:0, items:[]};
-    let review = null;
-
-    function sameItem(left, right) {
-      return (left?.kind || 'issue') === (right?.kind || 'issue') &&
-        left?.repository === right?.repository && Number(left?.number) === Number(right?.number);
-    }
-
-    function publish(status, error) {
-      const state = {status, revision:snapshot.revision, items:[...snapshot.items]};
-      state.degraded = snapshot.degraded === true;
-      state.refreshFailures = Number(snapshot.refreshFailures) || 0;
-      if (review?.acknowledged.size) state.reviewSummary = {
-          reviewed:review.acknowledged.size,
-          remaining:snapshot.items.filter(item => item.has_unseen_change === true).length,
-      };
-      if (error) state.error = error;
-      options.render?.(state);
-      if (status === 'ready') options.onCount?.(
-        snapshot.items.filter(item => item.has_unseen_change === true).length);
-      return state;
-    }
-
-    async function load() {
-      const requestGeneration = ++generation;
-      publish('loading');
-      try {
-        const result = await options.fetchJson('api/v1/following', {headers:{Accept:'application/json'}});
-        if (requestGeneration !== generation) return snapshot;
-        snapshot = {
-          revision:Number(result?.revision) || 0,
-          items:Array.isArray(result?.items) ? result.items.slice(0, 50)
-            .map(item => ({...item, kind:item.kind === 'pull' ? 'pull' : 'issue'})) : [],
-          degraded:result?.degraded === true,
-          refreshFailures:Number(result?.refresh_failures) || 0,
-        };
-        publish('ready');
-        return snapshot;
-      } catch (error) {
-        if (requestGeneration === generation) publish('error', error);
-        throw error;
-      }
-    }
-
-    async function acknowledge(item) {
-      const current = snapshot.items.find(candidate => sameItem(candidate, item) &&
-        candidate.updated_at === item?.updated_at);
-      if (!current || current.has_unseen_change !== true || typeof options.onAcknowledge !== 'function') return false;
-      await options.onAcknowledge(current);
-      current.has_unseen_change = false;
-      review?.acknowledged.add(current.kind + ':' + current.repository + '#' + current.number + '@' + current.updated_at);
-      publish('ready');
-      return true;
-    }
-
-    async function keepForLater(item) {
-      const exact = candidate => sameItem(candidate, item) && candidate.updated_at === item?.updated_at;
-      const current = snapshot.items.find(exact);
-      const index = review?.active ? review.items.findIndex(exact) : -1;
-      if (!current || index < 0 || typeof options.onKeep !== 'function') return null;
-      await options.onKeep(current);
-      current.has_unseen_change = true;
-      review.acknowledged.delete(current.kind + ':' + current.repository + '#' +
-        current.number + '@' + current.updated_at);
-      review.items.splice(index, 1);
-      const next = review.items[index] || null;
-      if (!next) review.active = false;
-      publish('ready');
-      if (next) await open(snapshot.items.findIndex(candidate => sameItem(candidate, next)));
-      return next;
-    }
-
-    async function open(index) {
-      const item = snapshot.items[Number(index)];
-      if (!item) return false;
-      await options.onOpen?.({...item, following:true});
-      await acknowledge(item);
-      return true;
-    }
-
-    async function startReview() {
-      const items = snapshot.items
-        .filter(item => item.has_unseen_change === true)
-        .map(item => ({...item, following:true}));
-      if (!items.length) return false;
-      review = {items, more:false, active:true, acknowledged:new Set()};
-      await open(snapshot.items.indexOf(snapshot.items.find(item => sameItem(item, items[0]))));
-      return true;
-    }
-
-    function finishReview() {
-      const completed = Boolean(review?.completed || (review?.active &&
-        !snapshot.items.some(item => item.has_unseen_change === true)));
-      if (review) review.active = false;
-      if (completed && !review.completed) {
-        review.completed = true;
-        options.onReviewComplete?.();
-      }
-      publish('ready');
-      return completed;
-    }
-
-    function retire(item) {
-      const same = candidate => sameItem(candidate, item);
-      const index = review?.active ? review.items.findIndex(same) : -1;
-      snapshot.items = snapshot.items.filter(candidate => !same(candidate));
-      if (index < 0) {
-        publish('ready');
-        return null;
-      }
-      review.items.splice(index, 1);
-      const next = review.items[index] || null;
-      if (!next) {
-        review.active = false;
-        if (!review.completed) {
-          review.completed = true;
-          options.onReviewComplete?.();
-        }
-      }
-      publish('ready');
-      return next ? {...next} : null;
-    }
-
-    return {
-      load, open, startReview, previewLoaded:acknowledge, keepForLater, finishReview, retire,
-      session:() => review?.active ? {items:[...review.items], more:false} : null,
-      items:() => snapshot.items.map(item => ({...item})),
-      count:() => snapshot.items.length,
-    };
-  }
-
-  function attachFollowing(onOpen, hooks = {}) {
-    const document = globalThis.document;
-    const query = selector => document.querySelector(selector);
-    const escapeHtml = value => String(value ?? '').replace(/[&<>"']/g, character =>
-      ({'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;',"'":'&#39;'})[character]);
-    const formatTime = value => new Date(value).toLocaleString();
-    const fetchJson = async (url, options) => {
-      const response = await fetch(url, options);
-      const payload = await response.json().catch(() => ({}));
-      if (!response.ok) throw new Error(payload.detail || payload.error || 'Following is temporarily unavailable.');
-      return payload;
-    };
-    const changeRevision = (item, action) => {
-      const [owner, repo] = item.repository.split('/');
-      return fetchJson('api/v1/following/' + encodeURIComponent(owner) + '/' +
-        encodeURIComponent(repo) + '/issues/' + item.number + '/' + action +
-        '?kind=' + encodeURIComponent(item.kind), {
-          method:'PUT', headers:{'Content-Type':'application/json', Accept:'application/json'},
-          body:JSON.stringify({updated_at:item.updated_at}),
-        });
-    };
-    let feature;
-    let activeReviewItem = null;
-    const show = () => query('#following-sheet').open || query('#following-sheet').showModal();
-    function render(state) {
-      hooks.onStatus?.(state.status);
-      const list = query('#following-list');
-      const status = query('#following-status');
-      const reviewButton = query('#review-following');
-      query('#retry-following').hidden = state.status !== 'error';
-      if (state.status === 'loading') return void (status.textContent = 'Loading watched items…');
-      if (state.status === 'error') return void (status.textContent = state.error?.message || 'Following is temporarily unavailable.');
-      const unseen = state.items.filter(item => item.has_unseen_change === true).length;
-      reviewButton.hidden = unseen === 0;
-      reviewButton.textContent = unseen === 1 ? 'Review new activity' : 'Review ' + unseen + ' new changes';
-      status.textContent = (state.reviewSummary
-        ? 'Reviewed ' + state.reviewSummary.reviewed + ' changes · ' + state.reviewSummary.remaining + ' still need review. '
-        : '') + (state.degraded ? 'Some watched items could not be refreshed. Showing last known details. ' : '') + (state.items.length
-        ? state.items.length + (state.items.length === 1 ? ' watched item.' : ' watched items.')
-        : 'No watched items yet. Watch an issue or pull request from Search to keep it here.');
-      list.innerHTML = state.items.map((item, index) =>
-        '<button class="following-card' + (item.has_unseen_change ? ' has-unseen-change' : '') +
-        '" type="button" data-following-index="' + index + '"><span>' +
-        (item.has_unseen_change ? '<em>' + escapeHtml(item.change_summary || 'New activity') + '</em>' : '') + '<strong>' +
-        escapeHtml(item.title) + '</strong><small>' + escapeHtml(
-        (item.kind === 'pull' ? 'Pull request' : 'Issue') + ' · ' + item.repository + ' #' + item.number +
-        ' · ' + item.state + ' · ' + formatTime(item.updated_at)) +
-        '</small></span><span aria-hidden="true">›</span></button>').join('');
-      list.querySelectorAll('[data-following-index]').forEach(button => button.addEventListener('click', () => {
-        query('#following-sheet').close();
-        feature.open(Number(button.dataset.followingIndex)).catch(() => {});
-      }));
-    }
-    feature = createFollowing({
-      fetchJson, render,
-      onCount:count => {
-        const value = query('[data-mobile-queue-count="following"]');
-        value.textContent = count;
-        value.closest('button').setAttribute('aria-label', 'Following, ' + count +
-          (count === 1 ? ' unseen change' : ' unseen changes'));
-        hooks.onCount?.(count, feature.items());
-      },
-      onOpen:item => {
-        activeReviewItem = item;
-        return onOpen(item);
-      },
-      onReviewComplete:hooks.onReviewComplete,
-      onAcknowledge:item => changeRevision(item, 'seen'),
-      onKeep:item => changeRevision(item, 'keep'),
-    });
-    query('#close-following').addEventListener('click', () => query('#following-sheet').close());
-    query('#review-following').addEventListener('click', () => {
-      query('#following-sheet').close();
-      feature.startReview().catch(() => {
-        show();
-      });
-    });
-    query('#retry-following').addEventListener('click', () => feature.load().catch(() => {}));
-    const keepButton = query('#keep-following-for-later');
-    keepButton.addEventListener('click', async () => {
-      const status = query('#keep-following-status');
-      keepButton.disabled = true;
-      status.textContent = 'Keeping this change for later…';
-      try {
-        if (!await feature.keepForLater(activeReviewItem)) query('#close-search-preview').click();
-        status.textContent = 'Kept for later.';
-      } catch (_) {
-        status.textContent = 'Could not keep this change for later. Retry when ready.';
-        keepButton.disabled = false;
-      }
-    });
-    return {
-      load:feature.load,
-      review:feature.startReview,
-      async route() {
-        await feature.load().then(feature.startReview).catch(() => false) || show();
-      },
-      open() {
-        show();
-        feature.load().catch(() => {});
-        return 'opened-following';
-      },
-      session:feature.session,
-      previewLoaded:feature.previewLoaded,
-      keepForLater:feature.keepForLater,
-      retire:feature.retire,
-      preview(state) {
-        const disposition = planningDisposition(state?.detail || state?.item);
-        keepButton.hidden = state?.item?.following !== true || disposition.active;
-        keepButton.disabled = false;
-        if (keepButton.hidden || state.status === 'loading') query('#keep-following-status').textContent = '';
-      },
-      returnToFollowing() {
-        const completed = feature.finishReview();
-        if (completed) return 'completed-following';
-        show();
-        globalThis.requestAnimationFrame?.(() => {
-          const target = query('#review-following:not([hidden])') || query('.following-card') || query('#close-following');
-          target?.focus();
-        });
-        return 'returned-following';
-      },
-    };
-  }
-
-  return {createFollowing, attachFollowing, planningDisposition};
-});

frontend/human-gates.js

@@ -1,510 +0,0 @@
-function createHumanGates(options = {}) {
-  const storage = options.storage || window.localStorage;
-  const getLogin = options.getLogin || (() => '');
-  const getAccountKey = options.getAccountKey || getLogin;
-  const isOnline = options.isOnline || (() => navigator.onLine);
-  const location = options.location || window.location;
-  const fetchJson = options.fetchJson;
-  const nodes = options.nodes || {};
-  let queue = { pending_count: 0, items: [] };
-  let reviewSnapshot = [];
-  let reviewIndex = -1;
-  let loadedAccountKey = '';
-  let loadEpoch = 0;
-  const decisionKeys = new Map();
-  let decisionFlight = null;
-  let openFlight = null;
-  let onChange = options.onChange;
-  let historyItems = [];
-  let historyNextCursor = null;
-  let historyLoadedMore = false;
-  let historyLoadError = '';
-
-  const escape = value => String(value ?? '').replace(/[&<>"']/g, character => ({
-    '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;',
-  })[character]);
-  const cacheKey = () => 'stackchain.human-gates.v1:' + String(getAccountKey() || '').trim().toLowerCase();
-  const progressKey = item => 'stackchain.human-gate-review.v1:' +
-    String(getAccountKey() || '').trim().toLowerCase() + ':' + item.id + ':' + item.revision;
-  const decisionStorageKey = () => 'stackchain.human-gate-decision.v1:' +
-    String(getAccountKey() || '').trim().toLowerCase();
-  const setText = (node, value) => { if (node) node.textContent = value; };
-  const setHtml = (node, value) => { if (node) node.innerHTML = value; };
-  const publish = state => onChange?.(JSON.parse(JSON.stringify(queue)), state);
-
-  function validSnapshot(value) {
-    return value && Number.isInteger(value.pending_count) && Array.isArray(value.items) ? value : null;
-  }
-
-  function restore() {
-    if (!getLogin()) return null;
-    try { return validSnapshot(JSON.parse(storage.getItem(cacheKey()) || 'null')); } catch (_) { return null; }
-  }
-
-  function save(value) {
-    if (!getLogin()) return;
-    try { storage.setItem(cacheKey(), JSON.stringify(value)); } catch (_) {}
-  }
-
-  function restoreProgress(item) {
-    if (!getLogin() || !item) return null;
-    try {
-      const value = JSON.parse(storage.getItem(progressKey(item)) || 'null');
-      if (!value || value.gate_id !== item.id || value.revision !== item.revision) return null;
-      return value;
-    } catch (_) { return null; }
-  }
-
-  function saveProgress(values = {}) {
-    const item = current();
-    if (!getLogin() || !item) return false;
-    const checklist = values.checklist || {};
-    const progress = {
-      gate_id:item.id, revision:item.revision,
-      checklist:Object.fromEntries(['exact_hash', 'artifacts_reviewed', 'provenance_reviewed'].map(key => [key, checklist[key] === true])),
-      reason:String(values.reason || ''), override_reason:String(values.override_reason || ''),
-    };
-    try { storage.setItem(progressKey(item), JSON.stringify(progress)); return true; } catch (_) { return false; }
-  }
-
-  function restorePendingDecision(item = null) {
-    if (!getLogin()) return null;
-    try {
-      const value = JSON.parse(storage.getItem(decisionStorageKey()) || 'null');
-      if (!value || typeof value !== 'object' || !value.idempotency_key || !value.operation ||
-          !value.payload || !value.gate_id || !Number.isInteger(value.revision)) return null;
-      if (item && (value.gate_id !== item.id || value.revision !== item.revision)) return null;
-      return value;
-    } catch (_) { return null; }
-  }
-
-  function savePendingDecision(value) {
-    storage.setItem(decisionStorageKey(), JSON.stringify(value));
-  }
-
-  function clearPendingDecision(item) {
-    if (!restorePendingDecision(item)) return;
-    try { storage.removeItem?.(decisionStorageKey()); } catch (_) {}
-  }
-
-  function valuesFromDetail() {
-    const checklist = Object.fromEntries(Array.from(nodes.detail?.querySelectorAll?.('[data-gate-checklist]') || []).map(input => [input.dataset.gateChecklist, input.checked]));
-    return {
-      checklist,
-      reason:nodes.detail?.querySelector?.('[data-gate-reason]')?.value || '',
-      override_reason:nodes.detail?.querySelector?.('[data-gate-override]')?.value || '',
-    };
-  }
-
-  function updateReadiness(values = valuesFromDetail()) {
-    const completed = ['exact_hash', 'artifacts_reviewed', 'provenance_reviewed']
-      .filter(key => values.checklist?.[key] === true).length;
-    setText(nodes.detail?.querySelector?.('[data-gate-readiness]'), completed + ' of 3 confirmations complete');
-  }
-
-  function captureProgress() {
-    if (!nodes.detail?.querySelectorAll) return false;
-    const values = valuesFromDetail();
-    updateReadiness(values);
-    return saveProgress(values);
-  }
-
-  nodes.detail?.addEventListener?.('input', captureProgress);
-  nodes.detail?.addEventListener?.('change', captureProgress);
-  function render() {
-    setText(nodes.count, String(queue.pending_count));
-    if (!queue.pending_count) {
-      setHtml(nodes.list, '<div class="human-gates-zero"><strong>Inbox zero</strong><span>No release candidates need your decision.</span></div>');
-      setText(nodes.status, 'Human Gates inbox zero.');
-      return;
-    }
-    setText(nodes.status, queue.pending_count + (queue.pending_count === 1 ? ' gate pending.' : ' gates pending.'));
-    setHtml(nodes.list, queue.items.map(item =>
-      '<button class="human-gate-card" type="button" data-human-gate-id="' + escape(item.id) + '">' +
-      '<strong>' + escape(item.title) + '</strong><code>' + escape(item.candidate_hash) + '</code>' +
-      '<span>Priority ' + escape(item.priority ?? 0) + '</span></button>'
-    ).join(''));
-  }
-
-  function setView(view) {
-    nodes.pendingTab?.setAttribute?.('aria-pressed', view === 'pending' ? 'true' : 'false');
-    nodes.historyTab?.setAttribute?.('aria-pressed', view === 'history' ? 'true' : 'false');
-  }
-
-  function renderHistory(preserveDetail = false) {
-    setView('history');
-    if (historyNextCursor) {
-      setText(nodes.status, historyItems.length + ' Human Gate decisions loaded. Older decisions are available.');
-    } else if (historyLoadedMore) {
-      setText(nodes.status, 'All ' + historyItems.length + ' Human Gate decisions loaded.');
-    } else {
-      setText(nodes.status, historyItems.length + (historyItems.length === 1 ? ' past Human Gate decision.' : ' past Human Gate decisions.'));
-    }
-    if (!historyItems.length) {
-      setHtml(nodes.list, '<div class="human-gates-zero"><strong>No decision history</strong><span>Released and held candidates will appear here.</span></div>');
-      setHtml(nodes.detail, '');
-      return;
-    }
-    setHtml(nodes.list, historyItems.map(item =>
-      '<button class="human-gate-card human-gate-history-card" type="button" data-human-gate-history-id="' + escape(item.id) + '">' +
-      '<strong>' + escape(item.title) + '</strong><span class="human-gate-state human-gate-state-' + escape(item.state) + '">' +
-      escape(item.state.charAt(0).toUpperCase() + item.state.slice(1)) + '</span>' +
-      '<code>' + escape(item.candidate_hash) + '</code><time>' + escape(new Date(Number(item.updated_at) * 1000).toLocaleString()) + '</time></button>'
-    ).join('') + (historyNextCursor ? '<button class="human-gate-history-more" type="button" data-human-gate-history-more>' +
-      (historyLoadError ? 'Retry older decisions' : 'Load older decisions') + '</button>' : ''));
-    Array.from(nodes.list?.querySelectorAll?.('[data-human-gate-history-id]') || []).forEach(card => {
-      card.addEventListener('click', () => selectHistory(card.dataset.humanGateHistoryId).catch(error => {
-        setText(nodes.status, error.message || 'Human Gate history is unavailable.');
-      }));
-    });
-    nodes.list?.querySelector?.('[data-human-gate-history-more]')?.addEventListener?.('click', () => {
-      loadMoreHistory().catch(error => setText(nodes.status, error.message || 'Older Human Gate decisions are unavailable.'));
-    });
-    if (!preserveDetail) setHtml(nodes.detail, '<div class="human-gates-zero"><strong>Decision history</strong><span>Open a candidate to review its durable receipt.</span></div>');
-  }
-
-  async function showHistory() {
-    if (!isOnline()) throw new Error('Human Gate history requires an online connection.');
-    if (!String(getLogin() || '').trim()) throw new Error('Authenticated account identity is required.');
-    const result = validSnapshot(await fetchJson('api/v1/human-gates?state=history&limit=20'));
-    if (!result) throw new Error('Human Gate history response is invalid.');
-    historyItems = result.items;
-    historyNextCursor = result.next_cursor || null;
-    historyLoadedMore = false;
-    historyLoadError = '';
-    renderHistory();
-    return JSON.parse(JSON.stringify(historyItems));
-  }
-
-  async function loadMoreHistory() {
-    if (!historyNextCursor) return JSON.parse(JSON.stringify(historyItems));
-    if (!isOnline()) throw new Error('Human Gate history requires an online connection.');
-    const cursor = historyNextCursor;
-    let result;
-    try {
-      result = validSnapshot(await fetchJson(
-        'api/v1/human-gates?state=history&limit=20&cursor=' + encodeURIComponent(cursor)
-      ));
-      if (!result) throw new Error('Human Gate history response is invalid.');
-    } catch (error) {
-      historyLoadError = error?.message || 'Older Human Gate decisions are unavailable.';
-      renderHistory(true);
-      setText(nodes.status, historyLoadError + ' Loaded decisions are still available.');
-      throw error;
-    }
-    const known = new Set(historyItems.map(item => item.id));
-    historyItems.push(...result.items.filter(item => !known.has(item.id)));
-    historyNextCursor = result.next_cursor || null;
-    historyLoadedMore = true;
-    historyLoadError = '';
-    renderHistory(true);
-    return JSON.parse(JSON.stringify(historyItems));
-  }
-
-  async function selectHistory(gateId) {
-    const summary = historyItems.find(item => item.id === gateId);
-    if (!summary) throw new Error('Gate is not in the current history.');
-    const detail = await fetchJson('api/v1/human-gates/' + encodeURIComponent(gateId));
-    if (!detail || detail.id !== gateId) throw new Error('Gate history detail is invalid.');
-    let receipt = null;
-    if (detail.receipt_id) receipt = await fetchJson('api/v1/human-gate-receipts/' + encodeURIComponent(detail.receipt_id));
-    const checklist = receipt?.checklist || {};
-    const confirmations = ['exact_hash', 'artifacts_reviewed', 'provenance_reviewed']
-      .filter(key => checklist[key] === true).map(key => '<li>' + escape(key.replaceAll('_', ' ')) + '</li>').join('');
-    setHtml(nodes.detail,
-      '<article class="human-gate-detail human-gate-receipt"><p class="small">' + escape(detail.state.toUpperCase()) + '</p>' +
-      '<h3>' + escape(detail.title) + '</h3><p>Project <strong>' + escape(detail.project) + '</strong></p>' +
-      '<p>Exact candidate <code>' + escape(detail.candidate_hash) + '</code></p>' +
-      (receipt ? '<p>Decision receipt <code>' + escape(receipt.receipt_id) + '</code></p>' +
-        '<p>Decided ' + escape(new Date(Number(receipt.decided_at) * 1000).toLocaleString()) + '</p>' +
-        (receipt.reason ? '<h4>Reason</h4><p>' + escape(receipt.reason) + '</p>' : '') +
-        (receipt.override_reason ? '<h4>Override</h4><p>' + escape(receipt.override_reason) + '</p>' : '') +
-        (confirmations ? '<h4>Confirmed</h4><ul>' + confirmations + '</ul>' : '') :
-        '<p>No decision receipt exists because this candidate was superseded.</p>') + '</article>');
-    return {detail, receipt};
-  }
-
-  function showPending() {
-    setView('pending');
-    render();
-    renderDetail(current());
-    return JSON.parse(JSON.stringify(queue));
-  }
-
-  function renderDetail(item) {
-    if (!item) {
-      setHtml(nodes.detail, '<div class="human-gates-zero"><strong>Inbox zero</strong><span>Fixed review snapshot complete.</span></div>');
-      return;
-    }
-    const progress = restoreProgress(item) || {checklist:{}, reason:'', override_reason:''};
-    const pendingDecision = restorePendingDecision(item);
-    const checked = key => progress.checklist?.[key] === true ? ' checked' : '';
-    const checks = (item.checks || []).map(check =>
-      '<li class="gate-check gate-check-' + escape(check.state) + '"><strong>' + escape(check.name) + '</strong> · ' + escape(check.state) + (check.required ? ' · required' : '') + '</li>'
-    ).join('');
-    const artifacts = (item.artifacts || []).map(artifact => '<li><a href="' + escape(artifact.url) + '" target="_blank" rel="noreferrer noopener">' + escape(artifact.name) + '</a></li>').join('');
-    const links = (item.links || []).map(link => '<li><a href="' + escape(link.url) + '" target="_blank" rel="noreferrer noopener">' + escape(link.label) + '</a></li>').join('');
-    const provenance = Object.entries(item.provenance || {}).map(([key, value]) => '<li><strong>' + escape(key) + '</strong> · ' + escape(value) + '</li>').join('');
-    const history = (item.history || []).map(event => '<li><strong>' + escape(event.action) + '</strong> · ' + escape(event.at) + '</li>').join('');
-    setHtml(nodes.detail,
-      '<article class="human-gate-detail"><h3>' + escape(item.title) + '</h3>' +
-      '<p>Project <strong>' + escape(item.project) + '</strong></p>' +
-      '<p>Exact candidate <code>' + escape(item.candidate_hash) + '</code></p>' +
-      '<p>Score ' + escape(item.score?.value ?? 'not supplied') + ' · ' + escape(item.score?.provenance || '') + '</p>' +
-      '<h4>Artifacts</h4><ul>' + artifacts + '</ul><h4>Links</h4><ul>' + links + '</ul>' +
-      '<h4>Checks</h4><ul>' + checks + '</ul><h4>Provenance</h4><ul>' + provenance + '</ul>' +
-      '<h4>History</h4><ul>' + history + '</ul>' +
-      '<label><input type="checkbox" data-gate-checklist="exact_hash"' + checked('exact_hash') + '> Exact hash reviewed</label>' +
-      '<label><input type="checkbox" data-gate-checklist="artifacts_reviewed"' + checked('artifacts_reviewed') + '> Artifacts reviewed</label>' +
-      '<label><input type="checkbox" data-gate-checklist="provenance_reviewed"' + checked('provenance_reviewed') + '> Provenance reviewed</label>' +
-      '<label>Hold reason<textarea data-gate-reason>' + escape(progress.reason) + '</textarea></label>' +
-      '<label>Override reason<textarea data-gate-override>' + escape(progress.override_reason) + '</textarea></label>' +
-      '<div class="human-gate-decision-tray' + (pendingDecision ? ' human-gate-decision-recovery' : '') + '"><div class="human-gate-decision-state">' +
-      (pendingDecision ? '<strong>Decision outcome unknown</strong><span role="status">The previous ' + escape(pendingDecision.decision) +
-        ' response was interrupted. Verify it before making another decision.</span>' :
-        '<strong data-gate-readiness>0 of 3 confirmations complete</strong><span data-gate-error role="alert" hidden></span>') + '</div>' +
-      '<div class="human-gate-decision-actions">' + (pendingDecision ?
-        '<button type="button" data-gate-recover>Verify decision</button>' :
-        '<button type="button" data-gate-decision="hold">Hold &amp; next</button><button type="button" data-gate-decision="release">Release &amp; next</button>') +
-      '</div></div></article>'
-    );
-    updateReadiness();
-  }
-
-  async function load() {
-    const epoch = ++loadEpoch;
-    const accountKey = String(getAccountKey() || '').trim().toLowerCase();
-    if (accountKey !== loadedAccountKey) {
-      loadedAccountKey = accountKey;
-      queue = { pending_count: 0, items: [] };
-      reviewSnapshot = [];
-      reviewIndex = -1;
-      render();
-    }
-    const cached = restore();
-    if (cached) {
-      queue = cached;
-      render();
-      publish({available:true, authoritative:false, cached:true});
-    }
-    try {
-      const live = validSnapshot(await fetchJson('api/v1/human-gates'));
-      if (epoch !== loadEpoch || accountKey !== loadedAccountKey) return queue;
-      if (!live) throw new Error('Human Gates response is invalid.');
-      queue = { pending_count: live.pending_count, items: live.items.slice() };
-      const interrupted = restorePendingDecision();
-      if (interrupted && interrupted.item?.id === interrupted.gate_id && interrupted.item.revision === interrupted.revision) {
-        const recoveryItem = {...interrupted.item, decision_recovery:true};
-        const existingIndex = queue.items.findIndex(candidate => candidate.id === interrupted.gate_id);
-        if (existingIndex >= 0) queue.items[existingIndex] = recoveryItem;
-        else {
-          queue.items.unshift(recoveryItem);
-          queue.pending_count += 1;
-        }
-      }
-      save(queue);
-      render();
-      publish({available:true, authoritative:true});
-      return queue;
-    } catch (error) {
-      if (epoch !== loadEpoch || accountKey !== loadedAccountKey) return queue;
-      if (!cached) {
-        publish({available:false, authoritative:false});
-        throw error;
-      }
-      setText(nodes.status, 'Offline cached gate list · reconnect before deciding.');
-      return queue;
-    }
-  }
-
-  function reviewNext() {
-    if (reviewIndex < 0) {
-      reviewSnapshot = queue.items.slice();
-      reviewIndex = 0;
-    }
-    const item = reviewSnapshot[reviewIndex] || null;
-    renderDetail(item);
-    if (item) {
-      const index = reviewIndex;
-      fetchJson('api/v1/human-gates/' + encodeURIComponent(item.id)).then(detail => {
-        if (!detail || detail.id !== item.id) throw new Error('Gate detail is invalid.');
-        if (reviewIndex !== index || reviewSnapshot[index]?.id !== item.id) return;
-        reviewSnapshot[index] = detail;
-        renderDetail(detail);
-      }).catch(() => { setText(nodes.status, 'Gate detail is unavailable. Retry while online.'); });
-    }
-    return item;
-  }
-
-  function select(gateId) {
-    if (reviewIndex < 0) reviewSnapshot = queue.items.slice();
-    const index = reviewSnapshot.findIndex(item => item.id === gateId);
-    if (index < 0) throw new Error('Gate is not in the current review snapshot.');
-    reviewIndex = index;
-    return reviewNext();
-  }
-
-  function current() { return reviewIndex < 0 ? null : (reviewSnapshot[reviewIndex] || null); }
-  function idempotencyKey(item, decision, payload) {
-    const operation = item.id + ':' + item.revision + ':' + decision + ':' + JSON.stringify(payload);
-    const pending = restorePendingDecision(item);
-    if (pending?.operation === operation) return { operation, key: pending.idempotency_key };
-    if (decisionKeys.has(operation)) return { operation, key: decisionKeys.get(operation) };
-    const nonce = globalThis.crypto?.randomUUID?.() || (Date.now().toString(36) + '-' + Math.random().toString(36).slice(2));
-    const key = 'human-gate:' + item.id + ':' + item.revision + ':' + decision + ':' + nonce;
-    decisionKeys.set(operation, key);
-    return { operation, key };
-  }
-
-  function completeDecision(item, decision, operation, receipt) {
-    decisionKeys.delete(operation);
-    clearPendingDecision(item);
-    try { storage.removeItem?.(progressKey(item)); } catch (_) {}
-    queue.items = queue.items.filter(candidate => candidate.id !== item.id);
-    queue.pending_count = Math.max(0, queue.pending_count - 1);
-    save(queue); render();
-    publish({available:true, authoritative:true, decision:true});
-    reviewIndex += 1;
-    const next = current();
-    if (next) reviewNext(); else renderDetail(null);
-    setText(nodes.status, next ? (decision === 'release' ? 'Released. Reviewing next gate.' : 'Held. Reviewing next gate.') : 'Decision saved. Human Gates review snapshot complete.');
-    return { receipt, next };
-  }
-
-  async function postDecision(item, pending) {
-    const receipt = await fetchJson('api/v1/human-gates/' + encodeURIComponent(item.id) + '/decision', {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json', 'Idempotency-Key': pending.idempotency_key },
-      body: JSON.stringify(pending.payload),
-    });
-    return completeDecision(item, pending.decision, pending.operation, receipt);
-  }
-
-  function decisionError(message, selector) {
-    const error = new Error(message);
-    error.targetSelector = selector;
-    return error;
-  }
-
-  async function decideAndNext(decision, values = {}) {
-    const item = current();
-    if (!item) throw new Error('No gate is selected.');
-    if (!isOnline()) throw new Error('Human Gate decisions require an online connection.');
-    if (!String(getLogin() || '').trim()) throw new Error('Authenticated account identity is required.');
-    const checklist = values.checklist || {};
-    const complete = ['exact_hash', 'artifacts_reviewed', 'provenance_reviewed'].every(key => checklist[key] === true);
-    if (decision === 'release' && !complete) {
-      const firstMissing = ['exact_hash', 'artifacts_reviewed', 'provenance_reviewed'].find(key => checklist[key] !== true);
-      throw decisionError('Complete the release checklist before deciding.', '[data-gate-checklist="' + firstMissing + '"]');
-    }
-    const unmet = (item.checks || []).filter(check => check.required && check.state !== 'success');
-    if (decision === 'release' && unmet.length && !String(values.override_reason || '').trim()) {
-      const names = unmet.map(check => String(check.name || 'Unnamed check')).join(', ');
-      throw decisionError('An explicit override reason is required for unmet required checks: ' + names + '.', '[data-gate-override]');
-    }
-    if (decision === 'hold' && !String(values.reason || '').trim()) {
-      throw decisionError('A hold reason is required.', '[data-gate-reason]');
-    }
-    const payload = {
-      expected_revision: item.revision, decision,
-      reason: String(values.reason || '').trim(),
-      override_reason: String(values.override_reason || '').trim(), checklist,
-    };
-    if (decisionFlight) return decisionFlight;
-    const operation = (async () => {
-      const decisionKey = idempotencyKey(item, decision, payload);
-      const pending = {
-        gate_id:item.id, revision:item.revision, decision, payload,
-        operation:decisionKey.operation, idempotency_key:decisionKey.key,
-        item:JSON.parse(JSON.stringify(item)),
-      };
-      savePendingDecision(pending);
-      try {
-        return await postDecision(item, pending);
-      } catch (error) {
-        renderDetail(item);
-        setText(nodes.status, 'Decision outcome unknown. Verify the interrupted decision while online.');
-        throw error;
-      }
-    })();
-    decisionFlight = operation;
-    try {
-      return await operation;
-    } finally {
-      if (decisionFlight === operation) decisionFlight = null;
-    }
-  }
-
-  async function recoverDecision() {
-    const item = current();
-    if (!item) throw new Error('No gate is selected.');
-    if (!isOnline()) throw new Error('Decision verification requires an online connection.');
-    if (!String(getLogin() || '').trim()) throw new Error('Authenticated account identity is required.');
-    const pending = restorePendingDecision(item);
-    if (!pending) throw new Error('No interrupted decision exists for this gate revision.');
-    if (decisionFlight) return decisionFlight;
-    const operation = postDecision(item, pending);
-    decisionFlight = operation;
-    try { return await operation; }
-    finally { if (decisionFlight === operation) decisionFlight = null; }
-  }
-
-  async function submitDecision(decision) {
-    const values = valuesFromDetail();
-    updateReadiness(values);
-    const errorNode = nodes.detail?.querySelector?.('[data-gate-error]');
-    if (errorNode) { errorNode.textContent = ''; errorNode.hidden = true; }
-    const buttons = Array.from(nodes.detail?.querySelectorAll?.('[data-gate-decision]') || []);
-    buttons.forEach(button => { button.disabled = true; });
-    try {
-      return await decideAndNext(decision, values);
-    } catch (error) {
-      if (errorNode) {
-        errorNode.textContent = error?.message || 'The decision could not be saved.';
-        errorNode.hidden = false;
-      }
-      let target = error?.targetSelector && nodes.detail?.querySelector?.(error.targetSelector);
-      if (!target && error?.targetSelector?.startsWith('[data-gate-checklist=')) {
-        const key = error.targetSelector.match(/"([^"]+)"/)?.[1];
-        target = Array.from(nodes.detail?.querySelectorAll?.('[data-gate-checklist]') || [])
-          .find(input => input.dataset.gateChecklist === key);
-      }
-      target?.scrollIntoView?.({block:'center', behavior:'smooth'});
-      target?.focus?.({preventScroll:true});
-      throw error;
-    } finally {
-      buttons.forEach(button => { button.disabled = false; });
-    }
-  }
-
-  function open() {
-    location.hash = '#/my-work/human-gates';
-    if (nodes.panel) nodes.panel.hidden = false;
-    if (openFlight) return openFlight;
-    const operation = (async () => {
-      setView('pending');
-      await load();
-      reviewSnapshot = queue.items.slice();
-      reviewIndex = 0;
-      return reviewNext();
-    })();
-    openFlight = operation;
-    const clearFlight = () => {
-      if (openFlight === operation) openFlight = null;
-    };
-    operation.then(clearFlight, clearFlight);
-    return operation;
-  }
-
-  return {
-    load, open, reviewNext, select, showHistory, loadMoreHistory, selectHistory, showPending,
-    decideAndNext, recoverDecision, submitDecision, current, saveProgress,
-    setOnChange(callback) { onChange = callback; },
-    restoreCached: restore,
-    snapshot: () => JSON.parse(JSON.stringify(queue)),
-    route: () => location.hash,
-  };
-}
-
-if (typeof module !== 'undefined') module.exports = createHumanGates;
-if (typeof window !== 'undefined') window.createHumanGates = createHumanGates;

frontend/install-app.js

@@ -1,79 +0,0 @@
-(function (root, factory) {
-  if (typeof module === 'object' && module.exports) module.exports = factory;
-  else root.createInstallApp = factory;
-})(typeof self !== 'undefined' ? self : this, function createInstallApp(options) {
-  const dismissedKey = 'stackchain.install.dismissed.v1';
-  let deferredPrompt = options.initialPrompt || null;
-  let installed = false;
-
-  function hide() {
-    options.card.hidden = true;
-  }
-
-  function showNativePrompt(event) {
-    event.preventDefault();
-    deferredPrompt = event;
-    options.guidance.hidden = true;
-    options.installButton.hidden = false;
-    options.card.hidden = false;
-  }
-
-  async function install() {
-    if (!deferredPrompt) return;
-    const prompt = deferredPrompt;
-    deferredPrompt = null;
-    options.installButton.disabled = true;
-    await prompt.prompt();
-    const choice = await prompt.userChoice;
-    if (choice.outcome === 'accepted') {
-      installed = true;
-      hide();
-      options.status.textContent = 'Stackchain was added to your device.';
-    } else {
-      hide();
-      options.installButton.disabled = false;
-      options.status.textContent = 'Installation was not completed.';
-    }
-  }
-
-  function dismiss() {
-    options.storage.setItem(dismissedKey, '1');
-    hide();
-  }
-
-  function start() {
-    if (options.isStandalone() || options.storage.getItem(dismissedKey) === '1') {
-      hide();
-      return;
-    }
-    if (deferredPrompt) showNativePrompt(deferredPrompt);
-    if (options.isIosSafari()) {
-      options.installButton.hidden = true;
-      options.guidance.hidden = false;
-      options.card.hidden = false;
-    }
-    options.window.addEventListener('beforeinstallprompt', showNativePrompt);
-    options.window.addEventListener('appinstalled', () => {
-      installed = true;
-      deferredPrompt = null;
-      hide();
-    });
-    options.installButton.addEventListener('click', install);
-    options.dismissButton.addEventListener('click', dismiss);
-  }
-
-  function state() {
-    if (installed || options.isStandalone()) {
-      return {state:'complete', detail:'Stackchain is installed on this device.'};
-    }
-    if (options.isIosSafari()) {
-      return {state:'incomplete', detail:'On Safari, tap Share, then Add to Home Screen.'};
-    }
-    if (deferredPrompt) {
-      return {state:'incomplete', detail:'Stackchain is ready to install.'};
-    }
-    return {state:'unavailable', detail:'Installation is available from a supported browser.'};
-  }
-
-  return {start, install, state};
-});

frontend/issue-attachment.js

@@ -1,418 +0,0 @@
-(function(root, factory) {
-  const review = typeof module === 'object' && module.exports ? require('./issue-evidence-review.js') : root.issueEvidenceReview;
-  const editor = typeof module === 'object' && module.exports ? require('./issue-evidence-editor.js') : root.issueEvidenceEditor;
-  const api = factory(review, editor);
-  if (typeof module === 'object' && module.exports) module.exports = api;
-  else root.issueAttachment = api;
-})(typeof self !== 'undefined' ? self : this, function(issueEvidenceReview, issueEvidenceEditor) {
-  'use strict';
-
-  const MAX_BYTES = 2 * 1024 * 1024;
-  const MAX_PIXELS = issueEvidenceReview.MAX_PIXELS;
-  const MAX_FILES = 5;
-  const MAX_FILES_MESSAGE = 'Up to 5 screenshots. Remove one before adding another.';
-  const IMAGE_TYPES = new Set(['image/png', 'image/jpeg', 'image/webp']);
-
-  function normalizeNote(value) {
-    return String(value || '').replace(/\s+/g, ' ').trim().slice(0, 240);
-  }
-
-  function escapeMarkdown(value) {
-    return value.replace(/([\\`*_[\]{}()<>#+\-.!|])/g, '\\$1');
-  }
-
-  const optimizeImage = issueEvidenceReview.optimizeImage;
-
-  function multipart(attachment) {
-    let blob = attachment?.blob;
-    if (!blob && attachment?.data) {
-      const binary = atob(String(attachment.data));
-      const bytes = Uint8Array.from(binary, character => character.charCodeAt(0));
-      blob = new Blob([bytes], { type: String(attachment.contentType || '') });
-    }
-    if (!blob) throw new Error('The saved screenshot is unavailable. Retry before sending.');
-    const form = new FormData();
-    form.append('file', blob, String(attachment.filename || 'screenshot'));
-    return form;
-  }
-
-  function create(options) {
-    const upload = options.upload;
-    const maxFiles = options.maxFiles === MAX_FILES ? MAX_FILES : 1;
-    const inspectPixels = options.inspectPixels === true;
-    const optimizeSelectedImage = options.optimizeImage || optimizeImage;
-    const onCheckpoint = options.onCheckpoint;
-    const createOperationId = options.createOperationId || (() => {
-      if (typeof globalThis !== 'undefined' && globalThis.crypto?.randomUUID) {
-        return globalThis.crypto.randomUUID();
-      }
-      return Date.now().toString(36) + '-' + Math.random().toString(36).slice(2);
-    });
-    let selected = [];
-    let selectionGeneration = 0;
-    let restoring = false;
-
-    function changed() {
-      if (!restoring && typeof onCheckpoint === 'function') {
-        Promise.resolve().then(onCheckpoint).catch(() => { /* Caller surfaces durable-storage failures. */ });
-      }
-    }
-
-    function commitSelection(file) {
-      if (!file || !IMAGE_TYPES.has(file.type) || !Number.isFinite(file.size) ||
-          file.size <= 0 || file.size > MAX_BYTES) {
-        throw new Error('The screenshot could not be optimized below 2 MB. Try cropping it and choose it again.');
-      }
-      if (selected.length >= maxFiles) {
-        if (maxFiles === 1) selected = [];
-        else throw new Error(MAX_FILES_MESSAGE);
-      }
-      selected.push({file, note:'', confirmed:null, serialized:null, operationId:createOperationId()});
-      changed();
-      return state();
-    }
-
-    function select(file) {
-      if (selected.length >= maxFiles && maxFiles > 1) {
-        throw new Error(MAX_FILES_MESSAGE);
-      }
-      const generation = ++selectionGeneration;
-      if (!file || !IMAGE_TYPES.has(file.type)) {
-        throw new Error('Choose a PNG, JPEG, or WebP screenshot.');
-      }
-      if (!Number.isFinite(file.size) || file.size <= 0) {
-        throw new Error('Choose a screenshot that is 2 MB or smaller.');
-      }
-      if (file.size > MAX_BYTES || inspectPixels) {
-        return Promise.resolve(optimizeSelectedImage(file)).then(optimized => {
-          if (generation !== selectionGeneration) return state();
-          return commitSelection(optimized);
-        });
-      }
-      return commitSelection(file);
-    }
-
-    function clear() {
-      selectionGeneration += 1;
-      selected = [];
-    }
-
-    function remove(index) {
-      const position = Number(index);
-      if (!Number.isInteger(position) || position < 0 || position >= selected.length) return state();
-      selectionGeneration += 1;
-      selected.splice(position, 1);
-      changed();
-      return state();
-    }
-
-    function move(fromIndex, toIndex) {
-      const from = Number(fromIndex);
-      const to = Number(toIndex);
-      if (!Number.isInteger(from) || !Number.isInteger(to) || from < 0 ||
-          from >= selected.length || to < 0 || to >= selected.length || from === to) return state();
-      const [item] = selected.splice(from, 1);
-      selected.splice(to, 0, item);
-      changed();
-      return state();
-    }
-
-    function replace(index, file) {
-      const position = Number(index);
-      if (!Number.isInteger(position) || position < 0 || position >= selected.length) return state();
-      if (!file || !IMAGE_TYPES.has(file.type) || !Number.isFinite(file.size) ||
-          file.size <= 0 || file.size > MAX_BYTES) {
-        throw new Error('The edited screenshot must be a PNG, JPEG, or WebP image no larger than 2 MB.');
-      }
-      selectionGeneration += 1;
-      selected[position] = {
-        ...selected[position], file, confirmed:null, serialized:null, operationId:createOperationId(),
-      };
-      changed();
-      return state();
-    }
-
-    function setNote(index, value) {
-      const position = Number(index);
-      if (!Number.isInteger(position) || position < 0 || position >= selected.length) return state();
-      selected[position].note = normalizeNote(value);
-      selected[position].serialized = null;
-      changed();
-      return state();
-    }
-
-    function note(index) {
-      const position = Number(index);
-      return Number.isInteger(position) && selected[position] ? selected[position].note : '';
-    }
-
-    function restore(value) {
-      restoring = true;
-      try {
-        if (Array.isArray(value)) {
-          clear();
-          if (value.length > maxFiles) throw new Error(MAX_FILES_MESSAGE);
-          value.forEach(attachment => restoreOne(attachment));
-          return state();
-        }
-        clear();
-        restoreOne(value);
-        return state();
-      } finally { restoring = false; }
-    }
-
-    function restoreOne(value) {
-      const contentType = String(value?.contentType || '');
-      const filename = String(value?.filename || '');
-      const blob = value?.blob;
-      const data = String(value?.data || '');
-      if (!blob && !data) {
-        throw new Error('The saved screenshot is unavailable. Retry before editing this issue.');
-      }
-      const padding = (data.match(/=*$/) || [''])[0].length;
-      const size = blob ? Number(blob.size) : Math.max(1, Math.floor(data.length * 3 / 4) - padding);
-      commitSelection({ name: filename, type: contentType, size, ...(blob ? { blob } : {}) });
-      const item = selected[selected.length - 1];
-      item.note = normalizeNote(value?.note);
-      item.serialized = {
-        ...(blob ? { filename, contentType, blob } : { filename, contentType, data }),
-        ...(item.note ? {note:item.note} : {}),
-      };
-      const operationId = String(value?.operationId || '').slice(0, 128);
-      if (operationId) item.operationId = operationId;
-      const markdown = String(value?.confirmed?.markdown || '');
-      if (markdown) item.confirmed = { markdown };
-    }
-
-    function state() {
-      const values = selected.map(item => ({
-        name: item.file.name,
-        size: item.file.size,
-        uploaded: Boolean(item.confirmed),
-      }));
-      return values.length > 1 ? values : (values[0] || null);
-    }
-
-    function serializeItem(item) {
-      if (!item.serialized) item.serialized = {
-        filename:item.file.name, contentType:item.file.type, blob:item.file.blob || item.file,
-        ...(item.note ? {note:item.note} : {}),
-      };
-      return {
-        ...item.serialized,
-        operationId:item.operationId,
-        ...(item.confirmed?.markdown ? { confirmed:{ markdown:item.confirmed.markdown } } : {}),
-      };
-    }
-
-    async function serialize() {
-      if (!selected.length) return null;
-      const values = selected.map(serializeItem);
-      return values.length > 1 ? values : values[0];
-    }
-
-    async function prepareComment(target, body) {
-      const text = String(body || '').trim();
-      if (!selected.length) return text;
-      const markdown = [];
-      for (const evidence of selected) {
-        if (!evidence.confirmed) {
-          const attachment = serializeItem(evidence);
-          evidence.confirmed = await upload({
-            repository: target.repository,
-            number: target.number,
-            filename: attachment.filename,
-            content_type: attachment.contentType,
-            ...(attachment.blob ? { blob: attachment.blob } : { data: attachment.data }),
-            operation_id: evidence.operationId,
-          });
-          if (!evidence.confirmed || typeof evidence.confirmed.markdown !== 'string' || !evidence.confirmed.markdown) {
-            evidence.confirmed = null;
-            throw new Error('The server did not confirm the screenshot upload.');
-          }
-          await onCheckpoint?.();
-        }
-        if (evidence.note) {
-          markdown.push('**Screenshot ' + (markdown.length + 1) + ' — ' + escapeMarkdown(evidence.note) + '**\n\n' +
-            evidence.confirmed.markdown);
-        } else markdown.push(evidence.confirmed.markdown);
-      }
-      const evidence = markdown.join('\n\n');
-      return text ? text + '\n\n' + evidence : evidence;
-    }
-
-    return { select, restore, remove, move, replace, setNote, note, clear, state, serialize, prepareComment };
-  }
-
-  function mount(options) {
-    const inputs = Array.from(new Set((options.inputs || [options.input]).filter(Boolean)));
-    if (!inputs.includes(options.input)) inputs.push(options.input);
-    const controller = create({
-      ...options, inspectPixels:true,
-      maxFiles:options.maxFiles || (options.input?.multiple ? MAX_FILES : 1),
-    });
-    const clearSelection = controller.clear;
-    const restoreSelection = controller.restore;
-    const reviewEnabled = Boolean(options.tray && options.earlier && options.later);
-    let previewUrl = '';
-    let selectionSequence = 0;
-    const review = reviewEnabled ? issueEvidenceReview.create({
-      ...options, edit:options.editor?.edit, controller,
-    }) : null;
-
-    function setBusy(value) {
-      inputs.forEach(input => { input.disabled = Boolean(value); });
-      options.remove.disabled = Boolean(value);
-      if (options.editor?.edit) options.editor.edit.disabled = Boolean(value) || !controller.state();
-      review?.setBusy(value);
-    }
-
-    function clearPreview() {
-      selectionSequence += 1;
-      if (previewUrl) options.revokeObjectURL(previewUrl);
-      previewUrl = '';
-      review?.clear();
-      if (options.editor?.edit) options.editor.edit.disabled = true;
-      options.image.src = '';
-      options.preview.hidden = true;
-      inputs.forEach(input => {
-        input.value = '';
-        input.disabled = false;
-      });
-      clearSelection();
-      options.onChange?.(controller.state());
-    }
-
-    function showPreview(file, optimized) {
-      if (previewUrl) options.revokeObjectURL(previewUrl);
-      previewUrl = options.createObjectURL(file);
-      options.image.src = previewUrl;
-      options.meta.textContent = file.name + ' · ' + Math.ceil(file.size / 1024) + ' KB';
-      options.preview.hidden = false;
-      if (options.editor?.edit) options.editor.edit.disabled = false;
-      options.status.textContent = optimized ? 'Screenshot optimized and ready to upload.' :
-        (options.readyMessage || 'Screenshot ready to upload with this comment.');
-    }
-
-    function selectFromInput(event) {
-      const sourceInput = event.target;
-      const files = Array.from(sourceInput.files || []);
-      const sequence = ++selectionSequence;
-      if (!files.length) return;
-      let first;
-      try { first = controller.select(files[0]); }
-      catch (error) {
-        options.status.textContent = error.message;
-        sourceInput.value = '';
-        return;
-      }
-      if (!reviewEnabled && files.length === 1 && (!first || typeof first.then !== 'function')) {
-        showPreview(files[0], false);
-        return;
-      }
-      let optimized = Boolean(first && typeof first.then === 'function');
-      if (optimized) {
-        options.status.textContent = 'Optimizing screenshot…';
-        inputs.forEach(input => { input.disabled = true; });
-      }
-      const selectAll = files.slice(1).reduce((pending, file) => pending.then(async () => {
-        const result = controller.select(file);
-        if (result && typeof result.then === 'function') {
-          optimized = true;
-          options.status.textContent = 'Optimizing screenshot…';
-          inputs.forEach(input => { input.disabled = true; });
-          await result;
-        }
-      }), Promise.resolve(first));
-      return selectAll.then(() => controller.serialize()).then(value => {
-        if (sequence !== selectionSequence) return;
-        const values = Array.isArray(value) ? value : [value];
-        const latest = values[values.length - 1];
-        if (reviewEnabled) {
-          review.render(values, values.length - 1, optimized);
-        } else {
-          showPreview(latest.blob, optimized);
-          if (values.length > 1) {
-            options.meta.textContent = values.length + ' screenshots ready · latest: ' + latest.filename;
-            options.status.textContent = values.length + ' screenshots ready to file in this order.';
-          }
-        }
-        options.onChange?.(controller.state());
-      }).catch(error => {
-        if (sequence === selectionSequence) {
-          options.status.textContent = error.message;
-          sourceInput.value = '';
-        }
-      }).finally(() => {
-        if (sequence === selectionSequence) inputs.forEach(input => { input.disabled = false; });
-      });
-    }
-    inputs.forEach(input => input.addEventListener('change', selectFromInput));
-    options.remove.addEventListener('click', () => {
-      const current = controller.state();
-      const count = Array.isArray(current) ? current.length : (current ? 1 : 0);
-      if (count <= 1) {
-        clearPreview();
-        options.status.textContent = options.removedMessage || 'Screenshot removed. Your comment is unchanged.';
-        return Promise.resolve();
-      }
-      const removedIndex = reviewEnabled ? review.activeIndex() : count - 1;
-      controller.remove(removedIndex);
-      selectionSequence += 1;
-      review?.afterRemoval(removedIndex, count);
-      return controller.serialize().then(value => {
-        const values = Array.isArray(value) ? value : [value];
-        if (reviewEnabled) {
-          review.render(values, review.activeIndex());
-        } else {
-          const latest = values[values.length - 1];
-          showPreview(latest.blob, false);
-          options.meta.textContent = values.length + ' screenshots ready · latest: ' + latest.filename;
-        }
-        options.status.textContent = options.removedMessage || 'Latest screenshot removed. Your text is unchanged.';
-        options.onChange?.(controller.state());
-      });
-    });
-
-    function restorePreview(value) {
-      clearPreview();
-      const restored = restoreSelection(value);
-      const values = Array.isArray(value) ? value : [value];
-      if (reviewEnabled) {
-        review.render(values, values.length - 1);
-        return restored;
-      }
-      const latest = values[values.length - 1];
-      previewUrl = latest.blob ? options.createObjectURL(latest.blob) :
-        'data:' + latest.contentType + ';base64,' + latest.data;
-      options.image.src = previewUrl;
-      options.meta.textContent = values.length > 1 ?
-        values.length + ' screenshots ready · latest: ' + latest.filename :
-        restored.name + ' · ' + Math.ceil(restored.size / 1024) + ' KB';
-      options.preview.hidden = false;
-      options.status.textContent = values.length > 1 ?
-        values.length + ' screenshots ready to file in this order.' :
-        (options.readyMessage || 'Screenshot ready to upload with this comment.');
-      return restored;
-    }
-
-    if (review && options.editor && issueEvidenceEditor) {
-      issueEvidenceEditor.mount({
-        ...options.editor,
-        controller,
-        getActiveIndex:review.activeIndex,
-        optimizeImage,
-        onApplied: async index => {
-          const value = await controller.serialize();
-          review.render(value, index);
-          options.status.textContent = options.editor.appliedMessage ||
-            'Edited screenshot flattened and ready to file.';
-        },
-      });
-      options.editor.edit.disabled = !controller.state();
-    }
-    return Object.assign(controller, { clear: clearPreview, restore: restorePreview, setBusy });
-  }
-
-  return { create, mount, multipart, optimizeImage, MAX_BYTES, MAX_PIXELS };
-});

frontend/issue-evidence-editor.js

@@ -1,306 +0,0 @@
-(function(root, factory) {
-  const api = factory();
-  if (typeof module === 'object' && module.exports) module.exports = api;
-  else root.issueEvidenceEditor = api;
-})(typeof self !== 'undefined' ? self : this, function() {
-  'use strict';
-
-  function boundedRect(value, bounds) {
-    const x = Math.max(bounds.x, Math.min(bounds.x + bounds.width - 1, Math.round(Number(value.x) || 0)));
-    const y = Math.max(bounds.y, Math.min(bounds.y + bounds.height - 1, Math.round(Number(value.y) || 0)));
-    const width = Math.max(1, Math.min(bounds.x + bounds.width - x, Math.round(Number(value.width) || 0)));
-    const height = Math.max(1, Math.min(bounds.y + bounds.height - y, Math.round(Number(value.height) || 0)));
-    return { x, y, width, height };
-  }
-
-  function boundedPoint(value, bounds) {
-    return {
-      x: Math.max(bounds.x, Math.min(bounds.x + bounds.width, Math.round(Number(value.x) || 0))),
-      y: Math.max(bounds.y, Math.min(bounds.y + bounds.height, Math.round(Number(value.y) || 0))),
-    };
-  }
-
-  function createModel(size) {
-    const full = { x:0, y:0, width:Math.max(1, Math.round(size.width)), height:Math.max(1, Math.round(size.height)) };
-    let crop = { ...full };
-    let redactions = [];
-    let annotations = [];
-    let history = [];
-
-    function remember() {
-      history.push({
-        crop:{...crop}, redactions:redactions.map(value => ({...value})),
-        annotations:annotations.map(value => ({...value})),
-      });
-    }
-    function intersects(annotation, bounds) {
-      const left = annotation.type === 'arrow' ? Math.min(annotation.startX, annotation.endX) : annotation.x;
-      const top = annotation.type === 'arrow' ? Math.min(annotation.startY, annotation.endY) : annotation.y;
-      const right = annotation.type === 'arrow' ? Math.max(annotation.startX, annotation.endX) : annotation.x + annotation.width;
-      const bottom = annotation.type === 'arrow' ? Math.max(annotation.startY, annotation.endY) : annotation.y + annotation.height;
-      return left < bounds.x + bounds.width && top < bounds.y + bounds.height && right > bounds.x && bottom > bounds.y;
-    }
-    function clampAnnotation(annotation) {
-      if (annotation.type === 'highlight') {
-        const x = Math.max(crop.x, annotation.x);
-        const y = Math.max(crop.y, annotation.y);
-        const right = Math.min(crop.x + crop.width, annotation.x + annotation.width);
-        const bottom = Math.min(crop.y + crop.height, annotation.y + annotation.height);
-        return { type:'highlight', x, y, width:Math.max(1, right - x), height:Math.max(1, bottom - y) };
-      }
-      const start = boundedPoint({x:annotation.startX, y:annotation.startY}, crop);
-      const end = boundedPoint({x:annotation.endX, y:annotation.endY}, crop);
-      return { type:'arrow', startX:start.x, startY:start.y, endX:end.x, endY:end.y };
-    }
-    function setCrop(value) {
-      remember();
-      crop = boundedRect(value, crop);
-      redactions = redactions.filter(rectangle =>
-        rectangle.x < crop.x + crop.width && rectangle.y < crop.y + crop.height &&
-        rectangle.x + rectangle.width > crop.x && rectangle.y + rectangle.height > crop.y
-      ).map(rectangle => boundedRect(rectangle, crop));
-      annotations = annotations.filter(annotation => intersects(annotation, crop)).map(clampAnnotation);
-      return snapshot();
-    }
-    function addRedaction(value) {
-      remember();
-      redactions.push(boundedRect(value, crop));
-      return snapshot();
-    }
-    function addHighlight(value) {
-      remember();
-      annotations.push({ type:'highlight', ...boundedRect(value, crop) });
-      return snapshot();
-    }
-    function addArrow(value) {
-      remember();
-      const start = boundedPoint({x:value.startX, y:value.startY}, crop);
-      const end = boundedPoint({x:value.endX, y:value.endY}, crop);
-      annotations.push({ type:'arrow', startX:start.x, startY:start.y, endX:end.x, endY:end.y });
-      return snapshot();
-    }
-    function undo() {
-      const previous = history.pop();
-      if (previous) {
-        crop = previous.crop;
-        redactions = previous.redactions;
-        annotations = previous.annotations;
-      }
-      return snapshot();
-    }
-    function reset() {
-      remember();
-      crop = { ...full };
-      redactions = [];
-      annotations = [];
-      return snapshot();
-    }
-    function snapshot() {
-      return {
-        crop:{...crop}, redactions:redactions.map(value => ({...value})),
-        annotations:annotations.map(value => ({...value})),
-      };
-    }
-    return { addArrow, addHighlight, addRedaction, reset, setCrop, snapshot, undo };
-  }
-
-  function namedBlob(blob, name) {
-    if (typeof File === 'function') return new File([blob], name, {type:blob.type});
-    Object.defineProperty(blob, 'name', {value:name, configurable:true});
-    return blob;
-  }
-
-  function paint(options) {
-    const state = options.model.snapshot();
-    const maxDimension = Number.isFinite(options.maxDimension) ? options.maxDimension : Infinity;
-    const scale = Math.min(1, maxDimension / Math.max(state.crop.width, state.crop.height));
-    const width = Math.max(1, Math.round(state.crop.width * scale));
-    const height = Math.max(1, Math.round(state.crop.height * scale));
-    options.canvas.width = width;
-    options.canvas.height = height;
-    const context = options.canvas.getContext('2d');
-    if (!context) throw new Error('Screenshot editing is unavailable in this browser.');
-    context.drawImage(options.source, state.crop.x, state.crop.y, state.crop.width, state.crop.height, 0, 0, width, height);
-    context.fillStyle = '#000000';
-    state.redactions.forEach(rectangle => context.fillRect(
-      Math.round((rectangle.x - state.crop.x) * scale),
-      Math.round((rectangle.y - state.crop.y) * scale),
-      Math.round(rectangle.width * scale),
-      Math.round(rectangle.height * scale),
-    ));
-    state.annotations.forEach(annotation => {
-      if (annotation.type === 'highlight') {
-        context.fillStyle = 'rgba(250, 204, 21, 0.38)';
-        context.fillRect(
-          Math.round((annotation.x - state.crop.x) * scale),
-          Math.round((annotation.y - state.crop.y) * scale),
-          Math.round(annotation.width * scale),
-          Math.round(annotation.height * scale),
-        );
-        return;
-      }
-      const startX = (annotation.startX - state.crop.x) * scale;
-      const startY = (annotation.startY - state.crop.y) * scale;
-      const endX = (annotation.endX - state.crop.x) * scale;
-      const endY = (annotation.endY - state.crop.y) * scale;
-      const angle = Math.atan2(endY - startY, endX - startX);
-      const head = Math.max(10, Math.min(24, 16 * scale));
-      context.save();
-      context.strokeStyle = '#facc15';
-      context.lineWidth = Math.max(4, 6 * scale);
-      context.lineCap = 'round';
-      context.lineJoin = 'round';
-      context.beginPath();
-      context.moveTo(Math.round(startX), Math.round(startY));
-      context.lineTo(Math.round(endX), Math.round(endY));
-      context.lineTo(endX - head * Math.cos(angle - Math.PI / 6), endY - head * Math.sin(angle - Math.PI / 6));
-      context.moveTo(Math.round(endX), Math.round(endY));
-      context.lineTo(endX - head * Math.cos(angle + Math.PI / 6), endY - head * Math.sin(angle + Math.PI / 6));
-      context.stroke();
-      context.restore();
-    });
-    return state;
-  }
-
-  async function flatten(options) {
-    paint(options);
-    const type = ['image/png', 'image/jpeg', 'image/webp'].includes(options.type) ? options.type : 'image/png';
-    const blob = await new Promise(resolve => options.canvas.toBlob(resolve, type, type === 'image/png' ? undefined : 0.9));
-    if (!blob || !blob.size) throw new Error('The edited screenshot could not be saved. Try again.');
-    return namedBlob(blob, options.name || 'edited-screenshot.png');
-  }
-
-  function attachmentBlob(value) {
-    if (value.blob) return value.blob;
-    const binary = atob(String(value.data || ''));
-    return new Blob([Uint8Array.from(binary, character => character.charCodeAt(0))], {type:value.contentType});
-  }
-
-  function mount(options) {
-    let source = null;
-    let model = null;
-    let mode = 'redact';
-    let start = null;
-    let selectedIndex = -1;
-    let previousFocus = null;
-
-    function status(message) { options.status.textContent = message; }
-    function setMode(value) {
-      mode = value;
-      options.crop.setAttribute('aria-pressed', value === 'crop' ? 'true' : 'false');
-      options.redact.setAttribute('aria-pressed', value === 'redact' ? 'true' : 'false');
-      options.highlight.setAttribute('aria-pressed', value === 'highlight' ? 'true' : 'false');
-      options.arrow.setAttribute('aria-pressed', value === 'arrow' ? 'true' : 'false');
-      status({
-        crop:'Drag around the part to keep.', redact:'Drag over private information to hide it.',
-        highlight:'Drag around the detail to highlight.', arrow:'Drag toward the detail you want to point out.',
-      }[value]);
-    }
-    function render() {
-      if (source && model) paint({source, model, canvas:options.canvas, maxDimension:1600});
-    }
-    function close() {
-      if (!source && !model) return;
-      options.dialog.hidden = true;
-      if (source && typeof source.close === 'function') source.close();
-      source = null;
-      model = null;
-      start = null;
-      (previousFocus || options.edit).focus();
-    }
-    async function open() {
-      const value = await options.controller.serialize();
-      const values = (Array.isArray(value) ? value : [value]).filter(Boolean);
-      selectedIndex = options.getActiveIndex();
-      const selected = values[selectedIndex];
-      if (!selected) return;
-      previousFocus = options.document.activeElement;
-      status('Opening screenshot editor…');
-      try {
-        const decode = options.decode || globalThis.createImageBitmap;
-        if (typeof decode !== 'function') throw new Error('decode');
-        source = await decode(attachmentBlob(selected));
-        model = createModel({width:source.width, height:source.height});
-        options.dialog.hidden = false;
-        render();
-        setMode('redact');
-        options.redact.focus();
-      } catch (_error) {
-        source = null;
-        status('This browser cannot edit the screenshot. Your original is unchanged.');
-      }
-    }
-    function point(event) {
-      const box = options.canvas.getBoundingClientRect();
-      const state = model.snapshot();
-      return {
-        x:state.crop.x + Math.round((event.clientX - box.left) * state.crop.width / box.width),
-        y:state.crop.y + Math.round((event.clientY - box.top) * state.crop.height / box.height),
-      };
-    }
-    options.canvas.addEventListener('pointerdown', event => {
-      if (!model) return;
-      start = point(event);
-      options.canvas.setPointerCapture?.(event.pointerId);
-    });
-    options.canvas.addEventListener('pointerup', event => {
-      if (!model || !start) return;
-      const end = point(event);
-      const dragStart = start;
-      const rectangle = {
-        x:Math.min(dragStart.x, end.x), y:Math.min(dragStart.y, end.y),
-        width:Math.abs(end.x - dragStart.x), height:Math.abs(end.y - dragStart.y),
-      };
-      start = null;
-      const tooSmall = mode === 'arrow' ? Math.hypot(end.x - dragStart.x, end.y - dragStart.y) < 8 :
-        rectangle.width < 3 || rectangle.height < 3;
-      if (tooSmall) {
-        status('Drag a larger area on the screenshot.');
-        return;
-      }
-      if (mode === 'crop') model.setCrop(rectangle);
-      else if (mode === 'redact') model.addRedaction(rectangle);
-      else if (mode === 'highlight') model.addHighlight(rectangle);
-      else model.addArrow({startX:dragStart.x, startY:dragStart.y, endX:end.x, endY:end.y});
-      render();
-      status({
-        crop:'Crop applied. Undo or reset if needed.', redact:'Private area hidden with an opaque redaction.',
-        highlight:'Highlight added.', arrow:'Arrow added.',
-      }[mode]);
-    });
-    options.edit.addEventListener('click', open);
-    options.crop.addEventListener('click', () => setMode('crop'));
-    options.redact.addEventListener('click', () => setMode('redact'));
-    options.highlight.addEventListener('click', () => setMode('highlight'));
-    options.arrow.addEventListener('click', () => setMode('arrow'));
-    options.undo.addEventListener('click', () => { if (model) { model.undo(); render(); status('Last edit undone.'); } });
-    options.reset.addEventListener('click', () => { if (model) { model.reset(); render(); status('Crop, redactions, and annotations reset.'); } });
-    options.cancel.addEventListener('click', close);
-    options.dialog.addEventListener('keydown', event => { if (event.key === 'Escape') { event.preventDefault(); close(); } });
-    options.apply.addEventListener('click', async () => {
-      if (!model || !source) return;
-      options.apply.disabled = true;
-      status('Applying flattened edit…');
-      try {
-        const current = await options.controller.serialize();
-        const values = Array.isArray(current) ? current : [current];
-        const selected = values[selectedIndex];
-        let derivative = await flatten({
-          source, model, canvas:options.exportCanvas, maxDimension:2048,
-          name:selected.filename, type:selected.contentType,
-        });
-        if (options.optimizeImage) derivative = await options.optimizeImage(derivative);
-        options.controller.replace(selectedIndex, derivative);
-        await options.onApplied(selectedIndex);
-        close();
-      } catch (error) {
-        status(error.message || 'The edited screenshot could not be applied. Your original is unchanged.');
-      } finally {
-        options.apply.disabled = false;
-      }
-    });
-    return { close, open };
-  }
-
-  return { createModel, flatten, mount, paint };
-});

frontend/issue-evidence-review.js

@@ -1,185 +0,0 @@
-(function(root, factory) {
-  const api = factory();
-  if (typeof module === 'object' && module.exports) module.exports = api;
-  else root.issueEvidenceReview = api;
-})(typeof self !== 'undefined' ? self : this, function() {
-  'use strict';
-
-  const MAX_BYTES = 2 * 1024 * 1024;
-  const MAX_PIXELS = 12 * 1024 * 1024;
-  const MAX_DIMENSION = 8192;
-
-  function namedBlob(blob, name) {
-    if (typeof File === 'function') return new File([blob], name, { type: blob.type });
-    Object.defineProperty(blob, 'name', { value: name, configurable: true });
-    return blob;
-  }
-
-  async function optimizeImage(file, environment = {}) {
-    const decode = environment.createImageBitmap || globalThis.createImageBitmap;
-    const makeCanvas = environment.createCanvas || (() => document.createElement('canvas'));
-    if (typeof decode !== 'function') throw new Error('This browser cannot safely inspect the screenshot. Try cropping it and choose it again.');
-    let bitmap;
-    try {
-      bitmap = await decode(file);
-      const width = Number(bitmap.width);
-      const height = Number(bitmap.height);
-      if (!Number.isSafeInteger(width) || !Number.isSafeInteger(height) || width <= 0 || height <= 0) {
-        throw new Error('decode');
-      }
-      const pixelScale = Math.min(1, Math.sqrt(MAX_PIXELS / (width * height)));
-      const dimensionScale = Math.min(1, MAX_DIMENSION / Math.max(width, height));
-      const byteScale = file.size > MAX_BYTES ? Math.sqrt(MAX_BYTES / file.size) * 0.92 : 1;
-      let scale = Math.min(pixelScale, dimensionScale, byteScale);
-      const canvas = makeCanvas();
-      const context = canvas && canvas.getContext && canvas.getContext('2d');
-      if (!context) throw new Error('decode');
-      for (let attempt = 0; attempt < 10; attempt += 1) {
-        canvas.width = Math.max(1, Math.floor(width * scale));
-        canvas.height = Math.max(1, Math.floor(height * scale));
-        context.drawImage(bitmap, 0, 0, canvas.width, canvas.height);
-        const blob = await new Promise(resolve => canvas.toBlob(resolve, file.type, file.type === 'image/png' ? undefined : 0.86));
-        if (!blob) throw new Error('encode');
-        if (blob.size > 0 && blob.size <= MAX_BYTES) return namedBlob(blob, file.name);
-        scale *= 0.8;
-      }
-    } catch (_error) {
-      throw new Error('The screenshot could not be optimized. Try cropping it and choose it again.');
-    } finally {
-      if (bitmap && typeof bitmap.close === 'function') bitmap.close();
-    }
-    throw new Error('The screenshot could not be optimized below 2 MB. Try cropping it and choose it again.');
-  }
-
-  function create(options) {
-    const controller = options.controller;
-    const documentRef = options.document || document;
-    let activeIndex = 0;
-    let busy = false;
-    let previewUrl = '';
-    let thumbnailUrls = [];
-
-    function revoke(url) {
-      if (url && !url.startsWith('data:')) options.revokeObjectURL(url);
-    }
-
-    function attachmentUrl(attachment) {
-      return attachment?.blob ? options.createObjectURL(attachment.blob) :
-        'data:' + attachment.contentType + ';base64,' + attachment.data;
-    }
-
-    function count() {
-      const value = controller.state();
-      return Array.isArray(value) ? value.length : (value ? 1 : 0);
-    }
-
-    function setBusy(value) {
-      busy = Boolean(value);
-      options.earlier.disabled = busy || activeIndex <= 0;
-      options.later.disabled = busy || activeIndex >= count() - 1;
-      if (options.note) options.note.disabled = busy;
-      if (options.edit) options.edit.disabled = busy || !count();
-      Array.from(options.tray.children || []).forEach(button => { button.disabled = busy; });
-    }
-
-    function updateNote(values) {
-      if (!options.note) return;
-      options.note.value = controller.note(activeIndex);
-      options.note.disabled = busy;
-      if (options.noteLabel) {
-        options.noteLabel.textContent = 'Evidence note for screenshot ' + (activeIndex + 1) + ' of ' +
-          values.length + ' (optional)';
-      }
-    }
-
-    function update(values, optimized = false) {
-      if (!values.length) return;
-      activeIndex = Math.max(0, Math.min(activeIndex, values.length - 1));
-      revoke(previewUrl);
-      previewUrl = attachmentUrl(values[activeIndex]);
-      options.image.src = previewUrl;
-      const current = values[activeIndex];
-      const size = current.blob ? current.blob.size : Math.max(1, Math.floor(String(current.data || '').length * 3 / 4));
-      options.meta.textContent = 'Screenshot ' + (activeIndex + 1) + ' of ' + values.length + ' · ' +
-        current.filename + ' · ' + Math.ceil(size / 1024) + ' KB';
-      options.preview.hidden = false;
-      if (options.edit) options.edit.disabled = busy;
-      Array.from(options.tray.children || []).forEach((button, index) =>
-        button.setAttribute('aria-pressed', index === activeIndex ? 'true' : 'false'));
-      options.earlier.disabled = busy || activeIndex === 0;
-      options.later.disabled = busy || activeIndex === values.length - 1;
-      updateNote(values);
-      options.status.textContent = optimized ? 'Screenshots optimized and ready to file in this order.' :
-        values.length + ' screenshots ready to file in this order.';
-    }
-
-    function render(value, index = activeIndex, optimized = false) {
-      const values = (Array.isArray(value) ? value : [value]).filter(Boolean);
-      activeIndex = Math.max(0, Math.min(index, values.length - 1));
-      thumbnailUrls.forEach(revoke);
-      thumbnailUrls = [];
-      options.tray.replaceChildren(...values.map((item, itemIndex) => {
-        const button = documentRef.createElement('button');
-        button.type = 'button';
-        button.className = 'issue-evidence-thumbnail';
-        button.setAttribute('aria-label', 'Review screenshot ' + (itemIndex + 1) + ' of ' + values.length + ': ' + item.filename);
-        const thumbnail = documentRef.createElement('img');
-        thumbnail.alt = '';
-        thumbnail.src = attachmentUrl(item);
-        thumbnailUrls.push(thumbnail.src);
-        button.appendChild(thumbnail);
-        const position = documentRef.createElement('span');
-        position.textContent = String(itemIndex + 1);
-        button.appendChild(position);
-        button.addEventListener('click', () => { activeIndex = itemIndex; update(values); });
-        return button;
-      }));
-      options.tray.hidden = !values.length;
-      if (values.length) update(values, optimized);
-    }
-
-    function clear() {
-      revoke(previewUrl);
-      thumbnailUrls.forEach(revoke);
-      previewUrl = '';
-      thumbnailUrls = [];
-      activeIndex = 0;
-      options.tray.replaceChildren();
-      options.tray.hidden = true;
-      options.earlier.disabled = true;
-      options.later.disabled = true;
-      if (options.note) {
-        options.note.value = '';
-        options.note.disabled = true;
-      }
-      if (options.edit) options.edit.disabled = true;
-      if (options.noteLabel) options.noteLabel.textContent = 'Evidence note (optional)';
-    }
-
-    function afterRemoval(removedIndex, previousCount) {
-      activeIndex = Math.min(removedIndex, previousCount - 2);
-    }
-
-    function move(offset) {
-      const total = count();
-      const destination = activeIndex + offset;
-      if (destination < 0 || destination >= total) return Promise.resolve();
-      controller.move(activeIndex, destination);
-      activeIndex = destination;
-      return controller.serialize().then(value => {
-        render(value, activeIndex);
-        options.status.textContent = 'Screenshot moved to position ' + (activeIndex + 1) + ' of ' + total + '.';
-      });
-    }
-
-    options.earlier.addEventListener('click', () => move(-1));
-    options.later.addEventListener('click', () => move(1));
-    options.note?.addEventListener('input', event => {
-      controller.setNote(activeIndex, event.target.value);
-    });
-    clear();
-    return { activeIndex: () => activeIndex, afterRemoval, clear, render, setBusy };
-  }
-
-  return { create, optimizeImage, MAX_PIXELS };
-});

frontend/issue-filing-receipt.js

@@ -1,95 +0,0 @@
-(function (root, factory) {
-  const api = factory();
-  if (typeof module === 'object' && module.exports) module.exports = api;
-  else root.createIssueFilingReceipt = api;
-})(typeof globalThis !== 'undefined' ? globalThis : this, function () {
-  'use strict';
-
-  function createIssueFilingReceipt({
-    root, heading, key, title, ownership, openLink, shareButton, filedButton,
-    relatedButton, fileAnotherButton, doneButton, status, navigator = {}, clipboard = navigator.clipboard,
-    onFileRelated = function () {},
-    onFileAnother = function () {},
-    onViewFiled = function () {},
-  }) {
-    let active = null;
-    let relatedPlan = null;
-    let restoreFocus = null;
-
-    function close() {
-      root.hidden = true;
-      active = null;
-      relatedPlan = null;
-      const target = restoreFocus;
-      restoreFocus = null;
-      target?.focus?.();
-    }
-
-    async function share() {
-      if (!active) return;
-      const payload = {
-        title: active.repository + '#' + active.number + ' · ' + active.title,
-        text: active.title,
-        url: active.url,
-      };
-      if (typeof navigator.share === 'function') {
-        try {
-          await navigator.share(payload);
-          return;
-        } catch (error) {
-          if (error?.name === 'AbortError') return;
-        }
-      }
-      if (typeof clipboard?.writeText !== 'function') {
-        status.textContent = 'Issue link is ready in Open in Gitea.';
-        return;
-      }
-      await clipboard.writeText(active.url);
-      status.textContent = 'Issue link copied.';
-    }
-
-    function show(issue, returnTarget, reusablePlan = null) {
-      active = issue;
-      relatedPlan = reusablePlan;
-      restoreFocus = returnTarget || null;
-      key.textContent = issue.repository + '#' + issue.number;
-      title.textContent = issue.title;
-      ownership.textContent = issue.assignees?.length
-        ? 'Assigned to @' + issue.assignees.join(', @') + '.'
-        : 'Created with no owner.';
-      openLink.href = issue.url;
-      status.textContent = '';
-      if (relatedButton) relatedButton.hidden = !relatedPlan;
-      root.hidden = false;
-      heading.focus();
-    }
-
-    shareButton.addEventListener('click', share);
-    filedButton?.addEventListener('click', () => {
-      if (!active) return;
-      const issue = active;
-      close();
-      onViewFiled(issue);
-    });
-    root.addEventListener('keydown', event => {
-      if (event.key !== 'Escape' || root.hidden) return;
-      event.preventDefault();
-      close();
-    });
-    doneButton.addEventListener('click', close);
-    relatedButton?.addEventListener('click', () => {
-      if (!relatedPlan) return;
-      const plan = relatedPlan;
-      close();
-      onFileRelated(plan);
-    });
-    fileAnotherButton.addEventListener('click', () => {
-      close();
-      onFileAnother();
-    });
-
-    return { show, close, share };
-  }
-
-  return createIssueFilingReceipt;
-});

frontend/issue-filing-review.js

@@ -1,181 +0,0 @@
-(function(root, factory) {
-  const api = factory();
-  if (typeof module === 'object' && module.exports) module.exports = api;
-  else root.createIssueFilingReview = api;
-})(typeof self !== 'undefined' ? self : this, function() {
-  'use strict';
-
-  const INTENT_LABELS = {
-    'create-and-assign': 'Create & assign to me',
-    'create-and-start': 'Create & start',
-    'follow-up-and-next': 'Create follow-up & next',
-  };
-
-  function clone(value) {
-    if (typeof structuredClone === 'function') return structuredClone(value);
-    return JSON.parse(JSON.stringify(value));
-  }
-
-  function create(options) {
-    let reviewed = null;
-    let trigger = null;
-    let busy = false;
-    let evidenceItems = [];
-    const generatedUrls = new Set();
-
-    function releaseEvidenceUrls() {
-      generatedUrls.forEach(url => options.revokeObjectURL?.(url));
-      generatedUrls.clear();
-      evidenceItems = [];
-    }
-
-    function evidenceUrl(attachment) {
-      if (attachment?.blob) {
-        const url = options.createObjectURL(attachment.blob);
-        generatedUrls.add(url);
-        return url;
-      }
-      if (attachment?.data) {
-        return 'data:' + String(attachment.contentType || 'application/octet-stream') +
-          ';base64,' + String(attachment.data);
-      }
-      return '';
-    }
-
-    function selectEvidence(index) {
-      const selected = evidenceItems[index];
-      if (!selected) return;
-      evidenceItems.forEach((item, position) =>
-        item.button.setAttribute('aria-pressed', position === index ? 'true' : 'false'));
-      const filename = selected.attachment.filename || 'Screenshot';
-      options.evidencePreview.hidden = false;
-      options.evidenceImage.src = selected.url;
-      options.evidenceImage.alt = 'Evidence ' + (index + 1) + ' of ' + evidenceItems.length + ': ' + filename;
-      options.evidencePosition.textContent = 'Evidence ' + (index + 1) + ' of ' + evidenceItems.length;
-      options.evidenceFilename.textContent = filename;
-      options.evidenceNote.textContent = selected.attachment.note || 'No evidence note.';
-    }
-
-    function renderVisualEvidence(attachments) {
-      releaseEvidenceUrls();
-      options.evidenceEmpty.hidden = attachments.length > 0;
-      options.evidencePreview.hidden = true;
-      options.evidenceImage.src = '';
-      evidenceItems = attachments.map((attachment, index) => {
-        const url = evidenceUrl(attachment);
-        const item = options.document.createElement('li');
-        const button = options.document.createElement('button');
-        const image = options.document.createElement('img');
-        const filename = attachment.filename || 'Screenshot';
-        button.setAttribute('type', 'button');
-        button.className = 'issue-filing-evidence-selector';
-        button.setAttribute('aria-label', 'Preview evidence ' + (index + 1) + ' of ' + attachments.length + ': ' + filename);
-        button.setAttribute('aria-pressed', 'false');
-        image.src = url;
-        image.alt = '';
-        button.appendChild(image);
-        item.appendChild(button);
-        return { attachment, button, item, url };
-      });
-      evidenceItems.forEach((entry, index) =>
-        entry.button.addEventListener('click', () => selectEvidence(index)));
-      options.evidenceList.replaceChildren(...evidenceItems.map(entry => entry.item));
-      if (evidenceItems.length) selectEvidence(0);
-    }
-
-    function close() {
-      options.sheet.hidden = true;
-      const previousTrigger = trigger;
-      trigger = null;
-      reviewed = null;
-      busy = false;
-      releaseEvidenceUrls();
-      options.confirmButton.disabled = false;
-      previousTrigger?.focus();
-    }
-
-    function render(payload) {
-      const draft = payload.draft;
-      options.repository.textContent = draft.repository || 'No repository';
-      options.intent.textContent = draft.unassigned === true ? 'Create unassigned' :
-        (INTENT_LABELS[payload.intent] || payload.intent);
-      if (options.issueType) options.issueType.textContent = draft.templateName || 'Blank issue';
-      options.title.textContent = draft.title;
-      options.body.textContent = draft.body || 'No note provided.';
-      const labels = (draft.labels || []).map(label => typeof label === 'string' ? label : label.name);
-      const milestone = draft.milestone?.title || draft.milestoneTitle || 'No milestone';
-      const dueDate = draft.dueDate || draft.due_date || 'No due date';
-      const owner = draft.unassigned === true ? 'Owner: No owner' : (draft.assignee
-        ? 'Owner: ' + (draft.assigneeName || draft.assignee) + ' (@' + draft.assignee + ')'
-        : 'Assigned to you');
-      const planning = [];
-      if (Number.isInteger(draft.estimateMinutes)) {
-        planning.push('Estimate: ' + draft.estimateMinutes + ' min');
-        const projected = draft.todayCapacity?.projectedMinutes;
-        if (Number.isInteger(projected)) planning.push(projected >= 0
-          ? 'Today after start: ' + projected + ' min free'
-          : 'Today after start: ' + Math.abs(projected) + ' min over capacity');
-      }
-      options.metadata.textContent = [
-        labels.length ? 'Labels: ' + labels.join(', ') : 'No labels',
-        'Milestone: ' + milestone,
-        'Due: ' + dueDate,
-        owner,
-        ...planning,
-      ].join(' · ');
-      if (options.blockerList) {
-        options.blockerList.replaceChildren(...(draft.blockers || []).map(blocker => {
-          const item = options.document.createElement('li');
-          item.textContent = blocker.repository + ' #' + blocker.number + ' — ' + blocker.title;
-          return item;
-        }));
-      }
-      const attachments = (draft.attachments || (draft.attachment ? [draft.attachment] : [])).filter(Boolean);
-      if (options.evidencePreview) {
-        renderVisualEvidence(attachments);
-        return;
-      }
-      options.evidenceList.replaceChildren(...attachments.map((attachment, index) => {
-        const item = options.document.createElement('li');
-        item.textContent = (index + 1) + '. ' + (attachment.filename || 'Screenshot') +
-          (attachment.note ? ' — ' + attachment.note : '');
-        return item;
-      }));
-    }
-
-    function open(payload, opener) {
-      reviewed = clone(payload);
-      trigger = opener || null;
-      busy = false;
-      options.confirmButton.disabled = false;
-      render(reviewed);
-      options.sheet.hidden = false;
-      options.backButton.focus();
-    }
-
-    options.backButton.addEventListener('click', close);
-    options.confirmButton.addEventListener('click', async () => {
-      if (!reviewed || busy) return;
-      busy = true;
-      options.confirmButton.disabled = true;
-      try {
-        await options.onConfirm(reviewed);
-        close();
-      } catch (error) {
-        busy = false;
-        options.confirmButton.disabled = false;
-        if (options.status) options.status.textContent = error.message;
-        options.confirmButton.focus();
-      }
-    });
-    options.document.addEventListener('keydown', event => {
-      if (!options.sheet.hidden && event.key === 'Escape' && !busy) {
-        event.preventDefault();
-        close();
-      }
-    });
-    return { close, open };
-  }
-
-  return create;
-});

frontend/issue-outbox.js

@@ -5,98 +5,16 @@ function createIssueOutbox({ storage, fetchJson, coordinator, backgroundSync, ge
   );
   const pending = new Map();
 
-  function captureAttachment(value) {
-    const contentType = String(value?.contentType || '');
-    const filename = String(value?.filename || '').slice(0, 255);
-    const blob = value?.blob;
-    const data = String(value?.data || '');
-    if (!filename || !['image/png', 'image/jpeg', 'image/webp'].includes(contentType)) return undefined;
-    const note = String(value?.note || '').replace(/\s+/g, ' ').trim().slice(0, 240);
-    const noteValue = note ? { note } : {};
-    if (blob) return { filename, contentType, blob, ...noteValue };
-    if (!data && value?.stored === true) return { filename, contentType, stored: true, ...noteValue };
-    if (!data) return undefined;
-    return { filename, contentType, data, ...noteValue };
-  }
-
-  function captureAttachments(values) {
-    if (!Array.isArray(values)) return undefined;
-    if (values.length > 5) throw new Error('You can attach up to 5 screenshots.');
-    const attachments = values.map(captureAttachment);
-    if (attachments.some(value => !value)) {
-      throw new Error('Some screenshots are unavailable. Choose them again before queueing.');
-    }
-    return attachments.length ? attachments : undefined;
-  }
-
-  function captureBlockers(values) {
-    if (!Array.isArray(values)) return undefined;
-    const seen = new Set();
-    const blockers = [];
-    for (const value of values) {
-      const repository = String(value?.repository || '').trim();
-      const number = Number(value?.number);
-      const key = repository + '#' + number;
-      if (!/^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/.test(repository) ||
-          !Number.isInteger(number) || number < 1 || seen.has(key)) continue;
-      seen.add(key);
-      blockers.push({
-        repository, number,
-        title: String(value?.title || '').replace(/\s+/g, ' ').trim().slice(0, 255),
-      });
-      if (blockers.length === 5) break;
-    }
-    return blockers.length ? blockers : undefined;
-  }
-
-  function captureEstimate(value) {
-    const estimate = Number(value);
-    return Number.isInteger(estimate) && estimate >= 5 && estimate <= 1440 ? estimate : undefined;
-  }
-
-  function captureRelatedDraft(value) {
-    const repository = String(value?.repository || '');
-    if (!/^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/.test(repository)) return undefined;
-    const plan = {
-      repository, title:'', body:String(value?.body || '').slice(0, 9000),
-      labelIds:Array.from(new Set((Array.isArray(value?.labelIds) ? value.labelIds : [])
-        .filter(id => Number.isInteger(id) && id > 0))).slice(0, 20),
-    };
-    const milestoneId = Number(value?.milestoneId);
-    if (Number.isInteger(milestoneId) && milestoneId > 0) plan.milestoneId = milestoneId;
-    if (/^\d{4}-\d{2}-\d{2}$/.test(String(value?.dueDate || ''))) plan.dueDate = String(value.dueDate);
-    if (value?.unassigned === true) plan.unassigned = true;
-    else if (/^[A-Za-z0-9_.-]+$/.test(String(value?.assignee || ''))) {
-      plan.assignee = String(value.assignee);
-      plan.assigneeName = String(value.assigneeName || value.assignee).replace(/\s+/g, ' ').trim().slice(0, 255);
-    }
-    const templateId = String(value?.templateId || '').slice(0, 80);
-    if (templateId) {
-      plan.templateId = templateId;
-      plan.templateName = String(value?.templateName || 'Issue template').trim().slice(0, 80);
-      plan.capturedBody = '';
-    }
-    const promotion = value?.checklistPromotion;
-    if (promotion?.repository && promotion?.number && promotion?.url && promotion?.updatedAt) {
-      plan.checklistPromotion = {
-        repository:String(promotion.repository), number:Number(promotion.number), url:String(promotion.url),
-        title:String(promotion.title || ''), body:String(promotion.body || '').slice(0, 10000),
-        updatedAt:String(promotion.updatedAt), taskIndex:Number(promotion.taskIndex),
-      };
-    }
-    return plan;
-  }
-
   function read() {
     try {
       const record = JSON.parse(storage?.getItem(storageKey) || 'null');
-      if (![1, 2, 3].includes(record?.version) || !Array.isArray(record.items)) return [];
+      if (![1, 2].includes(record?.version) || !Array.isArray(record.items)) return [];
       return record.items.filter(item => item && typeof item === 'object');
     } catch (_error) { return []; }
   }
 
   function write(items, mirror = true) {
-    storage?.setItem(storageKey, JSON.stringify({ version: 3, items }));
+    storage?.setItem(storageKey, JSON.stringify({ version: 2, items }));
     coordinator?.notify('issue');
     if (mirror && backgroundSync?.reconcile) {
       Promise.resolve(backgroundSync.reconcile(items))
@@ -105,7 +23,7 @@ function createIssueOutbox({ storage, fetchJson, coordinator, backgroundSync, ge
     }
   }
 
-  function prepareItem(draft) {
+  function enqueue(draft, mirror = true) {
     const ownerLogin = String(getOwnerLogin() || '').trim();
     if (!ownerLogin) throw new Error('Confirm your Gitea account before queueing an issue.');
     const items = read();
@@ -121,213 +39,58 @@ function createIssueOutbox({ storage, fetchJson, coordinator, backgroundSync, ge
       status: 'queued',
       queuedAt: Number(now()),
     };
-    const assignee = /^[A-Za-z0-9_.-]+$/.test(String(draft?.assignee || ''))
-      ? String(draft.assignee) : '';
-    if (assignee) {
-      item.assignee = assignee;
-      item.assigneeName = String(draft?.assigneeName || assignee).replace(/\s+/g, ' ').trim().slice(0, 255);
-    }
-    if (draft?.unassigned === true) item.unassigned = true;
-    const sourceCaptureId = String(draft?.sourceCaptureId || '').trim().slice(0, 128);
-    if (sourceCaptureId) item.sourceCaptureId = sourceCaptureId;
-    if (draft?.completionIntent === 'create-and-start' && !assignee && !item.unassigned) {
-      item.completionIntent = 'create-and-start';
-      item.estimateMinutes = captureEstimate(draft?.estimateMinutes);
-    }
-    const attachment = captureAttachment(draft?.attachment);
-    if (attachment) item.attachment = attachment;
-    const attachments = captureAttachments(draft?.attachments);
-    if (attachments) item.attachments = attachments;
-    const blockers = captureBlockers(draft?.blockers);
-    if (blockers) item.blockers = blockers;
-    const relatedDraft = captureRelatedDraft(draft?.relatedDraft);
-    if (relatedDraft) item.relatedDraft = relatedDraft;
-
     item.operationId = item.id;
     if (Number.isInteger(Number(draft?.milestoneId)) && Number(draft.milestoneId) > 0) {
       item.milestoneId = Number(draft.milestoneId);
     }
     if (/^\d{4}-\d{2}-\d{2}$/.test(String(draft?.dueDate || ''))) item.dueDate = String(draft.dueDate);
-    return item;
-  }
-
-  function localIndexItem(item) {
-    const hasAttachmentBytes = item?.attachment?.data || item?.attachment?.blob;
-    const hasBundleBytes = Array.isArray(item?.attachments) &&
-      item.attachments.some(value => value?.data || value?.blob);
-    if (!hasAttachmentBytes && !hasBundleBytes) return item;
-    return {
-      ...item,
-      ...(hasAttachmentBytes ? {attachment: {
-        filename: item.attachment.filename,
-        contentType: item.attachment.contentType,
-        stored: true,
-      }} : {}),
-      ...(Array.isArray(item.attachments) ? {attachments:item.attachments.map(value => ({
-        filename:value.filename, contentType:value.contentType, stored:true,
-        ...(value.note ? {note:value.note} : {}),
-      }))} : {}),
-    };
-  }
-
-  function enqueue(draft, mirror = true) {
-    const items = read();
-    const sourceCaptureId = String(draft?.sourceCaptureId || '').trim().slice(0, 128);
-    const existing = sourceCaptureId && items.find(item => item.sourceCaptureId === sourceCaptureId);
-    if (existing) return { ...existing };
-    const item = prepareItem(draft);
     items.push(item);
     write(items, mirror);
     return item;
   }
 
   async function enqueueDurably(draft) {
-    const sourceCaptureId = String(draft?.sourceCaptureId || '').trim().slice(0, 128);
-    const existing = sourceCaptureId && read().find(item => item.sourceCaptureId === sourceCaptureId);
-    if (existing) {
-      if (!backgroundSync?.reconcile || !backgroundSync?.requestSync) {
-        return { item: { ...existing }, background: false, durability: 'foreground-only', reused: true };
-      }
-      await backgroundSync.reconcile(read());
-      await backgroundSync.requestSync();
-      return { item: { ...existing }, background: true, durability: 'background', reused: true };
-    }
+    const item = enqueue(draft, false);
     if (!backgroundSync?.reconcile || !backgroundSync?.requestSync) {
-      const item = enqueue(draft, false);
       return { item, background: false, durability: 'foreground-only' };
     }
-    const item = prepareItem(draft);
-    const current = read();
     try {
-      await backgroundSync.reconcile([...current, item]);
-      const localItem = localIndexItem(item);
-      write([...current, item].map(localIndexItem), false);
+      await backgroundSync.reconcile(read());
       await backgroundSync.requestSync();
-      return { item: localItem, background: true, durability: 'background' };
+      return { item, background: true, durability: 'background' };
     } catch (error) {
-      const persisted = read().find(candidate => candidate.id === item.id);
-      if (!persisted) throw error;
-      return { item: persisted, background: false, durability: 'foreground-only', error };
+      return { item, background: false, durability: 'foreground-only', error };
     }
   }
 
-  async function hydrateForEdit(id) {
-    const item = read().find(candidate => candidate.id === id);
-    if (!item) return null;
-    const storedBundle = Array.isArray(item.attachments) && item.attachments.some(value => value?.stored);
-    const storedAttachment = item.attachment?.stored && !item.attachment.data && !item.attachment.blob;
-    if (!storedAttachment && !storedBundle) return { ...item };
-    if (!backgroundSync?.get) {
-      throw new Error('The saved screenshot is unavailable. Retry before editing this issue.');
-    }
-    const durable = await backgroundSync.get(id);
-    const attachment = captureAttachment(durable?.attachment);
-    const attachments = captureAttachments(durable?.attachments);
-    if (durable?.operationId !== item.operationId ||
-        (storedAttachment && (!attachment?.data && !attachment?.blob)) ||
-        (storedBundle && (!attachments || attachments.length !== item.attachments.length))) {
-      throw new Error('The saved screenshot is unavailable. Retry before editing this issue.');
-    }
-    return {
-      ...item,
-      ...(attachment ? {attachment} : {}),
-      ...(attachments ? {attachments} : {}),
-    };
-  }
-
-  function prepareUpdate(id, draft) {
-    let updated = null;
-    const items = read().map(item => {
-      if (item.id !== id) return item;
-      const repository = String(draft?.repository || '');
-      const title = String(draft?.title || '');
-      const body = String(draft?.body || '');
-      const labelIds = Array.isArray(draft?.labelIds) ? draft.labelIds.filter(Number.isInteger).slice(0, 20) : [];
-      const unassigned = draft?.unassigned === true;
-      const assignee = !unassigned && /^[A-Za-z0-9_.-]+$/.test(String(draft?.assignee || ''))
-        ? String(draft.assignee) : undefined;
-      const assigneeName = assignee
-        ? String(draft?.assigneeName || assignee).replace(/\s+/g, ' ').trim().slice(0, 255)
-        : undefined;
-      const milestoneId = Number.isInteger(Number(draft?.milestoneId)) && Number(draft.milestoneId) > 0
-        ? Number(draft.milestoneId) : undefined;
-      const dueDate = /^\d{4}-\d{2}-\d{2}$/.test(String(draft?.dueDate || ''))
-        ? String(draft.dueDate) : undefined;
-      const attachment = captureAttachment(draft?.attachment);
-      const attachments = captureAttachments(draft?.attachments);
-      const blockers = captureBlockers(draft?.blockers);
-      const relatedDraft = captureRelatedDraft(draft?.relatedDraft);
-      const attachmentChanged = JSON.stringify(item.attachment || null) !== JSON.stringify(attachment || null) ||
-        JSON.stringify(item.attachments || null) !== JSON.stringify(attachments || null);
-      const changed = item.repository !== repository || item.title !== title || item.body !== body
-        || JSON.stringify(item.labelIds || []) !== JSON.stringify(labelIds)
-        || Boolean(item.unassigned) !== unassigned
-        || item.assignee !== assignee || item.assigneeName !== assigneeName
-        || item.milestoneId !== milestoneId || item.dueDate !== dueDate
-        || item.estimateMinutes !== captureEstimate(draft?.estimateMinutes)
-        || attachmentChanged || JSON.stringify(item.blockers || null) !== JSON.stringify(blockers || null)
-        || JSON.stringify(item.relatedDraft || null) !== JSON.stringify(relatedDraft || null);
-      updated = {
-        ...item,
-        repository, title, body, labelIds,
-        unassigned: unassigned || undefined,
-        assignee, assigneeName, milestoneId, dueDate,
-        attachment, attachments, blockers, relatedDraft,
-        operationId: changed ? String(operationId()).slice(0, 128) : item.operationId,
-        status: 'queued',
-      };
-      if (draft?.completionIntent === 'create-and-start' && !assignee && !unassigned) {
-        updated.completionIntent = 'create-and-start';
-        updated.estimateMinutes = captureEstimate(draft?.estimateMinutes);
-      } else {
-        delete updated.completionIntent;
-        delete updated.estimateMinutes;
-      }
-      if (assignee === undefined) {
-        delete updated.assignee;
-        delete updated.assigneeName;
-      }
-      if (!unassigned) delete updated.unassigned;
-      if (milestoneId === undefined) delete updated.milestoneId;
-      if (dueDate === undefined) delete updated.dueDate;
-      if (attachment === undefined) delete updated.attachment;
-      if (attachments === undefined) delete updated.attachments;
-      if (blockers === undefined) delete updated.blockers;
-      if (relatedDraft === undefined) delete updated.relatedDraft;
-      if (attachmentChanged) {
-        delete updated.attachmentMarkdown;
-        delete updated.attachmentMarkdowns;
-      }
-      delete updated.error;
-      delete updated.deliveryState;
-      return updated;
-    });
-    return { items, updated };
-  }
-
   function update(id, draft, mirror = true) {
-    const { items, updated } = prepareUpdate(id, draft);
-    write(items, mirror);
+    let updated = null;
+    write(read().map(item => {
+      if (item.id !== id) return item;
+      updated = {
+        ...item,
+        repository: String(draft?.repository || ''), title: String(draft?.title || ''),
+        body: String(draft?.body || ''),
+        labelIds: Array.isArray(draft?.labelIds) ? draft.labelIds.filter(Number.isInteger).slice(0, 20) : [],
+        status: 'queued',
+      };
+      delete updated.error;
+      return updated;
+    }), mirror);
     return updated;
   }
 
   async function updateDurably(id, draft) {
-    if (!backgroundSync?.reconcile || !backgroundSync?.requestSync) {
-      const item = update(id, draft, false);
+    const item = update(id, draft, false);
+    if (!item || !backgroundSync?.reconcile || !backgroundSync?.requestSync) {
       return { item, background: false, durability: 'foreground-only' };
     }
-    const { items, updated: item } = prepareUpdate(id, draft);
-    if (!item) return { item, background: false, durability: 'foreground-only' };
     try {
-      await backgroundSync.reconcile(items);
-      const localItems = items.map(localIndexItem);
-      write(localItems, false);
+      await backgroundSync.reconcile(read());
       await backgroundSync.requestSync();
-      return { item: localIndexItem(item), background: true, durability: 'background' };
+      return { item, background: true, durability: 'background' };
     } catch (error) {
-      const persisted = read().find(candidate => candidate.id === id);
-      if (!persisted || persisted.operationId !== item.operationId) throw error;
-      return { item: persisted, background: false, durability: 'foreground-only', error };
+      return { item, background: false, durability: 'foreground-only', error };
     }
   }
 
@@ -338,129 +101,9 @@ function createIssueOutbox({ storage, fetchJson, coordinator, backgroundSync, ge
     return true;
   }
 
-  function persistDeliveryStage(id, stage) {
-    write(read().map(item => item.id === id ? { ...item, ...stage } : item));
-  }
-
-  function stageOperationId(operationId, stage) {
-    const suffix = ':' + stage;
-    return String(operationId || '').slice(0, 128 - suffix.length) + suffix;
-  }
-
-  function evidenceMarkdown(attachment, markdown, index) {
-    const note = String(attachment?.note || '').replace(/\s+/g, ' ').trim().slice(0, 240);
-    if (!note) return markdown;
-    const escaped = note.replace(/([\\`*_[\]{}()<>#+\-.!|])/g, '\\$1');
-    return '**Screenshot ' + (index + 1) + ' — ' + escaped + '**\n\n' + markdown;
-  }
-
-  function attachmentMultipart(attachment) {
-    let blob = attachment?.blob;
-    if (!blob && attachment?.data) {
-      const binary = atob(String(attachment.data));
-      const bytes = Uint8Array.from(binary, character => character.charCodeAt(0));
-      blob = new Blob([bytes], { type: String(attachment.contentType || '') });
-    }
-    if (!blob) throw new Error('The saved screenshot is unavailable. Retry before sending.');
-    const form = new FormData();
-    form.append('file', blob, String(attachment.filename || 'screenshot'));
-    return form;
-  }
-
-  async function sendDirect(item, repository) {
-    let issue = item.deliveredIssue;
-    if (!issue) {
-      issue = await fetchJson('api/v1/repos/' + repository + '/issues', {
-        method: 'POST',
-        headers: {
-          Accept: 'application/json', 'Content-Type': 'application/json',
-          'Idempotency-Key': item.operationId,
-        },
-        body: JSON.stringify({
-          title: item.title, body: item.body, label_ids: item.labelIds,
-          ...(item.unassigned ? { unassigned: true } : {}),
-          ...(item.assignee ? { assignee: item.assignee } : {}),
-          ...(item.milestoneId ? { milestone_id: item.milestoneId } : {}),
-          ...(item.dueDate ? { due_date: item.dueDate + 'T23:59:59Z' } : {}),
-        }),
-      });
-      if (item.attachment || item.attachments || item.blockers?.length) {
-        persistDeliveryStage(item.id, { deliveredIssue: issue });
-      }
-    }
-    const blockers = Array.isArray(item.blockers) ? item.blockers : [];
-    let deliveredBlockers = Math.min(Number(item.deliveredBlockers) || 0, blockers.length);
-    for (let index = deliveredBlockers; index < blockers.length; index += 1) {
-      const blocker = blockers[index];
-      await fetchJson(
-        'api/v1/repos/' + repository + '/issues/' + encodeURIComponent(issue.number) + '/blockers',
-        {
-          method: 'PATCH',
-          headers: {
-            Accept: 'application/json', 'Content-Type': 'application/json',
-            'Idempotency-Key': stageOperationId(item.operationId, 'blocker-' + index),
-          },
-          body: JSON.stringify({repository:blocker.repository, number:blocker.number, present:true}),
-        },
-      );
-      deliveredBlockers = index + 1;
-      persistDeliveryStage(item.id, { deliveredIssue:issue, deliveredBlockers });
-    }
-    const attachments = Array.isArray(item.attachments) ? item.attachments :
-      (item.attachment ? [item.attachment] : []);
-    if (!attachments.length) return issue;
-    const markdowns = Array.isArray(item.attachmentMarkdowns)
-      ? item.attachmentMarkdowns.slice(0, attachments.length)
-      : (item.attachmentMarkdown ? [item.attachmentMarkdown] : []);
-    for (let index = markdowns.length; index < attachments.length; index += 1) {
-      const uploaded = await fetchJson(
-        'api/v1/repos/' + repository + '/issues/' + encodeURIComponent(issue.number) + '/attachments',
-        {
-          method: 'POST',
-          headers: {
-            Accept: 'application/json',
-            'Idempotency-Key': stageOperationId(
-              item.operationId, attachments.length === 1 ? 'attachment' : 'attachment-' + index,
-            ),
-          },
-          body: attachmentMultipart(attachments[index]),
-        },
-      );
-      const markdown = String(uploaded?.markdown || '');
-      if (!markdown) {
-        const error = new Error('The server did not confirm the screenshot upload.');
-        error.status = 422;
-        throw error;
-      }
-      markdowns.push(markdown);
-      persistDeliveryStage(item.id, {
-        deliveredIssue: issue, attachmentMarkdowns:markdowns.slice(),
-        ...(attachments.length === 1 ? {attachmentMarkdown:markdown} : {}),
-      });
-    }
-    const markdown = markdowns.map((value, index) =>
-      evidenceMarkdown(attachments[index], value, index)).join('\n\n');
-    await fetchJson(
-      'api/v1/repos/' + repository + '/issues/' + encodeURIComponent(issue.number) + '/comments',
-      {
-        method: 'POST',
-        headers: {
-          Accept: 'application/json', 'Content-Type': 'application/json',
-          'Idempotency-Key': stageOperationId(item.operationId, 'attachment-comment'),
-        },
-        body: JSON.stringify({ body: markdown }),
-      },
-    );
-    return issue;
-  }
-
   async function sendItem(item, currentLogin) {
     if (!currentLogin || item.ownerLogin !== currentLogin) return { blocked: true };
     if (pending.has(item.id)) return pending.get(item.id);
-    const attemptAt = Number(now());
-    write(read().map(candidate => candidate.id === item.id ? {
-      ...candidate, status:'sending', lastAttemptAt:attemptAt,
-    } : candidate), false);
     const repository = item.repository.split('/').map(encodeURIComponent).join('/');
     const request = (async () => {
       try {
@@ -474,23 +117,27 @@ function createIssueOutbox({ storage, fetchJson, coordinator, backgroundSync, ge
           }
           issue = delivery.issue;
         } else {
-          issue = await sendDirect(item, repository);
+          issue = await fetchJson('api/v1/repos/' + repository + '/issues', {
+            method: 'POST',
+            headers: {
+              Accept: 'application/json', 'Content-Type': 'application/json',
+              'Idempotency-Key': item.operationId,
+            },
+            body: JSON.stringify({
+              title: item.title, body: item.body, label_ids: item.labelIds,
+              ...(item.milestoneId ? { milestone_id: item.milestoneId } : {}),
+              ...(item.dueDate ? { due_date: item.dueDate + 'T23:59:59Z' } : {}),
+            }),
+          });
         }
         if (!issue) return { blocked: true };
         discard(item.id);
-        return { issue, item };
+        return { issue };
       } catch (error) {
         const status = Number(error?.status || 0);
-        const attemptError = String(error.message || 'Delivery failed').slice(0, 240);
         if (status >= 400 && status < 500) {
           write(read().map(candidate => candidate.id === item.id ? {
             ...candidate, status: 'attention', error: String(error.message || 'Issue needs attention').slice(0, 240),
-            lastAttemptAt: attemptAt, lastAttemptError: attemptError,
-            ...(error.code === 'delivery_uncertain' ? { deliveryState: 'uncertain' } : {}),
-          } : candidate));
-        } else {
-          write(read().map(candidate => candidate.id === item.id ? {
-            ...candidate, status:'queued', lastAttemptAt:attemptAt, lastAttemptError:attemptError,
           } : candidate));
         }
         return { error, transient: !(status >= 400 && status < 500) };
@@ -503,31 +150,16 @@ function createIssueOutbox({ storage, fetchJson, coordinator, backgroundSync, ge
 
   async function flushQueue(currentLogin) {
     const confirmed = [];
-    const completions = [];
-    const filings = [];
-
     let blocked = 0;
     currentLogin = String(currentLogin || '').trim();
     for (const item of read()) {
-      if (item.status === 'attention' || item.status === 'completion') continue;
+      if (item.status === 'attention') continue;
       if (!currentLogin || item.ownerLogin !== currentLogin) { blocked += 1; continue; }
       const result = await sendItem(item, currentLogin);
-      if (result.issue) {
-        confirmed.push(result.issue);
-        if (result.item?.relatedDraft) filings.push({issue:result.issue, relatedDraft:result.item.relatedDraft});
-
-        if (result.item?.completionIntent) completions.push({
-          id: result.item.id,
-          intent: result.item.completionIntent,
-          ownerLogin: result.item.ownerLogin,
-          operationId: result.item.operationId,
-          estimateMinutes: result.item.estimateMinutes,
-          issue: result.issue,
-        });
-      }
+      if (result.issue) confirmed.push(result.issue);
       if (result.transient) break;
     }
-    return { confirmed, completions, filings, remaining: read(), blocked };
+    return { confirmed, remaining: read(), blocked };
   }
 
   async function flush(currentLogin) {
@@ -542,32 +174,9 @@ function createIssueOutbox({ storage, fetchJson, coordinator, backgroundSync, ge
     if (!currentLogin || item.ownerLogin !== currentLogin) {
       return { confirmed: [], remaining: read(), blocked: 1 };
     }
-    let queued = item;
-    if (item.status === 'attention') {
-      queued = {
-        ...item,
-        operationId: String(operationId()).slice(0, 128),
-        status: 'queued',
-      };
-      delete queued.error;
-      delete queued.deliveryState;
-      write(read().map(candidate => candidate.id === id ? queued : candidate));
-    }
-    const result = await sendItem(queued, currentLogin);
-    return {
-      confirmed: result.issue ? [result.issue] : [],
-      filings: result.issue && result.item?.relatedDraft ? [{issue:result.issue, relatedDraft:result.item.relatedDraft}] : [],
-
-      completions: result.issue && result.item?.completionIntent ? [{
-        id: result.item.id,
-        intent: result.item.completionIntent,
-        ownerLogin: result.item.ownerLogin,
-        operationId: result.item.operationId,
-        estimateMinutes: result.item.estimateMinutes,
-        issue: result.issue,
-      }] : [],
-      remaining: read(), blocked: 0,
-    };
+    update(id, item);
+    const result = await sendItem({ ...item, status: 'queued' }, currentLogin);
+    return { confirmed: result.issue ? [result.issue] : [], remaining: read(), blocked: 0 };
   }
 
   async function retry(id, currentLogin) {
@@ -579,53 +188,17 @@ function createIssueOutbox({ storage, fetchJson, coordinator, backgroundSync, ge
     const statuses = new Map((records || []).map(item => [item.id, item]));
     const items = read().flatMap(item => {
       const background = statuses.get(item.id);
-      const deliveryStage = {
-        ...(background?.deliveredIssue ? { deliveredIssue: background.deliveredIssue } : {}),
-        ...(background?.attachmentMarkdown ? { attachmentMarkdown: background.attachmentMarkdown } : {}),
-      };
-      if (background?.status === 'sent') {
-        if (item.completionIntent === 'create-and-start' && background.deliveredIssue) return [{
-          ...item, status: 'completion', deliveredIssue: background.deliveredIssue,
-        }];
-        return [];
-      }
+      if (background?.status === 'sent') return [];
       if (background?.status === 'attention') return [{
-        ...localIndexItem(item), ...deliveryStage, status: 'attention', error: String(background.error || 'Issue needs attention').slice(0, 240),
-        ...(background.deliveryState ? { deliveryState: background.deliveryState } : {}),
+        ...item, status: 'attention', error: String(background.error || 'Issue needs attention').slice(0, 240),
       }];
-      return [{ ...localIndexItem(item), ...deliveryStage }];
+      return [item];
     });
     write(items);
     return items;
   }
 
-  function pendingCompletions(currentLogin) {
-    const login = String(currentLogin || '').trim();
-    if (!login) return [];
-    return read().filter(item => item.status === 'completion' && item.ownerLogin === login &&
-      item.completionIntent === 'create-and-start' && item.deliveredIssue).map(item => ({
-        id: item.id,
-        intent: item.completionIntent,
-        ownerLogin: item.ownerLogin,
-        operationId: item.operationId,
-        estimateMinutes: item.estimateMinutes,
-        issue: item.deliveredIssue,
-      }));
-  }
-
-  function completeIntent(id, currentLogin) {
-    const login = String(currentLogin || '').trim();
-    const items = read();
-    const matched = items.some(item => item.id === id && item.status === 'completion' && item.ownerLogin === login);
-    if (!matched) return false;
-    write(items.filter(item => item.id !== id));
-    return true;
-  }
-
-  return {
-    enqueue, enqueueDurably, hydrateForEdit, update, updateDurably, discard, flush, retry, reconcileBackground,
-    pendingCompletions, completeIntent, list: () => read().map(item => ({ ...item })),
-  };
+  return { enqueue, enqueueDurably, update, updateDurably, discard, flush, retry, reconcileBackground, list: () => read().map(item => ({ ...item })) };
 }
 
 if (typeof module !== 'undefined' && module.exports) module.exports = createIssueOutbox;

frontend/issue-sheet.js

@@ -18,151 +18,14 @@ function createPlanningLoader({ loadLabels, loadMilestones }) {
   };
 }
 
-function escapeOptionHtml(value) {
-  return String(value || '').replace(/[&<>"']/g, character => ({
-    '&':'&amp;', '<':'&lt;', '>':'&gt;', '"':'&quot;', "'":'&#39;',
-  })[character]);
-}
-
-function appendChecklistTask(body, label) {
-  const normalized = String(label || '').trim().replace(/\s+/g, ' ');
-  if (!normalized) throw new Error('Enter a checklist step.');
-  const key = normalized.toLocaleLowerCase();
-  const duplicate = String(body || '').split('\n').some(line => {
-    const match = line.match(/^\s*[-*+]\s+\[[ xX]\]\s+(.*)$/);
-    return match && match[1].trim().replace(/\s+/g, ' ').toLocaleLowerCase() === key;
-  });
-  if (duplicate) throw new Error('That checklist step already exists.');
-  const prefix = body ? String(body).replace(/\s+$/, '') + '\n' : '';
-  return prefix + '- [ ] ' + normalized;
-}
-
-function manageChecklistTask(raw, targetIndex, operation = {}) {
-  const parts = String(raw || '').split(/(\r\n|\n|\r)/);
-  let fenced = false;
-  let taskIndex = 0;
-  for (let index = 0; index < parts.length; index += 2) {
-    const line = parts[index];
-    if (/^\s*```/.test(line)) { fenced = !fenced; continue; }
-    if (fenced) continue;
-    const task = line.match(/^([-*+]\s+\[[ xX]\]\s+)(.*)$/);
-    if (!task) continue;
-    if (taskIndex === Number(targetIndex)) {
-      if (operation.action === 'rename') {
-        const label = String(operation.label || '').trim().replace(/\s+/g, ' ');
-        if (!label) throw new Error('Enter a checklist step.');
-        const key = label.toLocaleLowerCase();
-        let inFence = false;
-        const duplicate = parts.some((candidate, candidateIndex) => {
-          if (candidateIndex % 2) return false;
-          if (/^\s*```/.test(candidate)) { inFence = !inFence; return false; }
-          if (inFence || candidateIndex === index) return false;
-          const match = candidate.match(/^[-*+]\s+\[[ xX]\]\s+(.*)$/);
-          return match && match[1].trim().replace(/\s+/g, ' ').toLocaleLowerCase() === key;
-        });
-        if (duplicate) throw new Error('That checklist step already exists.');
-        parts[index] = task[1] + label;
-      } else if (operation.action === 'remove') {
-        if (index + 1 < parts.length) parts.splice(index, 2);
-        else if (index > 0) parts.splice(index - 1, 2);
-      } else if (operation.action === 'move-earlier' && index >= 2 && /^(\s*[-*+]\s+\[[ xX]\]\s+)/.test(parts[index - 2])) {
-        [parts[index - 2], parts[index]] = [parts[index], parts[index - 2]];
-      } else if (operation.action === 'move-later' && index + 2 < parts.length && /^(\s*[-*+]\s+\[[ xX]\]\s+)/.test(parts[index + 2])) {
-        [parts[index], parts[index + 2]] = [parts[index + 2], parts[index]];
-      }
-      return parts.join('');
-    }
-    taskIndex += 1;
-  }
-  return parts.join('');
-}
-
-function checklistIsComplete(raw) {
-  const lines = String(raw || '').split(/(?:\r\n|\n|\r)/);
-  let fenced = false;
-  let found = false;
-  for (const line of lines) {
-    if (/^\s*```/.test(line)) { fenced = !fenced; continue; }
-    if (fenced) continue;
-    const task = line.match(/^\s*[-*+]\s+\[([ xX])\]\s+/);
-    if (!task) continue;
-    found = true;
-    if (task[1].toLocaleLowerCase() !== 'x') return false;
-  }
-  return found;
-}
-
-function completeDelegatedParentTask(raw, childUrl) {
-  const url = String(childUrl || '');
-  if (!/^https:\/\/[^\s)]+$/.test(url)) throw new Error('The delegated issue link is unavailable.');
-  const parts = String(raw || '').split(/(\r\n|\n|\r)/);
-  let fenced = false;
-  let taskIndex = 0;
-  for (let index = 0; index < parts.length; index += 2) {
-    const line = parts[index];
-    if (/^\s*```/.test(line)) { fenced = !fenced; continue; }
-    if (fenced) continue;
-    const task = line.match(/^(\s*[-*+]\s+\[)([ xX])(\]\s+.*)$/);
-    if (!task) continue;
-    const linkedTask = task[3].match(/^\]\s+\[[^\]]+\]\((https:\/\/[^\s)]+)\)\s*$/);
-    if (linkedTask?.[1] === url) {
-      const alreadyCompleted = task[2].toLocaleLowerCase() === 'x';
-      if (!alreadyCompleted) parts[index] = task[1] + 'x' + task[3];
-      const body = parts.join('');
-      return { body, taskIndex, alreadyCompleted, checklistComplete:checklistIsComplete(body) };
-    }
-    taskIndex += 1;
-  }
-  throw new Error('The parent checklist no longer links to this delegated issue.');
-}
-
-async function finishDelegatedParentReview({ parentItem, parentDetail, childUrl, updateContent, closeParent }) {
-  const completion = completeDelegatedParentTask(parentDetail?.body, childUrl);
-  if (!completion.alreadyCompleted) {
-    await updateContent(parentItem, {
-      title:parentDetail.title,
-      body:completion.body,
-      expectedUpdatedAt:parentDetail.updated_at,
-    });
-  }
-  if (completion.checklistComplete) await closeParent(parentItem);
-  return { updated:!completion.alreadyCompleted, closed:completion.checklistComplete };
-}
-
-function delegatedParentReference(childDetail) {
-  const body = String(childDetail?.body || '');
-  const match = body.match(/(?:^|\n)Related to \[([A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+)#([1-9]\d*)\]\((https:\/\/[^\s)]+)\)\.(?:\r?$|\s)/m);
-  if (!match) return null;
-  return { repository:match[1], number:Number(match[2]), url:match[3] };
-}
-
-function resolveDelegatedParent(child, childDetail, parentDetail) {
-  const parent = delegatedParentReference(childDetail);
-  if (!parent) return null;
-  try {
-    const completion = completeDelegatedParentTask(parentDetail?.body, child?.url);
-    return {
-      parent,
-      taskIndex:completion.taskIndex,
-      alreadyCompleted:completion.alreadyCompleted,
-      checklistComplete:completion.checklistComplete,
-    };
-  } catch (_error) {
-    return null;
-  }
-}
-
-function createIssueSheet({ fetchJson, storage, renderMarkdown = globalThis.renderMarkdown, toggleTask = renderMarkdown?.toggleTask, manageTask: manageTaskTransform = manageChecklistTask, relatedTaskDraft: relatedTaskDraftTransform = (...args) => globalThis.createIssueCapture?.relatedChecklistDraft(...args), linkRelatedTask: linkRelatedTaskTransform = (...args) => globalThis.createIssueCapture?.linkChecklistTask(...args), enqueueDurably, createConversationPager = globalThis.createConversationPager, createOperationId = () => globalThis.crypto?.randomUUID?.() || String(Date.now()) + '-' + Math.random() }) {
+function createIssueSheet({ fetchJson, storage, createConversationPager = globalThis.createConversationPager, createOperationId = () => globalThis.crypto?.randomUUID?.() || String(Date.now()) + '-' + Math.random() }) {
   let commentRequest = null;
   let closeRequest = null;
   let releaseRequest = null;
-  let handoffRequest = null;
-  let reassignRequest = null;
   let labelRequest = null;
   let editRequest = null;
   let dueDateRequest = null;
   let milestoneRequest = null;
-  let blockerRequest = null;
   const issuePath = item => 'api/v1/repos/' + item.repository.split('/').map(encodeURIComponent).join('/') +
     '/issues/' + encodeURIComponent(item.number);
   const draftKey = item => 'stackchain.issue-comment.v1:' + item.repository + '#' + item.number;
@@ -173,25 +36,16 @@ function createIssueSheet({ fetchJson, storage, renderMarkdown = globalThis.rend
   const milestoneDraftKey = item => 'stackchain.issue-milestone.v1:' + item.repository + '#' + item.number;
 
   return {
-    delegatedParentReference,
-    resolveDelegatedParent,
-    completeDelegatedParentTask,
-    readOnly(item) {
-      return Boolean(item?.is_completed || (item?.is_filed && !item?.is_assigned));
-    },
     load(item) {
-      const access = this.readOnly(item) ? '?access=filed' : '';
-      return fetchJson(issuePath(item) + '/detail' + access, {
+      return fetchJson(issuePath(item) + '/detail', {
         headers: { Accept: 'application/json' },
       });
     },
     conversation(item, initialPage) {
-      const access = this.readOnly(item) ? '&access=filed' : '';
       const pager = createConversationPager({
-        loadPage: page => fetchJson(
-          issuePath(item) + '/comments?page=' + encodeURIComponent(page) + '&limit=20' + access,
-          { headers: { Accept: 'application/json' } },
-        ),
+        loadPage: page => fetchJson(issuePath(item) + '/comments?page=' + encodeURIComponent(page) + '&limit=20', {
+          headers: { Accept: 'application/json' },
+        }),
       });
       pager.reset(initialPage || { comments: [], page: 1, older_page: null, total: 0 });
       return pager;
@@ -207,30 +61,6 @@ function createIssueSheet({ fetchJson, storage, renderMarkdown = globalThis.rend
         headers: { Accept: 'application/json' },
       });
     },
-    loadHandoffCandidates(item) {
-      const access = item?.is_filed ? '?access=filed' : '';
-      return fetchJson(issuePath(item) + '/handoff-candidates' + access, {
-        headers: { Accept: 'application/json' },
-      });
-    },
-    updateBlocker(item, blocker, remove = false) {
-      if (blockerRequest) return blockerRequest;
-      blockerRequest = fetchJson(issuePath(item) + '/blockers', {
-        method: remove ? 'DELETE' : 'POST',
-        headers: { Accept: 'application/json', 'Content-Type': 'application/json' },
-        body: JSON.stringify({ repository: blocker.repository, number: blocker.number }),
-      }).then(result => {
-        const dependencies = Array.isArray(result?.dependencies) ? result.dependencies : [];
-        const present = dependencies.some(candidate =>
-          candidate?.repository === blocker.repository && Number(candidate?.number) === Number(blocker.number)
-        );
-        if (result?.number !== item.number || result?.dependencies_available !== true || present === remove) {
-          throw new Error('Blocker change was not confirmed.');
-        }
-        return result;
-      }).finally(() => { blockerRequest = null; });
-      return blockerRequest;
-    },
     loadDraft(item) {
       try { return storage?.getItem(draftKey(item)) || ''; }
       catch (_error) { return ''; }
@@ -256,8 +86,7 @@ function createIssueSheet({ fetchJson, storage, renderMarkdown = globalThis.rend
     updateContent(item, draft) {
       if (editRequest) return editRequest;
       this.saveEditDraft(item, draft);
-      const access = this.readOnly(item) ? '?access=filed' : '';
-      editRequest = fetchJson(issuePath(item) + '/content' + access, {
+      editRequest = fetchJson(issuePath(item) + '/content', {
         method: 'PATCH',
         headers: { Accept: 'application/json', 'Content-Type': 'application/json' },
         body: JSON.stringify({
@@ -275,218 +104,6 @@ function createIssueSheet({ fetchJson, storage, renderMarkdown = globalThis.rend
       }).finally(() => { editRequest = null; });
       return editRequest;
     },
-    toggleTask(item, detail, taskIndex, checked) {
-      if (typeof toggleTask !== 'function') return Promise.reject(new Error('Checklist updates are unavailable.'));
-      return this.updateContent(item, {
-        title: detail.title,
-        body: toggleTask(detail.body, taskIndex, checked),
-        expectedUpdatedAt: detail.updated_at,
-      });
-    },
-    manageTask(item, detail, taskIndex, operation) {
-      if (typeof manageTaskTransform !== 'function') return Promise.reject(new Error('Checklist management is unavailable.'));
-      return this.updateContent(item, {
-        title: detail.title,
-        body: manageTaskTransform(detail.body, taskIndex, operation),
-        expectedUpdatedAt: detail.updated_at,
-      });
-    },
-    relatedTaskDraft(item, _detail, _taskIndex, label) {
-      if (typeof relatedTaskDraftTransform !== 'function') throw new Error('Related issue capture is unavailable.');
-      return relatedTaskDraftTransform(item, label);
-    },
-    linkRelatedTask(item, detail, taskIndex, child) {
-      if (typeof linkRelatedTaskTransform !== 'function') return Promise.reject(new Error('Related issue linking is unavailable.'));
-      return this.updateContent(item, {
-        title:detail.title,
-        body:linkRelatedTaskTransform(detail.body, taskIndex, child),
-        expectedUpdatedAt:detail.updated_at,
-      });
-    },
-    async addTask(item, detail, label) {
-      const body = appendChecklistTask(detail.body, label);
-      return this.updateContent(item, {
-        title: detail.title,
-        body,
-        expectedUpdatedAt: detail.updated_at,
-      });
-    },
-    async queueAddedTask(item, detail, label) {
-      if (typeof enqueueDurably !== 'function') {
-        throw new Error('Offline checklist updates are unavailable.');
-      }
-      const body = appendChecklistTask(detail.body, label);
-      await enqueueDurably({ kind:'issue-content', repository:item.repository, number:item.number,
-        title:detail.title, baseBody:detail.body, body, expectedUpdatedAt:detail.updated_at });
-      return { queued:true, detail:{ ...detail, body, checklist_pending:true } };
-    },
-    async queueManagedTask(item, detail, taskIndex, operation) {
-      if (typeof manageTaskTransform !== 'function' || typeof enqueueDurably !== 'function') {
-        throw new Error('Offline checklist management is unavailable.');
-      }
-      const body = manageTaskTransform(detail.body, taskIndex, operation);
-      const checklistOperation = {
-        action:String(operation?.action || ''), index:Number(taskIndex),
-        ...(operation?.label ? { label:String(operation.label) } : {}),
-      };
-      await enqueueDurably({ kind:'issue-content', repository:item.repository, number:item.number,
-        title:detail.title, baseBody:detail.body, body, expectedUpdatedAt:detail.updated_at, checklistOperation });
-      return { queued:true, detail:{ ...detail, body, checklist_pending:true } };
-    },
-    async queueTask(item, detail, taskIndex, checked) {
-      if (typeof toggleTask !== 'function' || typeof enqueueDurably !== 'function') {
-        throw new Error('Offline checklist updates are unavailable.');
-      }
-      const body = toggleTask(detail.body, taskIndex, checked);
-      await enqueueDurably({ kind:'issue-content', repository:item.repository, number:item.number,
-        title:detail.title, baseBody:detail.body, body, expectedUpdatedAt:detail.updated_at });
-      return { queued:true, detail:{ ...detail, body, checklist_pending:true } };
-    },
-    pendingTask(item, detail, items, ownerLogin) {
-      const pending = [...(items || [])].reverse().find(candidate => candidate?.kind === 'issue-content' &&
-        candidate.repository === item?.repository && Number(candidate.number) === Number(item?.number) &&
-        candidate.ownerLogin === ownerLogin && ['queued', 'sending', 'attention'].includes(candidate.status));
-      if (!pending) return { ...detail };
-      return { ...detail, title:pending.title, body:pending.body, checklist_pending:true };
-    },
-    bindTaskToggles({ container, status, retry, current, confirmed, restore }) {
-      container.addEventListener('change', async event => {
-        const control = event.target.closest('input.task-list-toggle');
-        const state = current();
-        if (!control || !state?.item || !state?.detail?.updated_at) return;
-        container.classList.add('checklist-pending');
-        container.querySelectorAll('input.task-list-toggle').forEach(input => { input.disabled = true; });
-        status.textContent = 'Updating checklist…';
-        try {
-          const result = await (state.offline ? this.queueTask : this.toggleTask).call(
-            this, state.item, state.detail, Number(control.dataset.taskIndex), control.checked
-          );
-          const latest = current();
-          if (latest?.item?.repository === state.item.repository && latest.item.number === state.item.number) {
-            confirmed(state.item, state.detail, state.offline ? result.detail : result);
-            if (state.offline) status.textContent = 'Checklist queued. Pending sync.';
-            else status.textContent = 'Checklist updated.';
-          }
-        } catch (error) {
-          const latest = current();
-          if (latest?.item?.repository === state.item.repository && latest.item.number === state.item.number) {
-            restore(state.detail);
-            status.textContent = error.message + ' Checklist was not changed; reload latest or use Edit issue.';
-            retry.hidden = false;
-          }
-        }
-      });
-    },
-    bindTaskManagement({ container, editor, label, earlier, later, fileRelated, onFileRelated, remove, cancel, status, sheetStatus, retry, current, confirmed }) {
-      let taskIndex = null;
-      let trigger = null;
-      const reset = (returnFocus = false) => {
-        editor.hidden = true;
-        status.textContent = '';
-        if (returnFocus && trigger?.isConnected) trigger.focus();
-        taskIndex = null;
-        trigger = null;
-      };
-      container.addEventListener('click', event => {
-        const control = event.target.closest('button.task-list-manage');
-        if (!control || !current()?.detail?.updated_at) return;
-        taskIndex = Number(control.dataset.taskIndex);
-        trigger = control;
-        label.value = control.dataset.taskLabel || '';
-        earlier.disabled = control.dataset.taskFirst === 'true';
-        later.disabled = control.dataset.taskLast === 'true';
-        fileRelated.disabled = /^\s*\[[^\]]+\]\([^)]+\)\s*$/.test(label.value);
-        editor.hidden = false;
-        status.textContent = fileRelated.disabled ? 'This step already links to related work.' :
-          'Rename, reorder, remove, or file this step as related work.';
-        label.focus();
-      });
-      const run = async operation => {
-        const state = current();
-        const selectedIndex = taskIndex;
-        if (!state?.item || !state.detail?.updated_at || selectedIndex === null) return;
-        if (operation.action === 'remove' && !globalThis.confirm('Remove this checklist step?')) return;
-        const controls = editor.querySelectorAll('button,input');
-        controls.forEach(control => { control.disabled = true; });
-        status.textContent = state.offline ? 'Queueing checklist change…' : 'Updating checklist…';
-        try {
-          const result = await (state.offline ? this.queueManagedTask : this.manageTask).call(
-            this, state.item, state.detail, selectedIndex, operation
-          );
-          if (current()?.item !== state.item) return;
-          confirmed(state.item, state.detail, state.offline ? result.detail : result);
-          reset();
-          sheetStatus.textContent = state.offline ? 'Checklist change queued. Pending sync.' : 'Checklist step updated.';
-          const focusIndex = operation.action === 'remove' ? Math.max(0, selectedIndex - 1) : selectedIndex;
-          container.querySelector('button.task-list-manage[data-task-index="' + focusIndex + '"]')?.focus();
-        } catch (error) {
-          if (current()?.item === state.item) {
-            status.textContent = error.message + ' Your change is still here; retry.';
-            retry.hidden = false;
-            label.focus();
-          }
-        } finally {
-          if (!editor.hidden) controls.forEach(control => { control.disabled = false; });
-        }
-      };
-      editor.addEventListener('submit', event => { event.preventDefault(); run({ action:'rename', label:label.value }); });
-      earlier.addEventListener('click', () => run({ action:'move-earlier' }));
-      later.addEventListener('click', () => run({ action:'move-later' }));
-      fileRelated.addEventListener('click', async () => {
-        const state = current();
-        const selectedIndex = taskIndex;
-        if (!state?.item || !state.detail?.updated_at || selectedIndex === null || fileRelated.disabled) return;
-        try {
-          await onFileRelated({ item:state.item, detail:state.detail, taskIndex:selectedIndex,
-            label:label.value, trigger });
-          reset();
-        } catch (error) {
-          status.textContent = error.message + ' The checklist step was not changed.';
-          label.focus();
-        }
-      });
-      remove.addEventListener('click', () => run({ action:'remove' }));
-      cancel.addEventListener('click', () => reset(true));
-      return { reset };
-    },
-    renderTasks(container, detail, interactive) {
-      container.classList.toggle('checklist-pending', detail.checklist_pending === true);
-      container.innerHTML = renderMarkdown(
-        detail.body || 'No description provided.', {
-          interactiveTasks: Boolean(interactive),
-          manageTasks: Boolean(interactive),
-        }
-      );
-    },
-    checklistCompletion(container, { interactive, today, offline, dismissed = false }) {
-      const tasks = Array.from(container.querySelectorAll('input.task-list-toggle'));
-      const visible = Boolean(interactive && !dismissed && tasks.length && tasks.every(task => task.checked));
-      return {
-        visible,
-        status: offline ? 'Checklist complete · pending sync' : 'Checklist complete',
-        label: today ? (offline ? 'Queue close & next' : 'Close & next') :
-          (offline ? 'Queue issue closure' : 'Close issue'),
-      };
-    },
-    mergeContent(snapshot, item, detail, confirmed, replace) {
-      return {
-        snapshot: snapshot ? replace(snapshot, item.repository, item.number, confirmed) : snapshot,
-        item: { ...item, ...confirmed, key:item.key },
-        detail: { ...detail, ...confirmed },
-      };
-    },
-    renderMilestoneEditor(item, confirmed, milestones, document = globalThis.document) {
-      const select = document.querySelector('#issue-milestone');
-      const status = document.querySelector('#issue-milestone-status');
-      select.innerHTML = '<option value="">No milestone</option>' + milestones.map(milestone =>
-        '<option value="' + Number(milestone.id) + '">' + escapeOptionHtml(milestone.title) + '</option>'
-      ).join('');
-      select.value = String(this.loadMilestoneDraft(item) ?? confirmed?.id ?? '');
-      select.disabled = false;
-      document.querySelector('#save-issue-milestone').disabled = false;
-      status.textContent = confirmed ? 'Planned for ' + confirmed.title + '.' : 'No milestone set.';
-    },
-
     loadDueDateDraft(item) {
       try {
         const raw = storage?.getItem(dueDateDraftKey(item));
@@ -566,13 +183,11 @@ function createIssueSheet({ fetchJson, storage, renderMarkdown = globalThis.rend
     },
     close(item) {
       if (closeRequest) return closeRequest;
-      const access = item?.is_filed && !item?.is_assigned ? '?access=filed' : '';
-      closeRequest = fetchJson(issuePath(item) + '/close' + access, {
+      closeRequest = fetchJson(issuePath(item) + '/close', {
         method: 'PATCH',
         headers: { Accept: 'application/json' },
       }).then(result => {
         if (result?.state !== 'closed') throw new Error('Issue closure was not confirmed.');
-        globalThis.dispatchEvent?.(new CustomEvent('stackchain:issue-closed',{detail:item}));
         return result;
       }).finally(() => { closeRequest = null; });
       return closeRequest;
@@ -594,48 +209,6 @@ function createIssueSheet({ fetchJson, storage, renderMarkdown = globalThis.rend
       }).finally(() => { releaseRequest = null; });
       return releaseRequest;
     },
-    handoff(item, recipient, currentLogin) {
-      if (handoffRequest) return handoffRequest;
-      handoffRequest = fetchJson(issuePath(item) + '/handoff', {
-        method: 'PATCH',
-        headers: { Accept: 'application/json', 'Content-Type': 'application/json' },
-        body: JSON.stringify({ recipient }),
-      }).then(result => {
-        if (
-          result?.number !== item.number ||
-          result?.recipient !== recipient ||
-          !Array.isArray(result.assignees) ||
-          !result.assignees.includes(recipient) ||
-          result.assignees.includes(currentLogin)
-        ) {
-          throw new Error('Issue handoff was not confirmed.');
-        }
-        return result;
-      }).finally(() => { handoffRequest = null; });
-      return handoffRequest;
-    },
-    reassign(item, recipient) {
-      if (reassignRequest) return reassignRequest;
-      const expectedAssignees = Array.isArray(item?.assignees) ? item.assignees.slice() : [];
-      reassignRequest = fetchJson(issuePath(item) + '/reassign', {
-        method: 'PATCH',
-        headers: { Accept: 'application/json', 'Content-Type': 'application/json' },
-        body: JSON.stringify({ recipient, expected_assignees: expectedAssignees }),
-      }).then(result => {
-        if (
-          result?.number !== item.number ||
-          result?.recipient !== recipient ||
-          !Array.isArray(result.assignees) ||
-          result.assignees.length !== 1 ||
-          result.assignees[0] !== recipient ||
-          JSON.stringify(result.previous_assignees) !== JSON.stringify(expectedAssignees)
-        ) {
-          throw new Error('Issue reassignment was not confirmed.');
-        }
-        return result;
-      }).finally(() => { reassignRequest = null; });
-      return reassignRequest;
-    },
     comment(item, body) {
       if (commentRequest) return commentRequest;
       this.saveDraft(item, body);
@@ -644,8 +217,7 @@ function createIssueSheet({ fetchJson, storage, renderMarkdown = globalThis.rend
         operationId = storage?.getItem(operationKey(item)) || String(createOperationId()).slice(0, 128);
         storage?.setItem(operationKey(item), operationId);
       } catch (_error) { operationId = String(createOperationId()).slice(0, 128); }
-      const access = this.readOnly(item) ? '?access=filed' : '';
-      commentRequest = fetchJson(issuePath(item) + '/comments' + access, {
+      commentRequest = fetchJson(issuePath(item) + '/comments', {
         method: 'POST',
         headers: { Accept: 'application/json', 'Content-Type': 'application/json', 'Idempotency-Key': operationId },
         body: JSON.stringify({ body }),
@@ -663,9 +235,4 @@ function createIssueSheet({ fetchJson, storage, renderMarkdown = globalThis.rend
 
 createIssueSheet.createPlanningLoader = createPlanningLoader;
 
-createIssueSheet.manageChecklistTask = manageChecklistTask;
-createIssueSheet.completeDelegatedParentTask = completeDelegatedParentTask;
-createIssueSheet.finishDelegatedParentReview = finishDelegatedParentReview;
-createIssueSheet.delegatedParentReference = delegatedParentReference;
-createIssueSheet.resolveDelegatedParent = resolveDelegatedParent;
 if (typeof module !== 'undefined' && module.exports) module.exports = createIssueSheet;

frontend/later-and-start.js

@@ -1,51 +0,0 @@
-function createLaterAndStart({ todayWork, todaySync, laterWork, refresh, warm, start, announce }) {
-  const pending = new Map();
-
-  async function run(item, identity) {
-    const added = todayWork.add(item);
-    if (added === 'full') {
-      announce('Today is limited to 5 items. Remove one, then try Start now again.');
-      return 'full';
-    }
-    if (added !== 'added' && added !== 'exists') {
-      announce('Could not save Today on this device. The item remains in Later; try again.');
-      return added;
-    }
-    if (added === 'added' && !todaySync.enqueue('add', identity)) {
-      todayWork.remove(item);
-      announce('Today sync is unavailable. The item remains in Later; try again.');
-      return 'sync-unavailable';
-    }
-    if (!laterWork.restore(item)) {
-      if (added === 'added') {
-        todayWork.remove(item);
-        todaySync.enqueue('remove', identity);
-        todaySync.flush();
-      }
-      announce('Could not remove this item from Later. Nothing was started; try again.');
-      return 'later-unavailable';
-    }
-    refresh();
-    if (added === 'added') todaySync.flush();
-    warm();
-    const outcome = await start(item);
-    if (outcome === 'gated') {
-      announce('Moved to Today. Choose how to handle its blocker before starting.');
-      return 'gated';
-    }
-    announce(added === 'exists' ? 'Opened the existing Today item.' : 'Moved to Today and opened.');
-    return 'started';
-  }
-
-  function startDeferred(item) {
-    const identity = todayWork.identity(item);
-    if (pending.has(identity)) return pending.get(identity);
-    const operation = run(item, identity).finally(() => pending.delete(identity));
-    pending.set(identity, operation);
-    return operation;
-  }
-
-  return { start: startDeferred };
-}
-
-if (typeof module !== 'undefined' && module.exports) module.exports = createLaterAndStart;

frontend/later-picker.js

@@ -1,105 +0,0 @@
-function createLaterPicker({
-  now = () => new Date(),
-  history = null,
-  eventTarget = null,
-  onState = () => {},
-  onConfirm = () => false,
-} = {}) {
-  let active = false;
-  let item = null;
-  let trigger = null;
-  let context = null;
-  let afterClose = null;
-  let committed = false;
-  let started = false;
-
-  function parse(input) {
-    const match = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2})$/.exec(String(input || ''));
-    if (!match) return { ok:false, message:'Choose a valid local date and time.' };
-    const parts = match.slice(1).map(Number);
-    const value = new Date(parts[0], parts[1] - 1, parts[2], parts[3], parts[4], 0, 0);
-    const sameLocalTime = value.getFullYear() === parts[0] &&
-      value.getMonth() === parts[1] - 1 && value.getDate() === parts[2] &&
-      value.getHours() === parts[3] && value.getMinutes() === parts[4];
-    if (!sameLocalTime) return { ok:false, message:'Choose a valid local date and time.' };
-    if (value <= now()) return { ok:false, message:'Choose a future date and time.' };
-    return { ok:true, value };
-  }
-
-  function formatLocal(value) {
-    const pad = part => String(part).padStart(2, '0');
-    return value.getFullYear() + '-' + pad(value.getMonth() + 1) + '-' + pad(value.getDate()) +
-      'T' + pad(value.getHours()) + ':' + pad(value.getMinutes());
-  }
-
-  function deactivate() {
-    if (!active) return false;
-    const restore = trigger;
-    active = false;
-    item = null;
-    trigger = null;
-    context = null;
-    committed = false;
-    onState({ open:false, message:'' });
-    restore?.focus?.();
-    const cleanup = afterClose;
-    afterClose = null;
-    cleanup?.();
-    return true;
-  }
-
-  function start() {
-    if (started || !eventTarget) return;
-    started = true;
-    eventTarget.addEventListener('popstate', event => {
-      if (active && !event.state?.laterPicker) deactivate();
-    });
-    eventTarget.addEventListener('keydown', event => {
-      if (active && event.key === 'Escape') {
-        event.preventDefault?.();
-        close();
-      }
-    });
-  }
-
-  function open(nextItem, nextTrigger, nextContext = 'card') {
-    if (!nextItem || active) return false;
-    active = true;
-    item = nextItem;
-    trigger = nextTrigger || null;
-    context = nextContext;
-    committed = false;
-    const suggested = new Date(now().getTime() + 60 * 60 * 1000);
-    suggested.setMinutes(Math.ceil(suggested.getMinutes() / 15) * 15, 0, 0);
-    if (history) history.pushState({ ...(history.state || {}), laterPicker:true }, '');
-    onState({ open:true, message:'', value:formatLocal(suggested) });
-    return true;
-  }
-
-  function close() {
-    if (!active) return false;
-    if (history?.state?.laterPicker) history.back();
-    else deactivate();
-    return true;
-  }
-
-  function submit(input) {
-    if (!active || committed) return false;
-    const result = parse(input);
-    if (!result.ok) {
-      onState({ open:true, message:result.message, value:String(input || '') });
-      return false;
-    }
-    const confirmed = typeof item?.confirm === 'function' ? item.confirm(result.value) :
-      onConfirm(item, result.value, context);
-    if (confirmed !== true && typeof confirmed !== 'function') return false;
-    committed = true;
-    afterClose = typeof confirmed === 'function' ? confirmed : null;
-    close();
-    return true;
-  }
-
-  return { parse, start, open, close, submit, current:() => active };
-}
-
-if (typeof module !== 'undefined' && module.exports) module.exports = createLaterPicker;

frontend/later-sync.js

@@ -1,277 +0,0 @@
-function createLaterSync({ storage, getLogin, fetchJson, onRemoteRecords, onStatus, createOperationId, createChannel, coordinator,
-  setTimer = globalThis.setTimeout, clearTimer = globalThis.clearTimeout, retryBaseMs = 1000, retryMaxMs = 30000,
-  now = Date.now, maxOfflineMs = 30 * 24 * 60 * 60 * 1000 }) {
-  const prefix = 'stackchain.later-sync.v1.';
-  const migrationPrefix = 'stackchain.later-sync-migrated.v1.';
-  const snapshotPrefix = 'stackchain.later-sync-snapshot.v1.';
-  let flushing = null;
-  let channel = null;
-  let channelKey = '';
-  let retryTimer = null;
-  let retryAttempt = 0;
-  let expiredCount = 0;
-  const knownOperationKeys = new Set();
-
-  function cancelRetry() {
-    if (retryTimer !== null) clearTimer?.(retryTimer);
-    retryTimer = null;
-  }
-
-  function scheduleRetry(error, ownerKey) {
-    if (retryTimer !== null || !pending().length || !ownerKey) return;
-    const advised = Number(error?.retryAfter);
-    const delayMs = Number.isFinite(advised) && advised >= 0
-      ? advised * 1000
-      : Math.min(retryMaxMs, retryBaseMs * (2 ** retryAttempt));
-    retryAttempt += 1;
-    onStatus?.('retrying', { delayMs });
-    retryTimer = setTimer?.(async () => {
-      retryTimer = null;
-      if (key() !== ownerKey) return false;
-      return flush();
-    }, delayMs);
-    retryTimer?.unref?.();
-  }
-
-  function key() {
-    const login = String(getLogin?.() || '').trim().toLowerCase();
-    return login ? prefix + encodeURIComponent(login) : '';
-  }
-
-  function snapshotKey() {
-    const storageKey = key();
-    return storageKey ? snapshotPrefix + storageKey.slice(prefix.length) : '';
-  }
-
-  function savedRevision() {
-    try {
-      const snapshot = JSON.parse(storage?.getItem(snapshotKey()) || 'null');
-      return Number.isInteger(snapshot?.revision) ? snapshot.revision : -1;
-    } catch (_error) {
-      return -1;
-    }
-  }
-
-  function validRecords(records) {
-    return records && typeof records === 'object' && !Array.isArray(records);
-  }
-
-  function adopt(plan, broadcast = true) {
-    if (!Number.isInteger(plan?.revision) || !validRecords(plan?.records)) return false;
-    if (plan.revision < savedRevision()) return false;
-    const snapshot = { revision: plan.revision, records: plan.records };
-    try {
-      storage?.setItem(snapshotKey(), JSON.stringify(snapshot));
-    } catch (_error) {
-      // Server truth remains usable in this tab when storage is unavailable.
-    }
-    onRemoteRecords?.(plan.records);
-    if (broadcast) channel?.postMessage(snapshot);
-    return true;
-  }
-
-  function ensureChannel() {
-    const storageKey = key();
-    if (!storageKey || channelKey === storageKey) return;
-    channel?.close?.();
-    const factory = createChannel || (globalThis.window?.BroadcastChannel
-      ? name => new globalThis.window.BroadcastChannel(name)
-      : null);
-    channelKey = storageKey;
-    channel = factory?.('stackchain-later-' + storageKey.slice(prefix.length)) || null;
-    channel?.addEventListener?.('message', event => {
-      if (key() === storageKey) adopt(event.data, false);
-    });
-  }
-
-  function pending() {
-    const storageKey = key();
-    if (!storageKey || !storage) return [];
-    const recordPrefix = storageKey + '.operation.';
-    try {
-      const legacy = JSON.parse(storage.getItem(storageKey) || '[]');
-      if (Array.isArray(legacy)) {
-        legacy.forEach((operation, index) => {
-          if (!operation?.operation_id) return;
-          const recordKey = recordPrefix + encodeURIComponent(operation.operation_id);
-          storage.setItem(recordKey, JSON.stringify({ operation, queued_at: index }));
-          knownOperationKeys.add(recordKey);
-        });
-        if (legacy.length) storage.removeItem(storageKey);
-      }
-      const keys = new Set([...knownOperationKeys].filter(candidate => candidate.startsWith(recordPrefix)));
-      for (let index = 0; index < Number(storage.length || 0); index += 1) {
-        const candidate = storage.key?.(index);
-        if (candidate?.startsWith(recordPrefix)) keys.add(candidate);
-      }
-      const records = [...keys].map(recordKey => {
-        const record = JSON.parse(storage.getItem(recordKey) || 'null');
-        return record ? { ...record, recordKey } : null;
-      }).filter(record => record?.operation);
-      const expired = records.filter(record => Number(record.queued_at) >= 1_000_000_000_000 &&
-        now() - Number(record.queued_at) > maxOfflineMs);
-      expired.forEach(record => {
-        storage.removeItem(record.recordKey);
-        knownOperationKeys.delete(record.recordKey);
-      });
-      if (expired.length) {
-        expiredCount += expired.length;
-        onStatus?.('expired', { count: expiredCount });
-      }
-      const activeRecords = records.filter(record => !expired.includes(record))
-        .sort((left, right) => Number(left.queued_at || 0) - Number(right.queued_at || 0) ||
-          left.operation.operation_id.localeCompare(right.operation.operation_id));
-      const latestByItem = new Map();
-      activeRecords.forEach(record => latestByItem.set(record.operation.item_id, record));
-      activeRecords.filter(record => latestByItem.get(record.operation.item_id) !== record).forEach(record => {
-        storage.removeItem(record.recordKey);
-        knownOperationKeys.delete(record.recordKey);
-      });
-      return activeRecords.filter(record => latestByItem.get(record.operation.item_id) === record)
-        .map(record => ({
-          ...record.operation,
-          base_revision: Number.isInteger(record.operation.base_revision)
-            ? record.operation.base_revision : 0,
-        })).filter(operation =>
-          operation && typeof operation.operation_id === 'string' &&
-          ['defer', 'restore'].includes(operation.action) && typeof operation.item_id === 'string' &&
-          (operation.action === 'restore' || typeof operation.wake_at === 'string'));
-    } catch (_error) {
-      return [];
-    }
-  }
-
-  function removeOperation(operationId) {
-    const storageKey = key();
-    if (!storageKey || !storage) return false;
-    const recordKey = storageKey + '.operation.' + encodeURIComponent(operationId);
-    try {
-      storage.removeItem(recordKey);
-      knownOperationKeys.delete(recordKey);
-      return true;
-    } catch (_error) {
-      return false;
-    }
-  }
-
-  function operationId() {
-    if (createOperationId) return createOperationId();
-    if (globalThis.crypto?.randomUUID) return globalThis.crypto.randomUUID();
-    return Date.now().toString(36) + '-' + Math.random().toString(36).slice(2);
-  }
-
-  function enqueue(action, itemId, wakeAt = null, handoff = null) {
-    if (!['defer', 'restore'].includes(action) || !itemId ||
-        (action === 'defer' && typeof wakeAt !== 'string') ||
-        ![null, 'today'].includes(handoff)) return false;
-    pending().filter(operation => operation.item_id === itemId)
-      .forEach(operation => removeOperation(operation.operation_id));
-    const operation = {
-      operation_id: operationId(), action, item_id: itemId, wake_at: wakeAt,
-      base_revision: Math.max(0, savedRevision()),
-    };
-    if (handoff) operation.handoff = handoff;
-    const storageKey = key();
-    if (!storageKey || !storage) return false;
-    const recordKey = storageKey + '.operation.' + encodeURIComponent(operation.operation_id);
-    let saved = false;
-    try {
-      storage.setItem(recordKey, JSON.stringify({ operation, queued_at: now() }));
-      knownOperationKeys.add(recordKey);
-      saved = true;
-      coordinator?.notify('later');
-    } catch (_error) { /* Report the persistence failure below. */ }
-    onStatus?.(saved ? 'pending' : 'error');
-    return saved;
-  }
-
-  function migrate(records) {
-    const storageKey = key();
-    if (!storageKey || !storage) return false;
-    const marker = migrationPrefix + storageKey.slice(prefix.length);
-    try {
-      if (storage.getItem(marker)) return false;
-      Object.entries(records || {}).forEach(([itemId, record]) => {
-        const wakeAt = record && typeof record === 'object' ? record.wake_at : record;
-        const handoff = record?.handoff === 'today' ? 'today' : null;
-        enqueue('defer', itemId, wakeAt, handoff);
-      });
-      storage.setItem(marker, '1');
-      return true;
-    } catch (_error) {
-      return false;
-    }
-  }
-
-  async function run() {
-    const ownerKey = key();
-    if (!ownerKey) return false;
-    ensureChannel();
-    expiredCount = 0;
-    try {
-      let operations = pending();
-      let plan;
-      let conflictCount = 0;
-      if (!operations.length) plan = await fetchJson('api/v1/later');
-      while (operations.length) {
-        if (key() !== ownerKey) return false;
-        const batch = operations.slice(0, 50);
-        plan = await fetchJson('api/v1/later', {
-          method: 'PATCH',
-          headers: { 'Content-Type': 'application/json' },
-          body: JSON.stringify({ operations: batch }),
-        });
-        const hasReceipts = Array.isArray(plan.accepted_operation_ids) ||
-          Array.isArray(plan.duplicate_operation_ids) || Array.isArray(plan.rejected_operations);
-        const received = hasReceipts ? [
-          ...(plan.accepted_operation_ids || []),
-          ...(plan.duplicate_operation_ids || []),
-          ...(plan.rejected_operations || []).map(item => item.operation_id),
-        ] : batch.map(item => item.operation_id);
-        conflictCount += (plan.rejected_operations || [])
-          .filter(item => item.reason === 'stale_intent').length;
-        for (const operationId of received) {
-          if (pending().some(candidate => candidate.operation_id === operationId) &&
-              !removeOperation(operationId)) {
-            throw new Error('Could not persist Later delivery receipt');
-          }
-        }
-        operations = pending();
-      }
-      adopt(plan);
-      onStatus?.(pending().length ? 'pending' :
-        (conflictCount ? 'conflict' : expiredCount ? 'expired' : 'saved'),
-        conflictCount ? { count: conflictCount } : expiredCount ? { count: expiredCount } : {});
-      retryAttempt = 0;
-      cancelRetry();
-      return true;
-    } catch (error) {
-      if (pending().length) scheduleRetry(error, ownerKey);
-      else onStatus?.('error');
-      return false;
-    }
-  }
-
-  function flush() {
-    if (!flushing) {
-      const delivery = coordinator ? coordinator.runExclusive('later', run) : run();
-      flushing = Promise.resolve(delivery).finally(() => { flushing = null; });
-    }
-    return flushing;
-  }
-
-  function startLifecycle({ window: windowObject, document: documentObject }) {
-    windowObject?.addEventListener?.('online', flush);
-    documentObject?.addEventListener?.('visibilitychange', () =>
-      documentObject.hidden ? false : flush()
-    );
-  }
-
-  coordinator?.subscribe(change => {
-    if (change.queue === 'later' && pending().length) flush();
-  });
-
-  return { enqueue, migrate, flush, pending, startLifecycle };
-}
-
-if (typeof module !== 'undefined' && module.exports) module.exports = createLaterSync;

frontend/later-work.js

@@ -1,4 +1,4 @@
-function createLaterWork({ storage, getLogin, now = () => new Date(), setTimer = setTimeout, clearTimer = clearTimeout, onWake = () => {}, onChange = () => {}, onExpire = () => {} }) {
+function createLaterWork({ storage, getLogin, now = () => new Date(), setTimer = setTimeout, clearTimer = clearTimeout, onWake = () => {} }) {
   const prefix = 'stackchain.later-work.v1.';
   let timer = null;
 
@@ -38,35 +38,15 @@ function createLaterWork({ storage, getLogin, now = () => new Date(), setTimer =
     }
   }
 
-  function defer(item, until, options = {}) {
+  function defer(item, until) {
     const key = storageKey();
     const id = identity(item);
     const wake = new Date(until);
-    if (!key) return 'unavailable';
-    if (!id || Number.isNaN(wake.getTime()) || wake <= now()) return 'invalid';
+    if (!key || !id || Number.isNaN(wake.getTime()) || wake <= now()) return false;
     const records = read();
-    const wakeAt = wake.toISOString();
-    const handoff = options.handoff === 'today' ? 'today' : null;
-    records[id] = handoff ? { wake_at:wakeAt, handoff } : wakeAt;
-    if (!write(records)) return 'unavailable';
-    onChange('defer', id, wakeAt, handoff);
-    return 'deferred';
-  }
-
-  function deferMany(items, until) {
-    const key = storageKey();
-    const wake = new Date(until);
-    const entries = (items || []).map(item => [identity(item), item]);
-    if (!key) return 'unavailable';
-    if (!entries.length || entries.some(([id]) => !id) || Number.isNaN(wake.getTime()) || wake <= now()) {
-      return 'invalid';
-    }
-    const records = read();
-    const wakeAt = wake.toISOString();
-    entries.forEach(([id]) => { records[id] = wakeAt; });
-    if (!write(records)) return 'unavailable';
-    entries.forEach(([id]) => onChange('defer', id, wakeAt));
-    return 'deferred';
+    records[id] = wake.toISOString();
+    write(records);
+    return true;
   }
 
   function presetUntil(preset) {
@@ -86,25 +66,10 @@ function createLaterWork({ storage, getLogin, now = () => new Date(), setTimer =
     const records = read();
     if (!id || !Object.prototype.hasOwnProperty.call(records, id)) return false;
     delete records[id];
-    if (!write(records)) return false;
-    onChange('restore', id, null);
+    write(records);
     return true;
   }
 
-  function adopt(records) {
-    if (!records || typeof records !== 'object' || Array.isArray(records)) return false;
-    const normalized = {};
-    Object.entries(records).forEach(([id, record]) => {
-      const wake = record && typeof record === 'object' ? record.wake_at : record;
-      const wakeTime = new Date(wake).getTime();
-      if (id && Number.isFinite(wakeTime)) {
-        const wakeAt = new Date(wakeTime).toISOString();
-        normalized[id] = record?.handoff === 'today' ? { wake_at:wakeAt, handoff:'today' } : wakeAt;
-      }
-    });
-    return write(normalized);
-  }
-
   function schedule(wakeTimes, current) {
     if (timer !== null) clearTimer(timer);
     timer = null;
@@ -122,40 +87,27 @@ function createLaterWork({ storage, getLogin, now = () => new Date(), setTimer =
     const available = new Map((items || []).map(item => [identity(item), item]));
     const retained = {};
     const wakeTimes = [];
-    const expired = [];
 
-    const handoffs = [];
-    Object.entries(records).forEach(([id, record]) => {
-      const wake = record && typeof record === 'object' ? record.wake_at : record;
+    Object.entries(records).forEach(([id, wake]) => {
       const wakeTime = new Date(wake).getTime();
-      if (!Number.isFinite(wakeTime) || wakeTime <= current) {
-        if (Number.isFinite(wakeTime)) {
-          expired.push(id);
-          if (record?.handoff === 'today') handoffs.push(id);
-        }
-        return;
-      }
+      if (!Number.isFinite(wakeTime) || wakeTime <= current) return;
       if (pruneMissing && !available.has(id)) return;
-      const wakeAt = new Date(wakeTime).toISOString();
-      retained[id] = record?.handoff === 'today' ? { wake_at:wakeAt, handoff:'today' } : wakeAt;
+      retained[id] = new Date(wakeTime).toISOString();
       wakeTimes.push(wakeTime);
     });
 
-    if (JSON.stringify(retained) !== JSON.stringify(records) && write(retained) && expired.length) {
-      onExpire(expired, handoffs);
-    }
+    if (JSON.stringify(retained) !== JSON.stringify(records)) write(retained);
     schedule(wakeTimes, current);
     const deferredIds = new Set(Object.keys(retained));
     const active = (items || []).filter(item => !deferredIds.has(identity(item)));
     const later = (items || []).flatMap(item => {
-      const record = retained[identity(item)];
-      const wake = record && typeof record === 'object' ? record.wake_at : record;
+      const wake = retained[identity(item)];
       return wake ? [{ ...item, deferred_until: wake }] : [];
     });
     return { active, later };
   }
 
-  return { identity, read, adopt, defer, deferMany, restore, presetUntil, partition };
+  return { identity, defer, restore, presetUntil, partition };
 }
 
 if (typeof module !== 'undefined' && module.exports) module.exports = createLaterWork;

frontend/live-data-status.js

@@ -1,185 +0,0 @@
-(function (root, factory) {
-  const api = factory();
-  if (typeof module !== 'undefined' && module.exports) module.exports = api;
-  else root.liveDataStatus = api;
-})(typeof globalThis !== 'undefined' ? globalThis : this, function () {
-  const feeds = [
-    ['context', 'Work'],
-    ['notifications', 'Updates'],
-    ['events', 'Activity'],
-  ];
-
-  function boundedSeconds(value) {
-    const seconds = Number(value);
-    return Number.isFinite(seconds) && seconds >= 0 ? Math.min(Math.round(seconds), 86400) : null;
-  }
-
-  function describe(freshness = {}) {
-    const sections = freshness.sections || {};
-    const hasSectionData = feeds.some(([key]) => Object.prototype.hasOwnProperty.call(sections, key));
-    const described = feeds.map(([key, label]) => {
-      const section = sections[key] || {};
-      const state = section.revalidating ? 'refreshing' :
-        (section.stale || section.degraded ? 'delayed' : 'live');
-      return { key, label, state, ageSeconds: boundedSeconds(section.age_seconds) };
-    });
-    const delayed = described.filter(feed => feed.state === 'delayed');
-    const refreshing = described.filter(feed => feed.state === 'refreshing');
-    let summary = hasSectionData ? 'Live' : 'Live data unavailable';
-    if (delayed.length === 1) summary = delayed[0].label + ' delayed';
-    else if (delayed.length > 1) summary = delayed.length + ' data feeds delayed';
-    else if (refreshing.length === 1) summary = refreshing[0].label + ' refreshing';
-    else if (refreshing.length > 1) summary = 'Refreshing live data';
-    const retryValues = described.map(feed => {
-      const section = sections[feed.key] || {};
-      return boundedSeconds(section.retry_in_seconds);
-    }).filter(value => value !== null && value > 0);
-    const aggregateRetry = boundedSeconds(freshness.retry_in_seconds);
-    if (aggregateRetry !== null && aggregateRetry > 0) retryValues.push(aggregateRetry);
-    return {
-      summary,
-      feeds: described,
-      nextRetrySeconds: retryValues.length ? Math.min(...retryValues) : null,
-    };
-  }
-
-  function createRefreshController({ button, output, refresh, onState = () => {} }) {
-    let pending = null;
-    function run() {
-      if (pending) return pending;
-      button.disabled = true;
-      output.textContent = 'Refreshing live data…';
-      onState('refreshing');
-      let request;
-      try {
-        request = refresh();
-      } catch (error) {
-        request = Promise.reject(error);
-      }
-      pending = Promise.resolve(request).then(result => {
-        if (!result) throw new Error('Live data remains unavailable.');
-        output.textContent = 'Live data refreshed.';
-        onState('success');
-        return result;
-      }).catch(error => {
-        output.textContent = error && error.message ? error.message : 'Live data refresh failed.';
-        onState('error');
-        return null;
-      }).finally(() => {
-        button.disabled = false;
-        pending = null;
-      });
-      return pending;
-    }
-    return { run };
-  }
-
-  function createSheetController(options) {
-    let ownsDetour = false;
-    let backgroundState = null;
-
-    function focusableControls() {
-      return [...options.sheet.querySelectorAll('button:not([disabled]), [tabindex]:not([tabindex="-1"])')]
-        .filter(control => !control.hidden);
-    }
-
-    function containBackground() {
-      if (backgroundState) return;
-      backgroundState = new Map((options.backgroundElements || []).map(element => [element, element.inert]));
-      backgroundState.forEach((_wasInert, element) => { element.inert = true; });
-    }
-
-    function releaseBackground() {
-      if (!backgroundState) return;
-      backgroundState.forEach((wasInert, element) => { element.inert = wasInert; });
-      backgroundState = null;
-    }
-
-    function finishClose() {
-      if (options.sheet.hidden) return;
-      options.sheet.hidden = true;
-      options.trigger.setAttribute('aria-expanded', 'false');
-      if (options.pausedStatus) options.pausedStatus.hidden = true;
-      releaseBackground();
-      if (ownsDetour) options.timerView?.finishDetour?.();
-      ownsDetour = false;
-      options.trigger.focus?.();
-    }
-
-    function close() {
-      if (options.history?.state?.liveDataStatus) {
-        options.history.back();
-        return;
-      }
-      finishClose();
-    }
-
-    function open() {
-      if (!options.sheet.hidden) return;
-      ownsDetour = options.timerView?.beginDetour?.('live-data-status')?.reason === 'live-data-status';
-      if (options.pausedStatus) options.pausedStatus.hidden = !ownsDetour;
-      if (options.returnButton) options.returnButton.hidden = !ownsDetour;
-      containBackground();
-      options.sheet.hidden = false;
-      options.trigger.setAttribute('aria-expanded', 'true');
-      if (options.history && !options.history.state?.liveDataStatus) {
-        options.history.pushState({ ...options.history.state, liveDataStatus:true }, '');
-      }
-      options.closeButton.focus();
-    }
-
-    function start() {
-      options.trigger.addEventListener('click', open);
-      options.closeButton.addEventListener('click', close);
-      options.returnButton?.addEventListener('click', close);
-      options.sheet.addEventListener('click', event => {
-        if (event.target === options.sheet) close();
-      });
-      options.escapeTarget?.addEventListener('keydown', event => {
-        if (options.sheet.hidden) return;
-        if (event.key === 'Escape') {
-          event.preventDefault?.();
-          close();
-          return;
-        }
-        if (event.key !== 'Tab') return;
-        const controls = focusableControls();
-        if (!controls.length) return;
-        const first = controls[0];
-        const last = controls[controls.length - 1];
-        if (event.shiftKey && event.target === first) {
-          event.preventDefault();
-          last.focus();
-        } else if (!event.shiftKey && event.target === last) {
-          event.preventDefault();
-          first.focus();
-        }
-      });
-      options.historyTarget?.addEventListener('popstate', event => {
-        if (!options.sheet.hidden && !event.state?.liveDataStatus) finishClose();
-      });
-    }
-
-    return { start, open, close };
-  }
-
-  function mount(options) {
-    const document = options.document;
-    const qs = selector => document.querySelector(selector);
-    const trigger = qs('#open-live-data-status');
-    trigger.addEventListener('click', options.onOpen);
-    return createSheetController({
-      sheet:qs('#live-data-status-sheet'), trigger,
-      closeButton:qs('#close-live-data-status'),
-      returnButton:qs('#return-from-live-data-status'),
-      pausedStatus:qs('#live-data-status-today-paused'),
-      timerView:options.timerView,
-      history:options.window.history,
-      historyTarget:options.window,
-      escapeTarget:document,
-      backgroundElements:[qs('header'), qs('main'), qs('#mobile-task-dock')].filter(Boolean),
-    });
-  }
-
-  return { describe, createRefreshController, createSheetController, mount };
-});

frontend/login.js

@@ -2,138 +2,14 @@
   if (typeof module === 'object' && module.exports) module.exports = factory;
   else root.createLoginController = factory;
 }(typeof self !== 'undefined' ? self : this, function createLoginController(options) {
-  function validShareContinuation(value) {
-    if (typeof value !== 'string' || !value.startsWith('./?') || value.includes('#')) return './';
-    const limits = { title: 200, text: 8000, url: 2048, launch: 8, shared: 6, search: 200,
-      preview: 200, search_kind: 5, search_state: 6, search_repository: 161 };
-    const params = new URLSearchParams(value.slice(3));
-    const entries = Array.from(params.entries());
-    if (!entries.length) return './';
-    const invalid = entries.some(([name, content]) => (
-      !Object.prototype.hasOwnProperty.call(limits, name)
-      || !content
-      || content.length > limits[name]
-    ));
-    if (invalid) return './';
-    if (Object.keys(limits).some(name => params.getAll(name).length > 1)) return './';
-    const search = params.get('search');
-    const preview = params.get('preview');
-    if (search !== null || preview !== null) {
-      if (entries.some(([name]) => ![
-        'search', 'preview', 'search_kind', 'search_state', 'search_repository'
-      ].includes(name))) return './';
-      if (search === null || preview === null) return './';
-      if (!/^(issue|pull):[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+:[1-9]\d*$/.test(preview)) return './';
-      const kind = params.get('search_kind');
-      const state = params.get('search_state');
-      const repository = params.get('search_repository');
-      if (kind !== null && !['all', 'issue', 'pull'].includes(kind)) return './';
-      if (state !== null && !['all', 'open', 'closed'].includes(state)) return './';
-      if (repository !== null && !/^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/.test(repository)) return './';
-      return value;
-    }
-    const launch = params.get('launch');
-    const shared = params.get('shared');
-    if (launch && !['continue', 'new', 'agenda'].includes(launch)) return './';
-    if (shared === 'bundle') {
-      if (launch !== 'new' || entries.some(([name]) => !['launch', 'shared'].includes(name))) return './';
-    } else if (shared !== null && (shared !== 'image' || launch !== 'new')) return './';
-    return value;
-  }
-
   const form = options.form;
   const status = options.status;
   const button = options.button;
-  const passkeyButton = options.passkeyButton;
-  const credentials = options.credentials;
   const fetchImpl = options.fetchImpl;
   const location = options.location;
-  const clearPrivateDeviceData = options.clearPrivateDeviceData;
-  const continuation = validShareContinuation(options.continuation);
   const setIntervalImpl = options.setIntervalImpl || setInterval;
   const clearIntervalImpl = options.clearIntervalImpl || clearInterval;
-  const setTimeoutImpl = options.setTimeoutImpl || setTimeout;
-  const clearTimeoutImpl = options.clearTimeoutImpl || clearTimeout;
-  const requestTimeoutMs = options.requestTimeoutMs || 15000;
   let timer = null;
-  let activeAttempt = false;
-
-  function setAttemptActive(active) {
-    activeAttempt = active;
-    button.disabled = active;
-    if (passkeyButton) passkeyButton.disabled = active || !credentials?.get;
-  }
-
-  async function requestWithDeadline(url, init) {
-    const controller = new AbortController();
-    const timeout = setTimeoutImpl(() => {
-      const error = new Error('Sign-in request timed out');
-      error.name = 'TimeoutError';
-      controller.abort(error);
-    }, requestTimeoutMs);
-    try {
-      return await fetchImpl(url, { ...init, signal: controller.signal });
-    } finally {
-      clearTimeoutImpl(timeout);
-    }
-  }
-
-  function decodeBase64Url(value) {
-    const padded = String(value).replaceAll('-', '+').replaceAll('_', '/')
-      + '='.repeat((4 - String(value).length % 4) % 4);
-    return Uint8Array.from(atob(padded), character => character.charCodeAt(0));
-  }
-
-  function encodeBase64Url(value) {
-    if (value === null || value === undefined) return null;
-    const bytes = new Uint8Array(value);
-    let binary = '';
-    bytes.forEach(byte => { binary += String.fromCharCode(byte); });
-    return btoa(binary).replaceAll('+', '-').replaceAll('/', '_').replaceAll('=', '');
-  }
-
-  function credentialJSON(credential) {
-    return {
-      id: credential.id,
-      type: credential.type,
-      rawId: encodeBase64Url(credential.rawId),
-      response: {
-        authenticatorData: encodeBase64Url(credential.response.authenticatorData),
-        clientDataJSON: encodeBase64Url(credential.response.clientDataJSON),
-        signature: encodeBase64Url(credential.response.signature),
-        userHandle: encodeBase64Url(credential.response.userHandle),
-      },
-    };
-  }
-
-  if (continuation !== './') {
-    const continuationParams = new URLSearchParams(continuation.slice(3));
-    status.textContent = continuationParams.has('preview')
-      ? 'Sign in to open the shared Search result.'
-      : 'Sign in to continue your shared capture.';
-  }
-
-  async function showReason(reason) {
-    if (reason === 'session-expired') {
-      status.textContent = 'Your session expired. Private drafts remain on this device. Sign in to continue.';
-      return;
-    }
-    if (reason === 'session-idle') {
-      status.textContent = 'Stackchain locked. Your drafts and queued work are still on this device. Sign in to resume.';
-      return;
-    }
-    if (reason !== 'session-revoked') return;
-    button.disabled = true;
-    status.textContent = 'This device was remotely signed out. Clearing Stackchain private data…';
-    try {
-      if (typeof clearPrivateDeviceData !== 'function') throw new Error('Private data purger unavailable.');
-      await clearPrivateDeviceData();
-      status.textContent = 'This device was remotely signed out. Stackchain private data was cleared. Sign in to use it again.';
-      button.disabled = false;
-    } catch (_error) {
-      status.textContent = 'This device was remotely signed out, but private data could not be cleared. Close other Stackchain tabs and clear this site’s data before signing in.';
-    }
-  }
 
   function showRetryCountdown(seconds) {
     let remaining = Math.max(1, Number.parseInt(seconds, 10) || 1);
@@ -152,29 +28,23 @@
     }, 1000);
   }
 
-  async function submit(accessToken, deviceLabel = 'This device') {
-    if (activeAttempt) return false;
-    setAttemptActive(true);
+  async function submit(accessToken) {
     status.textContent = 'Signing in…';
     let response;
     try {
-      response = await requestWithDeadline('api/v1/session', {
+      response = await fetchImpl('api/v1/session', {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ access_token: accessToken, device_label: deviceLabel }),
+        body: JSON.stringify({ access_token: accessToken }),
       });
-    } catch (error) {
+    } catch (_error) {
       form.reset();
-      status.textContent = error?.name === 'TimeoutError'
-        ? 'Sign-in timed out. Check your connection and try again.'
-        : 'Sign-in failed. Check your connection and try again.';
-      return false;
-    } finally {
-      setAttemptActive(false);
+      status.textContent = 'Sign-in failed. Check your connection and try again.';
+      return;
     }
     form.reset();
     if (response.ok) {
-      location.replace(continuation);
+      location.replace('./');
       return;
     }
     if (response.status === 429) {
@@ -184,81 +54,23 @@
     status.textContent = 'Sign-in failed. Check the token and try again.';
   }
 
-  async function signInWithPasskey(deviceLabel = 'This device') {
-    if (!credentials?.get) {
-      status.textContent = 'Passkeys are not supported in this browser. Use the access token.';
-      return false;
-    }
-    if (activeAttempt) return false;
-    setAttemptActive(true);
-    status.textContent = 'Waiting for your passkey…';
-    try {
-      const optionsResponse = await requestWithDeadline('api/v1/passkeys/authentication/options', {
-        method: 'POST', headers: { Accept: 'application/json' },
-      });
-      if (!optionsResponse.ok) throw new Error('No enrolled passkey');
-      const publicKey = await optionsResponse.json();
-      const challenge = publicKey.challenge;
-      publicKey.challenge = decodeBase64Url(publicKey.challenge);
-      publicKey.allowCredentials = (publicKey.allowCredentials || []).map(item => ({
-        ...item, id: decodeBase64Url(item.id),
-      }));
-      const credential = await credentials.get({ publicKey });
-      const response = await requestWithDeadline('api/v1/passkeys/authentication/verify', {
-        method: 'POST',
-        headers: { Accept: 'application/json', 'Content-Type': 'application/json' },
-        body: JSON.stringify({
-          challenge,
-          credential: credentialJSON(credential),
-          device_label: deviceLabel,
-          action: 'sign_in',
-          target: 'dashboard',
-        }),
-      });
-      if (!response.ok) throw new Error('Passkey verification failed');
-      location.replace(continuation);
-      return true;
-    } catch (error) {
-      status.textContent = error?.name === 'TimeoutError'
-        ? 'Passkey sign-in timed out. Check your connection and try again.'
-        : 'Passkey sign-in was not completed. Try again or use the access token.';
-      return false;
-    } finally {
-      setAttemptActive(false);
-    }
-  }
-
-  if (passkeyButton) passkeyButton.disabled = !credentials?.get;
-  return { submit, signInWithPasskey, showReason };
+  return { submit };
 }));
 
 if (typeof document !== 'undefined') {
   const form = document.getElementById('sign-in');
   const status = document.getElementById('status');
   const button = document.getElementById('submit-sign-in');
-  const passkeyButton = document.getElementById('passkey-sign-in');
-  const loginParams = new URLSearchParams(window.location.search);
   const controller = createLoginController({
     form,
     status,
     button,
-    passkeyButton,
-    credentials: window.navigator?.credentials,
     fetchImpl: fetch.bind(window),
     location: window.location,
-    continuation: loginParams.get('continue'),
-    clearPrivateDeviceData: window.stackchainPrivateDeviceData,
   });
-  controller.showReason(loginParams.get('reason'));
   form.addEventListener('submit', event => {
     event.preventDefault();
-    const data = new FormData(form);
-    const accessToken = data.get('access_token');
-    const deviceLabel = data.get('device_label');
-    controller.submit(accessToken, deviceLabel);
-  });
-  passkeyButton?.addEventListener('click', () => {
-    const data = new FormData(form);
-    controller.signInWithPasskey(data.get('device_label'));
+    const accessToken = new FormData(form).get('access_token');
+    controller.submit(accessToken);
   });
 }

frontend/manifest.webmanifest

@@ -12,38 +12,10 @@
     {"src": "static/icons/stackchain-192.png", "sizes": "192x192", "type": "image/png"},
     {"src": "static/icons/stackchain-512.png", "sizes": "512x512", "type": "image/png"}
   ],
-  "shortcuts": [
-    {
-      "name": "Continue work",
-      "short_name": "Continue",
-      "description": "Resume the highest-priority mobile work flow.",
-      "url": "./?launch=continue",
-      "icons": [{"src": "static/icons/stackchain-192.png", "sizes": "192x192", "type": "image/png"}]
-    },
-    {
-      "name": "New issue",
-      "short_name": "New",
-      "description": "Capture work now and file it online or offline.",
-      "url": "./?launch=new",
-      "icons": [{"src": "static/icons/stackchain-192.png", "sizes": "192x192", "type": "image/png"}]
-    },
-    {
-      "name": "Open Agenda",
-      "short_name": "Agenda",
-      "description": "Check every assigned deadline and continue the Agenda session.",
-      "url": "./?launch=agenda",
-      "icons": [{"src": "static/icons/stackchain-192.png", "sizes": "192x192", "type": "image/png"}]
-    }
-  ],
   "share_target": {
-    "action": "./share-target",
-    "method": "POST",
-    "enctype": "multipart/form-data",
-    "params": {
-      "title": "title",
-      "text": "text",
-      "url": "url",
-      "files": [{"name": "image", "accept": ["image/png", "image/jpeg", "image/webp"]}]
-    }
+    "action": "./",
+    "method": "GET",
+    "enctype": "application/x-www-form-urlencoded",
+    "params": {"title": "title", "text": "text", "url": "url"}
   }
 }

frontend/markdown.js

@@ -13,132 +13,17 @@
     })[character]);
   }
 
-  function renderInline(value) {
-    const code = [];
-    let rendered = escapeHtml(value).replace(/`([^`\n]+)`/g, (_match, body) => {
-      const marker = '\u0000CODE' + code.length + '\u0000';
-      code.push('<code>' + body + '</code>');
-      return marker;
-    });
-    rendered = rendered
-      .replace(/\[([^\]\n]+)\]\(([^\s)]+)(?:\s+&quot;[^&]*?&quot;)?\)/g, (_match, label, escapedUrl) => {
-        const url = escapedUrl.replace(/&amp;/g, '&');
-        const safe = /^(https?:|mailto:)/i.test(url) || /^(\/|#|\.\/|\.\.\/)/.test(url);
-        if (!safe) return label;
-        return '<a href="' + escapedUrl + '" target="_blank" rel="noopener noreferrer">' + label + '</a>';
+  return function renderMarkdown(raw) {
+    return escapeHtml(raw)
+      .replace(/^#{1,6}\s.*$/gm, (line) => {
+        const level = line.match(/^(#{1,6})/)[1].length;
+        return '<h' + level + '>' + line.replace(/^#{1,6}\s/, '') + '</h' + level + '>';
       })
       .replace(/\*\*(.+?)\*\*/g, '<strong>$1</strong>')
-      .replace(/(^|[^*])\*([^*\n]+)\*/g, '$1<em>$2</em>');
-    return rendered.replace(/\u0000CODE(\d+)\u0000/g, (_match, index) => code[Number(index)]);
-  }
-
-  function renderList(lines, options, firstTaskIndex) {
-    const taskList = lines.every(line => /^[-*+]\s+\[[ xX]\]\s+/.test(line));
-    const items = lines.map((line, offset) => {
-      let body = line.replace(/^[-*+]\s+/, '');
-      if (!taskList) return '<li>' + renderInline(body) + '</li>';
-      const checked = /^\[[xX]\]\s+/.test(body);
-      body = body.replace(/^\[[ xX]\]\s+/, '');
-      const control = options.interactiveTasks ?
-        ' class="task-list-toggle" data-task-index="' + (firstTaskIndex + offset) +
-          '" aria-label="Mark ' + escapeHtml(body) + (checked ? ' incomplete"' : ' complete"') :
-        ' disabled';
-      const manage = options.interactiveTasks && options.manageTasks ?
-        '<button type="button" class="task-list-manage" data-task-index="' + (firstTaskIndex + offset) +
-          '" data-task-label="' + escapeHtml(body) + '" aria-label="Manage step: ' + escapeHtml(body) + '"' +
-          (offset === 0 ? ' data-task-first="true"' : '') +
-          (offset === lines.length - 1 ? ' data-task-last="true"' : '') + '>Manage</button>' : '';
-      return '<li class="task-list-item"><input type="checkbox"' + control +
-        (checked ? ' checked' : '') + '> ' + renderInline(body) + manage + '</li>';
-    }).join('');
-    return '<ul' + (taskList ? ' class="task-list"' : '') + '>' + items + '</ul>';
-  }
-
-  function renderMarkdown(raw, options = {}) {
-    const lines = String(raw || '').replace(/\r\n?/g, '\n').split('\n');
-    const output = [];
-    let index = 0;
-    let taskIndex = 0;
-    while (index < lines.length) {
-      const line = lines[index];
-      if (!line.trim()) {
-        index += 1;
-        continue;
-      }
-      const fence = line.match(/^```([A-Za-z0-9_-]*)\s*$/);
-      if (fence) {
-        const body = [];
-        index += 1;
-        while (index < lines.length && !/^```\s*$/.test(lines[index])) {
-          body.push(lines[index]);
-          index += 1;
-        }
-        if (index < lines.length) index += 1;
-        const language = fence[1] ? ' class="language-' + fence[1] + '"' : '';
-        output.push('<pre><code' + language + '>' + escapeHtml(body.join('\n')) + '</code></pre>');
-        continue;
-      }
-      const heading = line.match(/^(#{1,6})\s+(.+)$/);
-      if (heading) {
-        const level = heading[1].length;
-        output.push('<h' + level + '>' + renderInline(heading[2]) + '</h' + level + '>');
-        index += 1;
-        continue;
-      }
-      if (/^>\s?/.test(line)) {
-        const quote = [];
-        while (index < lines.length && /^>\s?/.test(lines[index])) {
-          quote.push(lines[index].replace(/^>\s?/, ''));
-          index += 1;
-        }
-        output.push('<blockquote><p>' + renderInline(quote.join('\n')).replace(/\n/g, '<br>') + '</p></blockquote>');
-        continue;
-      }
-      if (/^[-*+]\s+/.test(line)) {
-        const list = [];
-        while (index < lines.length && /^[-*+]\s+/.test(lines[index])) {
-          list.push(lines[index]);
-          index += 1;
-        }
-        output.push(renderList(list, options, taskIndex));
-        if (list.every(candidate => /^[-*+]\s+\[[ xX]\]\s+/.test(candidate))) {
-          taskIndex += list.length;
-        }
-        continue;
-      }
-      const paragraph = [];
-      while (index < lines.length && lines[index].trim() &&
-             !/^```/.test(lines[index]) && !/^(#{1,6})\s+/.test(lines[index]) &&
-             !/^>\s?/.test(lines[index]) && !/^[-*+]\s+/.test(lines[index])) {
-        paragraph.push(lines[index]);
-        index += 1;
-      }
-      output.push('<p>' + renderInline(paragraph.join('\n')).replace(/\n/g, '<br>') + '</p>');
-    }
-    return output.join('');
-  }
-
-  renderMarkdown.toggleTask = function toggleTask(raw, targetIndex, checked) {
-    const parts = String(raw || '').split(/(\r\n|\n|\r)/);
-    let fenced = false;
-    let taskIndex = 0;
-    for (let index = 0; index < parts.length; index += 2) {
-      const line = parts[index];
-      if (/^\s*```/.test(line)) {
-        fenced = !fenced;
-        continue;
-      }
-      if (fenced) continue;
-      const task = line.match(/^([-*+]\s+\[)([ xX])(\])/);
-      if (!task) continue;
-      if (taskIndex === Number(targetIndex)) {
-        parts[index] = task[1] + (checked ? 'x' : ' ') + task[3] + line.slice(task[0].length);
-        return parts.join('');
-      }
-      taskIndex += 1;
-    }
-    return parts.join('');
+      .replace(/\*(.+?)\*/g, '<em>$1</em>')
+      .replace(/`([^`]+)`/g, '<code>$1</code>')
+      .replace(/^-\s?(.+)$/gm, '<li>$1</li>')
+      .replace(/(<li>.*<\/li>)/s, '<ul>$1</ul>')
+      .replace(/\n/g, '<br>');
   };
-
-  return renderMarkdown;
 });

frontend/mention-composer.js

@@ -1,147 +0,0 @@
-(function(root, factory) {
-  const api = factory();
-  if (typeof module === 'object' && module.exports) module.exports = api;
-  else root.createMentionComposer = api.create;
-})(typeof globalThis !== 'undefined' ? globalThis : this, function() {
-  'use strict';
-
-  function activeMention(value, caret) {
-    const before = String(value || '').slice(0, Math.max(0, caret));
-    const match = before.match(/(^|\s)@([A-Za-z0-9_.-]{2,39})$/);
-    if (!match) return null;
-    const start = before.length - match[2].length - 1;
-    return { start, end:before.length, query:match[2] };
-  }
-
-  function insertMention(value, mention, login) {
-    const text = String(value || '');
-    const suffixStart = mention.end < text.length && /\s/.test(text[mention.end]) ? mention.end + 1 : mention.end;
-    const inserted = '@' + login + ' ';
-    return {
-      value:text.slice(0, mention.start) + inserted + text.slice(suffixStart),
-      caret:mention.start + inserted.length,
-    };
-  }
-
-  function create(options) {
-    const textarea = options.textarea;
-    const listbox = options.listbox;
-    const status = options.status;
-    const setTimer = options.setTimer || setTimeout;
-    const clearTimer = options.clearTimer || clearTimeout;
-    const createOption = options.createOption || (() => document.createElement('button'));
-    let timer = null;
-    let requestId = 0;
-    let mention = null;
-    let candidates = [];
-    let activeIndex = -1;
-
-    function dismiss() {
-      requestId += 1;
-      candidates = [];
-      activeIndex = -1;
-      listbox.replaceChildren();
-      listbox.hidden = true;
-      textarea.setAttribute('aria-expanded', 'false');
-      textarea.removeAttribute('aria-activedescendant');
-      status.textContent = '';
-    }
-
-    function activate(index) {
-      if (!candidates.length) return;
-      activeIndex = (index + candidates.length) % candidates.length;
-      listbox.children.forEach((option, optionIndex) => {
-        option.setAttribute('aria-selected', optionIndex === activeIndex ? 'true' : 'false');
-      });
-      textarea.setAttribute('aria-activedescendant', listbox.children[activeIndex].id);
-    }
-
-    function select(index) {
-      if (!mention || !candidates[index]) return;
-      const result = insertMention(textarea.value, mention, candidates[index].login);
-      textarea.value = result.value;
-      textarea.setSelectionRange(result.caret, result.caret);
-      dismiss();
-      textarea.focus();
-      textarea.dispatchEvent?.(new Event('input', { bubbles:true }));
-    }
-
-    function render(items) {
-      candidates = Array.isArray(items) ? items : [];
-      activeIndex = -1;
-      listbox.replaceChildren();
-      candidates.forEach((candidate, index) => {
-        const option = createOption();
-        option.type = 'button';
-        option.id = listbox.id + '-option-' + index;
-        option.className = 'mention-option';
-        option.dataset.login = candidate.login;
-        option.setAttribute('role', 'option');
-        option.setAttribute('aria-selected', 'false');
-        option.textContent = '@' + candidate.login + (candidate.name !== candidate.login ? ' · ' + candidate.name : '');
-        option.addEventListener('pointerdown', event => {
-          event.preventDefault();
-          select(index);
-        });
-        listbox.appendChild(option);
-      });
-      listbox.hidden = !candidates.length;
-      textarea.setAttribute('aria-expanded', candidates.length ? 'true' : 'false');
-      status.textContent = candidates.length ? candidates.length + ' teammates found.' : 'No matching teammates.';
-    }
-
-    function schedule() {
-      if (timer !== null) clearTimer(timer);
-      mention = activeMention(textarea.value, textarea.selectionStart);
-      const repository = options.getRepository();
-      if (!mention || !repository) {
-        dismiss();
-        return;
-      }
-      const currentRequest = ++requestId;
-      timer = setTimer(async () => {
-        try {
-          const items = await options.loadCandidates(repository, mention.query);
-          if (currentRequest === requestId && repository === options.getRepository()) render(items);
-        } catch (_error) {
-          if (currentRequest === requestId) {
-            listbox.hidden = true;
-            textarea.setAttribute('aria-expanded', 'false');
-            status.textContent = 'Teammate suggestions unavailable; you can keep typing.';
-          }
-        }
-      }, options.delayMs ?? 180);
-    }
-
-    function keydown(event) {
-      if (event.key === 'Escape' && !listbox.hidden) {
-        event.preventDefault();
-        dismiss();
-      } else if (event.key === 'ArrowDown' && candidates.length) {
-        event.preventDefault();
-        activate(activeIndex + 1);
-      } else if (event.key === 'ArrowUp' && candidates.length) {
-        event.preventDefault();
-        activate(activeIndex < 0 ? candidates.length - 1 : activeIndex - 1);
-      } else if (event.key === 'Enter' && activeIndex >= 0) {
-        event.preventDefault();
-        select(activeIndex);
-      }
-    }
-
-    return {
-      start() {
-        textarea.setAttribute('autocomplete', 'off');
-        textarea.setAttribute('aria-autocomplete', 'list');
-        textarea.setAttribute('aria-controls', listbox.id);
-        textarea.setAttribute('aria-expanded', 'false');
-        textarea.addEventListener('input', schedule);
-        textarea.addEventListener('click', schedule);
-        textarea.addEventListener('keydown', keydown);
-      },
-      dismiss,
-    };
-  }
-
-  return { activeMention, insertMention, create };
-});

frontend/mobile-app-badge.js

@@ -1,125 +0,0 @@
-(function(root, factory) {
-  if (typeof module === 'object' && module.exports) module.exports = factory;
-  else root.createMobileAppBadge = factory;
-})(typeof self !== 'undefined' ? self : this, function createMobileAppBadge({
-  control,
-  status,
-  container,
-  navigator,
-  storage,
-  serviceWorker,
-}) {
-  const ENABLED_KEY = 'stackchain.app-badge.enabled.v1';
-  let enabled = false;
-  const confirmedCounts = {updates:0, following:0, 'human-gates':0};
-  let renderedCount = null;
-
-
-  function available() {
-    return typeof navigator?.setAppBadge === 'function'
-      && typeof navigator?.clearAppBadge === 'function';
-  }
-
-  async function syncPreference() {
-    try {
-      const registration = await serviceWorker?.ready;
-      registration?.active?.postMessage({type:'stackchain-app-badge-preference', enabled});
-      return Boolean(registration?.active);
-    } catch (_error) {
-      return false;
-    }
-  }
-
-  async function syncCount(channel, count) {
-    if (!enabled) return;
-    try {
-      const registration = await serviceWorker?.ready;
-      registration?.active?.postMessage({type:'stackchain-app-badge-count', channel, count});
-    } catch (_error) { /* A later refresh can retry. */ }
-  }
-
-  async function render() {
-    const confirmedCount = Math.min(
-      9999, confirmedCounts.updates + confirmedCounts.following + confirmedCounts['human-gates']
-    );
-    if (!enabled || !available() || renderedCount === confirmedCount) return true;
-    try {
-      if (confirmedCount > 0) await navigator.setAppBadge(confirmedCount);
-      else await navigator.clearAppBadge();
-      renderedCount = confirmedCount;
-      if (status) status.textContent = 'App icon badge is on and up to date.';
-      return true;
-    } catch (_error) {
-      if (status) status.textContent = 'Could not update the app icon badge. Stackchain still has the confirmed count.';
-      return false;
-    }
-  }
-
-  async function change() {
-    enabled = Boolean(control?.checked);
-    if (enabled) storage?.setItem(ENABLED_KEY, 'true');
-    else storage?.removeItem(ENABLED_KEY);
-    await syncPreference();
-    if (enabled) {
-      if (confirmedCounts.updates > 0) await syncCount('updates', confirmedCounts.updates);
-      if (confirmedCounts.following > 0) await syncCount('following', confirmedCounts.following);
-      if (confirmedCounts['human-gates'] > 0) await syncCount('human-gates', confirmedCounts['human-gates']);
-    }
-    if (!enabled && available()) {
-      confirmedCounts.updates = 0;
-      confirmedCounts.following = 0;
-      confirmedCounts['human-gates'] = 0;
-      try {
-        await navigator.clearAppBadge();
-        renderedCount = null;
-        if (status) status.textContent = 'App icon badge is off.';
-        return true;
-      } catch (_error) {
-        if (status) status.textContent = 'App icon badge is off, but the browser could not clear the old count.';
-        return false;
-      }
-    }
-    return render();
-  }
-
-  function start() {
-    if (!available()) {
-      if (container) container.hidden = true;
-      if (control) control.disabled = true;
-      if (status) status.textContent = 'App icon badges are unavailable in this browser.';
-      return false;
-    }
-    enabled = storage?.getItem(ENABLED_KEY) === 'true';
-    if (enabled) void syncPreference();
-    if (control) {
-      control.checked = enabled;
-      control.addEventListener('change', change);
-    }
-    if (status) status.textContent = enabled ? 'App icon badge is on.' : 'App icon badge is off.';
-    return true;
-  }
-
-  function readiness() {
-    if (!available()) return {state:'unavailable', detail:'App icon badges are unavailable in this browser.'};
-    return enabled
-      ? {state:'complete', detail:'The app icon shows review attention.'}
-      : {state:'incomplete', detail:'Show review attention without opening Stackchain.'};
-  }
-
-  async function enable() {
-    if (!available()) return false;
-    if (control) control.checked = true;
-    await change();
-    return true;
-  }
-
-  async function reconcile(channel, count, authoritative = false) {
-    if (!Object.hasOwn(confirmedCounts, channel)
-        || authoritative !== true || !Number.isSafeInteger(count) || count < 0 || count > 9999) return false;
-    confirmedCounts[channel] = count;
-    await syncCount(channel, count);
-    return render();
-  }
-
-  return {start, change, reconcile, readiness, enable};
-});

frontend/mobile-app-shortcuts.js

@@ -1,31 +0,0 @@
-(function (root, factory) {
-  const api = factory();
-  if (typeof module === 'object' && module.exports) module.exports = api;
-  else root.mobileAppShortcuts = api;
-})(typeof self !== 'undefined' ? self : this, function () {
-  const ACTIONS = new Set(['continue', 'new', 'agenda']);
-
-  function parse(search) {
-    const action = new URLSearchParams(search || '').get('launch');
-    return ACTIONS.has(action) ? action : null;
-  }
-
-  function createController(options) {
-    const launchAction = parse(options.search);
-    let handled = false;
-
-    function action() { return launchAction; }
-
-    function run() {
-      if (!launchAction || handled) return null;
-      handled = true;
-      if (launchAction === 'continue') return options.continueWork();
-      if (launchAction === 'new') return options.newIssue();
-      return options.agenda();
-    }
-
-    return {action, run};
-  }
-
-  return {parse, createController};
-});

frontend/mobile-composer-viewport.js

@@ -1,96 +0,0 @@
-(function (root, factory) {
-  const exported = factory();
-  if (typeof module === 'object' && module.exports) module.exports = exported;
-  else root.createMobileComposerViewport = exported;
-})(typeof self !== 'undefined' ? self : this, function () {
-  return function createMobileComposerViewport(options) {
-    const entries = options.entries || [];
-    const viewport = options.viewport;
-    const mediaQuery = options.mediaQuery;
-    const documentRef = options.document || document;
-    const schedule = options.schedule || (callback => requestAnimationFrame(callback));
-    let active = null;
-    let started = false;
-
-    function reveal() {
-      if (!active) return;
-      const focused = documentRef.activeElement;
-      const target = active.focusWithin && active.workspace.contains(focused) ? focused : active.workspace;
-      target.scrollIntoView({ block:active.focusWithin ? 'nearest' : 'end', inline:'nearest' });
-    }
-
-    function applyGeometry() {
-      if (!active || !viewport || !mediaQuery.matches) return;
-      active.panel.style.setProperty('--composer-viewport-top', `${viewport.offsetTop || 0}px`);
-      active.panel.style.setProperty('--composer-viewport-height', `${viewport.height}px`);
-      reveal();
-    }
-
-    function onViewportChange() {
-      schedule(applyGeometry);
-    }
-
-    function activate(entry) {
-      if (!viewport || !mediaQuery.matches) return;
-      if (active === entry) {
-        schedule(applyGeometry);
-        return;
-      }
-      if (active) deactivate(active, false);
-      active = entry;
-      entry.scrollTop = entry.panel.scrollTop;
-      entry.panel.classList?.add('composer-keyboard-active');
-      viewport.addEventListener('resize', onViewportChange);
-      viewport.addEventListener('scroll', onViewportChange);
-      applyGeometry();
-    }
-
-    function deactivate(entry, restore = true) {
-      if (active !== entry) return;
-      viewport?.removeEventListener('resize', onViewportChange);
-      viewport?.removeEventListener('scroll', onViewportChange);
-      entry.panel.classList?.remove('composer-keyboard-active');
-      entry.panel.style.removeProperty('--composer-viewport-top');
-      entry.panel.style.removeProperty('--composer-viewport-height');
-      active = null;
-      if (restore) schedule(() => { entry.panel.scrollTop = entry.scrollTop; });
-    }
-
-    function bind(entry) {
-      entry.onFocus = () => activate(entry);
-      entry.onFocusOut = () => schedule(() => {
-        if (!entry.workspace.contains(documentRef.activeElement)) deactivate(entry);
-      });
-      entry.focusTarget = entry.focusWithin ? entry.workspace : entry.composer;
-      entry.focusEvent = entry.focusWithin ? 'focusin' : 'focus';
-      entry.focusTarget.addEventListener(entry.focusEvent, entry.onFocus);
-      entry.workspace.addEventListener('focusout', entry.onFocusOut);
-    }
-
-    function unbind(entry) {
-      entry.focusTarget.removeEventListener(entry.focusEvent, entry.onFocus);
-      entry.workspace.removeEventListener('focusout', entry.onFocusOut);
-    }
-
-    return {
-      start() {
-        if (started) return;
-        started = true;
-        entries.forEach(bind);
-      },
-      close(panel) {
-        const entry = entries.find(candidate => candidate.panel === panel);
-        if (entry) deactivate(entry, false);
-      },
-      stop() {
-        if (!started) return;
-        if (active) deactivate(active, false);
-        entries.forEach(unbind);
-        started = false;
-      },
-      revealActive() {
-        schedule(applyGeometry);
-      },
-    };
-  };
-});

frontend/mobile-create-issue-nav.js

@@ -1,122 +0,0 @@
-function createMobileCreateIssueNavigation(options) {
-  const buttons = options.buttons || {};
-  const targets = options.targets || {};
-  const listeners = new Map();
-  const prefersReducedMotion = options.prefersReducedMotion || (() => false);
-  const targetNames = new Map(Object.entries(targets).map(([name, target]) => [target, name]));
-  let filingAvailable = !options.filing?.hidden;
-  let observer = null;
-  let navigationLockUntil = 0;
-
-  function select(name) {
-    Object.entries(buttons).forEach(([key, button]) => {
-      if (!button) return;
-      if (key === name) button.setAttribute('aria-current', 'location');
-      else button.removeAttribute('aria-current');
-    });
-  }
-
-  function setFilingAvailable(available) {
-    filingAvailable = Boolean(available);
-    const button = buttons.file;
-    if (!button) return;
-    if (filingAvailable) button.removeAttribute('aria-disabled');
-    else button.setAttribute('aria-disabled', 'true');
-  }
-
-  function navigate(name) {
-    if (name === 'file') setFilingAvailable(!options.filing?.hidden);
-    if (name === 'file' && !filingAvailable) return false;
-    const target = targets[name];
-    if (!target) return false;
-    target.scrollIntoView({
-      block: 'start',
-      behavior: prefersReducedMotion() ? 'auto' : 'smooth',
-    });
-    navigationLockUntil = Date.now() + 500;
-    select(name);
-    return true;
-  }
-
-  function reset(available = !options.filing?.hidden) {
-    setFilingAvailable(available);
-    select('describe');
-  }
-
-  return {
-    start() {
-      Object.entries(buttons).forEach(([name, button]) => {
-        if (!button || listeners.has(button)) return;
-        const listener = event => {
-          event.preventDefault();
-          navigate(name);
-        };
-        listeners.set(button, listener);
-        button.addEventListener('click', listener);
-      });
-      reset();
-      const observe = options.observe || ((handler, observedTargets, root) => {
-        if (typeof IntersectionObserver === 'undefined') return null;
-        const instance = new IntersectionObserver(handler, {
-          root,
-          rootMargin: '-20% 0px -60% 0px',
-          threshold: [0, 0.25, 0.5, 0.75, 1],
-        });
-        observedTargets.forEach(target => instance.observe(target));
-        return instance;
-      });
-      observer = observe(entries => {
-        if (Date.now() < navigationLockUntil) return;
-        const visible = entries
-          .filter(entry => entry.isIntersecting && targetNames.has(entry.target))
-          .filter(entry => targetNames.get(entry.target) !== 'file' || filingAvailable)
-          .sort((left, right) => right.intersectionRatio - left.intersectionRatio)[0];
-        if (visible) select(targetNames.get(visible.target));
-      }, Array.from(targetNames.keys()).filter(Boolean), options.root || null);
-    },
-    stop() {
-      listeners.forEach((listener, button) => button.removeEventListener('click', listener));
-      listeners.clear();
-      if (observer) observer.disconnect();
-      observer = null;
-    },
-    navigate,
-    reset,
-    select,
-    setFilingAvailable,
-  };
-}
-
-function attachMobileCreateIssueNavigation({ document, window }) {
-  const bySection = name => document.querySelector('[data-create-issue-section="' + name + '"]');
-  const filing = document.getElementById('create-issue-filing');
-  const sheet = document.getElementById('create-issue-sheet');
-  const navigation = createMobileCreateIssueNavigation({
-    root:document.querySelector('.create-issue-panel'),
-    buttons:{describe:bySection('describe'), evidence:bySection('evidence'), file:bySection('file')},
-    targets:{
-      describe:document.getElementById('create-issue-describe'),
-      evidence:document.getElementById('create-issue-evidence'),
-      file:filing,
-    },
-    filing,
-    prefersReducedMotion:() => window.matchMedia('(prefers-reduced-motion: reduce)').matches,
-  });
-  navigation.start();
-  document.getElementById('file-new-issue').addEventListener('click', () => {
-    setTimeout(() => navigation.navigate('file'), 0);
-  });
-  new MutationObserver(() => {
-    navigation.setFilingAvailable(!filing.hidden);
-    if (!filing.hidden && sheet.classList.contains('open')) navigation.navigate('file');
-  }).observe(filing, {attributes:true, attributeFilter:['hidden']});
-  new MutationObserver(() => {
-    if (sheet.classList.contains('open')) navigation.reset(!filing.hidden);
-  }).observe(sheet, {
-    attributes:true, attributeFilter:['class'],
-  });
-  return navigation;
-}
-
-if (typeof module !== 'undefined') module.exports = createMobileCreateIssueNavigation;
-else attachMobileCreateIssueNavigation({document, window});

frontend/mobile-delivery-recovery.js

@@ -1,156 +0,0 @@
-(function (root, factory) {
-  if (typeof module === 'object' && module.exports) module.exports = factory;
-  else root.createMobileDeliveryRecovery = factory;
-})(typeof self !== 'undefined' ? self : this, function createMobileDeliveryRecovery(options) {
-  const byId = id => typeof document === 'undefined' ? null : document.getElementById(id);
-  const elements = options.elements || (typeof document === 'undefined' ? null : {
-    dialog: byId('mobile-delivery-recovery'), close: byId('close-mobile-delivery-recovery'),
-    title: byId('mobile-delivery-recovery-title'), destination: byId('mobile-delivery-recovery-destination'),
-    reason: byId('mobile-delivery-recovery-reason'), progress: byId('mobile-delivery-recovery-progress'),
-    action: byId('mobile-delivery-recovery-action'), status: byId('mobile-delivery-recovery-status'),
-  });
-  const priority = {authorization: 0, attention: 1, uncertain: 2, waiting: 3};
-
-  function identity(item) {
-    return String(item?.outbox_id || item?.id || '');
-  }
-
-  function state(item) {
-    if (item?.status === 'authorization') return 'authorization';
-    if (item?.status === 'attention' || item?.checklist_conflict || item?.quarantined) return 'attention';
-    if (item?.delivery_state === 'uncertain') return 'uncertain';
-    return 'waiting';
-  }
-
-  function primary(item) {
-    const kind = state(item);
-    if (kind === 'authorization') {
-      return item?.outbox_kind === 'issue-close' ? 'Authorize & close' : 'Authorize & send';
-    }
-    if (item?.checklist_conflict) return 'Review changes';
-    if (kind === 'attention') return item?.quarantined ? 'Copy content' : 'Open current item';
-    if (kind === 'uncertain') return 'Verified not posted — retry';
-    return 'Retry now';
-  }
-
-  function ordered() {
-    return [...(options.getItems ? options.getItems() : [])].sort((left, right) => {
-      const byState = priority[state(left)] - priority[state(right)];
-      if (byState) return byState;
-      return identity(left).localeCompare(identity(right));
-    });
-  }
-
-  const stateLabels = {
-    authorization: 'Authorization required',
-    attention: 'Needs attention',
-    uncertain: 'Delivery uncertain',
-    waiting: 'Ready to retry',
-  };
-  let currentId = '';
-  let active = false;
-  let inFlight = null;
-
-  function currentItem(items) {
-    return items.find(item => identity(item) === currentId) || items[0];
-  }
-
-  function snapshot() {
-    const items = ordered();
-    const item = currentItem(items);
-    if (item) currentId = identity(item);
-    else currentId = '';
-    const index = item ? items.indexOf(item) : -1;
-    return {
-      count: items.length,
-      current: item ? {
-        id: identity(item),
-        state: state(item),
-        primary: primary(item),
-        position: index + 1,
-        total: items.length,
-      } : null,
-    };
-  }
-
-  function render() {
-    const result = snapshot();
-    if (!elements) return result;
-    const items = ordered();
-    const item = currentItem(items);
-    if (!item) {
-      if (active) {
-        active = false;
-        if (elements.dialog?.open) elements.dialog.close();
-        if (options.onComplete) options.onComplete();
-      }
-      return result;
-    }
-    elements.title.textContent = item.title || 'Queued delivery';
-    elements.destination.textContent = [item.repository, item.details].filter(Boolean).join(' · ') || 'Saved delivery';
-    elements.reason.textContent = item.last_attempt_error || item.ownership || stateLabels[state(item)];
-    elements.progress.textContent = 'Delivery ' + result.current.position + ' of ' + result.current.total + ' · ' + stateLabels[state(item)];
-    elements.action.textContent = primary(item);
-    if (elements.status) elements.status.textContent = '';
-    return result;
-  }
-
-  function open() {
-    const queue = byId('mobile-queue-sheet');
-    if (queue?.open) queue.close();
-    if (options.beforeOpen) options.beforeOpen();
-    currentId = '';
-    const result = snapshot();
-    if (!result.current) return 'empty';
-    active = true;
-    render();
-    if (elements?.dialog && !elements.dialog.open) elements.dialog.showModal();
-    return 'opened';
-  }
-
-  async function attend(item) {
-    const index = options.getIndex ? options.getIndex(item) : -1;
-    const selector = item.quarantined ? '.draft-copy' :
-      item.checklist_conflict ? '.draft-review-checklist' : '.draft-resume';
-    const action = document.querySelector('#my-work-list ' + selector + '[data-draft-index="' + index + '"]');
-    if (!action) throw new Error('Delivery changed.');
-    elements.dialog.close();
-    action.scrollIntoView();
-    action.focus();
-    return await action.onclick();
-  }
-
-  function activate() {
-    if (inFlight) return inFlight;
-    const items = ordered();
-    const item = currentItem(items);
-    const perform = state(item) === 'attention' ? attend : options.activate;
-    if (!item) return Promise.resolve(render());
-    if (elements?.action) elements.action.disabled = true;
-    if (elements?.status) elements.status.textContent = 'Working…';
-    inFlight = (async () => {
-      let failure = null;
-      try {
-        await perform(item, state(item));
-      } catch (error) {
-        failure = String(error?.message || 'Delivery could not be completed.').trim().slice(0, 160);
-      } finally {
-        if (elements?.action) elements.action.disabled = false;
-      }
-      const result = render();
-      if (failure && elements?.status) {
-        if (active && !elements.dialog.open) elements.dialog.showModal();
-        elements.status.textContent = failure + ' Try again.';
-      }
-      return result;
-    })().finally(() => { inFlight = null; });
-    return inFlight;
-  }
-
-  function start() {
-    if (elements?.action?.addEventListener) elements.action.addEventListener('click', activate);
-    if (elements?.close?.addEventListener) elements.close.addEventListener('click', () => elements.dialog.close());
-  }
-
-  return {activate, open, render, snapshot, start};
-});

frontend/mobile-device-setup.js

@@ -1,209 +0,0 @@
-(function (root, factory) {
-  if (typeof module === 'object' && module.exports) module.exports = factory;
-  else root.createMobileDeviceSetup = factory;
-})(typeof self !== 'undefined' ? self : this, function createMobileDeviceSetup(options) {
-  const promptDismissKey = 'stackchain.device-setup-prompt-dismissed-until';
-  const promptDismissMs = 7 * 24 * 60 * 60 * 1000;
-  const steps = [
-    ['install', options.installButton, options.installStatus, options.install, 'Install'],
-    ['offline', options.offlineButton, options.offlineStatus, options.enableOffline, 'Enable'],
-    ['protection', options.protectionButton, options.protectionStatus, options.protectStorage, 'Protect'],
-    ['push', options.pushButton, options.pushStatus, options.enablePush, 'Enable'],
-    ['appBadge', options.appBadgeButton, options.appBadgeStatus, options.enableAppBadge, 'Enable'],
-    ['deadline', options.deadlineButton, options.deadlineStatus, options.enableDeadline, 'Enable'],
-  ].filter(([_name, button, status, action]) => button && status && action);
-  let trigger = options.launcher;
-  let ownsDetour = false;
-  let backgroundInert = null;
-  let pendingResume = true;
-
-  function focusableControls() {
-    return [...options.sheet.querySelectorAll(
-      'button:not([disabled]), select:not([disabled]), input:not([disabled]), textarea:not([disabled]), [tabindex]:not([tabindex="-1"])'
-    )].filter(control => !control.hidden);
-  }
-
-  function containBackground() {
-    if (backgroundInert) return;
-    backgroundInert = new Map((options.backgroundElements || []).map(element => [element, element.inert]));
-    backgroundInert.forEach((_wasInert, element) => { element.inert = true; });
-  }
-
-  function releaseBackground() {
-    if (!backgroundInert) return;
-    backgroundInert.forEach((wasInert, element) => { element.inert = wasInert; });
-    backgroundInert = null;
-  }
-
-  function readinessCounts(readiness) {
-    const available = steps.filter(([name]) => readiness[name].state !== 'unavailable').length;
-    const complete = steps.filter(([name]) => readiness[name].state === 'complete').length;
-    return {available, complete};
-  }
-
-  function renderPrompt(readiness) {
-    if (!options.promptCard) return;
-    const {available, complete} = readinessCounts(readiness);
-    let dismissed = false;
-    try {
-      dismissed = Number(options.promptStorage?.getItem(promptDismissKey) || 0) > (options.now?.() ?? Date.now());
-    } catch (_error) {}
-    options.promptSummary.textContent = `${complete} of ${available} steps complete`;
-    options.promptCard.hidden = dismissed || available === 0 || complete === available;
-  }
-
-  async function render() {
-    const readiness = await options.getReadiness();
-    let available = 0;
-    let complete = 0;
-    steps.forEach(([name, button, status, _action, defaultActionLabel]) => {
-      const step = readiness[name];
-      status.textContent = step.detail;
-      button.textContent = step.actionLabel || defaultActionLabel;
-      button.hidden = step.state === 'complete' || step.state === 'unavailable';
-      button.disabled = step.state === 'pending';
-      if (step.state !== 'unavailable') available += 1;
-      if (step.state === 'complete') complete += 1;
-    });
-    options.readyStatus.textContent = complete === available
-      ? 'This device is ready.'
-      : `${complete} of ${available} available steps ready.`;
-    renderPrompt(readiness);
-    return readiness;
-  }
-
-  async function open(event) {
-    trigger = event?.currentTarget || options.launcher;
-    if (options.isMobile?.()) {
-      ownsDetour = options.timerView?.beginDetour?.('device-setup')?.reason === 'device-setup';
-    }
-    await render();
-    containBackground();
-    options.sheet.hidden = false;
-    if (options.history && !options.history.state?.deviceSetup) {
-      options.history.pushState({...options.history.state, deviceSetup:true}, '');
-    }
-    options.closeButton.focus();
-  }
-
-  function finishClose(resume = true) {
-    options.sheet.hidden = true;
-    releaseBackground();
-    if (resume && ownsDetour) options.timerView?.finishDetour?.();
-    ownsDetour = false;
-    trigger?.focus?.();
-  }
-
-  function close(resume = true) {
-    if (options.history?.state?.deviceSetup) {
-      pendingResume = resume;
-      options.history.back();
-      return;
-    }
-    finishClose(resume);
-  }
-
-  async function start() {
-    options.launcher.addEventListener('click', open);
-    options.promptLauncher?.addEventListener('click', open);
-    options.promptDismiss?.addEventListener('click', () => {
-      try {
-        options.promptStorage?.setItem(promptDismissKey, String((options.now?.() ?? Date.now()) + promptDismissMs));
-      } catch (_error) {}
-      options.promptCard.hidden = true;
-    });
-    options.closeButton.addEventListener('click', close);
-    options.returnButton?.addEventListener('click', () => close(false));
-    options.sheet.addEventListener('click', event => {
-      if (event.target === options.sheet) close();
-    });
-    options.escapeTarget.addEventListener('keydown', event => {
-      if (event.key === 'Escape' && !options.sheet.hidden) {
-        event.preventDefault?.();
-        close();
-      }
-      if (event.key !== 'Tab' || options.sheet.hidden) return;
-      const controls = focusableControls();
-      if (!controls.length) return;
-      const first = controls[0];
-      const last = controls[controls.length - 1];
-      if (event.shiftKey && event.target === first) {
-        event.preventDefault();
-        last.focus();
-      } else if (!event.shiftKey && event.target === last) {
-        event.preventDefault();
-        first.focus();
-      }
-    });
-    options.historyTarget?.addEventListener('popstate', event => {
-      if (!options.sheet.hidden && !event.state?.deviceSetup) {
-        finishClose(pendingResume);
-        pendingResume = true;
-      }
-    });
-    steps.forEach(([_name, button, _status, action]) => {
-      button.addEventListener('click', async () => {
-        button.disabled = true;
-        try { await action(); }
-        finally { await render(); }
-      });
-    });
-    renderPrompt(await options.getReadiness());
-  }
-
-  return {start, open, close, render};
-});
-
-if (typeof module === 'object' && module.exports) {
-  module.exports.mount = mountMobileDeviceSetup;
-} else {
-  self.createMobileDeviceSetup.mount = mountMobileDeviceSetup;
-}
-
-function mountMobileDeviceSetup(options) {
-  const qs = selector => options.document.querySelector(selector);
-  const window = options.window || options.document.defaultView;
-  return createMobileDeviceSetup({
-    launcher:qs('#open-device-setup'), closeButton:qs('#close-device-setup'),
-    sheet:qs('#device-setup-sheet'), installButton:qs('#device-setup-install'),
-    offlineButton:qs('#device-setup-offline'), pushButton:qs('#device-setup-push'),
-    protectionButton:qs('#device-setup-protection'),
-    appBadgeButton:qs('#device-setup-app-badge'),
-    deadlineButton:qs('#device-setup-deadline'),
-    installStatus:qs('#device-setup-install-status'), offlineStatus:qs('#device-setup-offline-status'),
-    protectionStatus:qs('#device-setup-protection-status'),
-    pushStatus:qs('#device-setup-push-status'), deadlineStatus:qs('#device-setup-deadline-status'),
-    appBadgeStatus:qs('#device-setup-app-badge-status'),
-    readyStatus:qs('#device-setup-ready-status'),
-    promptCard:qs('#device-readiness-card'), promptSummary:qs('#device-readiness-summary'),
-    promptLauncher:qs('#finish-device-setup'), promptDismiss:qs('#dismiss-device-readiness'),
-    promptStorage:options.promptStorage,
-    returnButton:qs('#return-from-device-setup'),
-    timerView:options.timerView,
-    isMobile:options.isMobile || (() => innerWidth <= 600),
-    escapeTarget:options.document,
-    history:window?.history,
-    historyTarget:window,
-    backgroundElements:[
-      qs('header'), qs('main'), qs('#mobile-task-dock'),
-    ].filter(Boolean),
-    getReadiness:() => ({
-      install:options.installApp.state(),
-      offline:!options.offlineAvailable()
-        ? {state:'unavailable', detail:'Offline saving is unavailable in this browser.'}
-        : options.offlineEnabled()
-          ? {state:'complete', detail:qs('#offline-work-status').textContent || 'Offline work is saved.'}
-          : {state:'incomplete', detail:'Private My Work and Today data are not saved offline.'},
-      protection:options.storageProtectionReadiness(),
-      push:options.notificationReadiness(),
-      appBadge:options.appBadgeReadiness(),
-      deadline:options.deadlineReadiness(),
-    }),
-    install:() => options.installApp.install(),
-    enableOffline:options.enableOffline,
-    protectStorage:options.protectStorage,
-    enablePush:options.enablePush,
-    enableAppBadge:options.enableAppBadge,
-    enableDeadline:options.enableDeadline,
-  });
-}

frontend/mobile-find-work-nav.js

@@ -1,194 +0,0 @@
-(function (root, factory) {
-  const api = factory();
-  if (typeof module === 'object' && module.exports) module.exports = api;
-  else root.createMobileFindWorkNavigation = api;
-})(typeof globalThis !== 'undefined' ? globalThis : this, function () {
-  'use strict';
-
-  const stages = ['discover', 'review', 'fit'];
-
-  return function createMobileFindWorkNavigation(options) {
-    const document = options.document;
-    const buttons = options.buttons || Object.fromEntries(stages.map(name =>
-      [name, document?.querySelector('[data-find-work-stage="' + name + '"]')]
-    ));
-    const sections = options.sections || Object.fromEntries(stages.map(name =>
-      [name, document?.getElementById('find-work-' + name + '-stage')]
-    ));
-    const history = options.history;
-    const eventTarget = options.eventTarget;
-    const onStageChange = options.onStageChange || (() => {});
-    const listeners = new Map();
-    let current = 'discover';
-    let selectedCount = 0;
-    let recovery = false;
-    let started = false;
-
-    function escape(value) {
-      return String(value || '').replace(/[&<>"']/g, character =>
-        ({ '&':'&amp;', '<':'&lt;', '>':'&gt;', '"':'&quot;', "'":'&#39;' })[character]
-      );
-    }
-
-    function renderReview() {
-      const reviewList = options.reviewList || document?.getElementById('find-work-review-list');
-      const reviewSummary = options.reviewSummary || document?.getElementById('find-work-review-summary');
-      if (!reviewList) return;
-      const items = options.controller?.selectedItems?.() || options.getSelectedItems?.() || [];
-      const planning = options.todayWork?.planning?.();
-      const today = options.todayWork ? {
-        limit:options.todayWork.limit, count:options.todayWork.read().length,
-        capacityMinutes:planning.capacity_minutes, estimates:planning.estimates,
-      } : options.getTodayState?.() || {};
-      const remainingSlots = Math.max(0, (Number(today.limit) || 0) - (Number(today.count) || 0));
-      const planned = Object.values(today.estimates || {}).reduce((sum, minutes) => sum + minutes, 0);
-      const remainingMinutes = today.capacityMinutes === null || today.capacityMinutes === undefined ? null :
-        Math.max(0, today.capacityMinutes - planned);
-      const formatMinutes = minutes => [Math.floor(minutes / 60) ? Math.floor(minutes / 60) + 'h' : '',
-        minutes % 60 ? minutes % 60 + 'm' : ''].filter(Boolean).join(' ') || '0m';
-      if (reviewSummary) reviewSummary.textContent = items.length + ' selected · ' + remainingSlots +
-        ' Today slot' + (remainingSlots === 1 ? '' : 's') + ' open' +
-        (remainingMinutes === null ? '' : ' · ' + formatMinutes(remainingMinutes) + ' available') + '.';
-      reviewList.innerHTML = items.map(item => {
-        const id = String(item.repository || '') + '#' + String(item.number || '');
-        return '<article class="find-work-review-item"><div><span class="small">' + escape(id) +
-          '</span><strong>' + escape(item.title || 'Untitled work') + '</strong></div>' +
-          '<button type="button" data-find-work-review-remove="' + escape(id) + '">Remove</button></article>';
-      }).join('');
-      reviewList.querySelectorAll('[data-find-work-review-remove]').forEach(button =>
-        button.addEventListener('click', () => {
-          const item = items.find(candidate => String(candidate.repository || '') + '#' +
-            String(candidate.number || '') === button.dataset.findWorkReviewRemove);
-          if (item) (options.controller?.toggleSelection || options.toggleSelection)?.(item);
-        })
-      );
-    }
-
-    function allowed(name) {
-      return stages.includes(name) && (name === 'discover' || selectedCount > 0 || recovery);
-    }
-
-    function paint(name, focus = false, notify = true) {
-      if (!allowed(name)) name = 'discover';
-      current = name;
-      stages.forEach(stage => {
-        const button = buttons[stage];
-        const section = sections[stage];
-        if (button) {
-          button.disabled = stage !== 'discover' && selectedCount === 0 && !recovery;
-          if (stage === name) button.setAttribute('aria-current', 'step');
-          else button.removeAttribute('aria-current');
-        }
-        if (section) section.hidden = stage !== name;
-      });
-      if (name === 'review') renderReview();
-      if (name === 'fit') options.openFit?.(options.controller?.selectedItems?.() || []);
-      if (notify) onStageChange(name);
-      if (focus) sections[name]?.focus?.();
-      return name;
-    }
-
-    function stateFor(name) {
-      const state = { ...(history?.state || {}) };
-      if (name === 'discover') delete state.findWorkStage;
-      else state.findWorkStage = name;
-      return state;
-    }
-
-    function go(name) {
-      if (!allowed(name) || name === current) return false;
-      const currentIndex = stages.indexOf(current);
-      const nextIndex = stages.indexOf(name);
-      if (nextIndex < currentIndex && history?.go) {
-        history.go(nextIndex - currentIndex);
-        return true;
-      }
-      if (nextIndex === currentIndex - 1 && history?.back) {
-        history.back();
-        return true;
-      }
-      history?.pushState?.(stateFor(name), '');
-      paint(name, true);
-      return true;
-    }
-
-    function onPopState(event) {
-      if (event.state?.taskOverlay !== 'find') return;
-      paint(event.state?.findWorkStage || 'discover', true);
-    }
-
-    function sync(state = {}) {
-      selectedCount = Math.max(0, Number(state.selectedCount) || 0);
-      recovery = state.recovery === true;
-      if (!allowed(current)) paint('discover');
-      else paint(current, false, false);
-    }
-
-    function open(hasRecovery) {
-      if (options.controller) {
-        selectedCount = options.controller.selection().count;
-        recovery = hasRecovery === true;
-      }
-      const restored = history?.state?.taskOverlay === 'find' ? history.state.findWorkStage : null;
-      return paint(allowed(restored) ? restored : 'discover');
-    }
-
-    function complete() {
-      selectedCount = 0;
-      recovery = false;
-      history?.replaceState?.(stateFor('discover'), '');
-      return paint('discover');
-    }
-
-    function back() {
-      if (current === 'discover') return false;
-      history?.back?.();
-      return true;
-    }
-
-    return {
-      start() {
-        if (started) return;
-        started = true;
-        stages.forEach(name => {
-          const button = buttons[name];
-          if (!button) return;
-          const listener = event => { event.preventDefault(); go(name); };
-          listeners.set(button, listener);
-          button.addEventListener('click', listener);
-        });
-        if (document) {
-          const bind = (id, action) => {
-            const button = document.getElementById(id);
-            if (!button) return;
-            const listener = event => { event.preventDefault(); action(); };
-            listeners.set(button, listener);
-            button.addEventListener('click', listener);
-          };
-          bind('select-find-work', () => { complete(); options.controller?.startSelection?.(); });
-          bind('cancel-find-work-selection', () => { complete(); options.controller?.cancelSelection?.(); });
-          bind('claim-selected-work', () => go('review'));
-          bind('continue-find-work-fit', () => go('fit'));
-          bind('back-find-work-discover', back);
-          bind('cancel-find-work-estimates', back);
-          bind('close-find-work', () => history?.go?.(-(stages.indexOf(current) + 1)));
-        }
-        eventTarget?.addEventListener?.('popstate', onPopState);
-        paint('discover');
-      },
-      stop() {
-        listeners.forEach((listener, button) => button.removeEventListener('click', listener));
-        listeners.clear();
-        eventTarget?.removeEventListener?.('popstate', onPopState);
-        started = false;
-      },
-      sync,
-      open,
-      go,
-      back,
-      complete,
-      renderReview,
-      stage: () => current,
-    };
-  };
-});

frontend/mobile-first-task.js

@@ -1,136 +0,0 @@
-(function (root, factory) {
-  if (typeof module === 'object' && module.exports) module.exports = factory;
-  else root.createMobileFirstTask = factory;
-})(typeof self !== 'undefined' ? self : this, function createMobileFirstTask(options) {
-  const doc = typeof document !== 'undefined' ? document : null;
-  const win = typeof window !== 'undefined' ? window : null;
-  options = Object.assign({
-    storage: typeof localStorage !== 'undefined' ? localStorage : null,
-    isOnline: () => typeof navigator === 'undefined' || navigator.onLine,
-    mediaQuery: win?.matchMedia('(max-width: 600px)') || {matches:false},
-    eventTarget: win,
-    setTimer: (...args) => globalThis.setTimeout(...args),
-    sheet: doc?.querySelector('#mobile-first-task'),
-    title: doc?.querySelector('#mobile-first-task-title'),
-    findButton: doc?.querySelector('#mobile-first-task-find'),
-    createButton: doc?.querySelector('#mobile-first-task-create'),
-    setupButton: doc?.querySelector('#mobile-first-task-setup'),
-    closeButton: doc?.querySelector('#close-mobile-first-task'),
-    status: doc?.querySelector('#mobile-first-task-status'),
-    coach: doc?.querySelector('[data-mobile-first-task-coach]'),
-    receipt: doc?.querySelector('#mobile-first-task-receipt'),
-    isTodayActive: () => false,
-    onFind: () => doc?.querySelector('#find-work')?.click(),
-    onCreate: () => doc?.querySelector('#new-issue')?.click(),
-    onSetup: () => doc?.querySelector('#open-device-setup')?.click(),
-  }, options);
-  const prefix = 'stackchain.first-task.v1:';
-
-  function account() {
-    return String(options.getLogin?.() || '').trim().toLowerCase();
-  }
-
-  function key() {
-    const login = account();
-    return login ? prefix + login : '';
-  }
-
-  function state() {
-    const currentKey = key();
-    if (!currentKey) return '';
-    try { return options.storage.getItem(currentKey) || ''; }
-    catch (_error) { return ''; }
-  }
-
-  function store(value) {
-    const currentKey = key();
-    const current = state();
-    if (!currentKey || current === value || current === 'complete') return false;
-    try {
-      options.storage.setItem(currentKey, value);
-      return true;
-    } catch (_error) { return false; }
-  }
-
-  function adoptRemote(value) {
-    return ['coaching', 'complete'].includes(value) && store(value);
-  }
-
-  function required() {
-    return Boolean(options.mediaQuery.matches && account() && !options.isTodayActive() && !state());
-  }
-
-  function renderCoach() {
-    if (!options.coach) return;
-    const visible = options.mediaQuery.matches && state() === 'coaching' && options.isTodayActive();
-    options.coach.hidden = !visible;
-    const host = options.coach.closest?.('[data-mobile-today-hud]');
-    if (visible && host) host.hidden = false;
-  }
-
-  function render() {
-    const online = options.isOnline();
-    const awaitingStart = options.hasWork();
-    options.findButton.disabled = !online;
-    if (options.title) options.title.textContent = awaitingStart ? 'Finish starting your first task' : 'Start your first task';
-    options.findButton.textContent = 'Find & start';
-    options.createButton.textContent = 'Create & start';
-    options.status.textContent = awaitingStart ?
-      'Your task is ready. Start it from Find or create and start another task.' : online ?
-      'Choose a task to claim and start, or create and start one of your own.' :
-      'You are offline. Create a task now and it will stay in Drafts until you reconnect.';
-  }
-
-  function open() {
-    if (!required()) return false;
-    render();
-    if (!options.sheet.open) options.sheet.showModal();
-    (options.findButton.disabled ? options.createButton : options.findButton).focus();
-    return true;
-  }
-
-  function refresh() {
-    if (account() && options.isTodayActive() && state() !== 'complete') {
-      store('coaching');
-      if (options.sheet.open) options.sheet.close();
-      renderCoach();
-      return 'coaching';
-    }
-    renderCoach();
-    if (options.sheet.open) render();
-    if (required() && options.hasWork()) return 'awaiting-start';
-    return required() ? 'required' : 'inactive';
-  }
-
-  function completeOutcome() {
-    if (state() !== 'coaching') return false;
-    store('complete');
-    options.eventTarget?.dispatchEvent?.(new CustomEvent('stackchain:first-task-complete'));
-    renderCoach();
-    if (options.receipt) {
-      options.receipt.hidden = false;
-      options.setTimer?.(() => { options.receipt.hidden = true; }, 6000);
-    }
-    return true;
-  }
-
-  function handoff(callback, requiresOnline = false) {
-    if (requiresOnline && !options.isOnline()) return;
-    if (options.sheet.open) options.sheet.close();
-    callback();
-  }
-
-  function start() {
-    options.findButton.addEventListener('click', () => handoff(options.onFind, true));
-    options.createButton.addEventListener('click', () => handoff(options.onCreate));
-    options.setupButton.addEventListener('click', () => handoff(options.onSetup));
-    options.closeButton.addEventListener('click', () => {
-      if (options.sheet.open) options.sheet.close();
-    });
-    options.eventTarget?.addEventListener('online', render);
-    options.eventTarget?.addEventListener('offline', render);
-  }
-
-  globalThis.stackchainFirstTaskCompleting = () => state() === 'coaching';
-  return {required, open, refresh, render, start, completeOutcome, adoptRemote};
-});

frontend/mobile-insights.js

@@ -1,110 +0,0 @@
-(function (root, factory) {
-  if (typeof module === 'object' && module.exports) module.exports = factory;
-  else root.createMobileInsights = factory;
-})(typeof self !== 'undefined' ? self : this, function (o) {
-  const route = '#/insights';
-  const events = o.eventTarget || self;
-  const location = o.location || self.location;
-  let active = false;
-  let previous = '#/my-work';
-  let retries = 0;
-  let backgroundInert = null;
-
-  function attr(element, name, value) {
-    if (value === null) element.removeAttribute(name);
-    else element.setAttribute(name, value);
-  }
-
-  function containBackground() {
-    if (backgroundInert) return;
-    backgroundInert = new Map(o.backgrounds.map(element => [element, element.inert]));
-    backgroundInert.forEach((_wasInert, element) => { element.inert = true; });
-  }
-
-  function releaseBackground() {
-    if (!backgroundInert) return;
-    backgroundInert.forEach((wasInert, element) => { element.inert = wasInert; });
-    backgroundInert = null;
-  }
-
-  function render(open, focus = false) {
-    const wasActive = active;
-    active = Boolean(open && o.mediaQuery.matches);
-    const detour = active ? o.detour?.() : null;
-    const started = detour?.beginDetour('insights');
-    if (detour && !started && retries++ < 40) setTimeout(sync, 250);
-    else if (started && retries) { retries = 0; setTimeout(sync, 500); }
-    else retries = 0;
-    if (wasActive && !active) o.detour?.()?.finishDetour();
-    attr(o.root, 'data-mobile-open', active ? 'true' : null);
-    attr(o.root, 'role', active ? 'dialog' : null);
-    attr(o.root, 'aria-modal', active ? 'true' : null);
-    attr(o.root, 'aria-hidden', active || !o.mediaQuery.matches ? null : 'true');
-    o.root.inert = !active && o.mediaQuery.matches;
-    if (active) containBackground();
-    else releaseBackground();
-    o.dock.hidden = active;
-    attr(o.hud, 'data-overlay-hidden', active ? 'true' : null);
-    if (active) o.closeButton.focus();
-    else if (focus) o.launcher.focus();
-  }
-
-  function url(hash) {
-    return (location.pathname || '') + (location.search || '') + hash;
-  }
-
-  function open() {
-    if (!o.mediaQuery.matches || active) return false;
-    previous = location.hash && location.hash !== route ? location.hash : '#/my-work';
-    const menu = o.menu || o.launcher.closest?.('details');
-    if (menu) menu.open = false;
-    o.history.pushState({ ...(o.history.state || {}), mobileInsights:true, previousHash:previous }, '', url(route));
-    render(true);
-    return true;
-  }
-
-  function sync() {
-    render(location.hash === route, active && location.hash !== route);
-  }
-
-  function close() {
-    if (!active) return false;
-    if (o.history.state?.mobileInsights) o.history.back();
-    else {
-      const state = { ...(o.history.state || {}) };
-      delete state.mobileInsights;
-      delete state.previousHash;
-      o.history.replaceState(state, '', url(previous));
-      render(false, true);
-    }
-    return true;
-  }
-
-  function returnToToday() {
-    if (!active) return false;
-    const state = { ...(o.history.state || {}) };
-    delete state.mobileInsights;
-    delete state.previousHash;
-    o.history.replaceState(state, '', url(previous));
-    render(false);
-    return true;
-  }
-
-  function start() {
-    o.launcher.addEventListener('click', open);
-    o.closeButton.addEventListener('click', close);
-    (o.returnButton || o.root.querySelector?.('[data-return-from-detour]'))?.addEventListener('click', returnToToday);
-    events.addEventListener('popstate', sync);
-    events.addEventListener('hashchange', sync);
-    events.addEventListener('keydown', event => {
-      if (active && event.key === 'Escape') {
-        event.preventDefault?.();
-        close();
-      }
-    });
-    o.mediaQuery.addEventListener?.('change', sync);
-    sync();
-  }
-
-  return { start, open, close, sync, current:() => active };
-});

frontend/mobile-issue-detail-nav.js

@@ -1,77 +0,0 @@
-function createMobileIssueDetailNavigation(options) {
-  const buttons = options.buttons || {};
-  const targets = options.targets || {};
-  const listeners = new Map();
-  const prefersReducedMotion = options.prefersReducedMotion || (() => false);
-  const targetNames = new Map(Object.entries(targets).map(([name, target]) => [target, name]));
-  let observer = null;
-
-  function select(name) {
-    Object.entries(buttons).forEach(([key, button]) => {
-      if (!button) return;
-      if (key === name) button.setAttribute('aria-current', 'location');
-      else button.removeAttribute('aria-current');
-    });
-  }
-
-  function navigate(name, navigationOptions = {}) {
-    const target = targets[name];
-    if (!target) return false;
-    const prepare = options.beforeNavigate && options.beforeNavigate[name];
-    if (prepare) prepare(target);
-    if (name === 'actions' && options.planning) options.planning.open = true;
-    target.scrollIntoView({
-      block: 'start',
-      behavior: prefersReducedMotion() ? 'auto' : 'smooth',
-    });
-    if (name === 'reply' && navigationOptions.focus !== false) target.focus();
-    select(name);
-    return true;
-  }
-
-  return {
-    start() {
-      Object.entries(buttons).forEach(([name, button]) => {
-        if (!button || listeners.has(button)) return;
-        const listener = event => {
-          event.preventDefault();
-          navigate(name);
-          if (options.onSectionChange) options.onSectionChange(name, { replace:false });
-        };
-        listeners.set(button, listener);
-        button.addEventListener('click', listener);
-      });
-      select('overview');
-      const observe = options.observe || ((handler, observedTargets) => {
-        if (typeof IntersectionObserver === 'undefined') return null;
-        const instance = new IntersectionObserver(handler, {
-          root: options.root || null,
-          rootMargin: '-20% 0px -60% 0px',
-          threshold: [0, 0.25, 0.5, 0.75, 1],
-        });
-        observedTargets.forEach(target => instance.observe(target));
-        return instance;
-      });
-      observer = observe(entries => {
-        const visible = entries
-          .filter(entry => entry.isIntersecting && targetNames.has(entry.target))
-          .sort((left, right) => right.intersectionRatio - left.intersectionRatio)[0];
-        if (visible) {
-          const name = targetNames.get(visible.target);
-          select(name);
-          if (options.onSectionChange) options.onSectionChange(name, { replace:true });
-        }
-      }, Array.from(targetNames.keys()).filter(Boolean));
-    },
-    stop() {
-      listeners.forEach((listener, button) => button.removeEventListener('click', listener));
-      listeners.clear();
-      if (observer) observer.disconnect();
-      observer = null;
-    },
-    navigate,
-    select,
-  };
-}
-
-if (typeof module !== 'undefined') module.exports = createMobileIssueDetailNavigation;

frontend/mobile-launch.js

@@ -1,33 +0,0 @@
-(function (root, factory) {
-  const api = factory();
-  if (typeof module === 'object' && module.exports) module.exports = api;
-  else root.mobileLaunch = api;
-})(typeof globalThis !== 'undefined' ? globalThis : this, function () {
-  const allowedFilters = new Set([
-    'all', 'today', 'attention', 'agenda', 'issue', 'pull', 'review', 'update', 'later', 'draft',
-  ]);
-
-  function chooseFilter({ saved, today = 0, attention = 0, agenda = 0 } = {}) {
-    if (allowedFilters.has(saved)) return saved;
-    if (today > 0) return 'today';
-    if (attention > 0) return 'attention';
-    if (agenda > 0) return 'agenda';
-    return 'all';
-  }
-
-  function createDisclosure({ disclosure, launcher }) {
-    function onKeydown(event) {
-      if (event.key !== 'Escape' || !disclosure.open) return;
-      event.preventDefault();
-      disclosure.open = false;
-      launcher.focus();
-    }
-    return {
-      start() {
-        disclosure.addEventListener('keydown', onKeydown);
-      },
-    };
-  }
-
-  return { chooseFilter, createDisclosure };
-});

frontend/mobile-plan-today-nav.js

@@ -1,104 +0,0 @@
-function createMobilePlanTodayNavigation(options) {
-  const buttons = options.buttons || {};
-  const targets = options.targets || {};
-  const root = options.root;
-  const listeners = new Map();
-  const prefersReducedMotion = options.prefersReducedMotion || (() => false);
-  const now = options.now || (() => Date.now());
-  const targetNames = new Map(Object.entries(targets).map(([name, target]) => [target, name]));
-  let observer = null;
-  let navigationLockUntil = 0;
-
-  function select(name) {
-    Object.entries(buttons).forEach(([key, button]) => {
-      if (!button) return;
-      if (key === name) button.setAttribute('aria-current', 'location');
-      else button.removeAttribute('aria-current');
-    });
-  }
-
-  function navigate(name) {
-    const target = targets[name];
-    if (!root || !target) return false;
-    root.scrollTo({
-      top: Math.max(0, target.offsetTop - root.offsetTop),
-      behavior: prefersReducedMotion() ? 'auto' : 'smooth',
-    });
-    navigationLockUntil = now() + 500;
-    select(name);
-    return true;
-  }
-
-  function reset() {
-    select('fit');
-  }
-
-  return {
-    start() {
-      Object.entries(buttons).forEach(([name, button]) => {
-        if (!button || listeners.has(button)) return;
-        const listener = event => {
-          event.preventDefault();
-          navigate(name);
-        };
-        listeners.set(button, listener);
-        button.addEventListener('click', listener);
-      });
-      reset();
-      const observe = options.observe || ((handler, observedTargets, observedRoot) => {
-        if (typeof IntersectionObserver === 'undefined') return null;
-        const instance = new IntersectionObserver(handler, {
-          root: observedRoot,
-          rootMargin: '-20% 0px -60% 0px',
-          threshold: [0, 0.25, 0.5, 0.75, 1],
-        });
-        observedTargets.forEach(target => instance.observe(target));
-        return instance;
-      });
-      observer = observe(entries => {
-        if (now() < navigationLockUntil) return;
-        const visible = entries
-          .filter(entry => entry.isIntersecting && targetNames.has(entry.target))
-          .sort((left, right) => right.intersectionRatio - left.intersectionRatio)[0];
-        if (visible) select(targetNames.get(visible.target));
-      }, Array.from(targetNames.keys()).filter(Boolean), root);
-    },
-    stop() {
-      listeners.forEach((listener, button) => button.removeEventListener('click', listener));
-      listeners.clear();
-      if (observer) observer.disconnect();
-      observer = null;
-    },
-    navigate,
-    reset,
-    select,
-  };
-}
-
-function attachMobilePlanTodayNavigation({document, window}) {
-  const bySection = name => document.querySelector('[data-plan-today-section="' + name + '"]');
-  const sheet = document.getElementById('plan-today-sheet');
-  const panel = document.querySelector('.plan-today-panel');
-  const navigation = createMobilePlanTodayNavigation({
-    root: panel,
-    buttons: {
-      fit: bySection('fit'),
-      today: bySection('today'),
-      available: bySection('available'),
-    },
-    targets: {
-      fit: document.getElementById('plan-today-fit'),
-      today: document.getElementById('plan-today-selected'),
-      available: document.getElementById('plan-today-available-work'),
-    },
-    prefersReducedMotion: () => window.matchMedia('(prefers-reduced-motion: reduce)').matches,
-  });
-  navigation.start();
-  new MutationObserver(() => {
-    if (!sheet.hidden) navigation.reset();
-  }).observe(sheet, {attributes: true, attributeFilter: ['hidden']});
-  return navigation;
-}
-
-if (typeof module !== 'undefined') module.exports = createMobilePlanTodayNavigation;
-else attachMobilePlanTodayNavigation({document, window});

frontend/mobile-pull-refresh.js

@@ -1,88 +0,0 @@
-(function (root, factory) {
-  if (typeof module !== 'undefined' && module.exports) module.exports = factory;
-  else root.createMobilePullRefresh = factory;
-})(typeof self !== 'undefined' ? self : this, function createMobilePullRefresh(options) {
-  const surface = options.surface || document.querySelector('#my-work');
-  const indicator = options.indicator || document.querySelector('#mobile-pull-refresh');
-  const threshold = options.threshold || 64;
-  const isMobile = options.isMobile || (() => window.matchMedia('(max-width: 600px)').matches);
-  const getScrollY = options.getScrollY || (() => window.scrollY);
-  const isBlocked = options.isBlocked || (() => Array.from(options.overlays || document.querySelectorAll('[role="dialog"], #whiteboard-modal, #markdown-modal')).some(overlay =>
-      (overlay.checkVisibility ? overlay.checkVisibility() : !overlay.closest('[hidden]')) &&
-      (overlay.classList.contains('open') || overlay.getAttribute('aria-modal') === 'true')));
-  let gesture = null;
-  let inFlight = null;
-
-  function show(state, text) {
-    indicator.hidden = false;
-    indicator.dataset.state = state;
-    indicator.textContent = text;
-  }
-
-  function resetGesture() {
-    gesture = null;
-  }
-
-  function startsOnExcludedTarget(target) {
-    if (!target) return false;
-    if (target.closest?.('button, a, input, textarea, select, summary, [contenteditable="true"], [role="button"]')) return true;
-    for (let node = target; node && node !== surface; node = node.parentElement) {
-      if ((node.scrollWidth || 0) > (node.clientWidth || 0)) return true;
-    }
-    return false;
-  }
-
-  function onPointerDown(event) {
-    if (inFlight || event.pointerType !== 'touch' || !isMobile() || getScrollY() > 0 || isBlocked() || startsOnExcludedTarget(event.target)) return;
-    gesture = {id:event.pointerId, x:event.clientX, y:event.clientY, ready:false};
-    surface.setPointerCapture?.(event.pointerId);
-  }
-
-  function onPointerMove(event) {
-    if (!gesture || gesture.id !== event.pointerId) return;
-    const dx = event.clientX - gesture.x;
-    const dy = event.clientY - gesture.y;
-    if (dy <= 0 || Math.abs(dx) > dy) return resetGesture();
-    event.preventDefault();
-    gesture.ready = dy >= threshold;
-    show(gesture.ready ? 'ready' : 'pulling', gesture.ready ? 'Release to refresh' : 'Pull to refresh');
-  }
-
-  async function onPointerUp(event) {
-    if (!gesture || gesture.id !== event.pointerId) return;
-    const shouldRefresh = gesture.ready;
-    resetGesture();
-    surface.releasePointerCapture?.(event.pointerId);
-    if (!shouldRefresh || inFlight) return;
-    show('refreshing', 'Refreshing My Work…');
-    inFlight = Promise.resolve().then(options.refresh);
-    try {
-      await inFlight;
-      show('success', 'My Work is up to date');
-    } catch (_) {
-      show('error', 'Could not refresh · pull to retry');
-    } finally {
-      inFlight = null;
-    }
-  }
-
-  function onPointerCancel() {
-    resetGesture();
-  }
-
-  return {
-    start() {
-      surface.addEventListener('pointerdown', onPointerDown);
-      surface.addEventListener('pointermove', onPointerMove);
-      surface.addEventListener('pointerup', onPointerUp);
-      surface.addEventListener('pointercancel', onPointerCancel);
-    },
-    stop() {
-      surface.removeEventListener('pointerdown', onPointerDown);
-      surface.removeEventListener('pointermove', onPointerMove);
-      surface.removeEventListener('pointerup', onPointerUp);
-      surface.removeEventListener('pointercancel', onPointerCancel);
-      resetGesture();
-    },
-  };
-});

frontend/mobile-queue-launcher.js

@@ -1,144 +0,0 @@
-(function (root, factory) {
-  if (typeof module === 'object' && module.exports) module.exports = factory;
-  else root.createMobileQueueLauncher = factory;
-})(typeof self !== 'undefined' ? self : this, function createMobileQueueLauncher(options) {
-  const emptyMessages = {
-    attention: 'No items need attention.',
-    update: 'No unread updates are ready to open.',
-    later: 'No deferred work is ready to open.',
-    draft: 'No drafts are ready to open.',
-  };
-  const labels = {
-    delivery: 'Recover Delivery', gate: 'Review Human Gates', attention: 'Start Attention',
-    today: 'Continue Today', update: 'Resume Updates', agenda: 'Open Agenda',
-    following: 'Review Following', authored: 'Open My PRs', filed: 'Review Filed',
-    later: 'Start Later', draft: 'Open Drafts',
-  };
-  const criticalQueueNames = ['delivery', 'gate'];
-  const defaultRoutineOrder = [
-    'attention', 'today', 'update', 'agenda', 'following', 'authored', 'filed', 'later', 'draft',
-  ];
-  const onlineOnlyQueues = new Set(['delivery', 'gate']);
-  const allQueues = [
-    'today', 'tomorrow', 'week', 'agenda', 'delivery', 'gate', 'attention',
-    'update', 'following', 'filed', 'authored', 'later', 'draft', 'find', 'recaps',
-  ];
-
-  function routineOrder() {
-    const proposed = options.getRoutineOrder ? options.getRoutineOrder() : defaultRoutineOrder;
-    if (!Array.isArray(proposed) || proposed.length !== defaultRoutineOrder.length ||
-        new Set(proposed).size !== defaultRoutineOrder.length ||
-        proposed.some(name => !defaultRoutineOrder.includes(name))) return defaultRoutineOrder.slice();
-    return proposed.slice();
-  }
-
-  function activeQueueNames() {
-    return criticalQueueNames.concat(routineOrder());
-  }
-
-  function recommend() {
-    const counts = options.getCounts ? options.getCounts() : {};
-    const online = options.isOnline ? options.isOnline() : true;
-    const match = activeQueueNames().map(name => [name, labels[name]]).find(([name]) =>
-      Number(counts[name]) > 0 && (online || !onlineOnlyQueues.has(name))
-    );
-    if (!match) return {name: 'find', count: 0, label: 'Find Work'};
-    const [name, label] = match;
-    const count = Math.max(0, Number(counts[name]) || 0);
-    return {name, count, label: label + ' (' + count + ')'};
-  }
-
-  function adaptiveRecommendation() {
-    const preparation = options.getPreparation ? options.getPreparation() : null;
-    if (preparation && (preparation.active || Number(preparation.total) > 0)) {
-      const prefix = preparation.active ? 'Resume preparation · ' : 'Start day · ';
-      return {name: 'prepare', count: Math.max(0, Number(preparation.total) || 0), label: prefix + preparation.label};
-    }
-    return recommend();
-  }
-
-  function presentation() {
-    const counts = options.getCounts ? options.getCounts() : {};
-    const names = activeQueueNames();
-    const active = names
-      .map(name => ({name, count: Math.max(0, Number(counts[name]) || 0)}))
-      .filter(item => item.count > 0);
-    names.forEach(name => {
-      if (counts[name + 'Unavailable'] && !active.some(item => item.name === name)) {
-        active.push({name, unavailable: true});
-      }
-    });
-    return {
-      nextUp: adaptiveRecommendation(),
-      active,
-      planning: ['today', 'tomorrow', 'week'],
-      all: allQueues.slice(),
-    };
-  }
-
-  function renderPresentation() {
-    const view = presentation();
-    const planning = new Set(view.planning);
-    const active = view.active.filter(item => !planning.has(item.name));
-    const activeNames = new Set(active.map(item => item.name));
-    if (options.nextAction) {
-      options.nextAction.textContent = view.nextUp.label;
-      options.nextAction.dataset.queue = view.nextUp.name;
-      const prefix = view.nextUp.name === 'prepare' ? 'Start or continue: ' : 'Next up: ';
-      options.nextAction.setAttribute('aria-label', prefix + view.nextUp.label);
-    }
-    active.forEach(item => {
-      const row = options.rows?.[item.name];
-      if (!row) return;
-      if (item.unavailable) row.setAttribute('data-unavailable', 'true');
-      else row.removeAttribute('data-unavailable');
-      options.activeList?.append(row);
-    });
-    view.planning.forEach(name => {
-      const row = options.rows?.[name];
-      if (row) options.planningList?.append(row);
-    });
-    view.all.forEach(name => {
-      if (planning.has(name) || activeNames.has(name)) return;
-      const row = options.rows?.[name];
-      if (!row) return;
-      row.removeAttribute('data-unavailable');
-      options.allList?.append(row);
-    });
-    if (options.activeSection) options.activeSection.hidden = active.length === 0;
-    return view;
-  }
-
-  function open(name) {
-    if (name === 'delivery' && options.openDelivery) return options.openDelivery();
-    if (name === 'gate' && options.openHumanGates) return options.openHumanGates();
-    if (name === 'today') return options.openToday();
-    if (name === 'agenda') return options.openAgenda();
-    if (name === 'update' && options.openUpdates) return options.openUpdates();
-    if (name === 'following' && options.openFollowing) return options.openFollowing();
-    if (name === 'filed' && options.openFiled) return options.openFiled();
-    options.selectFilter(name);
-    const action = options.firstAction(name);
-    if (!action) {
-      options.announce(emptyMessages[name] || 'No work is ready to open.');
-      return 'empty';
-    }
-    action.click();
-    return 'opened';
-  }
-
-  function continueWork() {
-    const next = adaptiveRecommendation();
-    if (next.name === 'prepare') {
-      options.openPreparation();
-      return 'prepare';
-    }
-    if (next.name === 'find') {
-      options.openFindWork();
-      return 'find';
-    }
-    return open(next.name);
-  }
-
-  return { open, recommend, adaptiveRecommendation, presentation, renderPresentation, continueWork };
-});

frontend/mobile-queue-priority.js

@@ -1,340 +0,0 @@
-(function (root, factory) {
-  if (typeof module === 'object' && module.exports) module.exports = factory;
-  else root.createMobileQueuePriority = factory;
-})(typeof self !== 'undefined' ? self : this, function createMobileQueuePriority(options = {}) {
-  const DEFAULT_ORDER = [
-    'attention', 'today', 'update', 'agenda', 'following', 'authored', 'filed', 'later', 'draft',
-  ];
-  const storage = options.storage;
-  const getLogin = options.getLogin || (() => '');
-  const fetchJson = options.fetchJson;
-  const prefix = 'stackchain-mobile-queue-priority-v1:';
-  const labels = options.labels || {};
-  const documentRef = options.document || (typeof document !== 'undefined' ? document : null);
-  const setTimer = options.setTimeout || setTimeout;
-  const clearTimer = options.clearTimeout || clearTimeout;
-  const debounceMs = Number.isFinite(options.debounceMs) ? Math.max(0, options.debounceMs) : 150;
-  const retryBaseMs = Number.isFinite(options.retryBaseMs) ? Math.max(1, options.retryBaseMs) : 1000;
-  const retryMaxMs = Number.isFinite(options.retryMaxMs) ? Math.max(retryBaseMs, options.retryMaxMs) : 30000;
-  let memory = null;
-  const syncFlights = new Map();
-  let debounceTimer = null;
-  let retryTimer = null;
-  let retryAccount = '';
-  let retryAttempts = 0;
-
-  function key() {
-    const login = String(getLogin() || '').trim().toLowerCase();
-    return login ? prefix + encodeURIComponent(login) : '';
-  }
-
-  function valid(order) {
-    return Array.isArray(order) && order.length === DEFAULT_ORDER.length &&
-      new Set(order).size === DEFAULT_ORDER.length &&
-      order.every(name => DEFAULT_ORDER.includes(name) && typeof name === 'string');
-  }
-
-  function fresh() {
-    return {revision:0, order:DEFAULT_ORDER.slice(), pending:false, status:'ready', remote:null};
-  }
-
-  function read() {
-    const accountKey = key();
-    if (!accountKey || !storage) return fresh();
-    if (memory?.key === accountKey) return memory.value;
-    let value = fresh();
-    try {
-      const saved = JSON.parse(storage.getItem(accountKey) || 'null');
-      if (valid(saved)) value = {revision:0, order:saved.slice(), pending:true, status:'pending', remote:null};
-      else if (saved && valid(saved.order) && Number.isInteger(saved.revision) && saved.revision >= 0) {
-        value = {
-          revision:saved.revision, order:saved.order.slice(), pending:Boolean(saved.pending),
-          status:saved.status === 'conflict' ? 'conflict' : (saved.pending ? 'pending' : 'ready'),
-          remote:saved.remote && valid(saved.remote.order) ? {
-            revision:Number(saved.remote.revision) || 0, order:saved.remote.order.slice(),
-          } : null,
-        };
-      }
-    } catch (_error) {}
-    memory = {key:accountKey, value};
-    return value;
-  }
-
-  function persist(value) {
-    const accountKey = key();
-    if (!accountKey || !storage) return false;
-    memory = {key:accountKey, value};
-    try {
-      storage.setItem(accountKey, JSON.stringify(value));
-      return true;
-    } catch (_error) {
-      return false;
-    }
-  }
-
-  function snapshot() {
-    const value = read();
-    return {
-      revision:value.revision, order:value.order.slice(), pending:value.pending,
-      status:value.status, remote:value.remote ? {revision:value.remote.revision, order:value.remote.order.slice()} : null,
-    };
-  }
-
-  function announce(value) {
-    if (options.status) {
-      options.status.textContent = ({pending:'Sync pending.', conflict:'Routine order changed on another device.',
-        syncing:'Syncing routine order…', error:'Routine order could not sync.', ready:''})[value.status] || '';
-    }
-    options.onState?.(snapshot());
-  }
-
-  function getOrder() {
-    return read().order.slice();
-  }
-
-  function save(order) {
-    if (!key() || !valid(order)) return false;
-    const current = read();
-    const value = {revision:current.revision, order:order.slice(), pending:true, status:'pending', remote:null};
-    if (!persist(value)) return false;
-    options.onChange?.(order.slice());
-    announce(value);
-    scheduleSync();
-    return true;
-  }
-
-  function scheduleSync() {
-    if (!fetchJson || !key()) return false;
-    if (debounceTimer) clearTimer(debounceTimer);
-    debounceTimer = setTimer(() => {
-      debounceTimer = null;
-      void sync();
-    }, debounceMs);
-    return true;
-  }
-
-  function clearRetry() {
-    if (retryTimer) clearTimer(retryTimer);
-    retryTimer = null;
-    retryAccount = '';
-    retryAttempts = 0;
-  }
-
-  function transient(error) {
-    const status = Number(error?.status) || 0;
-    return status === 0 || status === 408 || status === 425 || status === 429 || status >= 500;
-  }
-
-  function scheduleRetry(accountKey) {
-    if (retryTimer && retryAccount !== accountKey) clearRetry();
-    if (retryTimer || key() !== accountKey) return false;
-    const delay = Math.min(retryMaxMs, retryBaseMs * (2 ** retryAttempts));
-    retryAttempts += 1;
-    retryAccount = accountKey;
-    retryTimer = setTimer(() => {
-      retryTimer = null;
-      retryAccount = '';
-      const current = read();
-      if (key() !== accountKey || !current.pending || current.status === 'conflict') return;
-      void sync();
-    }, delay);
-    return true;
-  }
-
-  function move(name, delta) {
-    const order = getOrder();
-    const index = order.indexOf(name);
-    const next = index + (Number(delta) < 0 ? -1 : 1);
-    if (index < 0 || next < 0 || next >= order.length) return order;
-    [order[index], order[next]] = [order[next], order[index]];
-    save(order);
-    return order.slice();
-  }
-
-  function reset() {
-    const order = DEFAULT_ORDER.slice();
-    if (fetchJson && key()) save(order);
-    else {
-      const accountKey = key();
-      if (accountKey && storage) {
-        try { storage.removeItem(accountKey); } catch (_error) {}
-      }
-      memory = null;
-      options.onChange?.(order.slice());
-    }
-    return order;
-  }
-
-  function adopt(snapshotValue, accountKey = key()) {
-    if (!accountKey || key() !== accountKey) return snapshot();
-    if (!snapshotValue || !Number.isInteger(snapshotValue.revision) || snapshotValue.revision < 0 || !valid(snapshotValue.order)) {
-      throw new Error('Queue priority response is invalid.');
-    }
-    const value = {revision:snapshotValue.revision, order:snapshotValue.order.slice(), pending:false, status:'ready', remote:null};
-    clearRetry();
-    persist(value);
-    options.onChange?.(value.order.slice());
-    announce(value);
-    render();
-    return snapshot();
-  }
-
-  async function load() {
-    const accountKey = key();
-    if (!fetchJson || !accountKey) return snapshot();
-    try {
-      const remote = await fetchJson('api/v1/queue-priority');
-      if (key() !== accountKey) return snapshot();
-      const local = read();
-      if (local.pending) {
-        local.remote = valid(remote?.order) ? {revision:remote.revision, order:remote.order.slice()} : null;
-        persist(local);
-        return sync();
-      }
-      return adopt(remote, accountKey);
-    } catch (_error) {
-      if (key() !== accountKey) return snapshot();
-      const current = read();
-      current.status = current.pending ? 'pending' : 'error';
-      persist(current); announce(current);
-      return snapshot();
-    }
-  }
-
-  async function drain(accountKey) {
-    while (key() === accountKey) {
-      const current = read();
-      if (!current.pending) return snapshot();
-      const sent = {revision:current.revision, order:current.order.slice()};
-      current.status = 'syncing'; persist(current); announce(current);
-      try {
-        const saved = await fetchJson('api/v1/queue-priority', {
-          method:'PUT', headers:{'Content-Type':'application/json'},
-          body:JSON.stringify(sent),
-        });
-        if (key() !== accountKey) return snapshot();
-        if (!saved || !Number.isInteger(saved.revision) || !valid(saved.order)) {
-          throw new Error('Queue priority response is invalid.');
-        }
-        const latest = read();
-        if (latest.order.some((name, index) => name !== sent.order[index])) {
-          latest.revision = saved.revision; latest.pending = true;
-          latest.status = 'pending'; latest.remote = null;
-          persist(latest); announce(latest);
-          continue;
-        }
-        return adopt(saved, accountKey);
-      } catch (error) {
-        if (key() !== accountKey) return snapshot();
-        const latest = read();
-        const remote = error?.status === 409 && error?.payload?.detail?.snapshot;
-        if (remote && valid(remote.order) && Number.isInteger(remote.revision)) {
-          clearRetry();
-          latest.status = 'conflict'; latest.pending = true;
-          latest.remote = {revision:remote.revision, order:remote.order.slice()};
-        } else {
-          latest.status = 'pending'; latest.pending = true;
-          if (transient(error)) scheduleRetry(accountKey);
-        }
-        persist(latest); announce(latest); render();
-        return snapshot();
-      }
-    }
-    return snapshot();
-  }
-
-  function sync() {
-    if (debounceTimer) {
-      clearTimer(debounceTimer);
-      debounceTimer = null;
-    }
-    const accountKey = key();
-    const current = read();
-    if (!fetchJson || !accountKey || !current.pending) return Promise.resolve(snapshot());
-    if (syncFlights.has(accountKey)) return syncFlights.get(accountKey);
-    const flight = drain(accountKey).finally(() => {
-      if (syncFlights.get(accountKey) === flight) syncFlights.delete(accountKey);
-    });
-    syncFlights.set(accountKey, flight);
-    return flight;
-  }
-
-  async function useLocal() {
-    const current = read();
-    if (!current.remote) return snapshot();
-    current.revision = current.remote.revision;
-    current.remote = null; current.pending = true; current.status = 'pending';
-    persist(current);
-    return sync();
-  }
-
-  function useRemote() {
-    const current = read();
-    return current.remote ? adopt(current.remote) : snapshot();
-  }
-
-  function displayName(name) {
-    return labels[name] || name.charAt(0).toUpperCase() + name.slice(1);
-  }
-
-  function render() {
-    if (!options.list || !documentRef) return getOrder();
-    const order = getOrder();
-    const signedIn = Boolean(key());
-    const rows = order.map((name, index) => {
-      const row = documentRef.createElement('div');
-      row.setAttribute('data-queue-priority', name);
-      row.setAttribute('class', 'mobile-queue-priority-row');
-      const label = documentRef.createElement('span');
-      label.textContent = displayName(name);
-      const controls = documentRef.createElement('span');
-      controls.setAttribute('class', 'mobile-queue-priority-controls');
-      const earlier = documentRef.createElement('button');
-      earlier.textContent = 'Earlier'; earlier.setAttribute('type', 'button');
-      earlier.setAttribute('aria-label', 'Move ' + displayName(name) + ' earlier');
-      earlier.disabled = !signedIn || index === 0;
-      earlier.addEventListener('click', () => {
-        move(name, -1); render();
-      });
-      const later = documentRef.createElement('button');
-      later.textContent = 'Later'; later.setAttribute('type', 'button');
-      later.setAttribute('aria-label', 'Move ' + displayName(name) + ' later');
-      later.disabled = !signedIn || index === order.length - 1;
-      later.addEventListener('click', () => {
-        move(name, 1); render();
-      });
-      controls.append(earlier, later); row.append(label, controls);
-      return row;
-    });
-    options.list.replaceChildren(...rows);
-    if (options.resetButton) options.resetButton.disabled = !signedIn;
-    if (options.conflict) options.conflict.hidden = read().status !== 'conflict';
-    return order;
-  }
-
-  function start() {
-    options.resetButton?.addEventListener('click', () => {
-      reset(); render();
-    });
-    options.keepLocalButton?.addEventListener('click', () => { void useLocal(); });
-    options.useRemoteButton?.addEventListener('click', () => { useRemote(); });
-    return render();
-  }
-
-  function startLifecycle(lifecycle = {}) {
-    const windowObject = lifecycle.window;
-    const lifecycleDocument = lifecycle.document;
-    const reconcile = () => {
-      if (!key()) return Promise.resolve(snapshot());
-      return read().pending ? sync() : load();
-    };
-    windowObject?.addEventListener?.('online', () => { void reconcile(); });
-    lifecycleDocument?.addEventListener?.('visibilitychange', () => {
-      if (!lifecycleDocument.hidden) void reconcile();
-    });
-    return reconcile;
-  }
-
-  return {getOrder, move, reset, render, start, startLifecycle, load, sync, scheduleSync, useLocal, useRemote,
-    state:snapshot, defaultOrder:() => DEFAULT_ORDER.slice()};
-});

frontend/mobile-recent-work.js

@@ -1,455 +0,0 @@
-(function (root, factory) {
-  if (typeof module === 'object' && module.exports) module.exports = factory;
-  else root.createMobileRecentWork = factory;
-})(typeof globalThis !== 'undefined' ? globalThis : this, function createMobileRecentWork(options) {
-  'use strict';
-
-  const storage = options.storage;
-  const getLogin = options.getLogin;
-  const fetchJson = options.fetchJson;
-  const limit = Math.max(1, Number(options.limit) || 5);
-  const pinnedLimit = Math.max(1, Number(options.pinnedLimit) || 20);
-  const prefix = 'stackchain.mobile-recent-work.v1.';
-  const repositoryPattern = /^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/;
-  const kinds = new Set(['issue', 'filed', 'pull', 'review', 'update']);
-  const setTimer = options.setTimeout || setTimeout;
-  const clearTimer = options.clearTimeout || clearTimeout;
-  const debounceMs = Number.isFinite(options.debounceMs) ? Math.max(0, options.debounceMs) : 150;
-  const retryMs = Number.isFinite(options.retryMs) ? Math.max(1, options.retryMs) : 1000;
-  const retryMaxMs = Number.isFinite(options.retryMaxMs) ? Math.max(retryMs, options.retryMaxMs) : 30000;
-  let syncFlight = null;
-  let syncAccount = '';
-  let debounceTimer = null;
-  let retryTimer = null;
-  let retryAccount = '';
-  let retryAttempt = 0;
-  let operationSequence = 0;
-  let pinsExpanded = false;
-  let currentItem = null;
-
-  const detailPins = Array.from(options.detailPins || []);
-  detailPins.forEach(button => button.addEventListener?.('click', () => {
-    if (!currentItem) return;
-    const isPinned = pinned().some(item => item.route === currentItem.route);
-    if (isPinned) unpin(currentItem.route);
-    else pin(currentItem);
-  }));
-
-  options.pinnedToggle?.addEventListener?.('click', () => {
-    pinsExpanded = !pinsExpanded;
-    render();
-  });
-
-  function operationId() {
-    operationSequence += 1;
-    return Date.now().toString(36) + '-' + operationSequence.toString(36);
-  }
-
-  function clearRetry(resetAttempt = false) {
-    if (retryTimer) clearTimer(retryTimer);
-    retryTimer = null;
-    retryAccount = '';
-    if (resetAttempt) retryAttempt = 0;
-  }
-
-  function scheduleRetry(accountKey) {
-    if (retryTimer || key() !== accountKey || !hasPending(read())) return false;
-    retryAccount = accountKey;
-    const delay = Math.min(retryMaxMs, retryMs * (2 ** retryAttempt));
-    retryAttempt += 1;
-    retryTimer = setTimer(() => {
-      const timer = retryTimer;
-      retryTimer = null;
-      retryAccount = '';
-      if (timer) clearTimer(timer);
-      if (key() === accountKey && hasPending(read())) void sync();
-    }, delay);
-    return true;
-  }
-
-  function login() {
-    return String(getLogin?.() || '').trim().toLowerCase();
-  }
-
-  function key() {
-    const owner = login();
-    return owner ? prefix + owner : '';
-  }
-
-  function normalize(item) {
-    const kind = String(item?.kind || '');
-    const number = Number(item?.number ?? item?.notification_id);
-    if (!kinds.has(kind) || !Number.isSafeInteger(number) || number < 1) return null;
-    let route = '';
-    let repository = '';
-    if (kind === 'update') {
-      route = '#/my-work/update/' + number;
-    } else {
-      repository = String(item?.repository || '');
-      if (!repositoryPattern.test(repository)) return null;
-      route = '#/my-work/' + kind + '/' + repository + '/' + number;
-    }
-    const title = String(item?.title || item?.subject?.title || '').trim().slice(0, 180);
-    if (!title) return null;
-    return {kind, ...(repository ? {repository} : {}), number, title, route};
-  }
-
-  function normalizeList(value, maximum = limit) {
-    if (!Array.isArray(value)) return [];
-    const unique = [];
-    for (const candidate of value) {
-      const item = normalize(candidate);
-      if (item && !unique.some(existing => existing.route === item.route)) unique.push(item);
-      if (unique.length === maximum) break;
-    }
-    return unique;
-  }
-
-  function normalizePinOps(value) {
-    if (!Array.isArray(value)) return [];
-    const unique = [];
-    for (const candidate of value) {
-      const action = candidate?.action;
-      const item = action === 'pin' ? normalize(candidate.item) : null;
-      const route = action === 'pin' ? item?.route : String(candidate?.route || '');
-      if ((action !== 'pin' && action !== 'unpin') || !route || (action === 'pin' && !item)) continue;
-      if (!unique.some(existing => (existing.item?.route || existing.route) === route)) {
-        const normalized = action === 'pin' ? {action, item} : {action, route};
-        if (typeof candidate.operationId === 'string' && candidate.operationId) normalized.operationId = candidate.operationId;
-        unique.push(normalized);
-      }
-      if (unique.length === pinnedLimit) break;
-    }
-    return unique;
-  }
-
-  function normalizePending(value) {
-    if (!Array.isArray(value)) return [];
-    const unique = [];
-    for (const candidate of value) {
-      const item = normalize(candidate);
-      if (!item || unique.some(existing => existing.route === item.route)) continue;
-      if (typeof candidate.operationId === 'string' && candidate.operationId) item.operationId = candidate.operationId;
-      unique.push(item);
-      if (unique.length === limit) break;
-    }
-    return unique;
-  }
-
-  function empty() {
-    return {items:[], pinned:[], pending:[], pinOps:[]};
-  }
-
-  function read() {
-    const storageKey = key();
-    if (!storageKey) return empty();
-    try {
-      const parsed = JSON.parse(storage.getItem(storageKey) || 'null');
-      if (Array.isArray(parsed)) return {...empty(), items:normalizeList(parsed)};
-      return {
-        items:normalizeList(parsed?.items),
-        pinned:normalizeList(parsed?.pinned, pinnedLimit),
-        pending:normalizePending(parsed?.pending),
-        pinOps:normalizePinOps(parsed?.pinOps),
-      };
-    } catch (_) {
-      return empty();
-    }
-  }
-
-  function persist(value, accountKey = key()) {
-    if (!accountKey || accountKey !== key()) return false;
-    try {
-      storage.setItem(accountKey, JSON.stringify({
-        items:normalizeList(value.items),
-        pinned:normalizeList(value.pinned, pinnedLimit),
-        pending:normalizePending(value.pending),
-        pinOps:normalizePinOps(value.pinOps),
-      }));
-      return true;
-    } catch (_) {
-      return false;
-    }
-  }
-
-  function hasPending(value) {
-    return value.pending.length > 0 || value.pinOps.length > 0;
-  }
-
-  function announce(value = read(), status = null) {
-    if (!options.status) return;
-    options.status.textContent = status || (hasPending(value) ? 'Sync pending.' : '');
-  }
-
-  function items() {
-    return read().items;
-  }
-
-  function pinned() {
-    return read().pinned;
-  }
-
-  function state() {
-    const value = read();
-    const pendingCount = value.pending.length + value.pinOps.length;
-    return {pending:pendingCount > 0, pendingCount};
-  }
-
-  function scheduleSync() {
-    if (!fetchJson || !key()) return false;
-    if (debounceTimer) clearTimer(debounceTimer);
-    debounceTimer = setTimer(() => {
-      debounceTimer = null;
-      void sync();
-    }, debounceMs);
-    return true;
-  }
-
-  function record(item) {
-    const accountKey = key();
-    const normalized = normalize(item);
-    if (!accountKey || !normalized) return false;
-    const current = read();
-    current.items = [normalized, ...current.items.filter(existing => existing.route !== normalized.route)].slice(0, limit);
-    current.pinned = current.pinned.some(existing => existing.route === normalized.route)
-      ? [normalized, ...current.pinned.filter(existing => existing.route !== normalized.route)]
-      : current.pinned;
-    current.pending = [{...normalized, operationId:operationId()}, ...current.pending.filter(existing => existing.route !== normalized.route)].slice(0, limit);
-    if (!persist(current, accountKey)) return false;
-    announce(current);
-    render();
-    scheduleSync();
-    return true;
-  }
-
-  function queuePinOp(current, operation) {
-    const route = operation.item?.route || operation.route;
-    current.pinOps = [{...operation, operationId:operationId()}, ...current.pinOps.filter(existing => (existing.item?.route || existing.route) !== route)];
-  }
-
-  function pin(item) {
-    const accountKey = key();
-    const normalized = normalize(item);
-    if (!accountKey || !normalized) return false;
-    const current = read();
-    current.pinned = [normalized, ...current.pinned.filter(existing => existing.route !== normalized.route)].slice(0, pinnedLimit);
-    queuePinOp(current, {action:'pin', item:normalized});
-    if (!persist(current, accountKey)) return false;
-    announce(current);
-    render();
-    scheduleSync();
-    return true;
-  }
-
-  function unpin(route) {
-    const accountKey = key();
-    route = String(route || '');
-    if (!accountKey || !route) return false;
-    const current = read();
-    if (!current.pinned.some(item => item.route === route)) return false;
-    current.pinned = current.pinned.filter(item => item.route !== route);
-    queuePinOp(current, {action:'unpin', route});
-    if (!persist(current, accountKey)) return false;
-    announce(current);
-    render();
-    scheduleSync();
-    return true;
-  }
-
-  function applyPinOps(remote, operations) {
-    let result = normalizeList(remote, pinnedLimit);
-    for (const operation of [...normalizePinOps(operations)].reverse()) {
-      const route = operation.item?.route || operation.route;
-      result = operation.action === 'pin'
-        ? [operation.item, ...result.filter(item => item.route !== route)].slice(0, pinnedLimit)
-        : result.filter(item => item.route !== route);
-    }
-    return result;
-  }
-
-  function adopt(snapshot, accountKey, pending = [], pinOps = []) {
-    if (key() !== accountKey || !snapshot || !Array.isArray(snapshot.items)) return false;
-    const remote = normalizeList(snapshot.items);
-    const remotePinned = normalizeList(snapshot.pinned, pinnedLimit);
-    const unsent = normalizePending(pending);
-    const unsentPinOps = normalizePinOps(pinOps);
-    const value = {
-      items:normalizeList([...unsent, ...remote]),
-      pinned:applyPinOps(remotePinned, unsentPinOps),
-      pending:unsent,
-      pinOps:unsentPinOps,
-    };
-    persist(value, accountKey);
-    announce(value);
-    render();
-    return true;
-  }
-
-  async function drain(accountKey) {
-    while (key() === accountKey) {
-      const current = read();
-      if (!hasPending(current)) return current;
-      const sending = current.pending[current.pending.length - 1];
-      const pinOperation = sending ? null : current.pinOps[current.pinOps.length - 1];
-      announce(current, 'Syncing recent work…');
-      try {
-        let snapshot;
-        if (sending) {
-          snapshot = await fetchJson('api/v1/recent-work', {
-            method:'POST', headers:{'Content-Type':'application/json'}, body:JSON.stringify(normalize(sending)),
-          });
-        } else {
-          const isPin = pinOperation.action === 'pin';
-          snapshot = await fetchJson('api/v1/recent-work/pin', {
-            method:isPin ? 'PUT' : 'DELETE',
-            headers:{'Content-Type':'application/json'},
-            body:JSON.stringify(isPin ? pinOperation.item : {route:pinOperation.route}),
-          });
-        }
-        if (key() !== accountKey) return read();
-        const latest = read();
-        const pending = sending
-          ? latest.pending.filter(item => item.operationId !== sending.operationId)
-          : latest.pending;
-        const pinOps = pinOperation
-          ? latest.pinOps.filter(operation => {
-            const sameRoute = (operation.item?.route || operation.route) === (pinOperation.item?.route || pinOperation.route);
-            return !sameRoute || operation.action !== pinOperation.action || operation.operationId !== pinOperation.operationId;
-          })
-          : latest.pinOps;
-        if (!adopt(snapshot, accountKey, pending, pinOps)) throw new Error('Recent work response is invalid.');
-        retryAttempt = 0;
-      } catch (_error) {
-        if (key() === accountKey) {
-          announce(read());
-          scheduleRetry(accountKey);
-        }
-        return read();
-      }
-    }
-    return read();
-  }
-
-  function sync() {
-    if (debounceTimer) { clearTimer(debounceTimer); debounceTimer = null; }
-    const accountKey = key();
-    if (retryTimer && retryAccount !== accountKey) clearRetry(true);
-    else if (retryTimer) clearRetry(false);
-    if (!fetchJson || !accountKey || !hasPending(read())) return Promise.resolve(read());
-    if (syncFlight && syncAccount === accountKey) return syncFlight;
-    syncAccount = accountKey;
-    syncFlight = drain(accountKey).finally(() => {
-      if (syncAccount === accountKey) { syncFlight = null; syncAccount = ''; }
-    });
-    return syncFlight;
-  }
-
-  async function load() {
-    const accountKey = key();
-    if (!fetchJson || !accountKey) return read();
-    try {
-      const snapshot = await fetchJson('api/v1/recent-work');
-      if (key() !== accountKey) return read();
-      const current = read();
-      adopt(snapshot, accountKey, current.pending, current.pinOps);
-      return hasPending(current) ? sync() : read();
-    } catch (_error) {
-      if (key() === accountKey) announce(read(), hasPending(read()) ? null : 'Recent work could not sync.');
-      return read();
-    }
-  }
-
-  function startLifecycle(lifecycle = {}) {
-    const reconcile = () => hasPending(read()) ? sync() : load();
-    lifecycle.window?.addEventListener?.('online', () => { void reconcile(); });
-    lifecycle.document?.addEventListener?.('visibilitychange', () => {
-      if (!lifecycle.document.hidden) void reconcile();
-    });
-    return reconcile;
-  }
-
-  function detail(item) {
-    return item.kind === 'update'
-      ? 'Update · #' + item.number
-      : item.kind.charAt(0).toUpperCase() + item.kind.slice(1) + ' · ' + item.repository + ' #' + item.number;
-  }
-
-  function row(item, isPinned) {
-    const itemDetail = detail(item);
-    const wrapper = options.document.createElement('div');
-    const button = options.document.createElement('button');
-    const action = options.document.createElement('button');
-    const copy = options.document.createElement('span');
-    const primary = options.document.createElement('strong');
-    const secondary = options.document.createElement('small');
-    wrapper.setAttribute('class', 'mobile-recent-work-row');
-    primary.textContent = item.title;
-    secondary.textContent = itemDetail;
-    copy.appendChild(primary);
-    copy.appendChild(secondary);
-    button.appendChild(copy);
-    button.setAttribute('type', 'button');
-    button.setAttribute('data-recent-work-route', item.route);
-    button.setAttribute('aria-label', 'Open ' + item.title + ', ' + itemDetail.toLowerCase().replace(' · ', ' '));
-    button.addEventListener('click', () => {
-      if (isPinned) record(item);
-      options.openRoute?.(item.route);
-    });
-    action.textContent = isPinned ? 'Unpin' : 'Pin';
-    action.setAttribute('type', 'button');
-    action.setAttribute('data-recent-work-pin', isPinned ? 'unpin' : 'pin');
-    action.setAttribute('aria-label', (isPinned ? 'Unpin ' : 'Pin ') + item.title);
-    action.addEventListener('click', () => isPinned ? unpin(item.route) : pin(item));
-    wrapper.appendChild(button);
-    wrapper.appendChild(action);
-    return wrapper;
-  }
-
-  function renderCurrent() {
-    const isPinned = currentItem && pinned().some(item => item.route === currentItem.route);
-    detailPins.forEach(button => {
-      button.hidden = !currentItem;
-      if (!currentItem) return;
-      button.textContent = isPinned ? 'Pinned' : 'Pin';
-      button.setAttribute('aria-pressed', isPinned ? 'true' : 'false');
-      button.setAttribute('aria-label', (isPinned ? 'Unpin ' : 'Pin ') + currentItem.title);
-      button.setAttribute('data-current-work-pin', isPinned ? 'unpin' : 'pin');
-    });
-  }
-
-  function setCurrent(item) {
-    currentItem = normalize(item);
-    renderCurrent();
-    return Boolean(currentItem);
-  }
-
-  function render() {
-    const recent = items();
-    const fixed = pinned();
-    const fixedRoutes = new Set(fixed.map(item => item.route));
-    const visibleRecent = recent.filter(item => !fixedRoutes.has(item.route));
-    const list = options.list;
-    const section = options.section;
-    if (list && section && options.document) {
-      const rows = visibleRecent.map(item => row(item, false));
-      list.replaceChildren(...rows);
-      section.hidden = rows.length === 0;
-    }
-    if (options.pinnedList && options.pinnedSection && options.document) {
-      const visiblePins = pinsExpanded ? fixed : fixed.slice(0, 3);
-      const rows = visiblePins.map(item => row(item, true));
-      options.pinnedList.replaceChildren(...rows);
-      options.pinnedSection.hidden = rows.length === 0;
-    }
-    if (options.pinnedToggle) {
-      options.pinnedToggle.hidden = fixed.length <= 3;
-      options.pinnedToggle.textContent = pinsExpanded ? 'Show fewer' : 'Show all ' + fixed.length;
-      options.pinnedToggle.setAttribute('aria-expanded', pinsExpanded ? 'true' : 'false');
-      options.pinnedToggle.setAttribute('aria-controls', 'mobile-pinned-work-list');
-    }
-    renderCurrent();
-    return visibleRecent.length + fixed.length;
-  }
-
-  return {items, pinned, record, pin, unpin, setCurrent, render, load, sync, startLifecycle, state};
-});

frontend/mobile-review-detail-nav.js

@@ -1,81 +0,0 @@
-function createMobileReviewDetailNavigation(options) {
-  const buttons = options.buttons || {};
-  const targets = options.targets || {};
-  const listeners = new Map();
-  const prefersReducedMotion = options.prefersReducedMotion || (() => false);
-  const targetNames = new Map(Object.entries(targets).map(([name, target]) => [target, name]));
-  let observer = null;
-
-  function select(name) {
-    Object.entries(buttons).forEach(([key, button]) => {
-      if (!button) return;
-      if (key === name) button.setAttribute('aria-current', 'location');
-      else button.removeAttribute('aria-current');
-    });
-  }
-
-  function navigate(name, navigationOptions = {}) {
-    const target = targets[name];
-    if (!target) return false;
-    target.scrollIntoView({
-      block:'start',
-      behavior:prefersReducedMotion() ? 'auto' : 'smooth',
-    });
-    if (name === 'feedback' && options.summaryComposer && navigationOptions.focus !== false) {
-      options.summaryComposer.focus({ preventScroll:true });
-    }
-    select(name);
-    return true;
-  }
-
-  function reset() {
-    select('overview');
-  }
-
-  return {
-    start() {
-      Object.entries(buttons).forEach(([name, button]) => {
-        if (!button || listeners.has(button)) return;
-        const listener = event => {
-          event.preventDefault();
-          navigate(name);
-          if (options.onSectionChange) options.onSectionChange(name, { replace:false });
-        };
-        listeners.set(button, listener);
-        button.addEventListener('click', listener);
-      });
-      reset();
-      const observe = options.observe || ((handler, observedTargets, root) => {
-        if (typeof IntersectionObserver === 'undefined') return null;
-        const instance = new IntersectionObserver(handler, {
-          root:root || null,
-          rootMargin:'-20% 0px -60% 0px',
-          threshold:[0, 0.25, 0.5, 0.75, 1],
-        });
-        observedTargets.forEach(target => instance.observe(target));
-        return instance;
-      });
-      observer = observe(entries => {
-        const visible = entries
-          .filter(entry => entry.isIntersecting && targetNames.has(entry.target))
-          .sort((left, right) => right.intersectionRatio - left.intersectionRatio)[0];
-        if (visible) {
-          const name = targetNames.get(visible.target);
-          select(name);
-          if (options.onSectionChange) options.onSectionChange(name, { replace:true });
-        }
-      }, Array.from(targetNames.keys()).filter(Boolean), options.root || null);
-    },
-    stop() {
-      listeners.forEach((listener, button) => button.removeEventListener('click', listener));
-      listeners.clear();
-      if (observer) observer.disconnect();
-      observer = null;
-    },
-    navigate,
-    reset,
-    select,
-  };
-}
-
-if (typeof module !== 'undefined') module.exports = createMobileReviewDetailNavigation;

frontend/mobile-search-modal.js

@@ -1,83 +0,0 @@
-(function (root, factory) {
-  const createMobileSearchModal = factory();
-  if (typeof module !== 'undefined' && module.exports) module.exports = createMobileSearchModal;
-  else root.createMobileSearchModal = createMobileSearchModal;
-})(typeof globalThis !== 'undefined' ? globalThis : this, function () {
-  const FOCUSABLE = [
-    'a[href]', 'button', 'input', 'select', 'textarea',
-    '[tabindex]:not([tabindex="-1"])', '[contenteditable="true"]',
-  ].join(',');
-
-  return function createMobileSearchModal(options) {
-    const documentRef = options.document;
-    const backgrounds = Array.from(options.backgrounds || [
-      documentRef.querySelector?.('body > header'),
-      documentRef.querySelector?.('main'),
-      documentRef.querySelector?.('#mobile-task-dock'),
-    ]).filter(Boolean);
-    let surface = null;
-    let opener = null;
-    let priorInert = null;
-
-    function focusable() {
-      if (!surface || typeof surface.querySelectorAll !== 'function') return [];
-      return Array.from(surface.querySelectorAll(FOCUSABLE)).filter(element =>
-        !element.disabled && !element.hidden && element.getAttribute?.('aria-hidden') !== 'true' &&
-        (typeof element.matches !== 'function' || element.matches(':not([hidden])')) &&
-        (typeof element.getClientRects !== 'function' || element.getClientRects().length > 0)
-      );
-    }
-
-    function focus(element) {
-      if (element?.isConnected !== false && typeof element?.focus === 'function') element.focus();
-    }
-
-    function onKeydown(event) {
-      if (!surface || event.key !== 'Tab') return;
-      const controls = focusable();
-      if (!controls.length) {
-        event.preventDefault();
-        return;
-      }
-      const first = controls[0];
-      const last = controls[controls.length - 1];
-      if (event.shiftKey && documentRef.activeElement === first) {
-        event.preventDefault();
-        focus(last);
-      } else if (!event.shiftKey && documentRef.activeElement === last) {
-        event.preventDefault();
-        focus(first);
-      } else if (!controls.includes(documentRef.activeElement)) {
-        event.preventDefault();
-        focus(event.shiftKey ? last : first);
-      }
-    }
-
-    function transition(nextSurface, transitionOptions = {}) {
-      surface = nextSurface;
-      focus(transitionOptions.initialFocus || focusable()[0]);
-    }
-
-    function activate(nextSurface, activateOptions = {}) {
-      if (!surface) {
-        opener = activateOptions.opener || documentRef.activeElement || null;
-        priorInert = backgrounds.map(element => element.inert === true);
-        backgrounds.forEach(element => { element.inert = true; });
-      }
-      transition(nextSurface, activateOptions);
-    }
-
-    function deactivate() {
-      if (!surface) return;
-      backgrounds.forEach((element, index) => { element.inert = priorInert[index]; });
-      surface = null;
-      priorInert = null;
-      const restore = opener;
-      opener = null;
-      focus(restore);
-    }
-
-    documentRef.addEventListener('keydown', onKeydown);
-    return { activate, transition, deactivate, current: () => surface };
-  };
-});

frontend/mobile-search-preview-nav.js

@@ -1,132 +0,0 @@
-function createMobileSearchPreviewNavigation(options) {
-  const buttons = options.buttons || {};
-  const targets = options.targets || {};
-  const focusTargets = options.focusTargets || {};
-  const listeners = new Map();
-  const prefersReducedMotion = options.prefersReducedMotion || (() => false);
-  const targetNames = new Map(Object.entries(targets).map(([name, target]) => [target, name]));
-  let replyAvailable = options.replyAvailable !== false;
-  let observer = null;
-  let navigationLockUntil = 0;
-
-  function select(name) {
-    Object.entries(buttons).forEach(([key, button]) => {
-      if (!button) return;
-      if (key === name) button.setAttribute('aria-current', 'location');
-      else button.removeAttribute('aria-current');
-    });
-  }
-
-  function setReplyAvailable(available) {
-    replyAvailable = Boolean(available);
-    const button = buttons.reply;
-    if (!button) return;
-    if (replyAvailable) button.removeAttribute('aria-disabled');
-    else button.setAttribute('aria-disabled', 'true');
-  }
-
-  function navigate(name) {
-    if (name === 'reply' && !replyAvailable) return false;
-    const target = targets[name];
-    if (!target) return false;
-    target.scrollIntoView({
-      block: 'start',
-      behavior: prefersReducedMotion() ? 'auto' : 'smooth',
-    });
-    navigationLockUntil = Date.now() + 500;
-    select(name);
-    const focusTarget = focusTargets[name] || (name === 'reply' ? target : null);
-    if (focusTarget) focusTarget.focus({preventScroll:true});
-    return true;
-  }
-
-  function reset(available = replyAvailable) {
-    setReplyAvailable(available);
-    select('overview');
-  }
-
-  return {
-    start() {
-      Object.entries(buttons).forEach(([name, button]) => {
-        if (!button || listeners.has(button)) return;
-        const listener = event => {
-          event.preventDefault();
-          navigate(name);
-        };
-        listeners.set(button, listener);
-        button.addEventListener('click', listener);
-      });
-      reset(replyAvailable);
-      const observe = options.observe || ((handler, observedTargets, root) => {
-        if (typeof IntersectionObserver === 'undefined') return null;
-        const instance = new IntersectionObserver(handler, {
-          root,
-          rootMargin: '-20% 0px -60% 0px',
-          threshold: [0, 0.25, 0.5, 0.75, 1],
-        });
-        observedTargets.forEach(target => instance.observe(target));
-        return instance;
-      });
-      observer = observe(entries => {
-        if (Date.now() < navigationLockUntil) return;
-        const visible = entries
-          .filter(entry => entry.isIntersecting && targetNames.has(entry.target))
-          .filter(entry => targetNames.get(entry.target) !== 'reply' || replyAvailable)
-          .sort((left, right) => right.intersectionRatio - left.intersectionRatio)[0];
-        if (visible) select(targetNames.get(visible.target));
-      }, Array.from(targetNames.keys()).filter(Boolean), options.root || null);
-    },
-    stop() {
-      listeners.forEach((listener, button) => button.removeEventListener('click', listener));
-      listeners.clear();
-      if (observer) observer.disconnect();
-      observer = null;
-    },
-    navigate,
-    reset,
-    select,
-    setReplyAvailable,
-  };
-}
-
-function attachMobileSearchPreviewNavigation({document, window}) {
-  const bySection = name => document.querySelector('[data-search-preview-section="' + name + '"]');
-  const preview = document.getElementById('search-preview');
-  const reply = document.getElementById('search-preview-reply-workspace');
-  const navigation = createMobileSearchPreviewNavigation({
-    root:document.querySelector('.search-preview-panel'),
-    buttons:{
-      overview:bySection('overview'),
-      conversation:bySection('conversation'),
-      changes:bySection('changes'),
-      reply:bySection('reply'),
-      actions:bySection('actions'),
-    },
-    targets:{
-      overview:document.getElementById('search-preview-overview'),
-      conversation:document.getElementById('search-preview-conversation'),
-      changes:document.getElementById('search-preview-review'),
-      reply,
-      actions:document.getElementById('search-preview-actions'),
-    },
-    focusTargets:{reply:document.getElementById('search-preview-reply')},
-    replyAvailable:!reply.hidden,
-    prefersReducedMotion:() => window.matchMedia('(prefers-reduced-motion: reduce)').matches,
-  });
-  navigation.start();
-  new MutationObserver(() => navigation.setReplyAvailable(!reply.hidden)).observe(reply, {
-    attributes:true, attributeFilter:['hidden'],
-  });
-  new MutationObserver(() => {
-    if (preview.classList.contains('open')) navigation.reset(!reply.hidden);
-  }).observe(preview, {attributes:true, attributeFilter:['class']});
-  ['previous-search-result', 'next-search-result'].forEach(id => {
-    document.getElementById(id).addEventListener('click', () => {
-      setTimeout(() => navigation.reset(!reply.hidden), 0);
-    });
-  });
-  return navigation;
-}
-
-if (typeof module !== 'undefined') module.exports = createMobileSearchPreviewNavigation;
-else attachMobileSearchPreviewNavigation({document, window});

frontend/mobile-search-viewport.js

@@ -1,50 +0,0 @@
-(function (root, factory) {
-  const exported = factory();
-  if (typeof module === 'object' && module.exports) module.exports = exported;
-  else root.createMobileSearchViewport = exported;
-})(typeof self !== 'undefined' ? self : this, function () {
-  return function createMobileSearchViewport(options) {
-    const palette = options.palette;
-    const results = options.results;
-    const viewport = options.viewport;
-    const mediaQuery = options.mediaQuery;
-    const schedule = options.schedule || (callback => requestAnimationFrame(callback));
-    let active = false;
-    let scrollTop = 0;
-
-    function applyGeometry() {
-      if (!active || !mediaQuery.matches || !viewport) return;
-      palette.style.setProperty('--search-viewport-top', `${viewport.offsetTop || 0}px`);
-      palette.style.setProperty('--search-viewport-height', `${viewport.height}px`);
-    }
-
-    function onViewportChange() {
-      schedule(applyGeometry);
-    }
-
-    return {
-      open() {
-        if (active || !mediaQuery.matches || !viewport) return;
-        active = true;
-        applyGeometry();
-        viewport.addEventListener('resize', onViewportChange);
-        viewport.addEventListener('scroll', onViewportChange);
-      },
-      close() {
-        if (active && viewport) {
-          viewport.removeEventListener('resize', onViewportChange);
-          viewport.removeEventListener('scroll', onViewportChange);
-        }
-        active = false;
-        palette.style.removeProperty('--search-viewport-top');
-        palette.style.removeProperty('--search-viewport-height');
-      },
-      rememberScroll() {
-        scrollTop = results.scrollTop;
-      },
-      restoreScroll() {
-        schedule(() => { results.scrollTop = scrollTop; });
-      },
-    };
-  };
-});

frontend/mobile-start-day.js

@@ -1,201 +0,0 @@
-(function (root, factory) {
-  if (typeof module === 'object' && module.exports) module.exports = factory;
-  else root.createMobileStartDay = factory;
-})(typeof self !== 'undefined' ? self : this, function createMobileStartDay(options) {
-  const checkpointKey = 'stackchain.mobile-start-day.v1';
-  const storage = options.storage || (typeof localStorage !== 'undefined' ? localStorage : null);
-  const reviewOrder = [
-    ['delivery', 'Delivery recovery'],
-    ['gate', 'Human Gates'],
-    ['agenda', 'Agenda'],
-    ['attention', 'Attention'],
-    ['update', 'Updates'],
-    ['filed', 'Filed'],
-    ['following', 'Following'],
-  ];
-  const anonymousItems = new WeakMap();
-  let anonymousItemSequence = 0;
-
-  function count(value) {
-    return Math.max(0, Number(value) || 0);
-  }
-
-  function itemIdentity(item) {
-    if (item === null || item === undefined) return '';
-    if (typeof item !== 'object') return String(item);
-    const explicit = item.outbox_id || item.id || item.key || item.url;
-    if (explicit !== null && explicit !== undefined && String(explicit)) {
-      return String(item.kind || 'item') + ':' + String(explicit);
-    }
-    if (!anonymousItems.has(item)) anonymousItems.set(item, 'anonymous:' + (++anonymousItemSequence));
-    return anonymousItems.get(item);
-  }
-
-  function reviewPhases(counts) {
-    if (!options.getPhaseItems) {
-      return reviewOrder
-        .map(([name, label]) => ({name, label, count: count(counts[name])}))
-        .filter(phase => phase.count > 0);
-    }
-    const items = options.getPhaseItems() || {};
-    const seen = new Set();
-    return reviewOrder.flatMap(([name, label]) => {
-      let phaseCount = 0;
-      (items[name] || []).forEach(item => {
-        const identity = itemIdentity(item);
-        if (!identity || seen.has(identity)) return;
-        seen.add(identity);
-        phaseCount += 1;
-      });
-      return phaseCount ? [{name, label, count:phaseCount}] : [];
-    });
-  }
-
-  function localDay() {
-    const now = new Date();
-    const pad = value => String(value).padStart(2, '0');
-    return now.getFullYear() + '-' + pad(now.getMonth() + 1) + '-' + pad(now.getDate());
-  }
-
-  function identity() {
-    try {
-      return {
-        login: String(options.getLogin ? options.getLogin() : '').trim(),
-        day: String(options.getDay ? options.getDay() : localDay()),
-      };
-    } catch (_) {
-      return {login:'', day:''};
-    }
-  }
-
-  function checkpoint() {
-    if (!storage) return null;
-    const current = identity();
-    if (!current.login || !current.day) return null;
-    try {
-      const saved = JSON.parse(storage.getItem(checkpointKey) || 'null');
-      return saved?.login === current.login && saved?.day === current.day ? saved : null;
-    } catch (_) {
-      return null;
-    }
-  }
-
-  function saveCheckpoint(phase = null) {
-    if (!storage) return false;
-    const current = identity();
-    if (!current.login || !current.day) return false;
-    try {
-      storage.setItem(checkpointKey, JSON.stringify({...current, phase}));
-      return true;
-    } catch (_) {
-      return false;
-    }
-  }
-
-  function clearCheckpoint() {
-    if (!storage || !checkpoint()) return false;
-    try {
-      storage.removeItem(checkpointKey);
-      return true;
-    } catch (_) {
-      return false;
-    }
-  }
-
-  function briefing() {
-    const counts = options.getCounts ? options.getCounts() : {};
-    let phases = reviewPhases(counts);
-    const gateUnavailable = counts.gateUnavailable === true;
-    if (gateUnavailable) {
-      phases = phases.filter(phase => phase.name !== 'gate');
-      const afterDelivery = phases[0]?.name === 'delivery' ? 1 : 0;
-      phases.splice(afterDelivery, 0, {name:'gate', label:'Human Gates unavailable · retry', count:count(counts.gate)});
-    }
-    const followingUnavailable = counts.followingUnavailable === true;
-    if (followingUnavailable) {
-      phases = phases.filter(phase => phase.name !== 'following');
-      phases.push({name:'following', label:'Following unavailable', count:count(counts.following)});
-    }
-    const total = phases.reduce((sum, phase) => sum + phase.count, 0);
-    const today = count(counts.today);
-    const delivery = phases.find(phase => phase.name === 'delivery')?.count || 0;
-    const other = total - delivery;
-    const next = phases.length ? phases[0].name : (today ? 'today' : 'find');
-    const nextLabel = next === 'delivery' ? 'Review Delivery' :
-      (next === 'gate' && gateUnavailable ? 'Retry Human Gates' :
-      (next === 'following' && followingUnavailable ? 'Retry Following' :
-      (phases.length ? 'Review ' + phases[0].label : (today ? 'Continue Today' : 'Find Work'))));
-    const gateRetry = next === 'gate' && gateUnavailable;
-    const followingRetry = next === 'following' && followingUnavailable;
-    return {
-      total,
-      next,
-      label: nextLabel,
-      summary: gateRetry ? 'Human Gates need retry before Today · ' + today + ' planned' :
-        followingRetry ? 'Following needs retry before Today · ' + today + ' planned' :
-        delivery ? delivery + (delivery === 1 ? ' delivery needs' : ' deliveries need') +
-        ' action before Today' + (other ? ' · ' + other + ' other ' + (other === 1 ? 'item' : 'items') : '') +
-        ' · ' + today + ' planned' :
-        total ? total + ' items before Today · ' + today + ' planned' :
-        (today ? 'Review clear · ' + today + ' planned' : 'Review clear · Today is empty'),
-      phases,
-    };
-  }
-
-  function startNext() {
-    const next = briefing().next;
-    if (reviewOrder.some(([name]) => name === next)) saveCheckpoint(next);
-    else clearCheckpoint();
-    options.openQueue(next);
-    return next;
-  }
-
-  function state() {
-    const current = briefing();
-    return {active:Boolean(checkpoint()), next:current.next, label:current.label};
-  }
-
-  function completePhase(phase) {
-    const saved = checkpoint();
-    if (!saved || (saved.phase && saved.phase !== phase)) return false;
-    const current = render();
-    saveCheckpoint();
-    if (options.onHandoff) options.onHandoff(current);
-    return true;
-  }
-
-  function reconcile({authoritative = false, authoritativePhases = []} = {}) {
-    const saved = checkpoint();
-    if (!saved?.phase || (!authoritative && !authoritativePhases.includes(saved.phase))) return false;
-    const counts = options.getCounts ? options.getCounts() : {};
-    if (count(counts[saved.phase]) > 0) return false;
-    return completePhase(saved.phase);
-  }
-
-  function finish() {
-    const cleared = clearCheckpoint();
-    render();
-    return cleared;
-  }
-
-  function render() {
-    const current = briefing();
-    if (!options.elements) return current;
-    options.elements.summary.textContent = current.summary;
-    options.elements.phases.textContent = current.phases.length ?
-      current.phases.map(phase => phase.label + ' ' + phase.count).join(' · ') :
-      'All urgent queues reviewed';
-    if (options.elements.action) {
-      options.elements.action.textContent = checkpoint() ? 'Resume preparation · ' + current.label : current.label;
-    }
-    if (options.elements.finish) options.elements.finish.hidden = !checkpoint();
-    return current;
-  }
-
-  function start() {
-    render();
-    if (options.elements?.action) options.elements.action.addEventListener('click', startNext);
-  }
-
-  return {briefing, completePhase, finish, reconcile, render, start, startNext, state};
-});

frontend/mobile-task-dock.js

@@ -9,136 +9,45 @@
   let wasHidden = false;
 
   function select(name) {
-    if (!buttons[name]) return false;
     Object.entries(buttons).forEach(([key, button]) => {
       if (key === name) button.setAttribute('aria-current', 'page');
       else button.removeAttribute('aria-current');
     });
-    return true;
   }
 
   function refreshVisibility() {
-    const hidden = overlays.some(overlay => overlay.open || overlay.classList.contains('open'));
+    const hidden = overlays.some(overlay => overlay.classList.contains('open'));
     nav.hidden = hidden;
-    if (options.sessionHud) {
-      if (hidden) options.sessionHud.setAttribute('data-overlay-hidden', 'true');
-      else options.sessionHud.removeAttribute('data-overlay-hidden');
-    }
     if (wasHidden && !hidden && launcher) launcher.focus();
     wasHidden = hidden;
   }
 
-  function openQueues() {
-    if (!options.queueSheet || options.queueSheet.open) return;
-    options.queueSheet.showModal();
-  }
-
-  function closeQueues(returnToToday = false) {
-    options.queueSheet?.open && options.queueSheet.close();
-    if (returnToToday) options.detour?.()?.finishDetour();
-  }
-
   function start() {
     Object.entries(buttons).forEach(([name, button]) => {
       button.addEventListener('click', event => {
         launcher = event.currentTarget;
         select(name);
-        if (name === 'queues') options.detour?.()?.beginDetour(name);
-        options.actions?.[name]?.();
-        if (name === 'queues' && options.queueSheet) openQueues();
+        options.actions[name]();
       });
     });
-    if (options.queueSheet) {
-      options.queueClose?.addEventListener('click', () => closeQueues(true));
-      options.queueSheet.addEventListener('cancel', event => {
-        event.preventDefault();
-        closeQueues(true);
-      });
-      options.queueSheet.addEventListener('close', () => buttons.queues?.focus());
-      Object.entries(options.queueRows || {}).forEach(([name, row]) => {
-        row.addEventListener('click', () => {
-          closeQueues();
-          options.onSelectQueue?.(name, row);
-        });
-      });
-    }
     options.observe(refreshVisibility, overlays);
     refreshVisibility();
   }
 
-  function updateWork(mode) {
-    const text = {
-      continue:'Continue', resume:'Resume', start:'Start', plan:'Plan', find:'Find',
-      prepare:'Prepare', 'prepare-resume':'Resume prep',
-      delivery:'Delivery', attention:'Attention', update:'Updates', agenda:'Agenda',
-      following:'Following', authored:'My PRs', filed:'Filed', later:'Later', draft:'Drafts',
-    }[mode] || 'Work';
-    const queue = ['Delivery', 'Attention', 'Updates', 'Agenda', 'Following', 'My PRs', 'Filed', 'Later', 'Drafts'].includes(text);
-    if (options.workLabel) options.workLabel.textContent = text;
-    const actionLabel = mode === 'prepare' ? 'Prepare Today' :
-      mode === 'prepare-resume' ? 'Resume preparation' :
-      queue ? (mode === 'update' ? 'Resume ' : 'Open ') + text :
-      mode === 'find' ? 'Find work' : text + (mode === 'work' ? '' : ' Today');
-    if (buttons.work) buttons.work.setAttribute('aria-label', actionLabel);
-  }
-
   function updateAttention(count) {
     const total = Math.max(0, Number(count) || 0);
-    const visible = total > 0;
-    if (options.attentionBadge) {
-      options.attentionBadge.textContent = String(total);
-      options.attentionBadge.hidden = !visible;
+    const badge = options.attentionBadge;
+    if (badge) {
+      badge.textContent = String(total);
+      badge.hidden = total === 0;
     }
-    if (buttons.attention) {
-      buttons.attention.hidden = !visible;
-      buttons.attention.setAttribute('aria-label', 'Attention, ' + total + ' items');
+    if (buttons.work) {
+      buttons.work.setAttribute(
+        'aria-label',
+        total ? 'Work, ' + total + ' items need attention' : 'Work'
+      );
     }
-    if (visible) nav.setAttribute('data-attention', 'true');
-    else nav.removeAttribute('data-attention');
   }
 
-  function updateQueues(counts) {
-    const names = 'today agenda delivery gate attention update following filed authored later draft'.split(' ');
-    const normalized = Object.fromEntries(names.map(name => [name, Math.max(0, Number(counts?.[name]) || 0)]));
-    const actionableNames = ['today', 'delivery', 'gate', 'attention', 'update', 'following', 'filed', 'authored', 'later', 'draft'];
-    const active = actionableNames.reduce((total, name) => total + (normalized[name] > 0 ? 1 : 0), 0);
-    Object.entries(options.queueCounts || {}).forEach(([name, element]) => {
-      element.textContent = String(normalized[name] || 0);
-    });
-    options.queueRows?.update?.setAttribute(
-      'aria-label', 'Updates, ' + normalized.update + ' unread conversations'
-    );
-    options.queueRows?.following?.setAttribute(
-      'aria-label', 'Following, ' + normalized.following + ' unseen changes'
-    );
-    if (options.queueBadge) {
-      options.queueBadge.textContent = active + ' active';
-      options.queueBadge.hidden = active === 0;
-    }
-    if (options.deadlineBadge) {
-      options.deadlineBadge.textContent = normalized.agenda + ' due';
-      options.deadlineBadge.hidden = normalized.agenda === 0;
-    }
-    if (options.queueRows?.agenda) {
-      if (normalized.agenda > 0) options.queueRows.agenda.setAttribute('data-deadlines', 'true');
-      else options.queueRows.agenda.removeAttribute('data-deadlines');
-    }
-    const label = active === 0 && normalized.agenda === 0
-      ? 'Queues: no active queues; no upcoming deadlines'
-      : 'Queues: Today ' + normalized.today
-        + ', Agenda ' + normalized.agenda + ' due'
-        + ', Delivery ' + normalized.delivery
-        + ', Human Gates ' + normalized.gate
-        + ', Attention ' + normalized.attention
-        + ', Updates ' + normalized.update
-        + ', Following ' + normalized.following
-        + ', Filed ' + normalized.filed
-        + ', My PRs ' + normalized.authored
-        + ', Later ' + normalized.later
-        + ', Drafts ' + normalized.draft
-        + '; ' + active + ' active ' + (active === 1 ? 'queue' : 'queues');
-    buttons.queues?.setAttribute('aria-label', label);
-  }
-
-  return {start, select, refreshVisibility, updateAttention, updateQueues, updateWork};
+  return {start, refreshVisibility, updateAttention};
 });

frontend/mobile-today-command-bar.js

@@ -1,56 +0,0 @@
-(function (root, factory) {
-  if (typeof module !== 'undefined' && module.exports) module.exports = factory;
-  else root.createMobileTodayCommandBar = factory;
-})(typeof window !== 'undefined' ? window : this, function createMobileTodayCommandBar({
-  more,
-  sheet,
-  close,
-  firstAction,
-  endAction,
-  existingEndControl,
-  actionButtons = [],
-  hud,
-  dock,
-  style,
-  ResizeObserverImpl = typeof ResizeObserver === 'undefined' ? null : ResizeObserver,
-}) {
-  if (!more || !sheet) return null;
-
-  const dismiss = () => {
-    if (sheet.open) sheet.close();
-  };
-  const open = () => {
-    if (sheet.open) return;
-    more.setAttribute('aria-expanded', 'true');
-    sheet.showModal();
-    firstAction?.focus();
-  };
-
-  more.setAttribute('aria-expanded', 'false');
-  more.addEventListener('click', open);
-  close?.addEventListener('click', dismiss);
-  actionButtons.forEach(button => button?.addEventListener('click', dismiss));
-  endAction?.addEventListener('click', () => {
-    dismiss();
-    existingEndControl?.click();
-  });
-  sheet.addEventListener('cancel', event => {
-    event.preventDefault();
-    dismiss();
-  });
-  sheet.addEventListener('close', () => {
-    more.setAttribute('aria-expanded', 'false');
-    more.focus();
-  });
-
-  const measure = () => {
-    if (!style || !hud || !dock) return;
-    style.setProperty('--mobile-today-clearance', `${hud.offsetHeight + dock.offsetHeight + 16}px`);
-  };
-  const observer = ResizeObserverImpl && hud && dock ? new ResizeObserverImpl(measure) : null;
-  observer?.observe(hud);
-  observer?.observe(dock);
-  measure();
-
-  return { open, close:dismiss, measure, destroy:() => observer?.disconnect() };
-});

frontend/mobile-update-detail-nav.js

@@ -1,88 +0,0 @@
-function createMobileUpdateDetailNavigation(options) {
-  const buttons = options.buttons || {};
-  const targets = options.targets || {};
-  const listeners = new Map();
-  const prefersReducedMotion = options.prefersReducedMotion || (() => false);
-  const targetNames = new Map(Object.entries(targets).map(([name, target]) => [target, name]));
-  let observer = null;
-
-  function select(name) {
-    Object.entries(buttons).forEach(([key, button]) => {
-      if (!button) return;
-      if (key === name) button.setAttribute('aria-current', 'location');
-      else button.removeAttribute('aria-current');
-    });
-  }
-
-  function navigate(name, navigationOptions = {}) {
-    if (name === 'activity') {
-      if (options.jumpToNewActivity) options.jumpToNewActivity();
-      select(name);
-      return true;
-    }
-    const target = targets[name];
-    if (!target) return false;
-    if (name === 'context') target.open = true;
-    target.scrollIntoView({
-      block:'start',
-      behavior:prefersReducedMotion() ? 'auto' : 'smooth',
-    });
-    if (name === 'reply' && options.replyComposer && navigationOptions.focus !== false) {
-      options.replyComposer.focus({ preventScroll:true });
-    }
-    select(name);
-    return true;
-  }
-
-  function reset() {
-    if (targets.context) targets.context.open = false;
-    select('activity');
-  }
-
-  return {
-    start() {
-      Object.entries(buttons).forEach(([name, button]) => {
-        if (!button || listeners.has(button)) return;
-        const listener = event => {
-          event.preventDefault();
-          navigate(name);
-          if (options.onSectionChange) options.onSectionChange(name, { replace:false });
-        };
-        listeners.set(button, listener);
-        button.addEventListener('click', listener);
-      });
-      reset();
-      const observe = options.observe || ((handler, observedTargets) => {
-        if (typeof IntersectionObserver === 'undefined') return null;
-        const instance = new IntersectionObserver(handler, {
-          root:options.root || null,
-          rootMargin:'-20% 0px -60% 0px',
-          threshold:[0, 0.25, 0.5, 0.75, 1],
-        });
-        observedTargets.forEach(target => instance.observe(target));
-        return instance;
-      });
-      observer = observe(entries => {
-        const visible = entries
-          .filter(entry => entry.isIntersecting && targetNames.has(entry.target))
-          .sort((left, right) => right.intersectionRatio - left.intersectionRatio)[0];
-        if (visible) {
-          const name = targetNames.get(visible.target);
-          select(name);
-          if (options.onSectionChange) options.onSectionChange(name, { replace:true });
-        }
-      }, Array.from(targetNames.keys()).filter(Boolean));
-    },
-    stop() {
-      listeners.forEach((listener, button) => button.removeEventListener('click', listener));
-      listeners.clear();
-      if (observer) observer.disconnect();
-      observer = null;
-    },
-    navigate,
-    reset,
-    select,
-  };
-}
-
-if (typeof module !== 'undefined') module.exports = createMobileUpdateDetailNavigation;

frontend/mobile-work-entry.js

@@ -1,33 +0,0 @@
-(function (root, factory) {
-  if (typeof module === 'object' && module.exports) module.exports = factory;
-  else root.createMobileWorkEntry = factory;
-})(typeof self !== 'undefined' ? self : this, function createMobileWorkEntry(options) {
-  function mode() {
-    if (options.isTodayActive()) return 'continue';
-    const preparation = options.getPreparationState?.();
-    if (preparation?.active) return 'prepare-resume';
-    if (preparation?.next && !['today', 'find'].includes(preparation.next)) return 'prepare';
-    const recommended = options.queueLauncher && options.queueLauncher.recommend();
-    if (recommended && !['today', 'find'].includes(recommended.name)) return recommended.name;
-    if (options.getTodayCount() > 0 && options.isTodayResumable()) return 'resume';
-    if (options.getTodayCount() > 0) return 'start';
-    if (options.getEligibleCount() > 0) return 'plan';
-    if (options.shouldActivate?.()) return 'activate';
-    return 'find';
-  }
-
-  function open() {
-    const current = mode();
-    if (current === 'continue') options.continueToday();
-    else if (['prepare', 'prepare-resume'].includes(current)) options.prepareToday();
-    else if (current === 'resume') options.resumeToday();
-    else if (current === 'start') options.startToday();
-    else if (current === 'plan') options.planToday();
-    else if (current === 'activate') options.openActivation();
-    else if (current === 'find') options.findWork();
-    else options.queueLauncher.open(current);
-    return current;
-  }
-
-  return {mode, open};
-});

frontend/my-work.js

@@ -1,26 +1,15 @@
-function calendarDay(value) {
-  const match = String(value || '').match(/^(\d{4})-(\d{2})-(\d{2})(?:$|T)/);
-  if (!match) return '';
-  const date = new Date(Number(match[1]), Number(match[2]) - 1, Number(match[3]));
-  return date.getFullYear() === Number(match[1]) && date.getMonth() === Number(match[2]) - 1 &&
-    date.getDate() === Number(match[3]) ? match.slice(1, 4).join('-') : '';
-}
-
-function localDay(value) {
-  return value.getFullYear() + '-' + String(value.getMonth() + 1).padStart(2, '0') + '-' +
-    String(value.getDate()).padStart(2, '0');
-}
-
 function issueDueState(dueDate, now) {
-  const dueDay = calendarDay(dueDate);
-  if (!dueDay) return null;
-  const today = localDay(now);
+  if (!dueDate) return null;
+  const due = new Date(dueDate);
+  if (Number.isNaN(due.getTime())) return null;
+  const day = value => value.getFullYear() + '-' + String(value.getMonth() + 1).padStart(2, '0') + '-' +
+    String(value.getDate()).padStart(2, '0');
+  const dueDay = day(due);
+  const today = day(now);
   if (dueDay < today) return { label: 'Overdue', priority: 2 };
   if (dueDay === today) return { label: 'Due today', priority: 2.5 };
   return {
-    label: 'Due ' + new Date(
-      Number(dueDay.slice(0, 4)), Number(dueDay.slice(5, 7)) - 1, Number(dueDay.slice(8, 10))
-    ).toLocaleDateString(undefined, { month: 'short', day: 'numeric' }),
+    label: 'Due ' + due.toLocaleDateString(undefined, { month: 'short', day: 'numeric' }),
     priority: 4,
   };
 }
@@ -44,19 +33,6 @@ function needsAttention(item) {
   return Boolean(item && (item.has_update || item.is_review || urgencyReason(item)));
 }
 
-function updateActionability(item) {
-  const priorityLabels = ['p0', 'priority-high', 'critical'];
-  if ((item?.labels || []).some(label => priorityLabels.includes(String(label).toLowerCase()))) {
-    return { priority: 0, reason: 'Critical' };
-  }
-  if (item?.is_review) return { priority: 1, reason: 'Review requested' };
-  if (item?.is_assigned && ['Overdue', 'Due today'].includes(item?.due_label)) {
-    return { priority: 2, reason: item.due_label };
-  }
-  if (item?.is_assigned) return { priority: 3, reason: 'Assigned to you' };
-  return { priority: 4, reason: '' };
-}
-
 function buildMyWork(data, now = new Date()) {
   const login = data.user?.login || '';
   const issues = (data.issues || []).map((item) => ({ ...item, kind: 'issue' }));
@@ -70,27 +46,19 @@ function buildMyWork(data, now = new Date()) {
     );
     const assigned = (item.assignees || []).includes(login);
     const isReview = (item.work_reasons || []).includes('review_requested');
-    const isFiled = (item.work_reasons || []).includes('created_by_me');
-    const isAuthored = (item.work_reasons || []).includes('authored_by_me');
-    const isCompleted = isFiled && item.state === 'closed';
     const due = item.kind === 'issue' ? issueDueState(item.due_date, now) : null;
     const normalized = {
       ...item,
       key: (item.repository || 'unknown') + '#' + item.number,
       is_review: isReview,
-      is_filed: isFiled,
-      is_authored: isAuthored,
-      is_completed: isCompleted,
       is_assigned: assigned,
       has_update: false,
       ...(due ? { due_label: due.label } : {}),
       reason: priorityLabel ? priorityLabel + ' priority' :
         (due && due.priority < 4 ? due.label :
-          (isReview ? 'Needs your review' : (isCompleted ? 'Completed · review outcome' :
-            (assigned ? 'Assigned to you' : (isFiled ? 'Filed by you' :
-              (isAuthored ? 'Authored by you' : 'Open work')))))),
+          (isReview ? 'Needs your review' : (assigned ? 'Assigned to you' : 'Open work'))),
       _priority: priorityLabel ? 0 :
-        (due && due.priority < 4 ? due.priority : (isReview ? 3 : (isCompleted ? 3.5 : (assigned ? 4 : 5)))),
+        (due && due.priority < 4 ? due.priority : (isReview ? 3 : (assigned ? 4 : 5))),
     };
     normalized.needs_attention = needsAttention(normalized);
     normalized.attention_reason = attentionReason(normalized);
@@ -103,15 +71,13 @@ function buildMyWork(data, now = new Date()) {
     const subjectKind = String(update.subject_type || '').toLowerCase().includes('pull') ? 'pull' : 'issue';
     const existing = byKey.get(subjectKind + ':' + key);
     if (existing) {
-      const actionability = updateActionability(existing);
       existing.has_update = true;
       existing.needs_attention = true;
       existing.attention_reason = 'Unread update';
       existing.notification_id = update.id;
       existing.url = update.url || existing.url;
       existing.updated_at = update.updated_at || existing.updated_at;
-      existing.update_reason = actionability.reason;
-      existing._priority = actionability.priority;
+      existing._priority = Math.min(existing._priority, 1);
       return;
     }
     if (!update.url) return;
@@ -126,8 +92,7 @@ function buildMyWork(data, now = new Date()) {
       attention_reason: 'Unread update',
       notification_id: update.id,
       reason: 'Unread update',
-      update_reason: '',
-      _priority: 4,
+      _priority: 1,
     };
     work.push(item);
     byKey.set(subjectKind + ':' + key, item);
@@ -213,67 +178,10 @@ function createBulkNotificationAcknowledger({ markRead, onItems, onStatus }) {
   };
 }
 
-function createNotificationSelection({ limit = 50, onChange = () => {} } = {}) {
-  const maximum = Number.isInteger(limit) && limit > 0 ? limit : 50;
-  let active = false;
-  const selected = new Set();
-  const snapshot = () => ({
-    active,
-    ids: Array.from(selected),
-    count: selected.size,
-    limit: maximum,
-    at_limit: selected.size >= maximum,
-  });
-  const publish = () => onChange(snapshot());
-  const select = notificationId => {
-    if (!active || !Number.isInteger(notificationId)) return 'inactive';
-    if (selected.has(notificationId)) return 'already-selected';
-    if (selected.size >= maximum) return 'limit';
-    selected.add(notificationId);
-    publish();
-    return 'selected';
-  };
-  return {
-    start() {
-      if (active) return snapshot();
-      active = true;
-      publish();
-      return snapshot();
-    },
-    select,
-    toggle(notificationId) {
-      if (!selected.has(notificationId)) return select(notificationId);
-      selected.delete(notificationId);
-      publish();
-      return 'deselected';
-    },
-    retain(notificationIds) {
-      const allowed = new Set((notificationIds || []).filter(Number.isInteger));
-      let changed = false;
-      selected.forEach(id => {
-        if (!allowed.has(id)) {
-          selected.delete(id);
-          changed = true;
-        }
-      });
-      if (changed) publish();
-      return snapshot();
-    },
-    cancel() {
-      active = false;
-      selected.clear();
-      publish();
-      return snapshot();
-    },
-    snapshot,
-  };
-}
-
 function createNotificationPager({ load, onNotifications, onPagination, onStatus }) {
   let pagination = { page: 1, total: 0, has_more: false };
   let pending = false;
-  let completing = null;
-  const pager = {
+  return {
     reset(next) {
       pagination = { ...pagination, ...(next || {}) };
       onPagination(pagination);
@@ -307,31 +215,18 @@ function createNotificationPager({ load, onNotifications, onPagination, onStatus
         pending = false;
       }
     },
-    loadAll(getExisting) {
-      if (completing) return completing;
-      completing = (async () => {
-        while (pagination.has_more) {
-          const loaded = await pager.loadMore(getExisting());
-          if (!loaded) return false;
-        }
-        return true;
-      })().finally(() => { completing = null; });
-      return completing;
-    },
   };
-  return pager;
 }
 
 function createWorkPager({ load, onItems, onPagination, onStatus }) {
   let pagination = {};
   const pending = new Set();
-  const completing = new Map();
   const labels = {
     issue: 'issues',
     pull: 'pull requests',
     review: 'review requests',
   };
-  const pager = {
+  return {
     reset(next) {
       Object.entries(next || {}).forEach(([stream, value]) => {
         const current = pagination[stream];
@@ -380,109 +275,27 @@ function createWorkPager({ load, onItems, onPagination, onStatus }) {
         pending.delete(stream);
       }
     },
-    loadAll(stream, getExisting) {
-      if (completing.has(stream)) return completing.get(stream);
-      const completion = (async () => {
-        while (pagination[stream]?.has_more) {
-          const loaded = await pager.loadMore(stream, getExisting());
-          if (!loaded) return false;
-        }
-        return true;
-      })().finally(() => completing.delete(stream));
-      completing.set(stream, completion);
-      return completion;
-    },
   };
-  return pager;
 }
 
 function createNotificationReader({
   load, markRead, onOpen, onDetail, onItems, onStatus, onClose,
-  acknowledge = null,
-  queueRead = null,
-  loadSaved = () => null,
   loadConversation = null,
   onConversation = () => {},
-  onConversationStatus = () => {},
   createPager = typeof createConversationPager === 'function' ? createConversationPager : null,
-  getScope = () => '',
 }) {
   let selected = null;
   let loadVersion = 0;
   let marking = false;
   let conversationPager = null;
-  let offlineHydrated = false;
-  let prefetched = null;
-  let prefetchKey = '';
 
-  async function hydrateConversation(item, version) {
-    if (!loadConversation || !createPager || !item || offlineHydrated) return false;
-    onConversationStatus('Loading conversation…');
-    try {
-      const initial = await loadConversation(item.notification_id, null);
-      if (selected !== item || version !== loadVersion) return false;
-      conversationPager = createPager({
-        loadPage: page => loadConversation(item.notification_id, page),
-      });
-      const state = conversationPager.reset(initial);
-      onConversation(state);
-      onConversationStatus(state.comments.length + ' of ' +
-        Math.max(state.total || 0, state.comments.length) + ' messages loaded.');
-      return true;
-    } catch (_error) {
-      if (selected === item && version === loadVersion) {
-        conversationPager = null;
-        onConversationStatus('Conversation temporarily unavailable. Retry.');
-      }
-      return false;
-    }
-  }
-
-  function prefetch(item) {
-    if (!item) { prefetched = null; prefetchKey = ''; return false; }
-    const notificationId = item?.notification_id;
-    if (!Number.isInteger(notificationId) || offlineHydrated) return false;
-    const key = getScope() + notificationId;
-    if (prefetchKey === key) return prefetched;
-    if (prefetched) return false;
-    prefetchKey = key;
-    prefetched = load(notificationId);
-    return prefetched;
-  }
-
-  async function advanceAfterRead(items, current, queueing = false) {
-    const updated = acknowledgeNotification(items, current.notification_id);
-    onItems(updated);
-    const currentIndex = items.indexOf(current);
-    const remaining = items.slice(currentIndex + 1).concat(items.slice(0, currentIndex));
-    const next = remaining.find(item => item && item.has_update &&
-      Number.isInteger(item.notification_id) && (!queueing || loadSaved(item)));
-    if (next) await open(next, queueing ? loadSaved(next) : null);
-    else {
-      selected = null;
-      onClose();
-      onStatus('Inbox cleared.');
-    }
-    return { items: updated, item: current, next: next || null };
-  }
-
-  async function open(item, savedDetail = null) {
+  async function open(item) {
     selected = item;
-    offlineHydrated = Boolean(savedDetail && !Array.isArray(savedDetail));
     const version = ++loadVersion;
-    const preload = !offlineHydrated && prefetchKey === getScope() + item.notification_id ? prefetched : null;
-    prefetched = null;
-    prefetchKey = '';
     onOpen(item);
-    if (!preload) onStatus('Loading update…');
+    onStatus('Loading update…');
     try {
-      let detail;
-      if (offlineHydrated) detail = savedDetail;
-      else if (preload) detail = await preload.catch(() => {
-        onStatus('Loading update…');
-        return load(item.notification_id);
-      });
-      else detail = await load(item.notification_id);
+      const detail = await load(item.notification_id);
       if (selected !== item || version !== loadVersion) return false;
       onDetail(detail);
       if (createPager && loadConversation && detail.conversation) {
@@ -494,9 +307,6 @@ function createNotificationReader({
         conversationPager = null;
       }
       onStatus('Update ready.');
-      if (!offlineHydrated && detail.conversation_available) {
-        void hydrateConversation(item, version);
-      }
       return true;
     } catch (_error) {
       if (selected === item && version === loadVersion) {
@@ -508,26 +318,13 @@ function createNotificationReader({
 
   return {
     open,
-    prefetch,
-    retryConversation() {
-      if (!selected || offlineHydrated) return Promise.resolve(false);
-      return hydrateConversation(selected, loadVersion);
-    },
-    commentPager() {
-      return conversationPager;
-    },
     appendReply(comment) {
       if (!conversationPager) return false;
       onConversation(conversationPager.append(comment));
       return true;
     },
-    acceptReadAndNext(items, item = selected) {
-      if (!item || (selected && selected !== item)) return false;
-      selected = item;
-      return advanceAfterRead(items, item);
-    },
     async loadOlder() {
-      if (!conversationPager || !selected || offlineHydrated) return false;
+      if (!conversationPager || !selected) return false;
       const pager = conversationPager;
       const version = loadVersion;
       onStatus('Loading older messages…');
@@ -545,32 +342,28 @@ function createNotificationReader({
       }
     },
     async markReadAndNext(items) {
-      if (!selected || marking || (offlineHydrated && !queueRead)) return false;
-      const current = selected;
-      const queueing = offlineHydrated;
-      marking = true;
-      onStatus(queueing ? 'Queueing update read…' : 'Marking update read…');
-      try {
-        if (queueing) await queueRead(current.notification_id);
-        else await markRead(current.notification_id);
-        return await advanceAfterRead(items, current, queueing);
-      } catch (_error) {
-        onStatus(queueing ? 'Could not queue update read. Retry.' : 'Could not mark update read. Retry.');
-        return false;
-      } finally {
-        marking = false;
-      }
-    },
-    async acknowledgeAndNext(items) {
-      if (!selected || marking || offlineHydrated || !acknowledge) return false;
+      if (!selected || marking) return false;
       const current = selected;
       marking = true;
-      onStatus('Adding reaction and marking read…');
+      onStatus('Marking update read…');
       try {
-        await acknowledge(current.notification_id);
-        return await advanceAfterRead(items, current);
+        await markRead(current.notification_id);
+        const updated = acknowledgeNotification(items, current.notification_id);
+        onItems(updated);
+        const currentIndex = items.indexOf(current);
+        const remaining = items.slice(currentIndex + 1).concat(items.slice(0, currentIndex));
+        const next = remaining.find(item =>
+          item && item.has_update && Number.isInteger(item.notification_id)
+        );
+        if (next) await open(next);
+        else {
+          selected = null;
+          onClose();
+          onStatus('Inbox cleared.');
+        }
+        return { items: updated, next: next || null };
       } catch (_error) {
-        onStatus('Could not acknowledge update. Retry.');
+        onStatus('Could not mark update read. Retry.');
         return false;
       } finally {
         marking = false;
@@ -596,9 +389,9 @@ function createNotificationReplier({
         if ((storage.getItem(keyFor(item)) || '') !== body) storage.removeItem(operationKeyFor(item));
         storage.setItem(keyFor(item), body);
       }
-      catch (_error) {}
+      catch (_error) { /* Keep the editable textarea as the fallback. */ }
     },
-    async submit(item, body, attachment = null) {
+    async submit(item, body) {
       if (pending) return false;
       pending = true;
       this.saveDraft(item, body);
@@ -609,28 +402,11 @@ function createNotificationReplier({
       } catch (_error) { operationId = String(createOperationId()).slice(0, 128); }
       onStatus('Sending reply…');
       try {
-        if (attachment) {
-          onStatus('Saving screenshot for durable delivery…');
-          const admission = await authoredOutbox.enqueueDurably({
-            kind:'update-reply', notificationId:item.notification_id, body, operationId, attachment,
-          });
-          const delivery = await authoredOutbox.retry(admission.item.id, admission.item.ownerLogin);
-          if (!delivery.confirmed?.length) {
-            const remaining = delivery.remaining?.find(candidate => candidate.id === admission.item.id);
-            if (remaining?.status === 'attention') return false;
-            onStatus('Queued for sync when the connection returns.');
-            return { queued:true };
-          }
-          try { storage.removeItem(keyFor(item)); storage.removeItem(operationKeyFor(item)); }
-          catch (_error) {}
-          onStatus('Reply posted. You can mark this update read when ready.');
-          return delivery.confirmed[0];
-        }
         const result = await post(item.notification_id, body, operationId);
         try { storage.removeItem(keyFor(item)); }
-        catch (_error) {}
+        catch (_error) { /* The posted reply is still authoritative. */ }
         try { storage.removeItem(operationKeyFor(item)); }
-        catch (_error) {}
+        catch (_error) { /* A confirmed result no longer needs replay identity. */ }
         onStatus('Reply posted. You can mark this update read when ready.');
         return result;
       } catch (error) {
@@ -659,8 +435,6 @@ function createNotificationReplier({
 function filterMyWork(items, selectedFilter, selectedMilestone = 'all') {
   let filtered = items;
   if (selectedFilter === 'attention') filtered = items.filter(needsAttention);
-  else if (selectedFilter === 'filed') filtered = items.filter((item) => item.is_filed);
-  else if (selectedFilter === 'authored') filtered = items.filter((item) => item.is_authored);
   else if (selectedFilter === 'review') filtered = items.filter((item) => item.is_review);
   else if (selectedFilter === 'update') filtered = items.filter((item) => item.has_update);
   else if (selectedFilter !== 'all') filtered = items.filter((item) => item.kind === selectedFilter);
@@ -673,134 +447,6 @@ function filterMyWork(items, selectedFilter, selectedMilestone = 'all') {
   );
 }
 
-function createCompletedFiledReview({
-  storage,
-  getLogin,
-  key = 'stackchain.completed-filed-review.v1',
-}) {
-  const login = () => String(getLogin?.() || '').trim();
-  const ownerKey = () => key + ':' + login();
-  const identity = item => String(item?.repository || '') + '#' + String(item?.number || '');
-  const read = () => {
-    if (!login()) return { items:{}, pending:{} };
-    try {
-      const value = JSON.parse(storage?.getItem(ownerKey()) || '{}');
-      return value && value.version === 1 && value.items && typeof value.items === 'object' ? {
-        items:value.items,
-        pending:value.pending && typeof value.pending === 'object' ? value.pending : {},
-      } : { items:{}, pending:{} };
-    } catch (_error) { return { items:{}, pending:{} }; }
-  };
-  const receipt = (item, stamp = String(item?.updated_at || '')) => ({
-    repository:String(item?.repository || ''), number:item?.number, updated_at:stamp,
-  });
-  const save = value => storage?.setItem(ownerKey(), JSON.stringify({ version:1, ...value }));
-  const partition = items => {
-    const acknowledged = read().items;
-    const needsReview = [];
-    const reviewed = [];
-    (items || []).forEach(item => {
-      const isReviewed = item?.is_completed &&
-        acknowledged[identity(item)] === String(item.updated_at || '');
-      (isReviewed ? reviewed : needsReview).push(item);
-    });
-    reviewed.sort((left, right) => String(right.updated_at || '').localeCompare(String(left.updated_at || '')));
-    return { needsReview, reviewed };
-  };
-  return {
-    partition,
-    visible(items) {
-      return partition(items).needsReview;
-    },
-    pending() {
-      const state = read();
-      return Object.entries(state.pending).map(([itemIdentity, stamp]) => {
-        const boundary = itemIdentity.lastIndexOf('#');
-        return receipt({
-          repository:itemIdentity.slice(0, boundary),
-          number:Number(itemIdentity.slice(boundary + 1)),
-        }, stamp);
-      });
-    },
-    adopt(snapshot) {
-      const state = read();
-      let changed = false;
-      (snapshot?.receipts || []).forEach(remote => {
-        const itemIdentity = identity(remote);
-        const stamp = String(remote?.updated_at || '');
-        if (!remote?.repository || !Number.isInteger(remote?.number) || !stamp) return;
-        if (!state.items[itemIdentity] || state.items[itemIdentity] < stamp) {
-          state.items[itemIdentity] = stamp;
-          changed = true;
-        }
-        if (state.pending[itemIdentity] && state.pending[itemIdentity] <= stamp) {
-          delete state.pending[itemIdentity];
-        }
-      });
-      try { save(state); } catch (_error) { return false; }
-      return changed;
-    },
-    acknowledge(item) {
-      const stamp = String(item?.updated_at || '');
-      if (!login() || !item?.is_completed || !item?.repository || !Number.isInteger(item?.number) || !stamp) {
-        return false;
-      }
-      const state = read();
-      const entries = Object.entries({ ...state.items, [identity(item)]: stamp }).slice(-200);
-      const pending = Object.entries({ ...state.pending, [identity(item)]: stamp }).slice(-200);
-      try {
-        save({ items:Object.fromEntries(entries), pending:Object.fromEntries(pending) });
-        return true;
-      } catch (_error) { return false; }
-    },
-  };
-}
-
-function createFiledHistoryTabs({ root, review, onSelect }) {
-  const buttons = Array.from(root.querySelectorAll('[data-filed-view]'));
-  let partition = { needsReview:[], reviewed:[] };
-  buttons.forEach(button => button.addEventListener('click', () => onSelect(button.dataset.filedView)));
-  return {
-    prepare(items) {
-      partition = review.partition(items);
-      root.querySelector('#filed-needs-review-count').textContent =
-        partition.needsReview.filter(item => item.is_filed).length;
-      root.querySelector('#filed-reviewed-count').textContent = partition.reviewed.length;
-      return partition.needsReview;
-    },
-    render(selected, visible) {
-      root.hidden = !visible;
-      buttons.forEach(button =>
-        button.setAttribute('aria-pressed', String(button.dataset.filedView === selected))
-      );
-      return selected === 'reviewed' ? partition.reviewed : partition.needsReview;
-    },
-  };
-}
-
-function agendaMyWork(items, now = new Date()) {
-  const start = new Date(now.getFullYear(), now.getMonth(), now.getDate());
-  const today = localDay(start);
-  const tomorrowDate = new Date(start); tomorrowDate.setDate(tomorrowDate.getDate() + 1);
-  const tomorrow = localDay(tomorrowDate);
-  const afterTomorrowDate = new Date(start); afterTomorrowDate.setDate(afterTomorrowDate.getDate() + 2);
-  const afterTomorrow = localDay(afterTomorrowDate);
-  const horizonDate = new Date(start); horizonDate.setDate(horizonDate.getDate() + 7);
-  const horizon = localDay(horizonDate);
-  return (items || []).flatMap(item => {
-    if (item?.kind !== 'issue' || !item.is_assigned || !item.due_date) return [];
-    const due = calendarDay(item.due_date);
-    if (!due || due >= horizon) return [];
-    const group = due < today ? 'Overdue' : due < tomorrow ? 'Today' :
-      due < afterTomorrow ? 'Tomorrow' : 'Next 7 days';
-    return [{ ...item, agenda_group: group, _agenda_due: due }];
-  }).sort((left, right) =>
-    left._agenda_due.localeCompare(right._agenda_due) ||
-    String(left.repository || '').localeCompare(String(right.repository || '')) ||
-    Number(left.number || 0) - Number(right.number || 0)
-  ).map(({ _agenda_due, ...item }) => item);
-}
-
 function milestoneLanes(items) {
   const lanes = new Map();
   (items || []).forEach(item => {
@@ -821,68 +467,10 @@ function workIdentity(item) {
   return [kind, repository, number, notification].join(':');
 }
 
-function createWorkSessionCheckpoint({
-  storage,
-  getLogin,
-  onError = () => {},
-  key = 'stackchain.today-session.v1',
-}) {
-  const login = () => String(getLogin() || '').trim();
-  let errorReported = false;
-  const reportError = error => {
-    if (errorReported) return;
-    errorReported = true;
-    onError(error);
-  };
-  const read = () => {
-    const owner = login();
-    if (!owner) return null;
-    try {
-      const value = JSON.parse(storage.getItem(key) || 'null');
-      if (value?.version !== 1 || value.login !== owner || typeof value.identity !== 'string' ||
-          !Number.isInteger(value.index) || value.index < 0) return null;
-      return value;
-    } catch (error) {
-      reportError(error);
-      return null;
-    }
-  };
-  return {
-    read,
-    save(identity, index) {
-      const owner = login();
-      if (!owner) return false;
-      try {
-        storage.setItem(key, JSON.stringify({ version:1, login:owner, identity, index }));
-        return true;
-      } catch (error) {
-        reportError(error);
-        return false;
-      }
-    },
-    clear() {
-      if (!read()) return false;
-      try {
-        storage.removeItem(key);
-        return true;
-      } catch (error) {
-        reportError(error);
-        return false;
-      }
-    },
-  };
-}
-
-function createWorkSession({
-  getItems, getFilter, getMilestone = () => 'all', checkpoint = null,
-  checkpointEnabled = () => true, checkpointedEnabled = checkpointEnabled,
-  onOpen, onProgress, onFinish,
-}) {
+function createWorkSession({ getItems, getFilter, getMilestone = () => 'all', onOpen, onProgress, onFinish }) {
   let currentIdentity = '';
   let currentIndex = -1;
   let running = false;
-  let durable = false;
-  const activeCheckpoint = () => typeof checkpoint === 'function' ? checkpoint() : checkpoint;
 
   const queue = () => filterMyWork(getItems() || [], getFilter(), getMilestone());
   const report = (items, index) => onProgress({
@@ -892,12 +480,9 @@ function createWorkSession({
     can_next: index < items.length - 1,
   });
   const finish = () => {
-    const clearCheckpoint = durable;
     running = false;
-    durable = false;
     currentIdentity = '';
     currentIndex = -1;
-    if (clearCheckpoint) activeCheckpoint()?.clear();
     onFinish();
     return false;
   };
@@ -905,7 +490,6 @@ function createWorkSession({
     if (!items.length || index < 0 || index >= items.length) return finish();
     currentIndex = index;
     currentIdentity = workIdentity(items[index]);
-    if (durable) activeCheckpoint()?.save(currentIdentity, currentIndex);
     report(items, index);
     onOpen(items[index]);
     return true;
@@ -913,40 +497,11 @@ function createWorkSession({
 
   return {
     active: () => running,
-    checkpointed: item => running && durable && checkpointedEnabled() && (!item || workIdentity(item) === currentIdentity),
-    end: () => finish(),
-    resumable: () => Boolean(activeCheckpoint()?.read()),
-    reopen(requested = null) {
-      if (!running) return false;
-      const items = queue();
-      const requestedIdentity = requested ? workIdentity(requested) : currentIdentity;
-      const index = items.findIndex(item => workIdentity(item) === requestedIdentity);
-      if (index < 0) return false;
-      currentIdentity = requestedIdentity;
-      currentIndex = index;
-      if (durable && requested) activeCheckpoint()?.save(currentIdentity, currentIndex);
-      report(items, index);
-      onOpen(items[index]);
-      return true;
-    },
-    resume(requested = null) {
-      const saved = activeCheckpoint()?.read();
-      if (!saved) return false;
-      durable = true;
+    start() {
       const items = queue();
       if (!items.length) return finish();
       running = true;
-      const exact = items.findIndex(item => workIdentity(item) ===
-        (requested ? workIdentity(requested) : saved.identity));
-      return openAt(items, exact >= 0 ? exact : Math.min(saved.index, items.length - 1));
-    },
-    start(item = null) {
-      const items = queue();
-      if (!items.length) return finish();
-      running = true;
-      durable = Boolean(activeCheckpoint() && checkpointEnabled());
-      const requested = item ? items.findIndex(candidate => workIdentity(candidate) === workIdentity(item)) : 0;
-      return openAt(items, requested >= 0 ? requested : 0);
+      return openAt(items, 0);
     },
     reconcile() {
       if (!running) return false;
@@ -963,48 +518,21 @@ function createWorkSession({
       const index = items.findIndex(item => workIdentity(item) === currentIdentity);
       return index > 0 ? openAt(items, index - 1) : false;
     },
-    next(requested = null) {
+    next() {
       if (!running) return false;
       const items = queue();
       const index = items.findIndex(item => workIdentity(item) === currentIdentity);
-      if (requested) {
-        const requestedIndex = items.findIndex(item => workIdentity(item) === workIdentity(requested));
-        return requestedIndex >= 0 ? openAt(items, requestedIndex) : false;
-      }
       return index >= 0 && index < items.length - 1 ? openAt(items, index + 1) : finish();
     },
-    complete(requested = null) {
+    complete() {
       if (!running) return false;
       const items = queue();
-      if (requested) {
-        const requestedIndex = items.findIndex(item => workIdentity(item) === workIdentity(requested));
-        return requestedIndex >= 0 ? openAt(items, requestedIndex) : false;
-      }
       const stillPresent = items.findIndex(item => workIdentity(item) === currentIdentity);
       if (stillPresent >= 0) {
         return stillPresent < items.length - 1 ? openAt(items, stillPresent + 1) : finish();
       }
       return items.length ? openAt(items, Math.min(currentIndex, items.length - 1)) : finish();
     },
-    items: () => queue().slice(),
-    target(action) {
-      const items = queue();
-      if (!items.length) return null;
-      if (action === 'start') return items[0];
-      if (action === 'resume') {
-        const saved = activeCheckpoint()?.read();
-        if (!saved) return null;
-        const exact = items.findIndex(item => workIdentity(item) === saved.identity);
-        return items[exact >= 0 ? exact : Math.min(saved.index, items.length - 1)];
-      }
-      const current = items.findIndex(item => workIdentity(item) === currentIdentity);
-      if (action === 'continue') return current >= 0 ? items[current] : null;
-      if (action === 'next') return current >= 0 && current < items.length - 1 ? items[current + 1] : null;
-      if (action === 'complete') {
-        return items[current >= 0 ? Math.min(current + 1, items.length - 1) : Math.min(currentIndex, items.length - 1)];
-      }
-      return null;
-    },
   };
 }
 
@@ -1063,28 +591,10 @@ function summarizeMyWork(items) {
   return (updates ? updateLabel + ' · ' : '') + reviewLabel + ' · ' + assignedLabel;
 }
 
-function findQueueItems(items, query) {
-  const needle = String(query || '').trim().toLowerCase();
-  if (!needle) return (items || []).slice();
-  return (items || []).filter(item => {
-    const number = Number.isInteger(item?.number) ? '#' + item.number : '';
-    return [item?.repository, item?.key, number, item?.title]
-      .some(value => String(value || '').toLowerCase().includes(needle));
-  });
-}
-
-function filedFollowUpTarget(items) {
-  const item = (items || []).find(candidate => candidate?.is_filed);
-  if (!item) return null;
-  return { kind:item.has_update ? 'update' : 'issue', item };
-}
-
 function countMyWork(items) {
   return {
     all: items.length,
     attention: items.filter(needsAttention).length,
-    filed: items.filter((item) => item.is_filed).length,
-    authored: items.filter((item) => item.is_authored).length,
     issue: items.filter((item) => item.kind === 'issue').length,
     pull: items.filter((item) => item.kind === 'pull' && !item.is_review).length,
     review: items.filter((item) => item.is_review).length,
@@ -1094,12 +604,8 @@ function countMyWork(items) {
 
 if (typeof module !== 'undefined' && module.exports) {
   buildMyWork.filterMyWork = filterMyWork;
-  buildMyWork.createCompletedFiledReview = createCompletedFiledReview;
-  buildMyWork.createFiledHistoryTabs = createFiledHistoryTabs;
-  buildMyWork.agendaMyWork = agendaMyWork;
   buildMyWork.milestoneLanes = milestoneLanes;
   buildMyWork.createWorkSession = createWorkSession;
-  buildMyWork.createWorkSessionCheckpoint = createWorkSessionCheckpoint;
   buildMyWork.workIdentity = workIdentity;
   buildMyWork.replaceIssueLabels = replaceIssueLabels;
   buildMyWork.replaceIssueContent = replaceIssueContent;
@@ -1107,14 +613,11 @@ if (typeof module !== 'undefined' && module.exports) {
   buildMyWork.replaceIssueMilestone = replaceIssueMilestone;
   buildMyWork.removeIssue = removeIssue;
   buildMyWork.summarizeMyWork = summarizeMyWork;
-  buildMyWork.findQueueItems = findQueueItems;
-  buildMyWork.filedFollowUpTarget = filedFollowUpTarget;
   buildMyWork.countMyWork = countMyWork;
   buildMyWork.acknowledgeNotification = acknowledgeNotification;
   buildMyWork.createNotificationAcknowledger = createNotificationAcknowledger;
   buildMyWork.notificationIds = notificationIds;
   buildMyWork.createBulkNotificationAcknowledger = createBulkNotificationAcknowledger;
-  buildMyWork.createNotificationSelection = createNotificationSelection;
   buildMyWork.createNotificationPager = createNotificationPager;
   buildMyWork.createWorkPager = createWorkPager;
   buildMyWork.createNotificationReader = createNotificationReader;

frontend/notification-read-outbox.js

@@ -1,125 +0,0 @@
-function createNotificationReadOutbox({
-  storage, fetchJson, backgroundSync, coordinator, getOwnerLogin = () => '', now = () => Date.now(), maxItems = 100,
-}) {
-  const storageKey = 'stackchain.notification-read-outbox.v1';
-
-  function read() {
-    try {
-      const record = JSON.parse(storage?.getItem(storageKey) || 'null');
-      if (record?.version !== 1 || !Array.isArray(record.items)) return [];
-      return record.items.filter(item => item?.kind === 'notification-read' &&
-        Number.isInteger(item.notificationId) && item.notificationId > 0 && item.ownerLogin);
-    } catch (_error) { return []; }
-  }
-
-  function write(items, mirror = true) {
-    storage?.setItem(storageKey, JSON.stringify({ version: 1, items }));
-    coordinator?.notify('notification-read');
-    if (mirror && backgroundSync?.reconcile) {
-      Promise.resolve(backgroundSync.reconcile(items, 'notification-read'))
-        .then(() => items.length ? backgroundSync.requestSync?.() : undefined)
-        .catch(() => { /* Foreground reconnect remains available. */ });
-    }
-  }
-
-  function itemId(ownerLogin, notificationId) {
-    return 'notification-read:' + ownerLogin + ':' + notificationId;
-  }
-
-  async function enqueueDurably(notificationId) {
-    notificationId = Number(notificationId);
-    const ownerLogin = String(getOwnerLogin() || '').trim();
-    if (!ownerLogin) throw new Error('Confirm your Gitea account before queueing this update.');
-    if (!Number.isInteger(notificationId) || notificationId <= 0) throw new Error('Choose a valid update.');
-    const items = read();
-    const id = itemId(ownerLogin, notificationId);
-    let item = items.find(candidate => candidate.id === id);
-    if (!item) {
-      if (items.length >= maxItems) throw new Error('Update acknowledgement queue is full. Reconnect before clearing more updates.');
-      item = {
-        id, kind: 'notification-read', notificationId, ownerLogin,
-        status: 'queued', queuedAt: Number(now()),
-      };
-      items.push(item);
-      write(items, false);
-    }
-    if (!backgroundSync?.reconcile || !backgroundSync?.requestSync) {
-      return { item: { ...item }, background: false, durability: 'foreground-only' };
-    }
-    try {
-      await backgroundSync.reconcile(read(), 'notification-read');
-      await backgroundSync.requestSync();
-      return { item: { ...item }, background: true, durability: 'background' };
-    } catch (error) {
-      return { item: { ...item }, background: false, durability: 'foreground-only', error };
-    }
-  }
-
-  function suppress(items, login = getOwnerLogin()) {
-    const pending = new Set(read().filter(item => item.ownerLogin === String(login || '').trim())
-      .map(item => item.notificationId));
-    return (items || []).filter(item => !pending.has(Number(item?.notification_id ?? item?.id)));
-  }
-
-  async function send(item, currentLogin) {
-    if (!currentLogin || item.ownerLogin !== currentLogin) return { blocked: true };
-    if (backgroundSync?.send) return backgroundSync.send(item, currentLogin);
-    await fetchJson('api/v1/notifications/' + encodeURIComponent(item.notificationId) + '/read', {
-      method: 'PATCH', headers: { Accept: 'application/json' },
-    });
-    return { confirmed: true };
-  }
-
-  async function flush(currentLogin) {
-    currentLogin = String(currentLogin || '').trim();
-    const confirmed = [];
-    let items = read();
-    for (const item of items) {
-      if (item.ownerLogin !== currentLogin || item.status === 'attention') continue;
-      try {
-        const result = await send(item, currentLogin);
-        if (result?.blocked || result?.busy) continue;
-        if (result?.attention) {
-          items = items.map(candidate => candidate.id === item.id ? {
-            ...candidate, status: 'attention', error: String(result.error?.message || 'Update needs attention').slice(0, 240),
-          } : candidate);
-          write(items);
-          continue;
-        }
-        confirmed.push(item.notificationId);
-        items = items.filter(candidate => candidate.id !== item.id);
-        write(items);
-      } catch (error) {
-        const status = Number(error?.status || 0);
-        if (status >= 400 && status < 500) {
-          items = items.map(candidate => candidate.id === item.id ? {
-            ...candidate, status: 'attention', error: String(error?.message || 'Update needs attention').slice(0, 240),
-          } : candidate);
-          write(items);
-          continue;
-        }
-        break;
-      }
-    }
-    return { confirmed, remaining: read() };
-  }
-
-  function reconcileBackground(records) {
-    const states = new Map((records || []).filter(item => item?.kind === 'notification-read')
-      .map(item => [item.id, item]));
-    const items = read().flatMap(item => {
-      const state = states.get(item.id);
-      if (state?.status === 'sent') return [];
-      if (state?.status === 'attention') return [{
-        ...item, status: 'attention', error: String(state.error || 'Update needs attention').slice(0, 240),
-      }];
-      return [item];
-    });
-    write(items);
-    return items;
-  }
-
-  return { enqueueDurably, flush, suppress, reconcileBackground, list: () => read().map(item => ({ ...item })) };
-}
-
-if (typeof module !== 'undefined' && module.exports) module.exports = createNotificationReadOutbox;

frontend/notification-undo.js

@@ -1,85 +0,0 @@
-function createNotificationUndo({ restore, onItems, onStatus, onOffer = () => {}, onClear = () => {} }) {
-  let offered = null;
-  let pending = false;
-
-  return {
-    offer(item, items) {
-      if (!item || !Number.isInteger(item.notification_id)) return false;
-      offered = { item, items: Array.isArray(items) ? [...items] : [] };
-      const label = item.key || 'Update';
-      onStatus(label + ' marked read. Undo?');
-      onOffer(item);
-      return true;
-    },
-    async run() {
-      if (!offered || pending) return false;
-      const current = offered;
-      const label = current.item.key || 'Update';
-      pending = true;
-      onStatus('Restoring ' + label + '…');
-      try {
-        await restore(current.item.notification_id);
-        if (offered !== current) return false;
-        const restored = [current.item].concat(current.items.filter(
-          item => item?.notification_id !== current.item.notification_id
-        ));
-        offered = null;
-        onItems(restored, current.item);
-        onStatus(label + ' is unread again.');
-        onClear();
-        return true;
-      } catch (_error) {
-        onStatus('Could not restore ' + label + '. Retry Undo.');
-        return false;
-      } finally {
-        pending = false;
-      }
-    },
-    clear() {
-      offered = null;
-      onClear();
-    },
-  };
-}
-
-async function requestNotificationUnread(notificationId) {
-  const response = await fetch('api/v1/notifications/' + encodeURIComponent(notificationId) + '/unread', {
-    method: 'PATCH', headers: { Accept: 'application/json' },
-  });
-  const payload = await response.json().catch(() => ({}));
-  if (!response.ok) throw new Error(payload.error || 'Restore unread failed.');
-  return payload;
-}
-
-function createDashboardNotificationUndo({ restore, getItems, setItems, getNotifications, setNotifications, refresh, select }) {
-  let timer = null;
-  const controller = createNotificationUndo({
-    restore,
-    onItems: (items, restored) => {
-      setItems(items);
-      const notifications = getNotifications();
-      if (!notifications.some(item => item.id === restored.notification_id)) {
-        setNotifications([{ id:restored.notification_id }].concat(notifications));
-      }
-      refresh();
-    },
-    onStatus: message => {
-      select('#notification-undo-status').textContent = message;
-      select('#my-work-action-status').textContent = message;
-    },
-    onOffer: item => {
-      clearTimeout(timer);
-      select('#notification-undo').hidden = false;
-      select('#undo-notification').disabled = false;
-      select('#undo-notification').setAttribute('aria-label', 'Undo marking ' + (item.key || 'update') + ' read');
-      timer = setTimeout(() => controller.clear(), 10000);
-    },
-    onClear: () => { select('#notification-undo').hidden = true; },
-  });
-  return controller;
-}
-
-if (typeof module !== 'undefined' && module.exports) {
-  module.exports = createNotificationUndo;
-  module.exports.createDashboardNotificationUndo = createDashboardNotificationUndo;
-}

frontend/offline-issue-blocker.js

@@ -1,21 +0,0 @@
-function createOfflineIssueBlocker({
-  enqueueDurably,
-  onQueued = () => {},
-  createOperationId = () => globalThis.crypto?.randomUUID?.() || String(Date.now()) + '-' + Math.random().toString(16).slice(2),
-}) {
-  return async function queueOfflineIssueBlocker(item, blocker, present) {
-    const admission = await enqueueDurably({
-      kind: 'issue-blocker',
-      repository: String(item.repository || ''),
-      number: Number(item.number || 0),
-      blockerRepository: String(blocker.repository || ''),
-      blockerNumber: Number(blocker.number || 0),
-      present: present === true,
-      operationId: String(createOperationId()).slice(0, 128),
-    });
-    onQueued(item, blocker, present === true, admission);
-    return { admission };
-  };
-}
-
-if (typeof module !== 'undefined' && module.exports) module.exports = createOfflineIssueBlocker;

frontend/offline-issue-close.js

@@ -1,19 +0,0 @@
-function createOfflineIssueClose({ enqueueDurably, completeToday, createOperationId = () =>
-  globalThis.crypto?.randomUUID?.() || String(Date.now()) + '-' + Math.random().toString(16).slice(2) }) {
-  return async function closeOfflineIssue(item) {
-    const admission = await enqueueDurably({
-      kind: 'issue-close',
-      repository: String(item.repository || ''),
-      number: Number(item.number || 0),
-      body: '',
-      operationId: String(createOperationId()).slice(0, 128),
-    });
-    const advanced = Boolean(completeToday(item, {
-      successMessage: 'Issue closure queued. Next Today item opened.',
-      failureMessage: 'Issue closure queued, but Today still needs completion.',
-    }));
-    return { admission, advanced };
-  };
-}
-
-if (typeof module !== 'undefined' && module.exports) module.exports = createOfflineIssueClose;

frontend/offline-today.js

@@ -1,88 +0,0 @@
-(function (root, factory) {
-  const api = factory();
-  if (typeof module !== 'undefined' && module.exports) module.exports = api;
-  else root.createOfflineToday = api;
-})(typeof self !== 'undefined' ? self : this, function () {
-  'use strict';
-
-  const itemKey = item => [item?.kind, item?.repository, Number(item?.number || 0)].join(':');
-
-  function createOfflineToday({
-    loadDetail, loadSavedDetail, saveDetail, onStatus = () => {}, concurrency = 2, maxItems = 5,
-  }) {
-    let failed = new Set();
-    let generation = 0;
-
-    function bounded(items) {
-      return (Array.isArray(items) ? items : []).filter(item =>
-        ['issue', 'pull'].includes(item?.kind) && item?.repository && Number(item?.number) > 0
-      ).slice(0, Math.max(1, maxItems));
-    }
-
-    async function run(login, sourceItems, onlyFailed) {
-      login = String(login || '').trim();
-      const items = bounded(sourceItems);
-      const runGeneration = ++generation;
-      if (!login || !items.length) {
-        failed = new Set();
-        const empty = { total: items.length, ready: 0, failed: 0, pending: 0 };
-        onStatus(empty);
-        return empty;
-      }
-
-      const previousFailed = failed;
-      const savedDetails = new Map();
-      await Promise.all(items.map(async item => {
-        savedDetails.set(itemKey(item), await loadSavedDetail(login, item));
-      }));
-      const readyKeys = new Set(items.filter(item => savedDetails.get(itemKey(item))).map(itemKey));
-      const snapshot = pending => ({
-        total: items.length, ready: readyKeys.size, failed: failed.size, pending,
-      });
-      const candidates = items.filter(item => {
-        const key = itemKey(item);
-        if (onlyFailed && !previousFailed.has(key)) return false;
-        const saved = savedDetails.get(key);
-        return onlyFailed || !saved || saved.source_updated_at !== item.updated_at;
-      });
-      failed = new Set();
-      onStatus(snapshot(candidates.length));
-      let cursor = 0;
-
-      async function worker() {
-        while (cursor < candidates.length && runGeneration === generation) {
-          const item = candidates[cursor++];
-          try {
-            const detail = await loadDetail(item);
-            if (runGeneration !== generation) return;
-            const saved = await saveDetail(login, item, { ...detail, source_updated_at: item.updated_at });
-            if (saved === false) throw new Error('Offline detail was not durably admitted.');
-            readyKeys.add(itemKey(item));
-          } catch (_error) {
-            if (runGeneration === generation) failed.add(itemKey(item));
-          }
-          if (runGeneration === generation) {
-            onStatus(snapshot(Math.max(0, candidates.length - cursor)));
-          }
-        }
-      }
-
-      await Promise.all(Array.from(
-        { length: Math.min(Math.max(1, concurrency), candidates.length) }, worker
-      ));
-      if (runGeneration !== generation) return snapshot(0);
-      const status = snapshot(0);
-      onStatus(status);
-      return status;
-    }
-
-    return {
-      warm: (login, items) => run(login, items, false),
-      retry: (login, items) => run(login, items, true),
-      cancel() { generation += 1; failed = new Set(); },
-      failedKeys: () => Array.from(failed),
-    };
-  }
-
-  return createOfflineToday;
-});

frontend/offline-work.js

@@ -7,7 +7,6 @@
 
   const ENABLED_KEY = 'stackchain.offline-work.enabled.v1';
   const SNAPSHOT_KEY = 'stackchain.offline-work.snapshot.v1';
-  const DETAILS_KEY = 'stackchain.offline-work.details.v1';
   const VERSION = 1;
   const DEFAULT_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000;
   const ITEM_FIELDS = [
@@ -17,63 +16,6 @@
   const NOTIFICATION_FIELDS = [
     'id', 'number', 'title', 'unread', 'repository', 'subject_type', 'updated_at', 'url',
   ];
-  const DETAIL_FIELDS = [
-    'title', 'body', 'state', 'labels', 'assignees', 'author', 'url', 'due_date', 'milestone',
-    'id', 'repository', 'subject_type', 'subject_body', 'source_updated_at', 'head_sha', 'ci_state',
-  ];
-  const COMMENT_FIELDS = ['id', 'author', 'body', 'created_at', 'updated_at', 'url'];
-  const REVIEW_FILE_FIELDS = [
-    'filename', 'status', 'additions', 'deletions', 'diff_available', 'diff_binary', 'diff_truncated',
-  ];
-  const REVIEW_FIELDS = ['id', 'state', 'body', 'submitted_at'];
-
-  function createIndexedDbTransaction(indexedDB, dbName = 'stackchain-offline-work-v2') {
-    if (!indexedDB) return null;
-    let databasePromise;
-    function database() {
-      if (!databasePromise) databasePromise = new Promise((resolve, reject) => {
-        const request = indexedDB.open(dbName, 1);
-        request.onupgradeneeded = () => {
-          if (!request.result.objectStoreNames.contains('work')) {
-            request.result.createObjectStore('work', { keyPath: 'id' });
-          }
-        };
-        request.onsuccess = () => {
-          const db = request.result;
-          db.onversionchange = () => { db.close(); databasePromise = undefined; };
-          resolve(db);
-        };
-        request.onerror = () => reject(request.error || new Error('Offline work database failed to open.'));
-      });
-      return databasePromise;
-    }
-    const requested = request => new Promise((resolve, reject) => {
-      request.onsuccess = () => resolve(request.result);
-      request.onerror = () => reject(request.error);
-    });
-    return async work => {
-      const db = await database();
-      return new Promise((resolve, reject) => {
-        const transaction = db.transaction('work', 'readwrite');
-        const store = transaction.objectStore('work');
-        let result;
-        let workError;
-        transaction.oncomplete = () => workError ? undefined : resolve(result);
-        transaction.onerror = () => reject(transaction.error);
-        transaction.onabort = () => reject(workError || transaction.error || new Error('Offline work transaction aborted.'));
-        Promise.resolve(work({
-          get: key => requested(store.get(key)),
-          getAll: () => requested(store.getAll()),
-          put: value => requested(store.put(value)),
-          delete: key => requested(store.delete(key)),
-          clear: () => requested(store.clear()),
-        })).then(value => { result = value; }).catch(error => {
-          workError = error;
-          try { transaction.abort(); } catch (_) { reject(error); }
-        });
-      });
-    };
-  }
 
   function pick(source, fields) {
     const output = {};
@@ -83,272 +25,18 @@
     return output;
   }
 
-  function createOfflineWorkStore({
-    storage, indexedDB, transaction, now = () => new Date(), maxAgeMs = DEFAULT_MAX_AGE_MS,
-    maxDetails = 10, initializationTimeoutMs = 1500,
-  }) {
-    const transact = transaction || createIndexedDbTransaction(indexedDB);
-    let migrationPromise;
-    let readinessPromise;
-    let readinessGeneration = 0;
-    let readinessState = transact ? { state:'initializing', reason:'' } : { state:'ready', reason:'' };
-    let recordCache = null;
-    let pendingDurableClear = false;
-
-    function hydrateLegacyCache() {
-      const cache = new Map();
-      try {
-        const snapshot = JSON.parse(storage.getItem(SNAPSHOT_KEY) || 'null');
-        if (snapshot) cache.set('snapshot', { ...snapshot, id:'snapshot' });
-        const details = JSON.parse(storage.getItem(DETAILS_KEY) || '[]');
-        if (Array.isArray(details)) details.forEach(record => {
-          if (!record?.key || !record?.user_login || !record?.data) return;
-          const id = 'detail:' + record.user_login + ':' + record.key;
-          cache.set(id, { ...record, id });
-        });
-      } catch (_) { cache.clear(); }
-      recordCache = cache;
-    }
-
-    function migrateLegacy(generation) {
-      if (!transact) return Promise.resolve(true);
-      if (!migrationPromise) migrationPromise = (async () => {
-        let snapshot = null;
-        let details = [];
-        try {
-          snapshot = JSON.parse(storage.getItem(SNAPSHOT_KEY) || 'null');
-          const parsedDetails = JSON.parse(storage.getItem(DETAILS_KEY) || '[]');
-          details = Array.isArray(parsedDetails) ? parsedDetails : [];
-        } catch (_) {
-          return false;
-        }
-        if (!snapshot && !details.length) return true;
-        await transact(async records => {
-          if (snapshot && !(await records.get('snapshot'))) {
-            await records.put({ ...snapshot, id:'snapshot' });
-          }
-          for (const record of details.slice(-Math.max(1, maxDetails))) {
-            if (!record?.key || !record?.user_login || !record?.data) continue;
-            const id = 'detail:' + record.user_login + ':' + record.key;
-            if (!(await records.get(id))) await records.put({ ...record, id });
-          }
-        });
-        if (generation !== readinessGeneration || readinessState.state === 'degraded') return false;
-        storage.removeItem(SNAPSHOT_KEY);
-        storage.removeItem(DETAILS_KEY);
-        return true;
-      })().catch(() => false);
-      return migrationPromise;
-    }
-
-    async function initialize(generation) {
-      const migrated = await migrateLegacy(generation);
-      if (!migrated || generation !== readinessGeneration || readinessState.state === 'degraded') return false;
-      if (pendingDurableClear) {
-        await transact(async records => { await records.clear(); });
-        if (generation !== readinessGeneration || readinessState.state === 'degraded') return false;
-        pendingDurableClear = false;
-        recordCache = new Map();
-        return true;
-      }
-      return transact(async records => {
-        const currentTime = now().getTime();
-        const valid = [];
-        for (const record of await records.getAll()) {
-          const savedAt = Date.parse(record?.saved_at || '');
-          const validShape = record?.id === 'snapshot' ?
-            record.version === VERSION && record.user_login && record.data :
-            record?.id?.startsWith('detail:') && record.user_login && record.key && record.data;
-          if (!validShape || !Number.isFinite(savedAt) || currentTime - savedAt > maxAgeMs) {
-            if (record?.id) await records.delete(record.id);
-          } else valid.push(record);
-        }
-        if (generation !== readinessGeneration || readinessState.state === 'degraded') return false;
-        recordCache = new Map(valid.map(record => [record.id, record]));
-        return true;
-      });
-    }
-
-    function startReady() {
-      const generation = ++readinessGeneration;
-      readinessState = { state:'initializing', reason:'' };
-      const operation = initialize(generation).catch(() => false);
-      readinessPromise = new Promise(resolve => {
-        const timer = setTimeout(() => {
-          if (generation !== readinessGeneration || readinessState.state !== 'initializing') return;
-          hydrateLegacyCache();
-          readinessState = { state:'degraded', reason:'deadline' };
-          resolve(false);
-        }, Math.max(1, Number(initializationTimeoutMs) || 1500));
-        operation.then(available => {
-          if (generation !== readinessGeneration || readinessState.state === 'degraded') return;
-          clearTimeout(timer);
-          if (available) readinessState = { state:'ready', reason:'' };
-          else {
-            hydrateLegacyCache();
-            readinessState = { state:'degraded', reason:'unavailable' };
-          }
-          resolve(Boolean(available));
-        });
-      });
-      return readinessPromise;
-    }
-
-    function ready() {
-      if (!transact || readinessState.state === 'ready') return Promise.resolve(true);
-      if (readinessState.state === 'degraded') return Promise.resolve(false);
-      return readinessPromise || startReady();
-    }
-
-    function status() {
-      return { ...readinessState };
-    }
-
-    function retry() {
-      if (!transact) return Promise.resolve(true);
-      migrationPromise = undefined;
-      readinessPromise = undefined;
-      return startReady();
-    }
+  function createOfflineWorkStore({ storage, now = () => new Date(), maxAgeMs = DEFAULT_MAX_AGE_MS }) {
     function enabled() {
       try { return storage.getItem(ENABLED_KEY) === 'true'; }
       catch (_) { return false; }
     }
 
     function clear() {
-      if (transact) {
-        try {
-          storage.removeItem(SNAPSHOT_KEY);
-          storage.removeItem(DETAILS_KEY);
-        } catch (_) { /* IndexedDB remains the source of truth. */ }
-        if (readinessState.state === 'degraded') {
-          pendingDurableClear = true;
-          recordCache = new Map();
-          return Promise.resolve(true);
-        }
-        migrationPromise = Promise.resolve(true);
-        return transact(async records => {
-          await records.clear();
-          recordCache = new Map();
-          return true;
-        }).catch(() => false);
-      }
-      try {
-        storage.removeItem(SNAPSHOT_KEY);
-        storage.removeItem(DETAILS_KEY);
-      }
+      try { storage.removeItem(SNAPSHOT_KEY); }
       catch (_) { return false; }
       return true;
     }
 
-    function detailKey(item) {
-      if (item?.kind === 'update') {
-        const notificationId = Number(item?.notification_id || 0);
-        return Number.isInteger(notificationId) && notificationId > 0 ? 'update:' + notificationId : '';
-      }
-      const kind = item?.kind === 'review' ? 'review' :
-        item?.kind === 'pull' ? 'pull' : item?.kind === 'issue' ? 'issue' : '';
-      const repository = String(item?.repository || '');
-      const number = Number(item?.number || 0);
-      return kind && repository && number > 0 ? [kind, repository, number].join(':') : '';
-    }
-
-    function readDetails() {
-      try {
-        const value = JSON.parse(storage.getItem(DETAILS_KEY) || '[]');
-        return Array.isArray(value) ? value : [];
-      } catch (_) {
-        try { storage.removeItem(DETAILS_KEY); } catch (_error) { /* Best effort purge. */ }
-        return [];
-      }
-    }
-
-    function saveDetail(login, item, detail) {
-      const key = detailKey(item);
-      login = String(login || '').trim();
-      if (!enabled() || !login || !key || !detail) return false;
-      const conversation = detail.conversation || {};
-      const data = {
-        ...pick(detail, DETAIL_FIELDS),
-        conversation: {
-          comments: (conversation.comments || []).slice(-20).map(comment => pick(comment, COMMENT_FIELDS)),
-          page: Number(conversation.page || 1),
-          older_page: conversation.older_page ?? null,
-          total: Number(conversation.total || 0),
-        },
-      };
-      if (item?.is_review || item?.kind === 'review') {
-        data.files = (detail.files || []).slice(0, 50).map(file => ({
-          ...pick(file, REVIEW_FILE_FIELDS),
-          diff_lines: (file?.diff_lines || []).slice(0, 400).map(line => String(line)),
-        }));
-        data.reviews = (detail.reviews || []).slice(-20).map(review => ({
-          ...pick(review, REVIEW_FIELDS),
-          user: pick(review?.user, ['login']),
-        }));
-      }
-      const record = {
-        key,
-        user_login: login,
-        saved_at: now().toISOString(),
-        data,
-      };
-      if (transact) {
-        record.id = 'detail:' + login + ':' + key;
-        return ready().then(available => available ? transact(async records => {
-          const existing = (await records.getAll()).filter(candidate =>
-            candidate?.id?.startsWith('detail:') && candidate.id !== record.id
-          );
-          await records.put(record);
-          const overflow = existing.concat(record).sort((a, b) =>
-            String(a.saved_at).localeCompare(String(b.saved_at))
-          ).slice(0, -Math.max(1, maxDetails));
-          for (const candidate of overflow) await records.delete(candidate.id);
-          overflow.forEach(candidate => recordCache.delete(candidate.id));
-          recordCache.set(record.id, record);
-          return true;
-        }) : false).catch(() => false);
-      }
-      const records = readDetails().filter(candidate =>
-        !(candidate?.key === key && candidate?.user_login === login)
-      );
-      records.push(record);
-      try { storage.setItem(DETAILS_KEY, JSON.stringify(records.slice(-Math.max(1, maxDetails)))); }
-      catch (_) { return false; }
-      return true;
-    }
-
-    function loadDetail(login, item) {
-      const key = detailKey(item);
-      login = String(login || '').trim();
-      if (!login || !key) return null;
-      if (transact) {
-        const id = 'detail:' + login + ':' + key;
-        if (!recordCache) return ready().then(() => loadDetail(login, item));
-        const record = recordCache.get(id);
-        if (!record) return null;
-        const savedAt = Date.parse(record.saved_at || '');
-        if (!record.data || !Number.isFinite(savedAt) || now().getTime() - savedAt > maxAgeMs) {
-          recordCache.delete(id);
-          transact(async records => { await records.delete(id); }).catch(() => {});
-          return null;
-        }
-        return { ...record.data, saved_at: record.saved_at };
-      }
-      const records = readDetails();
-      const currentTime = now().getTime();
-      const valid = records.filter(record => {
-        const savedAt = Date.parse(record?.saved_at || '');
-        return record?.key && record?.user_login && record?.data && Number.isFinite(savedAt) &&
-          currentTime - savedAt <= maxAgeMs;
-      });
-      if (valid.length !== records.length) {
-        try { storage.setItem(DETAILS_KEY, JSON.stringify(valid)); } catch (_) { /* Best effort purge. */ }
-      }
-      const record = valid.find(candidate => candidate.key === key && candidate.user_login === login);
-      return record ? { ...record.data, saved_at: record.saved_at } : null;
-    }
-
     function setEnabled(value) {
       try {
         storage.setItem(ENABLED_KEY, value ? 'true' : 'false');
@@ -360,7 +48,6 @@
     function save(snapshot) {
       if (!enabled() || !snapshot?.user?.login) return false;
       const record = {
-        id: 'snapshot',
         version: VERSION,
         user_login: String(snapshot.user.login),
         saved_at: now().toISOString(),
@@ -373,36 +60,12 @@
           notification_pagination: snapshot.notification_pagination || {},
         },
       };
-      if (transact) {
-        return ready().then(available => available ? transact(async records => {
-          await records.put(record);
-          recordCache.set(record.id, record);
-          return true;
-        }) : false).catch(() => false);
-      }
       try { storage.setItem(SNAPSHOT_KEY, JSON.stringify(record)); }
       catch (_) { return false; }
       return true;
     }
 
     function load(expectedLogin) {
-      if (transact) {
-        if (!recordCache) return ready().then(() => load(expectedLogin));
-        const record = recordCache.get('snapshot');
-        const savedAt = Date.parse(record?.saved_at || '');
-        const invalid = record?.version !== VERSION || !record?.user_login || !record?.data ||
-          !Number.isFinite(savedAt);
-        const expired = Number.isFinite(savedAt) && now().getTime() - savedAt > maxAgeMs;
-        if (invalid || expired) {
-          if (record) {
-            recordCache.delete('snapshot');
-            transact(async records => { await records.delete('snapshot'); }).catch(() => {});
-          }
-          return null;
-        }
-        if (expectedLogin && record.user_login !== expectedLogin) return null;
-        return { ...record.data, saved_at: record.saved_at };
-      }
       let record;
       try { record = JSON.parse(storage.getItem(SNAPSHOT_KEY) || 'null'); }
       catch (_) { clear(); return null; }
@@ -418,7 +81,7 @@
       return { ...record.data, saved_at: record.saved_at };
     }
 
-    return { enabled, setEnabled, ready, retry, status, save, load, saveDetail, loadDetail, clear };
+    return { enabled, setEnabled, save, load, clear };
   }
 
   return createOfflineWorkStore;

frontend/outbox-coordinator.js

@@ -15,7 +15,7 @@ function createOutboxCoordinator({
   let sequence = 0;
 
   function validChange(value) {
-    return value && ['issue', 'authored', 'today', 'later'].includes(value.queue) ? value : null;
+    return value && (value.queue === 'issue' || value.queue === 'authored') ? value : null;
   }
 
   function publish(change) {

frontend/photo-draft-inbox.js

@@ -1,80 +0,0 @@
-(function (root, factory) {
-  const createPhotoDraftInbox = factory();
-  if (typeof module === 'object' && module.exports) module.exports = createPhotoDraftInbox;
-  else root.createPhotoDraftInbox = createPhotoDraftInbox;
-})(typeof globalThis !== 'undefined' ? globalThis : this, function () {
-  'use strict';
-
-  function targetKey(route) {
-    if (route?.kind === 'update') {
-      const notificationId = Number(route.notification_id || 0);
-      return notificationId > 0 ? 'update:' + notificationId : '';
-    }
-    const kind = route?.kind === 'search' ? route.target_kind : route?.kind;
-    const repository = String(route?.repository || '');
-    const number = Number(route?.number || 0);
-    return ['issue', 'pull'].includes(kind) && repository && number > 0 ?
-      kind + ':' + repository.toLowerCase() + '#' + number : '';
-  }
-
-  function removeTarget(item) {
-    const route = item?.route || {};
-    if (route.kind === 'update') return { kind:'update', notificationId:Number(route.notification_id) };
-    return {
-      kind:route.kind === 'search' ? route.target_kind : route.kind,
-      repository:route.repository,
-      number:Number(route.number),
-    };
-  }
-
-  return function createPhotoDraftInbox({ conversation, search }) {
-    let items = [];
-
-    async function refresh(existing = []) {
-      const occupied = new Set(existing.map(item => targetKey(item?.route)).filter(Boolean));
-      const results = await Promise.allSettled([
-        conversation?.list?.() || [],
-        search?.list?.() || [],
-      ]);
-      items = results.flatMap(result => result.status === 'fulfilled' && Array.isArray(result.value) ? result.value : [])
-        .filter(item => {
-          const key = targetKey(item?.route);
-          if (!key || occupied.has(key)) return false;
-          occupied.add(key);
-          return true;
-        })
-        .sort((left, right) => Number(right.updated_at || 0) - Number(left.updated_at || 0) ||
-          String(left.id || '').localeCompare(String(right.id || '')));
-      return items.slice();
-    }
-
-    function list() { return items.slice(); }
-
-    async function discard(item) {
-      if (!item || !items.some(candidate => candidate.id === item.id && candidate.photo_store === item.photo_store)) {
-        return false;
-      }
-      const store = item.photo_store === 'search' ? search : conversation;
-      if (!store?.remove) return false;
-      await store.remove(removeTarget(item));
-      items = items.filter(candidate => !(candidate.id === item.id && candidate.photo_store === item.photo_store));
-      return true;
-    }
-
-    function description(item) {
-      return item?.kind === 'photo-reply' ?
-        Number(item.photo_count || 0) + (Number(item.photo_count) === 1 ? ' saved photo' : ' saved photos') :
-        (item?.preview || 'Unfinished draft');
-    }
-
-    function searchTarget(item) {
-      const route = item?.route || {};
-      return {
-        kind:route.target_kind, repository:route.repository,
-        number:route.number, title:item?.title,
-      };
-    }
-
-    return { refresh, list, discard, description, searchTarget };
-  };
-});

frontend/pick-work.js

@@ -1,26 +1,14 @@
-function createFindWork({ fetchJson, onItems, onPagination, onStatus, onSelection = () => {}, onFacets = () => {} }) {
+function createFindWork({ fetchJson, onItems, onPagination, onStatus }) {
   let available = [];
   let pagination = { page: 1, total: 0, has_more: false };
   let loadRequest = null;
-  let loadGeneration = 0;
-  let query = '';
-  let filters = { repositories: [], labels: [] };
-  let facetView;
   let claimRequest = null;
   const previewed = new Set();
-  let selecting = false;
-  const selected = new Map();
 
   function itemKey(item) {
     return String(item?.repository || '') + '#' + String(item?.number || '');
   }
 
-  function emitSelection() {
-    const state = { active: selecting, count: selected.size, ids: Array.from(selected.keys()) };
-    onSelection(state);
-    return state;
-  }
-
   function apply(result, append) {
     const incoming = Array.isArray(result?.items) ? result.items : [];
     if (append) {
@@ -43,31 +31,13 @@ function createFindWork({ fetchJson, onItems, onPagination, onStatus, onSelectio
     };
     onItems(available.slice());
     onPagination({ ...pagination });
-    if (result?.facets) onFacets({
-      repositories: Array.isArray(result.facets.repositories) ? result.facets.repositories.slice() : [],
-      labels: Array.isArray(result.facets.labels) ? result.facets.labels.slice() : [],
-    });
-    if (result?.facets && typeof document !== 'undefined') {
-      facetView ||= attachFindWorkFacets(document.querySelector('#find-work-filters'), value =>
-        String(value).replace(/[&<>"']/g, character => ({'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;',"'":'&#39;'}[character])),
-      next => { filters = next; loadPage(1, false); });
-      facetView(result.facets);
-    }
   }
 
-  function loadPage(page, append, requestedQuery = query) {
-    if (loadRequest && requestedQuery === query && append) return loadRequest;
-    const generation = ++loadGeneration;
-    const params = new URLSearchParams();
-    params.set('facets', 'true');
-    if (requestedQuery) params.set('q', requestedQuery);
-    filters.repositories.forEach(value => params.append('repository', value));
-    filters.labels.forEach(value => params.append('label', value));
-    const queryPart = params.toString() ? '&' + params.toString() : '';
-    const request = fetchJson('api/v1/available-issues?page=' + page + queryPart, {
+  function loadPage(page, append) {
+    if (loadRequest) return loadRequest;
+    loadRequest = fetchJson('api/v1/available-issues?page=' + page, {
       headers: { Accept: 'application/json' },
     }).then(result => {
-      if (generation !== loadGeneration) return result;
       apply(result, append);
       if (result?.refresh_failed === true) {
         onStatus('Showing saved available work. Catalog refresh failed; retrying shortly.');
@@ -75,9 +45,8 @@ function createFindWork({ fetchJson, onItems, onPagination, onStatus, onSelectio
         onStatus('Showing saved available work while the catalog refreshes…');
       }
       return result;
-    }).finally(() => { if (loadRequest === request) loadRequest = null; });
-    loadRequest = request;
-    return request;
+    }).finally(() => { loadRequest = null; });
+    return loadRequest;
   }
 
   return {
@@ -91,66 +60,9 @@ function createFindWork({ fetchJson, onItems, onPagination, onStatus, onSelectio
       if (!pagination.has_more) return Promise.resolve(false);
       return loadPage(pagination.page + 1, true);
     },
-    search(value) {
-      query = String(value || '').trim();
-      return loadPage(1, false, query);
-    },
-    query() {
-      return query;
-    },
-    setFilters(next) {
-      filters = {
-        repositories: Array.from(new Set((next?.repositories || []).map(String))).slice(0, 10),
-        labels: Array.from(new Set((next?.labels || []).map(String))).slice(0, 10),
-      };
-      return loadPage(1, false);
-    },
-    filters() {
-      return { repositories: filters.repositories.slice(), labels: filters.labels.slice() };
-    },
-
     items() {
       return available.slice();
     },
-    startSelection() {
-      selecting = true;
-      selected.clear();
-      return emitSelection();
-    },
-    cancelSelection() {
-      selecting = false;
-      selected.clear();
-      return emitSelection();
-    },
-    toggleSelection(item) {
-      if (!selecting || !item) return emitSelection();
-      const key = itemKey(item);
-      if (selected.has(key)) selected.delete(key);
-      else selected.set(key, item);
-      return emitSelection();
-    },
-    fillSelection(limit) {
-      limit = Math.max(0, Math.floor(Number(limit) || 0));
-      if (!limit) return { selected: selected.size, added: 0, limit };
-      selecting = true;
-      const before = selected.size;
-      available.some(item => {
-        if (selected.size >= limit) return true;
-        selected.set(itemKey(item), item);
-        return false;
-      });
-      emitSelection();
-      return { selected: selected.size, added: selected.size - before, limit };
-    },
-    isSelected(item) {
-      return selected.has(itemKey(item));
-    },
-    selectedItems() {
-      return Array.from(selected.values());
-    },
-    selection() {
-      return { active: selecting, count: selected.size, ids: Array.from(selected.keys()) };
-    },
     togglePreview(item) {
       const key = itemKey(item);
       if (previewed.has(key)) previewed.delete(key);
@@ -179,8 +91,6 @@ function createFindWork({ fetchJson, onItems, onPagination, onStatus, onSelectio
         pagination.total = Math.max(available.length, pagination.total - 1);
         pagination.has_more = available.length < pagination.total;
         previewed.delete(itemKey(item));
-        selected.delete(itemKey(item));
-        emitSelection();
         onItems(available.slice());
         onPagination({ ...pagination });
         onStatus('Assigned ' + key + ' to you.');
@@ -191,23 +101,4 @@ function createFindWork({ fetchJson, onItems, onPagination, onStatus, onSelectio
   };
 }
 
-function attachFindWorkFacets(root, escapeHtml, onChange) {
-  const values = name => Array.from(root.querySelectorAll('input[name="' + name + '"]:checked'), input => input.value);
-  root.onchange = event => event.target.type === 'checkbox' && onChange({ repositories:values('find-work-repository'), labels:values('find-work-label') });
-  root.querySelector('#clear-find-work-filters').onclick = () => {
-    root.querySelectorAll('input').forEach(input => { input.checked = false; });
-    onChange({ repositories:[], labels:[] });
-  };
-  return facets => {
-    const active = { repositories:values('find-work-repository'), labels:values('find-work-label') };
-    const render = (id, choices, selected, name) => {
-      root.querySelector(id).innerHTML = choices.map(value => '<label class="find-work-filter-option"><input type="checkbox" name="' + name + '" value="' + escapeHtml(value) + '"' + (selected.includes(value) ? ' checked' : '') + ' />' + escapeHtml(value) + '</label>').join('');
-    };
-    render('#find-work-repository-filters', facets.repositories || [], active.repositories, 'find-work-repository');
-    render('#find-work-label-filters', facets.labels || [], active.labels, 'find-work-label');
-    const count = active.repositories.length + active.labels.length;
-    root.querySelector('#find-work-filter-count').textContent = count ? '(' + count + ' active)' : '';
-  };
-}
-
 if (typeof module !== 'undefined' && module.exports) module.exports = createFindWork;

frontend/plan-today-preview.js

@@ -1,63 +0,0 @@
-(function (root, factory) {
-  const api = factory();
-  if (typeof module === 'object' && module.exports) module.exports = api;
-  else root.createPlanTodayPreview = api;
-})(typeof globalThis !== 'undefined' ? globalThis : this, function () {
-  'use strict';
-
-  return function createPlanTodayPreview({
-    planner,
-    identity,
-    getScroll = () => 0,
-    setScroll = () => {},
-    onOpen = () => {},
-    onClose = () => {},
-  }) {
-    let current = null;
-
-    function open(item, trigger = null) {
-      if (!item || !identity?.(item) || !planner?.snapshot().open) return false;
-      current = { item, trigger, scroll:Number(getScroll()) || 0 };
-      onOpen(item, trigger);
-      return true;
-    }
-
-    function setDependencies({ available, dependencies } = {}) {
-      if (!current) return false;
-      current.dependencies_available = available === true;
-      current.dependencies = Array.isArray(dependencies) ? dependencies.filter(item => item?.state === 'open') : [];
-      current.requires_override = !current.dependencies_available || current.dependencies.length > 0;
-      return true;
-    }
-
-    function close({ add = false, override = false } = {}) {
-      if (!current) return 'closed';
-      if (add && current.requires_override && !override) {
-        return current.dependencies_available ? 'blocked' : 'dependencies-unavailable';
-      }
-      const { item, trigger, scroll } = current;
-      let result = 'returned';
-      if (add) {
-        const id = identity(item);
-        result = planner.snapshot().ids.includes(id) ? 'already-added' : planner.toggle(item);
-      }
-      current = null;
-      setScroll(scroll);
-      onClose(item, trigger);
-      return result;
-    }
-
-    function snapshot() {
-      if (!current) return { open:false };
-      const state = { open:true, item:current.item, trigger:current.trigger, scroll:current.scroll };
-      if (Object.prototype.hasOwnProperty.call(current, 'dependencies_available')) {
-        state.dependencies_available = current.dependencies_available;
-        state.dependencies = current.dependencies;
-        state.requires_override = current.requires_override;
-      }
-      return state;
-    }
-
-    return { open, close, setDependencies, snapshot };
-  };
-});

frontend/plan-today-readiness.js

@@ -1,41 +0,0 @@
-function createPlanTodayReadiness({ identity, inspect, concurrency = 3 }) {
-  const workerCount = Math.max(1, Math.floor(Number(concurrency) || 1));
-  let generation = 0;
-
-  async function run(items) {
-    const runGeneration = ++generation;
-    const candidates = Array.from(items || []);
-    const results = new Array(candidates.length);
-    let next = 0;
-
-    async function worker() {
-      while (next < candidates.length) {
-        const index = next;
-        next += 1;
-        const item = candidates[index];
-        let result;
-        try {
-          result = await inspect(item);
-        } catch (_error) {
-          result = { status:'unverified' };
-        }
-        results[index] = [identity(item), result];
-      }
-    }
-
-    await Promise.all(Array.from(
-      { length:Math.min(workerCount, candidates.length) },
-      () => worker(),
-    ));
-    if (runGeneration !== generation) return null;
-    return Object.fromEntries(results);
-  }
-
-  function cancel() {
-    generation += 1;
-  }
-
-  return { run, cancel };
-}
-
-if (typeof module !== 'undefined' && module.exports) module.exports = createPlanTodayReadiness;

frontend/plan-today.js

@@ -1,199 +0,0 @@
-function createPlanToday({ identity, save, start, limit = 5 }) {
-  let openState = false;
-  let draftIds = [];
-  let itemsById = new Map();
-  let capacityMinutes = null;
-  let estimates = {};
-  let recommendations = {};
-  let recommendationAware = false;
-  let capacityAware = false;
-  let buildState = null;
-  let buildReadiness = null;
-
-  function cleanItems(items) {
-    const unique = new Map();
-    for (const item of items || []) {
-      const id = identity?.(item);
-      if (id && !unique.has(id)) unique.set(id, item);
-    }
-    return unique;
-  }
-
-  function open(selectedItems, candidates, planning = null, actualMinutes = null) {
-    itemsById = cleanItems([...(selectedItems || []), ...(candidates || [])]);
-    draftIds = [];
-    for (const item of selectedItems || []) {
-      const id = identity?.(item);
-      if (id && itemsById.has(id) && !draftIds.includes(id) && draftIds.length < limit) draftIds.push(id);
-    }
-    capacityAware = Boolean(planning && ('capacity_minutes' in planning || 'estimates' in planning));
-    capacityMinutes = Number.isInteger(planning?.capacity_minutes) && planning.capacity_minutes > 0
-      ? planning.capacity_minutes : null;
-    estimates = {};
-    for (const [id, minutes] of Object.entries(planning?.estimates || {})) {
-      if (Number.isInteger(minutes) && minutes > 0) estimates[id] = minutes;
-    }
-    recommendations = {};
-    recommendationAware = actualMinutes !== null;
-    buildState = null;
-    buildReadiness = null;
-    for (const [id, minutes] of Object.entries(actualMinutes || {})) {
-      if (draftIds.includes(id) && Number.isInteger(minutes) && minutes >= 5 && minutes <= 1440 &&
-          estimates[id] !== minutes) recommendations[id] = minutes;
-    }
-    if (Object.keys(recommendations).length) capacityAware = true;
-    openState = true;
-    return snapshot();
-  }
-
-  function toggle(item) {
-    if (!openState) return 'closed';
-    const id = identity?.(item);
-    if (!id) return 'unavailable';
-    itemsById.set(id, item);
-    const index = draftIds.indexOf(id);
-    if (index >= 0) {
-      draftIds.splice(index, 1);
-      return 'removed';
-    }
-    if (draftIds.length >= limit) return 'full';
-    draftIds.push(id);
-    return 'added';
-  }
-
-  function move(id, direction) {
-    const index = draftIds.indexOf(id);
-    const target = direction === 'up' ? index - 1 : direction === 'down' ? index + 1 : -1;
-    if (!openState || index < 0 || target < 0 || target >= draftIds.length) return false;
-    [draftIds[index], draftIds[target]] = [draftIds[target], draftIds[index]];
-    return true;
-  }
-
-  function close() {
-    openState = false;
-    draftIds = [];
-    itemsById = new Map();
-    capacityMinutes = null;
-    estimates = {};
-    recommendations = {};
-    recommendationAware = false;
-    capacityAware = false;
-    buildState = null;
-    buildReadiness = null;
-  }
-
-  function cancel() {
-    close();
-    return true;
-  }
-
-  function setCapacity(minutes) {
-    capacityAware = true;
-    capacityMinutes = Number.isInteger(minutes) && minutes > 0 ? minutes : null;
-    return snapshot();
-  }
-
-  function setEstimate(id, minutes) {
-    const resolvingBuildEstimate = buildState?.needs_estimate?.includes(id);
-    if (!openState || (!draftIds.includes(id) && !resolvingBuildEstimate)) return false;
-    capacityAware = true;
-    if (!Number.isInteger(minutes) || minutes < 5 || minutes > 1440) return false;
-    estimates[id] = minutes;
-    if (resolvingBuildEstimate && buildReadiness) buildRecommendation(buildReadiness);
-    return true;
-  }
-
-  function applyRecommendation(id) {
-    const minutes = recommendations[id];
-    if (!openState || !draftIds.includes(id) || !Number.isInteger(minutes)) return false;
-    estimates[id] = minutes;
-    delete recommendations[id];
-    capacityAware = true;
-    return true;
-  }
-
-  function buildRecommendation(readiness = {}) {
-    if (!openState) return null;
-    buildReadiness = { ...readiness };
-    const selected = [];
-    const reasons = {};
-    const skipped = [];
-    const needsEstimate = [];
-    let used = 0;
-    for (const [id, item] of itemsById) {
-      if (selected.length >= limit) break;
-      const check = readiness[id] || { status:'unverified' };
-      if (check.status !== 'ready') {
-        skipped.push({
-          id,
-          status:check.status === 'blocked' ? 'blocked' : 'unverified',
-          reason:check.reason || (check.status === 'blocked' ? 'Blocked' : 'Could not verify readiness'),
-        });
-        continue;
-      }
-      const minutes = estimates[id];
-      if (!Number.isInteger(minutes)) {
-        needsEstimate.push(id);
-        continue;
-      }
-      if (capacityMinutes !== null && used + minutes > capacityMinutes) continue;
-      selected.push(id);
-      reasons[id] = item.reason || item.attention_reason || 'Ranked My Work';
-      used += minutes;
-    }
-    draftIds = selected;
-    capacityAware = true;
-    buildState = { selected:[...selected], reasons, skipped, needs_estimate:needsEstimate };
-    return buildState;
-  }
-
-  function commit({ start: startAfterSave = false, confirmOverCapacity = false } = {}) {
-    if (!openState) return 'closed';
-    const ids = [...draftIds];
-    const state = snapshot();
-    if (state.over_capacity && !confirmOverCapacity) return 'confirm-over-capacity';
-    const payload = capacityAware ? {
-      ids,
-      capacity_minutes: capacityMinutes,
-      estimates: Object.fromEntries(ids.filter(id => estimates[id]).map(id => [id, estimates[id]])),
-    } : ids;
-    if (save?.(payload) === false) return 'unavailable';
-    const first = ids.length ? itemsById.get(ids[0]) : null;
-    close();
-    if (startAfterSave && first) start?.(first);
-    return 'saved';
-  }
-
-  function snapshot() {
-    const basic = { open: openState, ids: [...draftIds], count: draftIds.length, limit };
-    if (!capacityAware) return basic;
-    const selectedEstimates = Object.fromEntries(draftIds.filter(id => estimates[id]).map(id => [id, estimates[id]]));
-    const plannedMinutes = Object.values(selectedEstimates).reduce((total, value) => total + value, 0);
-    const remainingMinutes = capacityMinutes === null ? null : capacityMinutes - plannedMinutes;
-    return {
-      ...basic,
-      capacity_minutes: capacityMinutes,
-      estimates: selectedEstimates,
-      ...(recommendationAware ? { recommendations:Object.fromEntries(
-        draftIds.filter(id => recommendations[id]).map(id => [id, recommendations[id]])
-      ) } : {}),
-      planned_minutes: plannedMinutes,
-      remaining_minutes: remainingMinutes,
-      unestimated_count: draftIds.length - Object.keys(selectedEstimates).length,
-      over_capacity: remainingMinutes !== null && remainingMinutes < 0,
-      ...(buildState ? { build:buildState } : {}),
-    };
-  }
-
-  function item(id) {
-    return itemsById.get(id) || null;
-  }
-
-  function candidates() {
-    return [...itemsById.entries()].filter(([id]) => !draftIds.includes(id)).map(([, value]) => value);
-  }
-
-  return { open, toggle, move, cancel, setCapacity, setEstimate, applyRecommendation, buildRecommendation, commit, snapshot, item, candidates };
-}
-
-if (typeof module !== 'undefined' && module.exports) module.exports = createPlanToday;

frontend/private-data-inventory.js

@@ -1,43 +0,0 @@
-(function (root, factory) {
-  if (typeof module === 'object' && module.exports) module.exports = factory;
-  else root.inspectStackchainPrivateDatabases = factory(root.indexedDB);
-})(typeof globalThis !== 'undefined' ? globalThis : this, function createPrivateDataInspector(indexedDB) {
-  function requestResult(request) {
-    return new Promise((resolve, reject) => {
-      request.onsuccess = () => resolve(request.result);
-      request.onerror = () => reject(request.error || new Error('Private storage inventory failed.'));
-      request.onblocked = () => reject(new Error('Private storage inventory was blocked.'));
-    });
-  }
-
-  async function countDatabase(name) {
-    const database = await requestResult(indexedDB.open(name));
-    try {
-      const storeNames = Array.from(database.objectStoreNames);
-      if (!storeNames.length) return 0;
-      const transaction = database.transaction(storeNames, 'readonly');
-      const counts = await Promise.all(storeNames.map(storeName =>
-        requestResult(transaction.objectStore(storeName).count())
-      ));
-      return counts.reduce((total, count) => total + Number(count || 0), 0);
-    } finally {
-      database.close();
-    }
-  }
-
-  return async function inspectPrivateDatabases(registeredNames) {
-    if (!indexedDB?.databases) return { recordCount: 0, unavailable: true };
-    try {
-      const existing = new Set((await indexedDB.databases()).map(database => database.name));
-      const counts = await Promise.all(
-        registeredNames.filter(name => existing.has(name)).map(countDatabase)
-      );
-      return {
-        recordCount: counts.reduce((total, count) => total + count, 0),
-        unavailable: false,
-      };
-    } catch (_error) {
-      return { recordCount: 0, unavailable: true };
-    }
-  };
-});

frontend/private-data-registry.js

@@ -1,14 +0,0 @@
-(function (root) {
-  const databases = Object.freeze([
-    'stackchain-background-outbox-v1',
-    'stackchain-offline-work-v2',
-    'stackchain-unfiled-captures-v1',
-    'stackchain-voice-transcripts-v1',
-    'stackchain-search-reply-drafts-v1',
-    'stackchain-conversation-reply-drafts-v1',
-    'stackchain-today-action-mailbox-v1',
-    'stackchain-app-badge-preference-v1',
-  ]);
-  if (typeof module !== 'undefined' && module.exports) module.exports = databases;
-  else root.stackchainPrivateDatabases = databases;
-})(typeof globalThis !== 'undefined' ? globalThis : this);

frontend/private-device-data.js

@@ -1,67 +0,0 @@
-(function (root, factory) {
-  if (typeof module !== 'undefined' && module.exports) {
-    module.exports = options => factory({
-      ...options,
-      privateDatabases: require('./private-data-registry.js'),
-    });
-  }
-  else root.stackchainPrivateDeviceData = factory({
-    localStorage: root.localStorage,
-    sessionStorage: root.sessionStorage,
-    indexedDB: root.indexedDB,
-    caches: root.caches,
-    serviceWorker: root.navigator?.serviceWorker,
-    MessageChannel: root.MessageChannel,
-    privateDatabases: root.stackchainPrivateDatabases,
-  });
-})(typeof window !== 'undefined' ? window : this, function createPrivateDeviceDataPurger({
-  localStorage, sessionStorage, indexedDB, caches, serviceWorker, MessageChannel, privateDatabases,
-}) {
-  function removeOwnedStorage(storage) {
-    if (!storage) return;
-    const keys = [];
-    for (let index = 0; index < storage.length; index += 1) {
-      const key = storage.key(index);
-      if (key?.startsWith('stackchain.')) keys.push(key);
-    }
-    keys.forEach(key => storage.removeItem(key));
-  }
-
-  async function stopWorkerOutbox() {
-    const registration = await serviceWorker?.ready;
-    if (!registration?.active || !MessageChannel) return;
-    await new Promise((resolve, reject) => {
-      const channel = new MessageChannel();
-      const timeout = setTimeout(() => reject(new Error('Background outbox purge timed out.')), 3000);
-      channel.port1.onmessage = event => {
-        clearTimeout(timeout);
-        if (event.data?.ok) resolve();
-        else reject(new Error(event.data?.error || 'Background outbox purge failed.'));
-      };
-      registration.active.postMessage({ type: 'stackchain-purge-outbox' }, [channel.port2]);
-    });
-  }
-
-  function deletePrivateDatabase(name) {
-    if (!indexedDB) return Promise.resolve();
-    return new Promise((resolve, reject) => {
-      let request;
-      try { request = indexedDB.deleteDatabase(name); }
-      catch (error) { reject(error); return; }
-      request.onsuccess = () => resolve();
-      request.onerror = () => reject(request.error || new Error('IndexedDB deletion failed.'));
-      request.onblocked = () => reject(new Error('IndexedDB deletion was blocked.'));
-    });
-  }
-
-  return async function clearPrivateDeviceData() {
-    await stopWorkerOutbox();
-    removeOwnedStorage(localStorage);
-    if (sessionStorage !== localStorage) removeOwnedStorage(sessionStorage);
-    for (const name of privateDatabases) await deletePrivateDatabase(name);
-    const keys = await caches?.keys?.() || [];
-    await Promise.all(
-      keys.filter(key => key.startsWith('stackchain-dashboard-')).map(key => caches.delete(key))
-    );
-  };
-});

frontend/progressive-capture.js

@@ -1,182 +0,0 @@
-function createProgressiveCapture({
-  document,
-  storage,
-  getLogin = () => '',
-  createCaptures = globalThis.createUnfiledCaptures,
-  requestFullWorkspace = async () => {
-    const lifecycle = await globalThis.stackchainWorkspaceLifecycle;
-    return lifecycle?.optionalReady;
-  },
-  createId,
-  now,
-}) {
-  const button = document.querySelector('[data-mobile-task="new"]');
-  const root = document.querySelector('#create-issue-sheet');
-  const title = document.querySelector('#create-issue-title');
-  const body = document.querySelector('#create-issue-body');
-  const heading = document.querySelector('#create-issue-heading');
-  const save = document.querySelector('#save-unfiled-issue');
-  const file = document.querySelector('#file-new-issue');
-  const cancel = document.querySelector('#cancel-new-issue');
-  const status = document.querySelector('#my-work-action-status');
-  const captures = createCaptures({
-    storage,
-    getCaptureLogin:getLogin,
-    getCurrentLogin:getLogin,
-    ...(createId ? {createId} : {}),
-    ...(now ? {now} : {}),
-  });
-  const listeners = [];
-  let started = false;
-  let saving = null;
-  let saved = false;
-  let handedOff = false;
-  const checkpointKey = 'stackchain.progressive-capture.v1';
-
-  function listen(element, name, callback) {
-    element?.addEventListener?.(name, callback);
-    listeners.push([element, name, callback]);
-  }
-
-  function close() {
-    root?.classList.remove('open');
-  }
-
-  function readCheckpoints() {
-    try {
-      const record = JSON.parse(storage?.getItem(checkpointKey) || 'null');
-      if (record?.version !== 1 || !Array.isArray(record.items)) return [];
-      return record.items.filter(item => item && typeof item.ownerLogin === 'string' &&
-        typeof item.title === 'string' && typeof item.body === 'string');
-    } catch (_error) { return []; }
-  }
-
-  function readCheckpoint() {
-    const login = String(getLogin() || '').trim();
-    if (!login) return null;
-    return readCheckpoints().find(item => item.ownerLogin === login) || null;
-  }
-
-  function checkpoint() {
-    const ownerLogin = String(getLogin() || '').trim();
-    if (!ownerLogin) return false;
-    try {
-      const items = readCheckpoints().filter(item => item.ownerLogin !== ownerLogin);
-      items.push({
-        ownerLogin,
-        title:String(title?.value || '').slice(0, 255),
-        body:String(body?.value || '').slice(0, 10000),
-      });
-      storage?.setItem(checkpointKey, JSON.stringify({
-        version:1, items,
-      }));
-      return true;
-    } catch (_error) { return false; }
-  }
-
-  function clearCheckpoint(expected) {
-    const current = readCheckpoint();
-    if (!current || current.title !== expected.title || current.body !== expected.body) return false;
-    try {
-      const ownerLogin = String(getLogin() || '').trim();
-      const items = readCheckpoints().filter(item => item.ownerLogin !== ownerLogin);
-      if (items.length) storage?.setItem(checkpointKey, JSON.stringify({version:1, items}));
-      else storage?.removeItem(checkpointKey);
-      return true;
-    } catch (_error) { return false; }
-  }
-
-  function open(event) {
-    saved = false;
-    const recovered = readCheckpoint();
-    if (recovered) {
-      if (title) title.value = recovered.title;
-      if (body) body.value = recovered.body;
-      if (status) status.textContent = 'Unfinished capture restored from this phone.';
-    }
-    if (heading) heading.textContent = 'Capture work';
-    root?.classList.add('open');
-    title?.focus?.();
-  }
-
-  async function saveDraft() {
-    if (saved || saving) return saving;
-    save.disabled = true;
-    const draft = {title:title?.value || '', body:body?.value || ''};
-    saving = Promise.resolve().then(() => captures.save(draft)).then(() => {
-      saved = true;
-      clearCheckpoint(draft);
-      if (title) title.value = '';
-      if (body) body.value = '';
-      close();
-      if (status) status.textContent = 'Saved to Drafts. Choose a repository when you’re ready to file it.';
-      return true;
-    }).catch(error => {
-      if (status) status.textContent = error.message;
-      title?.focus?.();
-      return false;
-    }).finally(() => {
-      save.disabled = false;
-      saving = null;
-    });
-    return saving;
-  }
-
-  async function fileNow() {
-    if (file.disabled) return false;
-    file.disabled = true;
-    if (status) status.textContent = 'Loading filing tools…';
-    try {
-      await requestFullWorkspace();
-      return true;
-    } catch (_error) {
-      file.disabled = false;
-      if (status) status.textContent = 'Filing tools unavailable. Your capture is still editable; retry when connected.';
-      title?.focus?.();
-      return false;
-    }
-  }
-
-  function start() {
-    if (started) return false;
-    started = true;
-    root?.classList.add('progressive-capture');
-    listen(button, 'click', open);
-    listen(save, 'click', saveDraft);
-    listen(file, 'click', fileNow);
-    listen(cancel, 'click', close);
-    listen(title, 'input', checkpoint);
-    listen(body, 'input', checkpoint);
-    return true;
-  }
-
-  function handoff() {
-    if (handedOff) return null;
-    handedOff = true;
-    const state = {
-      open:Boolean(root?.classList.contains('open')),
-      title:title?.value || '', body:body?.value || '',
-    };
-    state.complete = () => clearCheckpoint(state);
-    root?.classList.remove('progressive-capture');
-    file.disabled = false;
-    listeners.forEach(([element, name, callback]) => element?.removeEventListener?.(name, callback));
-    listeners.length = 0;
-    return state;
-  }
-
-  return {start, handoff};
-}
-
-if (typeof window !== 'undefined' && typeof document !== 'undefined' &&
-    typeof createUnfiledCaptures === 'function' &&
-    window.matchMedia?.('(max-width: 600px)').matches === true) {
-  window.stackchainProgressiveCapture = createProgressiveCapture({
-    document,
-    storage:window.localStorage,
-    getLogin:() => window.stackchainProgressiveMyWork?.login?.() || '',
-  });
-  window.stackchainProgressiveCapture.start();
-}
-
-if (typeof module !== 'undefined' && module.exports) module.exports = createProgressiveCapture;

frontend/progressive-human-gates.js

@@ -1,110 +0,0 @@
-function createProgressiveHumanGates(options = {}) {
-  const document = options.document || globalThis.document;
-  const location = options.location || globalThis.location;
-  const history = options.history || globalThis.history;
-  const storage = options.storage || globalThis.localStorage;
-  const isOnline = options.isOnline || (() => globalThis.navigator?.onLine !== false);
-  const fetchJson = options.fetchJson || (async (path, requestOptions = {}) => {
-    const response = await fetch(path, requestOptions);
-    const payload = await response.json().catch(() => ({}));
-    if (!response.ok) throw new Error(payload.error || payload.detail?.message || payload.detail || 'Review request failed.');
-    return payload;
-  });
-  const liveSnapshot = options.liveSnapshot || null;
-  const getIdentity = options.getIdentity || (async () => {
-    const response = liveSnapshot ? await liveSnapshot.acquire({requireIdentity:true}) :
-      await fetchJson('api/v1/live', {headers:{Accept:'application/json'}});
-    const user = response?.context?.user || {};
-    const login = String(user.login || '').trim();
-    return {login, accountKey:login && user.id ? String(user.id) + ':' + login : login};
-  });
-  const query = selector => document.querySelector(selector);
-  const nodes = {
-    count:query('#human-gates-count'), list:query('#human-gates-list'),
-    status:query('#human-gates-status'), panel:query('#human-gates'),
-    detail:query('#human-gate-detail'),
-    pendingTab:query('#human-gates-pending'), historyTab:query('#human-gates-history'),
-  };
-  let login = '';
-  let accountKey = '';
-  let started = false;
-  let startFlight = null;
-
-  const controller = createHumanGates({
-    storage, isOnline, location, fetchJson,
-    getLogin:() => login, getAccountKey:() => accountKey, nodes,
-  });
-
-  const showError = error => {
-    if (nodes.status) nodes.status.textContent = error?.message || 'Human Gates are unavailable.';
-  };
-  const open = () => start(true).catch(showError);
-  query('#open-human-gates')?.addEventListener?.('click', open);
-  query('#close-human-gates')?.addEventListener?.('click', () => {
-    if (nodes.panel) nodes.panel.hidden = true;
-    if (location.hash === '#/my-work/human-gates') history.replaceState({}, '', '#/my-work');
-  });
-  nodes.list?.addEventListener?.('click', event => {
-    const card = event.target?.closest?.('[data-human-gate-id]');
-    if (card) controller.select(card.dataset.humanGateId);
-  });
-  nodes.detail?.addEventListener?.('click', event => {
-    const recovery = event.target?.closest?.('[data-gate-recover]');
-    if (recovery) {
-      recovery.disabled = true;
-      controller.recoverDecision().catch(error => {
-        showError(error);
-        recovery.disabled = false;
-      });
-      return;
-    }
-    const decision = event.target?.closest?.('[data-gate-decision]')?.dataset.gateDecision;
-    if (!decision) return;
-    controller.submitDecision(decision).catch(error => {
-      if (!error?.targetSelector) showError(error);
-    });
-  });
-  nodes.pendingTab?.addEventListener?.('click', () => controller.showPending());
-  nodes.historyTab?.addEventListener?.('click', () => controller.showHistory().catch(showError));
-
-  async function start(force = false) {
-    if (!force && location.hash !== '#/my-work/human-gates') return false;
-    if (started) return controller.open().then(() => true);
-    if (startFlight) return startFlight;
-    startFlight = (async () => {
-      const identity = await getIdentity();
-      login = String(identity?.login || '').trim();
-      accountKey = String(identity?.accountKey || login).trim();
-      if (!login) throw new Error('Authenticated account identity is required.');
-      await controller.open();
-      started = true;
-      return true;
-    })();
-    try { return await startFlight; }
-    finally { startFlight = null; }
-  }
-
-  return {
-    start,
-    handoff() {
-      return {
-        controller, started,
-        adoptIdentity(nextLogin, nextAccountKey) {
-          login = String(nextLogin || '').trim();
-          accountKey = String(nextAccountKey || login).trim();
-        },
-      };
-    },
-  };
-}
-
-if (typeof window !== 'undefined' && typeof document !== 'undefined') {
-  window.stackchainProgressiveHumanGates = createProgressiveHumanGates({
-    document, liveSnapshot:window.stackchainProgressiveLiveSnapshot,
-  });
-  void window.stackchainProgressiveHumanGates.start().catch(() => {});
-}
-if (typeof module !== 'undefined' && module.exports) {
-  globalThis.createHumanGates = globalThis.createHumanGates || require('./human-gates.js');
-  module.exports = createProgressiveHumanGates;
-}

frontend/progressive-live-snapshot.js

@@ -1,49 +0,0 @@
-function createProgressiveLiveSnapshot({fetchSnapshot}) {
-  let value = null;
-  let flight = null;
-
-  const hasIdentity = snapshot => {
-    const user = snapshot?.context?.user || {};
-    return Boolean(String(user.login || '').trim());
-  };
-  const requireUsable = (snapshot, options) => {
-    if (!options?.requireIdentity || hasIdentity(snapshot)) return snapshot;
-    if (value === snapshot) value = null;
-    throw new Error('Authenticated account identity is unavailable.');
-  };
-  const acquire = (options = {}) => {
-    if (value) return Promise.resolve().then(() => requireUsable(value, options));
-    if (flight) return flight.then(snapshot => requireUsable(snapshot, options));
-    flight = Promise.resolve().then(() => fetchSnapshot()).then(snapshot => {
-      value = snapshot;
-      flight = null;
-      return snapshot;
-    }, error => {
-      flight = null;
-      throw error;
-    });
-    return flight.then(snapshot => requireUsable(snapshot, options));
-  };
-
-  return {
-    acquire,
-    snapshot:() => value,
-    pending:() => flight,
-    identity() {
-      const user = value?.context?.user || {};
-      const login = String(user.login || '').trim();
-      return {login, accountKey:login && user.id ? String(user.id) + ':' + login : login};
-    },
-  };
-}
-
-if (typeof window !== 'undefined') {
-  window.stackchainProgressiveLiveSnapshot = createProgressiveLiveSnapshot({
-    fetchSnapshot:async () => {
-      const response = await fetch('api/v1/live', {headers:{Accept:'application/json'}});
-      if (!response.ok) throw new Error('HTTP ' + response.status);
-      return response.json();
-    },
-  });
-}
-if (typeof module !== 'undefined' && module.exports) module.exports = createProgressiveLiveSnapshot;