From d543534c9cd0744bea84162639cc53e9799a5638 Mon Sep 17 00:00:00 2001
From: Matthew P Munger <matthew@webflow.com>
Date: Wed, 26 Aug 2026 11:58:10 -0500
Subject: [PATCH 1/2] feat: put an owner and a start date on the case, and
 retire the task board (S5)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Option 7a: two fields on the case, plus Copy as ticket. No plan object and
no task object.

`start` stamps `owner` and `startedAt` and nothing else writes either. Both
are written inside `applyAction`, beside the checkpoints `mark_fixed`
schedules, so there is no second door into `in_progress` that could reach the
state without the stamp — and the registry allows `start` only from `todo`,
so neither field can be overwritten by a later move. Neither is editable by
hand: a field that can drift from the history entry beside it is a second
answer to "who has this", which is the defect the case object exists to
remove. `checklist` is gone; `notes` is free text with no schema.

The owner is the identity `attributionOf` gives the caller, not the caller.
F4 split the two on purpose — the class is a permission and this is the
record of who — and `start` is person-only, so the class here is known and
constant; a field typed to admit `{ kind: "system" }` is a field that
eventually holds one. Going through `attributionOf` also means the owner and
the attribution column in history are one answer to one question (rule 20),
and that the two identities F4 declines to render are the two this declines
to store: a system caller, and the migrated person nobody can name. Both
leave the field absent, and the row then says so.

The Fix queue draws itself, like Watch. To do above In progress, in the order
`queue.fix.holds` already states, impact-ordered within each group with
unmeasured findings last (rule 18). In progress rows carry the owner's
initials, name and start date; past thirty days that date renders amber and
that is the whole of it — no escalation, no email, no second threshold. The
queue says so at the top, because a reader who has been told there is no
escalation can leave a case for thirty-one days on purpose.

A legacy record that arrives already in progress never passed through
`start`, so it has no owner. The row says so rather than inventing one.

Copy as ticket is plain markdown on the clipboard and the entire integration
surface. A tracker connection would be a second home for the work's state,
and a second home is where it disagrees with the first. The saving comes from
`formatCaseImpact`, which is the call the case detail makes, so the ticket's
figure is the case's figure to the byte; an unmeasured finding says "Not
measured" and never 0. The link is `casePath` — `/issues/{id}`, no
`/issues/case/` segment to get wrong.

Deleted: the `/tasks` redirect stub (C1a made it redundant), the standalone
`api/agent-audits/verify` endpoint and its client — W1's checkpoint evaluator
replaces it — and the "Add to tasks" / "Add workaround to tasks" affordance
with the dead Tasks-board plumbing behind it.

`EFFORT_LABEL` moved to `impact-format.ts` and `enteredAt` generalised out of
`fixedAtOf`, both because S5 gave them a third reader that is not a component.
---
 src/app/(app)/issues/page.tsx                 |  23 +-
 src/app/(app)/pages/pages-content.tsx         |  12 +-
 src/app/(app)/tasks/page.tsx                  |  15 -
 src/app/api/agent-audits/verify/route.ts      |  27 --
 src/components/case-detail.tsx                | 195 ++++++--
 src/components/copy-ticket-button.tsx         | 102 ++++
 src/components/fix-queue.tsx                  |  96 ++++
 src/components/fix-row.tsx                    | 170 +++++++
 src/components/issue-row.tsx                  |  23 +-
 src/components/store.tsx                      | 119 +----
 src/lib/__tests__/fix-work.test.ts            | 437 ++++++++++++++++++
 src/lib/__tests__/webflow-performance.test.ts |   4 -
 src/lib/agentAuditServer.ts                   |  28 --
 src/lib/checkpoint-evaluation.ts              |   8 +-
 src/lib/fix-copy.ts                           | 157 +++++++
 src/lib/fix-ticket.ts                         |  99 ++++
 src/lib/impact-format.ts                      |  57 ++-
 src/lib/issue-case.ts                         | 101 +++-
 src/lib/webflowPerformance.ts                 |   4 -
 19 files changed, 1415 insertions(+), 262 deletions(-)
 delete mode 100644 src/app/(app)/tasks/page.tsx
 delete mode 100644 src/app/api/agent-audits/verify/route.ts
 create mode 100644 src/components/copy-ticket-button.tsx
 create mode 100644 src/components/fix-queue.tsx
 create mode 100644 src/components/fix-row.tsx
 create mode 100644 src/lib/__tests__/fix-work.test.ts
 create mode 100644 src/lib/fix-copy.ts
 create mode 100644 src/lib/fix-ticket.ts

diff --git a/src/app/(app)/issues/page.tsx b/src/app/(app)/issues/page.tsx
index 81819a4..2651b38 100644
--- a/src/app/(app)/issues/page.tsx
+++ b/src/app/(app)/issues/page.tsx
@@ -31,6 +31,7 @@ import {
 } from "@/components/issue-empty";
 import { SelectMenu } from "@/components/select-menu";
 import { WatchQueue } from "@/components/watch-queue";
+import { FixQueue } from "@/components/fix-queue";
 import { WATCH_EMPTY } from "@/lib/watch-copy";
 
 /**
@@ -155,11 +156,21 @@ export default function IssuesPage() {
     return <EverythingResolved caseCount={view.cases.length} showAllHref={linkTo({ queue: "show_all" })} />;
   }
 
-  // Watch is not grouped by remediation and not sorted by impact: it is a run
-  // of fixes waiting on evidence, ordered by what is heard from next. It reads
-  // the queue's cases directly rather than the folded groups.
+  /**
+   * Two of the four queues draw themselves, and both for the same reason.
+   *
+   * Decide and Show all are lists of undecided things, so they are grouped by
+   * remediation, folded at the savings gate and sorted however the reader asks —
+   * every one of those is a way of deciding. Fix and Watch hold things that have
+   * already been decided, and neither question left has a sort control as its
+   * answer: Fix asks which to do next, Watch asks what is heard from when. Both
+   * read the queue's cases directly rather than the folded groups, because a
+   * fold is a triage affordance and there is no triage left to do.
+   */
+  const isFix = queue === "fix";
   const isWatch = queue === "watch";
-  const hasRows = isWatch ? view.inQueue.length > 0 : view.groups.length > 0 || view.tail.length > 0;
+  const ownQueue = isFix || isWatch;
+  const hasRows = ownQueue ? view.inQueue.length > 0 : view.groups.length > 0 || view.tail.length > 0;
 
   return (
     <div style={{ minWidth: 0 }}>
@@ -167,9 +178,11 @@ export default function IssuesPage() {
 
       <QueueTabs activeQueue={queue} counts={view.counts} hrefFor={(next) => linkTo({ queue: next })} />
 
+      {hasRows && isFix ? <FixQueue cases={view.inQueue} basePath={basePath} /> : null}
+
       {hasRows && isWatch ? <WatchQueue cases={view.inQueue} /> : null}
 
-      {hasRows && !isWatch ? (
+      {hasRows && !ownQueue ? (
         <>
           <div
             style={{
diff --git a/src/app/(app)/pages/pages-content.tsx b/src/app/(app)/pages/pages-content.tsx
index 4877201..8f1cf8b 100644
--- a/src/app/(app)/pages/pages-content.tsx
+++ b/src/app/(app)/pages/pages-content.tsx
@@ -49,7 +49,7 @@ import { normalizeCollectionSchedule } from "@/lib/collectionSchedule";
 import { evidenceForPage, visitorExperienceTrend } from "@/lib/visitorExperience";
 import { performanceIssueCounts, siteCulpritRollups, sitePerformanceIssues } from "@/lib/performanceIssues";
 import type { PerformanceIssueStatus } from "@/lib/performanceIssues";
-import { customerActionabilityFor, recommendationIsCustomerActionable, remediationTone, triageActionLabel, webflowClassificationFor } from "@/lib/webflowPerformance";
+import { customerActionabilityFor, recommendationIsCustomerActionable, remediationTone, webflowClassificationFor } from "@/lib/webflowPerformance";
 import { siteNativeElementRollups } from "@/lib/nativeElements";
 import { compareLabAndField } from "@/lib/labFieldComparison";
 import { fieldPriorityRankForRec, recommendationEvidenceSignal } from "@/lib/fieldPrioritization";
@@ -260,7 +260,6 @@ function DashboardContent({
     setRangeDays,
     dashSort,
     sortDash,
-    triageRec,
     pathFor,
     visitorExperienceVisible,
     visitorExperience,
@@ -567,13 +566,8 @@ function DashboardContent({
             <span className="watcher-ribbon__running" aria-label="Analysis is running">
               <Circle size={10} weight="fill" />
             </span>
-          ) : topRibbonRec ? (
-            <>
-              {topRibbonEvidence && <FieldEvidenceChip signal={topRibbonEvidence} />}
-              <button type="button" className="watcher-ribbon__primary" onClick={() => triageRec(topRibbonRec.key)}>
-                {triageActionLabel(topRibbonRec)}
-              </button>
-            </>
+          ) : topRibbonRec && topRibbonEvidence ? (
+            <FieldEvidenceChip signal={topRibbonEvidence} />
           ) : null}
           <Link className="watcher-ribbon__inbox" href={pathFor(`${DESTINATION_PATH.issues}?queue=decide`)}>
             {`Open ${QUEUE_LABEL.decide}`}
diff --git a/src/app/(app)/tasks/page.tsx b/src/app/(app)/tasks/page.tsx
deleted file mode 100644
index e761bcc..0000000
--- a/src/app/(app)/tasks/page.tsx
+++ /dev/null
@@ -1,15 +0,0 @@
-import { redirect } from "next/navigation";
-import { getEnv } from "@/lib/env";
-import { normalizeBasePath, withBasePath } from "@/lib/paths";
-import { DESTINATION_PATH } from "@/lib/vocabulary";
-
-export const runtime = "nodejs";
-export const dynamic = "force-dynamic";
-
-/**
- * Retired destination. What lived here is now the Fix queue on the issues
- * list; this route only exists to keep old links from 404ing.
- */
-export default function RedirectToFixQueue() {
-  redirect(withBasePath(normalizeBasePath(getEnv("BASE_URL")), `${DESTINATION_PATH.issues}?queue=fix`));
-}
diff --git a/src/app/api/agent-audits/verify/route.ts b/src/app/api/agent-audits/verify/route.ts
deleted file mode 100644
index fc55ce7..0000000
--- a/src/app/api/agent-audits/verify/route.ts
+++ /dev/null
@@ -1,27 +0,0 @@
-import { relayAgentAuditResponse, requestAgentAuditVerify } from "@/lib/agentAuditServer";
-import { authorizedProjectForRequest } from "@/lib/projects";
-
-export const runtime = "nodejs";
-export const dynamic = "force-dynamic";
-
-/**
- * Re-run the provider checks recorded on one implemented agent task.
- *
- * Only the task key travels. The collector resolves which checks to run from
- * stored state, so an arbitrary check set can never be submitted.
- */
-export async function POST(request: Request): Promise<Response> {
-  const body = (await request.json().catch(() => ({}))) as { recKey?: unknown };
-  if (typeof body.recKey !== "string" || !body.recKey) {
-    return Response.json({ error: "recKey is required" }, { status: 400 });
-  }
-  try {
-    const project = await authorizedProjectForRequest(request, "admin");
-    return relayAgentAuditResponse(await requestAgentAuditVerify(project.tenant, body.recKey));
-  } catch (error) {
-    return Response.json(
-      { error: error instanceof Error ? error.message : "Verification is unavailable" },
-      { status: 503 },
-    );
-  }
-}
diff --git a/src/components/case-detail.tsx b/src/components/case-detail.tsx
index 0372c41..86804e3 100644
--- a/src/components/case-detail.tsx
+++ b/src/components/case-detail.tsx
@@ -1,6 +1,6 @@
 "use client";
 
-import { useMemo } from "react";
+import { useMemo, useState } from "react";
 import { attributionOf } from "@/lib/caller";
 import {
   RESOLVING_INTERVAL,
@@ -10,8 +10,10 @@ import {
   primaryActionFor,
   type IssueCase,
 } from "@/lib/issue-case";
-import { runOf } from "@/lib/checkpoint-evaluation";
-import { formatImpact } from "@/lib/impact-format";
+import { fixedAtOf, runOf } from "@/lib/checkpoint-evaluation";
+import { formatCaseImpact } from "@/lib/impact-format";
+import { ticketMarkdown } from "@/lib/fix-ticket";
+import { FIX_NOTES_PLACEHOLDER } from "@/lib/fix-copy";
 import {
   CONFIDENCE_LABEL,
   DESTINATION_LABEL,
@@ -19,6 +21,7 @@ import {
   EVIDENCE_SOURCE_LABEL,
   ISSUE_ACTION_LABEL,
   WORK_STATE_LABEL,
+  queueHoldsState,
   type ExclusionReason,
   type IssueAction,
 } from "@/lib/vocabulary";
@@ -40,6 +43,7 @@ import { ObjectDetailHeader } from "@/components/object-detail-header";
 import { StatusChip } from "@/components/status-chip";
 import { CasePages } from "@/components/case-pages";
 import { CheckpointTrack } from "@/components/checkpoint-track";
+import { CopyTicketButton } from "@/components/copy-ticket-button";
 import { daysOf, formatDate } from "@/lib/watch-copy";
 
 /**
@@ -51,9 +55,10 @@ import { daysOf, formatDate } from "@/lib/watch-copy";
  *   2 impact/effort  what it costs and what it takes — the decision inputs
  *   3 taxonomy       category, severity, confidence
  *   4 affected pages which pages, and which of them count
- *   5 evidence       who measured it, never averaged
- *   6 checkpoints    only once there is something to check
- *   7 history        what happened, oldest last
+ *   5 notes          free text, for whoever picks this up
+ *   6 evidence       who measured it, never averaged
+ *   7 checkpoints    only once there is something to check
+ *   8 history        what happened, oldest last
  *
  * Taxonomy never comes first. A row of chips above the diagnosis asks the
  * reader to classify a problem they have not been told about yet — the
@@ -77,6 +82,22 @@ export interface CaseDetailProps {
   onAction?: (action: IssueAction, issue: IssueCase) => void;
   onExclude?: (pageId: string, reason: ExclusionReason) => void;
   onInclude?: (pageId: string) => void;
+  /**
+   * Persist the case's notes.
+   *
+   * Withheld the same way `onExclude` is, and for the same reason: a notes box
+   * that accepts what you type, shows it, and loses it on reload is worse than
+   * no notes box. The section renders read-only when there is a note and no
+   * handler, and not at all when there is neither.
+   */
+  onNotesChange?: (notes: string) => void;
+  /**
+   * The deployment's public URL, for the link in a copied ticket.
+   *
+   * Absent yields the root-relative `/issues/{id}`, which is wrong in a ticket
+   * visibly rather than silently. See `absoluteUrl`.
+   */
+  appUrl?: string;
   now?: Date;
   locale?: string;
 }
@@ -92,6 +113,96 @@ function Section({ title, children }: { title: string; children: React.ReactNode
   );
 }
 
+/**
+ * Free text, for whoever picks this up.
+ *
+ * No schema, no required fields, no length limit and nothing derived from what
+ * is written here. That is the point of it: the other eight sections of a case
+ * are shapes the app imposed on a finding, and every one of them is occasionally
+ * the wrong shape for the thing somebody needs to say. This is where that goes.
+ *
+ * Three states, and the middle one is the one worth explaining. With a handler
+ * it is editable. With a note and no handler it is shown but not editable — a
+ * box that takes what you type and loses it on reload is worse than a box that
+ * does not take it, and hiding a note that exists because nothing can save a new
+ * one would be hiding evidence. With neither it is not rendered at all.
+ *
+ * Committed on blur rather than on every keystroke. A case is derived from
+ * stored records, so a write is a round trip; per-keystroke saving would put one
+ * in flight per character and reorder them under any latency at all.
+ */
+function CaseNotes({
+  notes,
+  onNotesChange,
+}: {
+  notes?: string;
+  onNotesChange?: (notes: string) => void;
+}) {
+  const [draft, setDraft] = useState(notes ?? "");
+  const [seen, setSeen] = useState(notes);
+
+  // A case re-derived by a later run brings its own note, and the draft follows
+  // it so an edit made elsewhere is not overwritten by a stale buffer.
+  //
+  // Adjusted during render rather than in an effect. An effect would paint the
+  // old note first and correct it on the next pass, which is a visible flash of
+  // the wrong text; React re-runs this component before committing anything, so
+  // the reader only ever sees the new one.
+  if (notes !== seen) {
+    setSeen(notes);
+    setDraft(notes ?? "");
+  }
+
+  if (!onNotesChange) {
+    if (!notes) return null;
+    return (
+      <Section title="Notes">
+        <p
+          style={{
+            margin: 0,
+            maxWidth: "72ch",
+            fontSize: 12.5,
+            lineHeight: 1.6,
+            color: "var(--text-body)",
+            // Whatever they typed, laid out the way they typed it.
+            whiteSpace: "pre-wrap",
+          }}
+        >
+          {notes}
+        </p>
+      </Section>
+    );
+  }
+
+  return (
+    <Section title="Notes">
+      <textarea
+        value={draft}
+        onChange={(event) => setDraft(event.target.value)}
+        onBlur={() => {
+          if (draft !== (notes ?? "")) onNotesChange(draft);
+        }}
+        placeholder={FIX_NOTES_PLACEHOLDER}
+        rows={3}
+        style={{
+          display: "block",
+          width: "100%",
+          maxWidth: "72ch",
+          padding: "9px 11px",
+          borderRadius: 8,
+          border: "1px solid var(--border-strong)",
+          background: "var(--surface-card)",
+          color: "var(--text-body)",
+          font: "inherit",
+          fontSize: 12.5,
+          lineHeight: 1.6,
+          resize: "vertical",
+        }}
+      />
+    </Section>
+  );
+}
+
 /** One reference figure: a label above, the reading below. */
 function Figure({ label, value, muted }: { label: string; value: string; muted?: boolean }) {
   return (
@@ -120,24 +231,24 @@ export function CaseDetail({
   onAction,
   onExclude,
   onInclude,
+  onNotesChange,
+  appUrl,
   now,
   locale,
 }: CaseDetailProps) {
   const included = includedPages(issue);
   const run = useMemo(() => runOf(issue), [issue]);
-  const fixedAt = useMemo(
-    () => [...issue.history].reverse().find((entry) => entry.to === "fixed")?.at,
-    [issue.history],
-  );
+  const fixedAt = useMemo(() => fixedAtOf(issue), [issue]);
 
   // Impact is the worst reading on a page this case counts — the same statistic
   // as the group header above it and the row beside it, never a sum (rule 19).
   // Adding four pages' savings would invent a figure no run produced.
-  const worst = useMemo(() => {
-    const readings = included.map((pageId) => impactByPage?.[pageId] ?? 0);
-    return readings.length ? Math.max(...readings, 0) : issue.impactMs;
-  }, [included, impactByPage, issue.impactMs]);
-  const impact = formatImpact(worst || issue.impactMs);
+  //
+  // The derivation moved into `formatCaseImpact` in S5, when "Copy as ticket"
+  // became a reader of the same figure that renders off screen. The brief asks
+  // for the ticket's string to be byte-identical to this one, and the only way
+  // to promise that is for there to be one string rather than two that agree.
+  const impact = formatCaseImpact(issue, impactByPage);
 
   /**
    * The state's own legal moves, in the order the header offers them.
@@ -180,6 +291,22 @@ export function CaseDetail({
   const sources = issue.evidence.length;
   const conflicting = issue.confidence === "unclear" && sources >= 2;
 
+  /**
+   * The ticket, offered on the two states the Fix queue holds.
+   *
+   * Asked of the registry rather than written as `todo || in_progress`, so a
+   * state that joins the fix queue gets the button without anyone remembering.
+   * It is not offered from Decide, where the case has not been committed to and
+   * a ticket would be a plan for work nobody has agreed to do, nor from Watch,
+   * where the work is done and what is outstanding is evidence rather than
+   * effort.
+   */
+  const inFixQueue = queueHoldsState("fix", issue.state);
+  const ticket = useMemo(
+    () => (inFixQueue ? ticketMarkdown(issue, { pageTitles, impactByPage, appUrl }) : ""),
+    [appUrl, impactByPage, inFixQueue, issue, pageTitles],
+  );
+
   return (
     <div style={{ minWidth: 0, paddingBottom: 48 }}>
       <ObjectDetailHeader
@@ -193,21 +320,27 @@ export function CaseDetail({
              why in a sentence. A disabled Accept is the thing this replaces —
              it tells the reader they lack permission, which is not what is
              true; there is simply nothing documented to commit to. */
-          noAction ? (
-            <p
-              style={{
-                margin: 0,
-                maxWidth: "34ch",
-                fontSize: 12.5,
-                lineHeight: 1.55,
-                color: "var(--text-muted)",
-              }}
-            >
-              {noAction}
-            </p>
-          ) : (
-            <ObjectDetailHeaderActions actions={actions} />
-          )
+          <>
+            {noAction ? (
+              <p
+                style={{
+                  margin: 0,
+                  maxWidth: "34ch",
+                  fontSize: 12.5,
+                  lineHeight: 1.55,
+                  color: "var(--text-muted)",
+                }}
+              >
+                {noAction}
+              </p>
+            ) : (
+              <ObjectDetailHeaderActions actions={actions} />
+            )}
+            {/* Below the transitions, because copying is not one. Start and
+                Mark fixed change what is true about the work; this takes a
+                copy of what is already true and changes nothing. */}
+            {inFixQueue ? <CopyTicketButton ticket={ticket} /> : null}
+          </>
         }
         metadata={
           <div style={{ display: "flex", flexWrap: "wrap", gap: 28 }}>
@@ -232,6 +365,8 @@ export function CaseDetail({
           />
         </div>
 
+        <CaseNotes notes={issue.notes} onNotesChange={onNotesChange} />
+
         <Section title="Evidence">
           <p style={{ margin: "0 0 10px", fontSize: 12.5, color: "var(--text-muted)", maxWidth: "72ch" }}>
             {conflicting
diff --git a/src/components/copy-ticket-button.tsx b/src/components/copy-ticket-button.tsx
new file mode 100644
index 0000000..3d6f491
--- /dev/null
+++ b/src/components/copy-ticket-button.tsx
@@ -0,0 +1,102 @@
+"use client";
+
+import { useCallback, useEffect, useState } from "react";
+import { FIX_ACTION_COPY_TICKET, FIX_TICKET_COPIED } from "@/lib/fix-copy";
+
+/**
+ * "Copy as ticket" — the case, as plain markdown, on the clipboard.
+ *
+ * The whole integration surface. There is no tracker connection behind this and
+ * there is not going to be one: a connection is a second place the work's state
+ * lives, and a second place the work's state lives is a place it disagrees with
+ * the first. That is the defect the case object exists to remove, and adding it
+ * back across a network boundary would put it somewhere nobody can reconcile it.
+ * A person pressing this knows they took a copy and knows when.
+ *
+ * The confirmation is inline and it expires. A toast would appear somewhere else
+ * on the screen, which for an action this local means the reader has to look
+ * away from the thing they just acted on to find out whether it worked.
+ *
+ * The failure message is not from the locked list because the locked list has no
+ * failure message. A clipboard write can be refused — an insecure origin, a
+ * permissions policy, a browser that has never had the API — and a button that
+ * says "Copied" when nothing was copied is worse than one that says it could
+ * not: the reader pastes an empty ticket into a message and finds out later.
+ */
+
+/** How long the confirmation stays up. Long enough to read, short enough to not be furniture. */
+const CONFIRMATION_MS = 4000;
+
+const COPY_FAILED = "Couldn't reach the clipboard — copy it from the case instead.";
+
+export interface CopyTicketButtonProps {
+  /**
+   * The ticket, built by the caller.
+   *
+   * A string rather than the case, so this component knows nothing about what a
+   * ticket contains and cannot grow a second opinion about it. `ticketMarkdown`
+   * is the one writer.
+   */
+  ticket: string;
+}
+
+export function CopyTicketButton({ ticket }: CopyTicketButtonProps) {
+  const [result, setResult] = useState<"copied" | "failed" | null>(null);
+
+  useEffect(() => {
+    if (!result) return;
+    const timer = setTimeout(() => setResult(null), CONFIRMATION_MS);
+    return () => clearTimeout(timer);
+  }, [result]);
+
+  const copy = useCallback(() => {
+    void (async () => {
+      try {
+        await navigator.clipboard.writeText(ticket);
+        setResult("copied");
+      } catch {
+        setResult("failed");
+      }
+    })();
+  }, [ticket]);
+
+  return (
+    // A column, because the header stacks its actions and a confirmation beside
+    // the button would widen the whole column by a sentence.
+    <span style={{ display: "flex", flexDirection: "column", alignItems: "stretch", gap: 6 }}>
+      <button
+        type="button"
+        onClick={copy}
+        style={{
+          appearance: "none",
+          cursor: "pointer",
+          whiteSpace: "nowrap",
+          fontSize: 13,
+          fontWeight: 500,
+          padding: "8px 15px",
+          borderRadius: 8,
+          border: "1px solid var(--border-strong)",
+          background: "var(--surface-card)",
+          color: "var(--text-body)",
+        }}
+      >
+        {FIX_ACTION_COPY_TICKET}
+      </button>
+
+      {/* Announced when it arrives, because a reader who pressed the button with
+          the keyboard has no other way to learn that it worked. */}
+      <span
+        role="status"
+        aria-live="polite"
+        style={{
+          maxWidth: "34ch",
+          fontSize: 12.5,
+          lineHeight: 1.45,
+          color: result === "failed" ? "var(--status-warning-text)" : "var(--text-muted)",
+        }}
+      >
+        {result === "copied" ? FIX_TICKET_COPIED : result === "failed" ? COPY_FAILED : ""}
+      </span>
+    </span>
+  );
+}
diff --git a/src/components/fix-queue.tsx b/src/components/fix-queue.tsx
new file mode 100644
index 0000000..1771ddb
--- /dev/null
+++ b/src/components/fix-queue.tsx
@@ -0,0 +1,96 @@
+import { byWorstMeasured, type IssueCase } from "@/lib/issue-case";
+import { FIX_GROUPS, FIX_QUEUE_NOTE } from "@/lib/fix-copy";
+import { WORK_STATE_LABEL } from "@/lib/vocabulary";
+import { FixRow } from "@/components/fix-row";
+
+/**
+ * The Fix tab: what has been committed to, and what is being worked on.
+ *
+ * Two groups, To do above In progress, in the order the registry holds them.
+ * That order is the reading order of the queue rather than a ranking: To do is
+ * the shelf you take from and In progress is what is off the shelf, so the
+ * choice comes before the check.
+ *
+ * Impact-ordered inside each group, worst measured first, with unmeasured
+ * findings moved as a block rather than sorted by their zero (rule 18). It does
+ * not take the list's sort control. The list sorts because it is being triaged
+ * and there are several honest ways to read a queue of undecided things; this is
+ * a queue of decided things, and the only question left is which to do next.
+ *
+ * One nudge, stated once at the top and rendered once per row: the started date,
+ * amber after thirty days. Nothing escalates after it. That is written down
+ * where the reader can see it, because a reader who has been told there is no
+ * escalation can leave a case for thirty-one days on purpose — and a reader who
+ * suspects there might be one starts managing the queue instead of the work.
+ */
+
+export interface FixQueueProps {
+  cases: readonly IssueCase[];
+  basePath: string;
+  now?: Date;
+}
+
+export function FixQueue({ cases, basePath, now }: FixQueueProps) {
+  const groups = FIX_GROUPS.map((state) => ({
+    state,
+    // A group is impact-ordered within itself and never against the other one.
+    // The two are answering different questions, so interleaving them would put
+    // a job nobody has started above one somebody is holding on the strength of
+    // a number that says nothing about either.
+    cases: cases.filter((item) => item.state === state).sort(byWorstMeasured),
+  })).filter((group) => group.cases.length > 0);
+
+  return (
+    <div>
+      <p
+        style={{
+          margin: "0 0 16px",
+          padding: "0 40px",
+          fontSize: 12.5,
+          color: "var(--text-muted)",
+          maxWidth: "78ch",
+        }}
+      >
+        {FIX_QUEUE_NOTE}
+      </p>
+
+      <div style={{ borderBottom: "1px solid var(--border-hairline)" }}>
+        {groups.map((group) => (
+          <section key={group.state}>
+            {/* The registry's own name for the state, so the heading and the
+                chip on the case it leads to cannot say different words. An
+                empty group is not drawn at all — a heading with nothing under
+                it reads as a load that has not finished. */}
+            <h2
+              style={{
+                display: "flex",
+                alignItems: "baseline",
+                gap: 8,
+                margin: 0,
+                padding: "14px 40px 6px",
+                borderTop: "1px solid var(--border-hairline)",
+                background: "var(--surface-page)",
+                // Rule 8: a group heading tells you which group you are reading,
+                // so it carries meaning and keeps the 12px floor.
+                fontSize: 12,
+                fontWeight: 600,
+                letterSpacing: ".04em",
+                textTransform: "uppercase",
+                color: "var(--text-muted)",
+              }}
+            >
+              {WORK_STATE_LABEL[group.state]}
+              <span style={{ fontWeight: 500, letterSpacing: 0, textTransform: "none" }}>
+                {group.cases.length}
+              </span>
+            </h2>
+
+            {group.cases.map((issue) => (
+              <FixRow key={issue.id} issue={issue} basePath={basePath} now={now} />
+            ))}
+          </section>
+        ))}
+      </div>
+    </div>
+  );
+}
diff --git a/src/components/fix-row.tsx b/src/components/fix-row.tsx
new file mode 100644
index 0000000..3c50747
--- /dev/null
+++ b/src/components/fix-row.tsx
@@ -0,0 +1,170 @@
+import Link from "next/link";
+import { includedPages, enteredAt, type IssueCase } from "@/lib/issue-case";
+import { formatCaseImpact } from "@/lib/impact-format";
+import { FIX_NO_OWNER, fixOwnerMeta, fixTodoMeta, startedLongAgo } from "@/lib/fix-copy";
+import { caseHref } from "@/lib/paths";
+
+/**
+ * One case in the Fix queue.
+ *
+ * Two shapes, because the two groups answer different questions. A To do row is
+ * being chosen from, so it says how big the job is, when it was committed to and
+ * what it costs. An In progress row is being checked on, so it says who has it
+ * and since when. Neither carries the other's line: a To do row with an owner
+ * field would be an empty field on every row, and an In progress row still
+ * showing its accepted date would bury the one date that matters under one that
+ * has stopped mattering.
+ *
+ * There is no Start and no Mark fixed here. Both live on the case, for the same
+ * reason Accept and Dismiss do: a transition fired from a list is one fired
+ * without reading the plan. The row's job is to get you to the case.
+ */
+
+/**
+ * The owner, as a circle with their initials.
+ *
+ * Initials rather than a photograph because there is no photograph — an owner is
+ * whoever fired `start`, which is a name and nothing else. A silhouette
+ * placeholder would be a picture of not knowing, which takes the same space as
+ * the name it is standing next to and says less than it.
+ *
+ * `aria-hidden`, because the name is rendered in full immediately to its right.
+ * A screen reader that announced both would read the owner twice, once as
+ * letters.
+ *
+ * The letters sit at the registry's 12px floor rather than under it. Rule 8
+ * exempts an element carrying no meaning to lose, and these qualify — but taking
+ * the exemption would have bought a two-pixel circle at the cost of the one
+ * place in the app where an initial is the only thing identifying a person on a
+ * row. The circle grew instead.
+ */
+function OwnerAvatar({ name }: { name: string }) {
+  const initials = name
+    .split(/\s+/)
+    .filter(Boolean)
+    .slice(0, 2)
+    .map((part) => part[0]!.toUpperCase())
+    .join("");
+
+  return (
+    <span
+      aria-hidden
+      style={{
+        display: "inline-flex",
+        alignItems: "center",
+        justifyContent: "center",
+        flex: "0 0 auto",
+        width: 26,
+        height: 26,
+        borderRadius: "50%",
+        border: "1px solid var(--border-hairline)",
+        background: "var(--surface-raised)",
+        color: "var(--text-muted)",
+        fontSize: 12,
+        fontWeight: 600,
+        letterSpacing: ".01em",
+      }}
+    >
+      {initials || "?"}
+    </span>
+  );
+}
+
+export interface FixRowProps {
+  issue: IssueCase;
+  basePath: string;
+  now?: Date;
+}
+
+export function FixRow({ issue, basePath, now }: FixRowProps) {
+  const impact = formatCaseImpact(issue);
+  const diagnosis = issue.diagnosis || issue.title;
+  const inProgress = issue.state === "in_progress";
+  // Amber past thirty days, and amber is the whole of it: the text changes
+  // colour and nothing else happens. No background wash, no border, no icon, no
+  // second threshold behind it. It is a fact about how long this has been open,
+  // rendered so you can see it without reading every row.
+  const stale = inProgress && startedLongAgo(issue.startedAt, now ?? new Date());
+
+  return (
+    <Link
+      href={caseHref(basePath, issue.id)}
+      style={{
+        display: "flex",
+        alignItems: "center",
+        gap: 14,
+        padding: "11px 40px",
+        borderTop: "1px solid var(--border-hairline)",
+        textDecoration: "none",
+        color: "var(--text-body)",
+        background: "var(--surface-card)",
+      }}
+    >
+      <span style={{ flex: "1 1 auto", minWidth: 0 }}>
+        <span
+          style={{
+            display: "block",
+            fontSize: 13,
+            fontWeight: 500,
+            whiteSpace: "nowrap",
+            overflow: "hidden",
+            textOverflow: "ellipsis",
+          }}
+          title={diagnosis}
+        >
+          {diagnosis}
+        </span>
+
+        <span
+          style={{
+            display: "flex",
+            alignItems: "center",
+            gap: 7,
+            marginTop: 3,
+            fontSize: 12.5,
+            color: stale ? "var(--status-warning-text)" : "var(--text-muted)",
+          }}
+        >
+          {inProgress
+            ? issue.owner
+              ? (
+                <>
+                  <OwnerAvatar name={issue.owner} />
+                  <span
+                    style={{ minWidth: 0, overflow: "hidden", textOverflow: "ellipsis", whiteSpace: "nowrap" }}
+                  >
+                    {fixOwnerMeta(issue.owner, issue.startedAt, now)}
+                  </span>
+                </>
+              )
+              // No avatar for a case nobody is recorded against. A circle with a
+              // question mark in it would be a picture of an owner where there
+              // is none.
+              : <span>{FIX_NO_OWNER}</span>
+            : (
+              <span
+                style={{ minWidth: 0, overflow: "hidden", textOverflow: "ellipsis", whiteSpace: "nowrap" }}
+              >
+                {fixTodoMeta(includedPages(issue).length, enteredAt(issue, "todo"), issue.effort, now)}
+              </span>
+            )}
+        </span>
+      </span>
+
+      {/* The figure the group is ordered by. A list sorted on something it does
+          not show is a list the reader cannot check. */}
+      <span
+        style={{
+          flex: "0 0 auto",
+          fontSize: 12.5,
+          fontWeight: 600,
+          fontVariantNumeric: "tabular-nums",
+          textAlign: "right",
+          color: impact.measured ? "var(--magnitude-value)" : "var(--text-muted)",
+        }}
+      >
+        {impact.text}
+      </span>
+    </Link>
+  );
+}
diff --git a/src/components/issue-row.tsx b/src/components/issue-row.tsx
index 24c15fb..3b2f201 100644
--- a/src/components/issue-row.tsx
+++ b/src/components/issue-row.tsx
@@ -1,7 +1,7 @@
 import Link from "next/link";
 import type { CSSProperties } from "react";
-import type { Effort, IssueCase } from "@/lib/issue-case";
-import { formatGroupImpact, formatImpact } from "@/lib/impact-format";
+import type { IssueCase } from "@/lib/issue-case";
+import { EFFORT_LABEL, formatGroupImpact, formatImpact } from "@/lib/impact-format";
 import { scopeLineOf } from "@/lib/scope-line";
 import { CONFIDENCE_LABEL } from "@/lib/vocabulary";
 import { caseHref } from "@/lib/paths";
@@ -51,23 +51,14 @@ export const ISSUE_ROW_NEST_INDENT = 18;
  * a second renderer of the same figure, and the scope phrase moved to
  * `lib/scope-line.ts` when the digest became a second writer of that. Both are
  * re-exported here so the list's existing importers keep one name for each.
+ *
+ * `EFFORT_LABEL` followed impact into `impact-format.ts` in S5, when "Copy as
+ * ticket" became a third reader that is not a component. Same re-export, same
+ * reason: the list's importers keep one name for it.
  */
-export { formatGroupImpact, formatImpact };
+export { EFFORT_LABEL, formatGroupImpact, formatImpact };
 export { scopeLineOf };
 
-/**
- * Effort is a band on the case, not a registry concept, so its words live here
- * beside impact.
- */
-export const EFFORT_LABEL: Record<Effort, string> = {
-  minutes: "Minutes",
-  hours: "Hours",
-  days: "Days",
-  // Not a dash. The stored estimate said "Needs review", which is the absence of
-  // a band, and rule 18's reasoning applies to any missing reading: say so.
-  unknown: "No estimate",
-};
-
 /** One line, ellipsed. Applied to every free-text cell in the list. */
 export const TRUNCATE_CELL: CSSProperties = {
   minWidth: 0,
diff --git a/src/components/store.tsx b/src/components/store.tsx
index 4ae4661..0c588c9 100644
--- a/src/components/store.tsx
+++ b/src/components/store.tsx
@@ -25,7 +25,7 @@ import { localISODate } from "@/lib/ui";
 import { withBasePath } from "@/lib/paths";
 import { defaultNewPageFlag, flagCapacityError } from "@/lib/watchCapacity";
 import { applyWatchlistPageOrder, changePageFlagOrder } from "@/lib/watchlistOrder";
-import { isTaskMarker, removeTaskMarker, taskMarkerText } from "@/lib/taskMarkers";
+import { isTaskMarker } from "@/lib/taskMarkers";
 import { pageTrend } from "@/lib/scoring";
 import { normalizeState } from "@/lib/store/normalize";
 import type { Project } from "@/lib/projects";
@@ -139,13 +139,9 @@ interface StoreValue extends AppState {
   setExternalAgentAuditEnabled: (enabled: boolean) => void;
   refreshExternalAgentAudit: (pageId: string) => void;
   addAgentIssueTask: (pageId: string, caseKey: string) => void;
-  verifyAgentIssueTask: (recKey: string) => void;
   externalAgentAuditRefreshing: boolean;
   removePage: (id: string) => void;
-  saveTask: (key: string) => void;
-  triageRec: (key: string) => void;
   ignoreRec: (key: string) => void;
-  advanceTask: (key: string, to: "todo" | "in-progress" | "done") => void;
   submitAdd: () => void;
   submitMarker: () => void;
   deleteMarker: () => void;
@@ -821,49 +817,6 @@ export function StoreProvider({
     [flash, pathFor],
   );
 
-  const verifyAgentIssueTask = useCallback(
-    (recKey: string) => {
-      void (async () => {
-        try {
-          const response = await fetch(pathFor("/api/agent-audits/verify"), {
-            method: "POST",
-            headers: { "content-type": "application/json" },
-            body: JSON.stringify({ recKey }),
-            cache: "no-store",
-          });
-          const body = (await response.json().catch(() => null)) as {
-            status?: string;
-            refusedReason?: string;
-            code?: string;
-          } | null;
-          if (!response.ok && !body?.status) {
-            // A provider that cannot answer leaves the task verifying. Say so
-            // plainly rather than implying the fix failed.
-            flash(
-              body?.refusedReason === "not-consented"
-                ? "Enable external agent audits to verify this fix automatically"
-                : body?.code === "ORA_SCAN_DISABLED"
-                  ? "External verification is turned off for this deployment"
-                  : "Couldn't reach the provider — this fix stays unverified",
-            );
-            return;
-          }
-          flash(
-            body?.status === "resolved" ? "Provider re-check passed — issue resolved"
-              : body?.status === "returned" ? "Provider re-check still failing — issue returned to open work"
-                : "Provider could not confirm yet — still verifying",
-          );
-          const state = await fetch(pathFor("/api/state"), { cache: "no-store" });
-          const payload = (await state.json().catch(() => null)) as { state?: AppState } | null;
-          if (payload?.state) apply(normalizeState(payload.state));
-        } catch {
-          flash("Couldn't reach the provider — this fix stays unverified");
-        }
-      })();
-    },
-    [apply, flash, pathFor],
-  );
-
   const addAgentIssueTask = useCallback(
     (pageId: string, caseKey: string) => {
       // No optimistic apply: the server re-assembles the case from stored
@@ -942,25 +895,6 @@ export function StoreProvider({
     [mutate],
   );
 
-  const saveTask = useCallback(
-    (key: string) => {
-      const cur = dataRef.current;
-      mutate(
-        { ...cur, recs: cur.recs.map((r) => (r.key === key ? { ...r, status: "task", taskStatus: "todo" } : r)) },
-        { url: `/api/recs`, body: { key, action: "save" } },
-        { success: "Saved to Tasks — track it on the Tasks board", failure: "Couldn't save to Tasks — try again" },
-      );
-    },
-    [mutate],
-  );
-
-  const triageRec = useCallback(
-    (key: string) => {
-      saveTask(key);
-    },
-    [saveTask],
-  );
-
   const ignoreRec = useCallback(
     (key: string) => {
       const cur = dataRef.current;
@@ -973,53 +907,6 @@ export function StoreProvider({
     [mutate],
   );
 
-  const advanceTask = useCallback(
-    (key: string, to: "todo" | "in-progress" | "done") => {
-      const cur = dataRef.current;
-      const rec = cur.recs.find((r) => r.key === key);
-      if (!rec) return;
-      // Idempotent: re-dropping an already-done card onto Done must not log a
-      // second change marker or a duplicate set of follow-ups (audit).
-      if (to === rec.taskStatus) return;
-      const date = localISODate();
-      if (to === "done") {
-        const text = taskMarkerText(rec.title);
-        // Completing a task logs a change marker + schedules follow-ups, so it
-        // goes through the marker route (sequential storage, REQ-043/044).
-        mutate(
-          {
-            ...cur,
-            recs: cur.recs.map((r) => (r.key === key ? { ...r, taskStatus: "done", doneDate: date } : r)),
-            pages: cur.pages.map((p) =>
-              p.id === rec.pageId ? { ...p, markers: [...(p.markers || []), { id: crypto.randomUUID(), i: p.history.length - 1, date, text, source: "task", recKey: key }] } : p,
-            ),
-          },
-          { url: `/api/pages/${rec.pageId}/markers`, body: { text, date, recKey: key, taskStatus: "done" } },
-          { success: `Task completed — change marker logged on ${rec.pageTitle}`, failure: "Couldn't complete the task — try again" },
-        );
-        // Marker-triggered verification. The existing change marker and the
-        // 2/7/30-day follow-ups above are untouched; this only adds the
-        // provider re-check of the ids this task recorded.
-        if (rec.source === "agent-readiness" && (rec.agentIssue?.verificationCheckIds.length ?? 0) > 0) {
-          verifyAgentIssueTask(key);
-        }
-      } else {
-        const optimistic = structuredClone(cur);
-        const optimisticRec = optimistic.recs.find((item) => item.key === key);
-        if (!optimisticRec) return;
-        optimisticRec.taskStatus = to;
-        optimisticRec.doneDate = null;
-        removeTaskMarker(optimistic, optimisticRec);
-        mutate(
-          optimistic,
-          { url: `/api/recs`, body: { key, action: "advance", to } },
-          { success: to === "in-progress" ? "Task moved to In progress" : "Task moved back to To do", failure: "Couldn't move the task — try again" },
-        );
-      }
-    },
-    [mutate, verifyAgentIssueTask],
-  );
-
   const setForm = useCallback((f: Partial<AddForm>) => setFormState((prev) => ({ ...prev, ...f })), []);
 
   const submitAdd = useCallback(() => {
@@ -1267,15 +1154,11 @@ export function StoreProvider({
     setExternalAgentAuditEnabled,
     refreshExternalAgentAudit,
     addAgentIssueTask,
-    verifyAgentIssueTask,
     externalAgentAuditRefreshing,
     updateAlertWebhookUrl,
     setVisitorExperienceVisible,
     removePage,
-    saveTask,
-    triageRec,
     ignoreRec,
-    advanceTask,
     submitAdd,
     submitMarker,
     deleteMarker,
diff --git a/src/lib/__tests__/fix-work.test.ts b/src/lib/__tests__/fix-work.test.ts
new file mode 100644
index 0000000..8716973
--- /dev/null
+++ b/src/lib/__tests__/fix-work.test.ts
@@ -0,0 +1,437 @@
+import { readFileSync, readdirSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { describe, expect, it } from "vitest";
+import {
+  applyAction,
+  byWorstMeasured,
+  markFixed,
+  start,
+  type IssueCase,
+  type IssueState,
+} from "../issue-case";
+import { FIX_GROUPS, FIX_QUEUE_NOTE, OWNER_AMBER_DAYS, fixOwnerMeta, fixTodoMeta, startedLongAgo } from "../fix-copy";
+import { ticketMarkdown } from "../fix-ticket";
+import { EFFORT_LABEL, NOT_MEASURED, formatCaseImpact } from "../impact-format";
+import {
+  DISMISS_REASONS,
+  ISSUE_TRANSITIONS,
+  WORK_STATE_LABEL,
+  type IssueAction,
+  type TransitionActor,
+} from "../vocabulary";
+import { UNKNOWN_USER, attributionOf, type Caller } from "../caller";
+import { casePath } from "../paths";
+
+/**
+ * S5 — the fix queue, and the two fields the start transition writes.
+ *
+ * Registry rule 21: these assert the decision rather than the code. Where the
+ * registry states a fact — the fix queue's two states and their order, their
+ * labels — the assertion reads it off `vocabulary.json`, so a change to the
+ * decided vocabulary that this chunk has not been brought in line with fails
+ * here rather than shipping. Where the decision is S5's own, the assertion
+ * checks the two halves of it against each other: the thirty in the sentence the
+ * reader is shown against the thirty the predicate actually turns on, and the
+ * ticket's saving against the one the case renders.
+ *
+ * Asserting the locked strings against themselves is deliberately not done. A
+ * literal here and the same literal in `fix-copy.ts` is a mirror against a
+ * mirror — it proves the two copies agree and never that either is right.
+ */
+
+const moduleDir = path.dirname(fileURLToPath(import.meta.url));
+const srcDir = path.resolve(moduleDir, "../..");
+const registry = JSON.parse(
+  readFileSync(path.resolve(moduleDir, "../../../vocabulary.json"), "utf8"),
+) as {
+  concepts: {
+    queue: { values: { key: string; holds: string[] }[] };
+    work_state: { values: { key: string; label: string }[] };
+    action: { values: { key: string; from: string[]; to: string }[] }
+  };
+};
+
+const registryActions = registry.concepts.action.values;
+const registryFixHolds = registry.concepts.queue.values.find((value) => value.key === "fix")!.holds;
+
+/** Every source file under `src/`, so a new writer cannot arrive unnoticed. */
+function sourceFiles(): string[] {
+  const found: string[] = [];
+  const walk = (dir: string) => {
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      const full = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (entry.name !== "__tests__") walk(full);
+      } else if (/\.tsx?$/.test(entry.name)) {
+        found.push(full);
+      }
+    }
+  };
+  walk(srcDir);
+  return found;
+}
+
+/** Files under `src/` whose text matches, named relative to `src/`. */
+function filesMatching(pattern: RegExp): string[] {
+  return sourceFiles()
+    .filter((file) => pattern.test(readFileSync(file, "utf8")))
+    .map((file) => path.relative(srcDir, file).replace(/\\/g, "/"))
+    .sort();
+}
+
+/**
+ * The files that could write to a case at all — the module itself and everything
+ * that imports from it.
+ *
+ * The narrowing matters. `startedAt` is an ordinary field name elsewhere in the
+ * app: collection jobs have one, so do runs and projects, and a scan of every
+ * file would be answering a different question loudly enough to be turned off.
+ * Nothing can write a case's field without reaching the case, and nothing
+ * reaches the case without importing from here.
+ */
+function caseWriters(pattern: RegExp): string[] {
+  const imports = /from "(?:\.\/|\.\.\/|@\/lib\/)issue-case"/;
+  return sourceFiles()
+    .filter((file) => {
+      const text = readFileSync(file, "utf8");
+      if (!imports.test(text) && !/lib[\\/]issue-case\.ts$/.test(file)) return false;
+      return pattern.test(text);
+    })
+    .map((file) => path.relative(srcDir, file).replace(/\\/g, "/"))
+    .sort();
+}
+
+const DAY_MS = 86_400_000;
+const NOW = new Date("2026-08-26T12:00:00.000Z");
+const daysBefore = (days: number) => new Date(NOW.getTime() - days * DAY_MS).toISOString();
+
+/** A person's id in this app is their account email (F4's `Caller`). */
+const GRACE: Caller = { kind: "person", userId: "grace@example.com" };
+const ADA: Caller = { kind: "person", userId: "ada@example.com" };
+
+/**
+ * A caller of a given class, for driving a transition this test does not care
+ * about the identity of.
+ *
+ * Keyed on the class rather than asking whether a permission set contains one.
+ * F4's guard forbids testing `transition.actor` against anything but a caller's
+ * `kind`, and that is the right shape here too: the permission set names a
+ * class this transition allows, and this builds a caller of it.
+ */
+function callerOfKind(kind: TransitionActor): Caller {
+  return kind === "person"
+    ? { kind: "person", userId: "someone-else@example.com" }
+    : { kind: "system", agent: "checkpoint" };
+}
+
+function makeCase(overrides: Partial<IssueCase> = {}): IssueCase {
+  return {
+    id: "PW-2291",
+    cause: "fonts.example.com:font-display",
+    state: "todo",
+    title: "Ensure text remains visible during webfont load",
+    diagnosis: "Body text is invisible for a second while the webfont loads.",
+    detectedAt: daysBefore(40),
+    confirmedRuns: 3,
+    scope: "pages",
+    pageIds: ["p1", "p2"],
+    strategies: ["mobile"],
+    impactMs: 1900,
+    effort: "hours",
+    confidence: "confirmed",
+    remediation: { steps: ["Add font-display: swap.", "Preload the two weights in use."], actionability: "direct" },
+    successCriteria: "Text paints with the fallback within 100 ms.",
+    checkpoints: [],
+    evidence: [],
+    history: [{ at: daysBefore(35), from: "new", to: "todo", by: ADA }],
+    ...overrides,
+  };
+}
+
+/* ── The two fields, and the one transition that writes them ────────────── */
+
+describe("S5 — start is what assigns a case", () => {
+  it("stamps the owner and the start date, from the transition that moved it", () => {
+    const at = daysBefore(3);
+    const started = start(makeCase(), { by: GRACE, at });
+
+    expect(started.state).toBe("in_progress");
+    expect(started.owner).toBe(attributionOf(GRACE));
+    expect(started.startedAt).toBe(at);
+    // The stamp and the history entry are one fact recorded once: the same
+    // instant, and the same identity the history column renders. Nothing can
+    // show one date for "started" and another for the move that started it, or
+    // name one owner in the queue and another in the history.
+    expect(started.history.at(-1)!.at).toBe(started.startedAt);
+    expect(attributionOf(started.history.at(-1)!.by)).toBe(started.owner);
+  });
+
+  it("leaves the owner absent where F4 declines to name one", () => {
+    // A migrated person caller recorded the class and threw the identity away.
+    // `attributionOf` withholds it, so the stamp withholds it too — a sentinel
+    // in an owner field would render as a person nobody can find (rule 18).
+    const migrated = start(makeCase(), { by: { kind: "person", userId: UNKNOWN_USER }, at: daysBefore(3) });
+    expect(migrated.owner).toBeUndefined();
+    // The date is still a fact and is still recorded. Not knowing who started
+    // it is not the same as not knowing when.
+    expect(migrated.startedAt).toBe(daysBefore(3));
+  });
+
+  it("is the only transition that writes either field", () => {
+    const owned = makeCase({ owner: attributionOf(GRACE)!, startedAt: daysBefore(3) });
+
+    for (const action of registryActions) {
+      if (action.key === "start") continue;
+      for (const from of action.from as IssueState[]) {
+        const before: IssueCase = {
+          ...owned,
+          state: from,
+          // `resolve` requires checkpoint agreement, and `dismiss` a reason;
+          // supply both so every registry transition is genuinely exercised.
+          checkpoints: [{ interval: "30d", result: "agreed" }],
+        };
+        // F4 validates the caller's CLASS, so a system-only transition has to
+        // be offered a system caller or it is refused before it can prove
+        // anything about the owner fields. The class is taken from the
+        // registry's own permission set, so `resolve` is exercised rather than
+        // skipped and no class is assumed here.
+        const [permitted] = ISSUE_TRANSITIONS[action.key as IssueAction].actor;
+        const after = applyAction(before, action.key as IssueAction, {
+          by: callerOfKind(permitted),
+          at: daysBefore(1),
+          // The registry's own first reason, not a hand-written one — a literal
+          // here would fail for saying the wrong word rather than for the thing
+          // this test is about.
+          reason: DISMISS_REASONS[0],
+        });
+        expect(after.owner, `${action.key} from ${from} rewrote the owner`).toBe(owned.owner);
+        expect(after.startedAt, `${action.key} from ${from} rewrote the start date`).toBe(owned.startedAt);
+      }
+    }
+  });
+
+  it("cannot be fired twice, so the stamp is never overwritten", () => {
+    // The registry's guarantee, not this module's: `start` is legal only from
+    // `todo`, and a started case is `in_progress`.
+    const startAction = registryActions.find((action) => action.key === "start")!;
+    expect(startAction.from).toEqual(["todo"]);
+    expect(startAction.to).toBe("in_progress");
+    expect(startAction.from).not.toContain(startAction.to);
+  });
+
+  it("keeps both fields out of every hand but the transition's", () => {
+    // A field a screen can set is a field that drifts from its history entry.
+    // Any new file that writes either name shows up here as a failure and has to
+    // justify itself, which is the mechanism rule 20 asks for.
+    expect(caseWriters(/\bstartedAt\b/)).toEqual([
+      "components/fix-row.tsx",
+      "lib/fix-copy.ts",
+      "lib/issue-case.ts",
+    ]);
+    // `owner:` and `owner =` are the assignment shapes; `issue.owner` is a read
+    // and prose about ownership is neither, so neither is matched. Exactly one
+    // file assigns it, and that file assigns it in exactly one place.
+    expect(caseWriters(/\bowner\s*[:=][^=]/)).toEqual(["lib/issue-case.ts"]);
+  });
+
+  it("carries free-text notes and neither a checklist nor a due date", () => {
+    const withNote = makeCase({ notes: "Ping the brand team about the fallback stack." });
+    expect(withNote.notes).toBe("Ping the brand team about the fallback stack.");
+    // The two shapes S5 deletes. A note has no schema; the moment it grows
+    // required fields it is a task object with a different name.
+    expect(filesMatching(/\bchecklist\b/)).toEqual([]);
+    expect(filesMatching(/\bdueDate\b|\bdue_date\b/)).toEqual([]);
+  });
+});
+
+/* ── The one nudge ──────────────────────────────────────────────────────── */
+
+describe("S5 — the started date is the only nudge", () => {
+  it("turns amber at the threshold the reader was promised", () => {
+    // The two halves of one decision: the number in the sentence shown to the
+    // reader, and the number the predicate turns on. Neither is asserted against
+    // a literal, so they can only pass by agreeing with each other.
+    expect(FIX_QUEUE_NOTE).toContain(`${OWNER_AMBER_DAYS} days`);
+    expect(startedLongAgo(daysBefore(OWNER_AMBER_DAYS - 1), NOW)).toBe(false);
+    expect(startedLongAgo(daysBefore(OWNER_AMBER_DAYS), NOW)).toBe(true);
+    expect(startedLongAgo(daysBefore(OWNER_AMBER_DAYS + 1), NOW)).toBe(true);
+  });
+
+  it("has no second threshold behind it", () => {
+    // A case that has been open for three months looks exactly like one that has
+    // been open for thirty days. Nothing escalates, so the predicate changes
+    // value exactly once across the whole range — a second nudge would be a
+    // second flip, whatever it was called.
+    const readings = Array.from({ length: 180 }, (_, day) => startedLongAgo(daysBefore(day), NOW));
+    const flips = readings.filter((value, index) => index > 0 && value !== readings[index - 1]);
+    expect(flips).toHaveLength(1);
+    // And the state it settles into is amber, not something further along.
+    expect(readings.at(-1)).toBe(true);
+  });
+
+  it("does not call an unowned case stale", () => {
+    // Absent is not overdue. A case with no start date is unowned, which the row
+    // says in its own words rather than by turning a date it does not have amber.
+    expect(startedLongAgo(undefined, NOW)).toBe(false);
+  });
+});
+
+/* ── The queue ──────────────────────────────────────────────────────────── */
+
+describe("S5 — the fix queue", () => {
+  it("groups To do above In progress, in the registry's own order", () => {
+    expect(FIX_GROUPS).toEqual(registryFixHolds);
+    expect(FIX_GROUPS[0]).toBe("todo");
+    expect(FIX_GROUPS[1]).toBe("in_progress");
+    expect(FIX_GROUPS).toHaveLength(2);
+  });
+
+  it("heads each group with the registry's word for the state", () => {
+    for (const state of FIX_GROUPS) {
+      const declared = registry.concepts.work_state.values.find((value) => value.key === state)!;
+      expect(WORK_STATE_LABEL[state]).toBe(declared.label);
+    }
+  });
+
+  it("orders each group by impact, with unmeasured findings last", () => {
+    const cases = [
+      makeCase({ id: "unmeasured", impactMs: 0 }),
+      makeCase({ id: "small", impactMs: 400 }),
+      makeCase({ id: "worst", impactMs: 2600 }),
+    ];
+    // Rule 18: the unmeasured one is moved as a block rather than sorted by its
+    // zero, so it cannot outrank a 400 ms finding on an empty reading.
+    expect([...cases].sort(byWorstMeasured).map((item) => item.id)).toEqual(["worst", "small", "unmeasured"]);
+  });
+
+  it("says a different thing on each group's rows", () => {
+    const accepted = daysBefore(2);
+    const todo = fixTodoMeta(4, accepted, "hours", NOW);
+    expect(todo).toBe(`4 pages · accepted 2 days ago · ${EFFORT_LABEL.hours}`);
+    expect(fixTodoMeta(1, accepted, "hours", NOW)).toContain("1 page ·");
+
+    const owner = fixOwnerMeta("Grace Hopper", daysBefore(1), NOW);
+    expect(owner).toBe("Grace Hopper · started yesterday");
+    // The owner line carries no accepted date and no effort: the question on an
+    // In progress row is who has it, not what it would cost to pick up.
+    expect(owner).not.toContain("accepted");
+    expect(owner).not.toContain(EFFORT_LABEL.hours);
+  });
+});
+
+/* ── Copy as ticket ─────────────────────────────────────────────────────── */
+
+describe("S5 — copy as ticket", () => {
+  const pageTitles = { p1: "Home", p2: "Pricing" };
+
+  it("carries the diagnosis, the pages, the remediation, the impact, the effort and the link", () => {
+    const issue = makeCase();
+    const ticket = ticketMarkdown(issue, { pageTitles });
+
+    expect(ticket).toContain(issue.diagnosis);
+    expect(ticket).toContain("- Home");
+    expect(ticket).toContain("- Pricing");
+    expect(ticket).toContain("1. Add font-display: swap.");
+    expect(ticket).toContain("2. Preload the two weights in use.");
+    expect(ticket).toContain(EFFORT_LABEL.hours);
+    expect(ticket).toContain(casePath(issue.id));
+  });
+
+  it("links to /issues/{id} and to no other shape of address", () => {
+    const ticket = ticketMarkdown(makeCase(), { pageTitles });
+    expect(ticket).toContain("/issues/PW-2291");
+    // The id is the whole address. There is no `/issues/case/` route, and a
+    // ticket outlives the person who filed it.
+    expect(ticket).not.toContain("/issues/case/");
+    expect(ticket).not.toContain("?queue=");
+  });
+
+  it("keeps the origin when it has one, so the link resolves from outside the app", () => {
+    const ticket = ticketMarkdown(makeCase(), { pageTitles, appUrl: "https://watch.example.com/app" });
+    expect(ticket).toContain("https://watch.example.com/app/issues/PW-2291");
+  });
+
+  it("states the impact the case states, to the byte", () => {
+    const issue = makeCase();
+    const impactByPage = { p1: 2600, p2: 900 };
+    // The figure the case detail renders, from the call the case detail makes.
+    // Not a second derivation that happens to agree — the same one.
+    const onScreen = formatCaseImpact(issue, impactByPage);
+    expect(onScreen.text).toBe("2.6 s");
+    expect(ticketMarkdown(issue, { pageTitles, impactByPage })).toContain(onScreen.text);
+
+    // Both readers reach the figure through the one function, which is what
+    // makes the agreement above structural rather than coincidental.
+    for (const reader of ["lib/fix-ticket.ts", "components/case-detail.tsx"]) {
+      expect(readFileSync(path.join(srcDir, reader), "utf8")).toContain("formatCaseImpact");
+    }
+  });
+
+  it("says Not measured for an unmeasured finding, and never 0", () => {
+    const issue = makeCase({ impactMs: 0 });
+    const ticket = ticketMarkdown(issue, { pageTitles });
+
+    // Rule 18. An absent measurement is not a small one, and a ticket reading
+    // "0 ms" would be read by a stranger as a finding worth nothing.
+    expect(ticket).toContain(NOT_MEASURED);
+    expect(ticket).toBe(ticketMarkdown(issue, { pageTitles, impactByPage: {} }));
+    expect(ticket).not.toMatch(/\b0\s*(ms|s)\b/);
+    expect(ticket).not.toMatch(/:\s*0\s*$/m);
+  });
+
+  it("offers no tracker integration to disagree with the case", () => {
+    // The whole point of markdown on a clipboard: it holds no state, so it
+    // cannot drift from the case it was taken from. An integration would be a
+    // second home for the work's state, which is the defect the case object was
+    // built to remove, re-created where nobody can reconcile it.
+    //
+    // Asserted as "this path talks to nothing" rather than as a list of vendor
+    // names, because the next tracker is not on the list.
+    for (const file of ["lib/fix-ticket.ts", "components/copy-ticket-button.tsx"]) {
+      const text = readFileSync(path.join(srcDir, file), "utf8");
+      expect(text, `${file} reaches the network`).not.toMatch(/\bfetch\s*\(|XMLHttpRequest|\bapi\//);
+    }
+  });
+});
+
+/* ── The hand-off, and what S5 deletes ──────────────────────────────────── */
+
+describe("S5 — marking fixed hands off to the checkpoints", () => {
+  it("schedules W1's checks rather than a verification target", () => {
+    const at = daysBefore(0);
+    const fixed = markFixed(start(makeCase(), { by: GRACE, at: daysBefore(5) }), { by: GRACE, at });
+
+    expect(fixed.state).toBe("fixed");
+    expect(fixed.checkpoints.map((checkpoint) => checkpoint.interval)).toEqual(["2d", "7d", "30d"]);
+    expect(fixed.checkpoints.every((checkpoint) => checkpoint.result === "scheduled")).toBe(true);
+    // The owner and the start date survive the fix. Who did it and when they
+    // began are facts about what happened, not a status that expires.
+    expect(fixed.owner).toBe(attributionOf(GRACE));
+    expect(fixed.startedAt).toBe(daysBefore(5));
+  });
+
+  it("has no standalone verification endpoint left to call", () => {
+    expect(filesMatching(/agent-audits\/verify|requestAgentAuditVerify/)).toEqual([]);
+  });
+});
+
+describe("S5 — what the fix queue replaces", () => {
+  it("leaves no route or component named task", () => {
+    const named = sourceFiles()
+      .map((file) => path.relative(srcDir, file).replace(/\\/g, "/"))
+      .filter((file) => /(^|\/)tasks?(\/|\.|-)/i.test(file));
+    expect(named).toEqual([]);
+  });
+
+  it("leaves no add-to-tasks affordance", () => {
+    expect(filesMatching(/Add to tasks|Add workaround to tasks/i)).toEqual([]);
+  });
+
+  it("introduces no plan or batch object with a state of its own", () => {
+    // Considered and dropped: a plan spanning three cases needs a state of its
+    // own, and that state disagrees with its cases' states inside a week. Batch
+    // work is a saved filter over cases, which has nothing to disagree with.
+    expect(filesMatching(/\b(interface|type|class)\s+(Fix)?(Plan|Batch)\b/)).toEqual([]);
+  });
+});
diff --git a/src/lib/__tests__/webflow-performance.test.ts b/src/lib/__tests__/webflow-performance.test.ts
index 28c3475..af27fb2 100644
--- a/src/lib/__tests__/webflow-performance.test.ts
+++ b/src/lib/__tests__/webflow-performance.test.ts
@@ -7,7 +7,6 @@ import {
   formatDiagnosticImpact,
   isDocumentedWebflowAudit,
   recommendationIsCustomerActionable,
-  triageActionLabel,
 } from "../webflowPerformance";
 
 describe("Webflow performance taxonomy", () => {
@@ -54,9 +53,6 @@ describe("Webflow performance taxonomy", () => {
     expect(formatDiagnosticImpact({ savingsMs: 0, savingsBytes: 0 })).toBe("Detected");
     expect(formatDiagnosticImpact({ savingsMs: 0, savingsBytes: 65_536 })).toBe("64 KB");
     expect(effortLabel({ id: "unused-css-rules", estTime: "2 days" })).toBe("2 days");
-    expect(triageActionLabel({ id: "unused-css-rules" })).toBe("Add workaround to tasks");
-    expect(triageActionLabel({ id: "dom-size" })).toBe("Add workaround to tasks");
-    expect(triageActionLabel({ id: "uses-responsive-images" })).toBe("Add to tasks");
   });
 
   it("keeps platform ownership separate from neutral customer guidance", () => {
diff --git a/src/lib/agentAuditServer.ts b/src/lib/agentAuditServer.ts
index 1caecc3..b4c1bdf 100644
--- a/src/lib/agentAuditServer.ts
+++ b/src/lib/agentAuditServer.ts
@@ -67,34 +67,6 @@ export async function requestAgentAuditRefresh(
   });
 }
 
-/**
- * Ask the collector to re-verify one implemented agent task. The task key is
- * the only input; the collector resolves the provider check ids server-side.
- */
-export async function requestAgentAuditVerify(
-  tenant: string,
-  recKey: string,
-  fetchFn: typeof fetch = fetch,
-): Promise<Response> {
-  const configured = getEnv("FDE_DATA_URL") ?? getEnv("COLLECTOR_URL");
-  if (!configured && getEnv("DATASET_MODE") !== "live") {
-    return Response.json({
-      error: "external agent verification is unavailable without a collector",
-      code: "ORA_SCAN_DISABLED",
-    }, { status: 503 });
-  }
-  return fetchFn(`${collectorBaseUrl()}/data/${encodeURIComponent(tenant)}/agent-audits/ora/verify`, {
-    method: "POST",
-    headers: {
-      authorization: `Bearer ${collectorSecret()}`,
-      "content-type": "application/json",
-    },
-    body: JSON.stringify({ recKey }),
-    cache: "no-store",
-    signal: AbortSignal.timeout(60_000),
-  });
-}
-
 /** Relay a collector response with a bounded body and no caching. */
 export async function relayAgentAuditResponse(response: Response): Promise<Response> {
   const body = await response.text();
diff --git a/src/lib/checkpoint-evaluation.ts b/src/lib/checkpoint-evaluation.ts
index a24d419..ddc052f 100644
--- a/src/lib/checkpoint-evaluation.ts
+++ b/src/lib/checkpoint-evaluation.ts
@@ -1,6 +1,7 @@
 import {
   applyAction,
   checkpointsAgree,
+  enteredAt,
   includedPages,
   reopenForPages,
   type Checkpoint,
@@ -391,9 +392,14 @@ export function nextDueAt(issue: IssueCase): string | null {
  * date the row shows and the date the transition happened are the same fact.
  * The last such entry wins — a case that came back and was fixed again is
  * being watched from the second fix, not the first.
+ *
+ * `enteredAt` is that read, generalised in S5 when the fix queue needed the same
+ * question asked about `todo`. This keeps its name because Watch's readers ask
+ * for the fix date rather than for a state, and the reasoning above is about the
+ * fix date specifically.
  */
 export function fixedAtOf(issue: IssueCase): string | undefined {
-  return [...issue.history].reverse().find((entry) => entry.to === "fixed")?.at;
+  return enteredAt(issue, "fixed");
 }
 
 /**
diff --git a/src/lib/fix-copy.ts b/src/lib/fix-copy.ts
new file mode 100644
index 0000000..03f96e2
--- /dev/null
+++ b/src/lib/fix-copy.ts
@@ -0,0 +1,157 @@
+import type { Effort } from "./issue-case";
+import { EFFORT_LABEL } from "./impact-format";
+import { QUEUE_HOLDS, type WorkState } from "./vocabulary";
+import { daysUntil } from "./watch-copy";
+import { naturalDate } from "./ui";
+
+/**
+ * The words the Fix queue says, in one place.
+ *
+ * Locked copy from the S5 brief. Four of its ten strings are deliberately NOT
+ * restated here, because something already owns them and rule 20 says a string
+ * is stated once:
+ *
+ *   - `fix.group.todo` and `fix.group.in_progress` are `WORK_STATE_LABEL.todo`
+ *     and `WORK_STATE_LABEL.in_progress`. The registry names the states, and
+ *     the group headings are those names — a second literal would let the
+ *     heading and the chip on the row beneath it disagree about what the state
+ *     is called.
+ *   - `fix.action.start` and `fix.action.mark_fixed` are
+ *     `ISSUE_ACTION_LABEL.start` and `.mark_fixed`, for the same reason. The
+ *     buttons are already built from the registry's transition table by
+ *     `primaryActionFor`; giving them a second source of words would mean a
+ *     relabelled transition renamed the button on the case and not the one on
+ *     the row.
+ *
+ * `watch-copy.ts` made the identical call about the four checkpoint outcome
+ * labels. This module is its counterpart for the queue one step to its left.
+ */
+
+/* ── The groups ─────────────────────────────────────────────────────────── */
+
+/**
+ * The two groups, To do above In progress.
+ *
+ * Read off the registry rather than written down, because the registry already
+ * states this order: `queue.fix.holds` is `["todo", "in_progress"]`, and that is
+ * the order the queue reads in — what has been committed to but not picked up,
+ * then what someone is holding. A hand-kept array here would be a second
+ * statement of an order the registry owns, and the two would part company the
+ * first time a state joined the queue.
+ */
+export const FIX_GROUPS: readonly WorkState[] = QUEUE_HOLDS.fix;
+
+/* ── The one nudge ──────────────────────────────────────────────────────── */
+
+/**
+ * When a start date turns amber.
+ *
+ * The number and the sentence that explains it sit together so they cannot
+ * drift apart — `FIX_QUEUE_NOTE` below promises the reader thirty days, and this
+ * is the thirty. It is the whole of the queue's pressure: there is no second
+ * threshold after it, no colour past amber, no email, and nothing that escalates
+ * on the thirty-first day. A queue that nags twice has taught the reader to
+ * ignore it once.
+ */
+export const OWNER_AMBER_DAYS = 30;
+
+/**
+ * Whether a start date has passed the amber mark.
+ *
+ * Whole calendar days, through the same `daysUntil` the Watch countdown uses, so
+ * the two never disagree about when a day turned over. A case with no start date
+ * is not stale — it is unowned, which is a different thing the row says in
+ * different words.
+ */
+export function startedLongAgo(startedAt: string | undefined, now: Date): boolean {
+  if (!startedAt) return false;
+  const until = daysUntil(startedAt, now);
+  return until !== null && -until >= OWNER_AMBER_DAYS;
+}
+
+/* ── The rows ───────────────────────────────────────────────────────────── */
+
+/**
+ * What a To do row says under its diagnosis: how much of the site it covers,
+ * when it was committed to, and what doing it costs.
+ *
+ * The page figure is a count rather than a list of titles. The scope line on the
+ * issues list already names pages where naming them fits; here the reader is
+ * choosing what to pick up next, and the size of the job is the useful fact.
+ */
+export function fixTodoMeta(pages: number, acceptedAt: string | undefined, effort: Effort, now?: Date): string {
+  return `${pages} ${pages === 1 ? "page" : "pages"} · accepted ${whenOf(acceptedAt, now)} · ${EFFORT_LABEL[effort]}`;
+}
+
+/** What an In progress row says under its diagnosis: who has it, and since when. */
+export function fixOwnerMeta(name: string, startedAt: string | undefined, now?: Date): string {
+  return `${name} · started ${whenOf(startedAt, now)}`;
+}
+
+/**
+ * The row for a case that is in progress with nobody recorded against it.
+ *
+ * NOT from the locked list, and deliberately so. The locked copy covers the
+ * case S5 creates, where `start` stamped an owner and a date on the way in. It
+ * does not cover the legacy record that arrives already `in_progress` through
+ * `stateFromTaskStatus`, having never passed through `start` — and there is no
+ * honest way to render `fix.owner.meta` for one, because there is no name and no
+ * date to put in it.
+ *
+ * So it says what is true. This is rule 18's reasoning applied to a name instead
+ * of a reading: an absent owner is not an unimportant owner, and the two things
+ * that must not happen are inventing one and printing an empty line where one
+ * belongs. "No estimate" and "Not measured" are the same sentence about
+ * different fields.
+ */
+export const FIX_NO_OWNER = "No owner recorded";
+
+/**
+ * A date as the reader would say it — "today", "4 days ago", "Dec 8, 2025".
+ *
+ * `naturalDate` is the app's one statement of that, and it already degrades to
+ * the input string for something it cannot parse. An absent date is the case
+ * this adds: a migrated case whose history begins mid-lifecycle has no accepted
+ * date, and rule 18 says the row says so rather than rendering a plausible one.
+ */
+function whenOf(iso: string | undefined, now?: Date): string {
+  if (!iso) return "on an unrecorded date";
+  return naturalDate(iso, now ?? new Date());
+}
+
+/* ── The queue ──────────────────────────────────────────────────────────── */
+
+/**
+ * The sentence under the tabs, which is the queue's entire theory of pressure.
+ *
+ * It says what the amber means and, more importantly, what it does not mean and
+ * what does not follow it. A reader who has been told there is no escalation can
+ * leave a case sitting for thirty-one days on purpose, which is a decision; a
+ * reader who suspects there might be one manages the queue instead of the work.
+ */
+export const FIX_QUEUE_NOTE =
+  "The started date is the only nudge in this queue. After 30 days it turns amber — a statement of fact, not a warning, and there is no escalation after it.";
+
+/* ── Notes ──────────────────────────────────────────────────────────────── */
+
+/**
+ * The empty state of the notes field.
+ *
+ * It names the reader rather than the format, because there is no format. No
+ * schema, no required fields, nothing derived from what is typed here.
+ */
+export const FIX_NOTES_PLACEHOLDER = "Notes for whoever picks this up";
+
+/* ── Copy as ticket ─────────────────────────────────────────────────────── */
+
+export const FIX_ACTION_COPY_TICKET = "Copy as ticket";
+
+/**
+ * What the button says once it has done it.
+ *
+ * "wherever your work lives" is the point of the whole affordance: there is no
+ * tracker integration here and there is not going to be one. Page Watch does not
+ * know or care whether the paste lands in Jira, Linear, a pull request or a
+ * message, and a ticket that is plain markdown works in all four.
+ */
+export const FIX_TICKET_COPIED = "Copied. Paste it wherever your work lives.";
diff --git a/src/lib/fix-ticket.ts b/src/lib/fix-ticket.ts
new file mode 100644
index 0000000..a487f12
--- /dev/null
+++ b/src/lib/fix-ticket.ts
@@ -0,0 +1,99 @@
+import { includedPages, type IssueCase } from "./issue-case";
+import { EFFORT_LABEL, formatCaseImpact } from "./impact-format";
+import { EFFORT_LABEL_TEXT, IMPACT_LABEL } from "./case-copy";
+import { absoluteUrl, casePath } from "./paths";
+
+/**
+ * A case as a ticket, in plain markdown.
+ *
+ * Six things, in the order a person reading a ticket needs them: what is wrong,
+ * where, what to do about it, what it is worth, what it costs, and where the
+ * evidence lives. Nothing else. This is not a summary of the case — it is the
+ * part of the case that survives being pasted somewhere Page Watch cannot see.
+ *
+ * There are no tracker integrations here and there is not going to be one. An
+ * integration is a second place the work's state lives, and a second place the
+ * work's state lives is a place it disagrees with the first — which is the
+ * defect the whole case object was built to remove, re-created across a network
+ * boundary where nobody can reconcile it. Markdown on the clipboard has no
+ * state, so it cannot drift; it is a copy of a fact, taken at a moment, by a
+ * person who knows they took it.
+ *
+ * Three things this module is careful about:
+ *
+ *   1. The saving comes from `formatCaseImpact`, which is the same call the case
+ *      detail makes. Not a reimplementation of it, and not `formatImpact` on a
+ *      differently-derived number — the brief requires the ticket's string to be
+ *      byte-identical to the case's, and the only way to promise that is for
+ *      there to be one string.
+ *   2. An unmeasured finding therefore says "Not measured" and never 0
+ *      (rule 18). This module contains no number formatting at all, which is
+ *      what makes that true rather than remembered.
+ *   3. The link is `casePath`, which is the app's one statement of a case's
+ *      address: `/issues/{id}`. There is no `/issues/case/` route to get wrong,
+ *      and a ticket outlives the person who filed it, so a link spelled by hand
+ *      here would be discovered broken by a stranger.
+ */
+
+export interface TicketOptions {
+  /** Page titles by id. Ids are the fallback, so a missing map degrades to something resolvable. */
+  pageTitles?: Record<string, string>;
+  /**
+   * Per-page savings, exactly as the case detail receives them.
+   *
+   * Pass whatever the case is rendering. Passing nothing is legal and yields the
+   * case's own `impactMs`, which is what a surface with no per-page readings
+   * shows too — so the two still agree.
+   */
+  impactByPage?: Record<string, number>;
+  /**
+   * The deployment's public URL, for a link that resolves outside the app.
+   *
+   * Absent yields the root-relative `/issues/{id}`. That is wrong in a ticket in
+   * a visible way rather than a silent one, which is the same trade
+   * `absoluteUrl` was written for.
+   */
+  appUrl?: string;
+}
+
+/** Steps as a numbered list; the honest line when a migrated case has none. */
+function remediationOf(issue: IssueCase): string {
+  const steps = issue.remediation.steps.filter((step) => step.trim() !== "");
+  // `accept` refuses a case with no steps, so a case that reached the fix queue
+  // through the app always has them. A case migrated straight to `todo` from the
+  // legacy `status: "task"` never passed that guard, and an empty section would
+  // read as a fix with no work in it.
+  if (steps.length === 0) return "_None recorded._";
+  return steps.map((step, index) => `${index + 1}. ${step}`).join("\n");
+}
+
+/** The pages the case counts. Excluded pages are not in the work, so not in the ticket. */
+function pagesOf(issue: IssueCase, pageTitles: Record<string, string>): string {
+  const pages = includedPages(issue);
+  if (pages.length === 0) return "_None recorded._";
+  return pages.map((pageId) => `- ${pageTitles[pageId] ?? pageId}`).join("\n");
+}
+
+export function ticketMarkdown(issue: IssueCase, options: TicketOptions = {}): string {
+  const impact = formatCaseImpact(issue, options.impactByPage);
+  // The case's own plain sentence where it has one. `fromRec` leaves `diagnosis`
+  // empty rather than authoring copy, and the stored title is what the source
+  // called it — the same fallback the list row makes, not a second one.
+  const diagnosis = issue.diagnosis || issue.title;
+
+  return [
+    `# ${issue.id} — ${diagnosis}`,
+    "",
+    "## Pages",
+    pagesOf(issue, options.pageTitles ?? {}),
+    "",
+    "## Remediation",
+    remediationOf(issue),
+    "",
+    `${IMPACT_LABEL}: ${impact.text}`,
+    `${EFFORT_LABEL_TEXT}: ${EFFORT_LABEL[issue.effort]}`,
+    "",
+    absoluteUrl(options.appUrl ?? "", casePath(issue.id)),
+    "",
+  ].join("\n");
+}
diff --git a/src/lib/impact-format.ts b/src/lib/impact-format.ts
index a3837d4..3cf662c 100644
--- a/src/lib/impact-format.ts
+++ b/src/lib/impact-format.ts
@@ -1,4 +1,4 @@
-import { hasMeasuredImpact, type IssueCase } from "./issue-case";
+import { hasMeasuredImpact, includedPages, type Effort, type IssueCase } from "./issue-case";
 
 /**
  * What an impact reading means, for every surface that writes or reads one.
@@ -15,6 +15,13 @@ import { hasMeasuredImpact, type IssueCase } from "./issue-case";
  * write a line about it, on the identical grounds. Two spellings of "too small
  * to hear about" would be two places to get rule 18 wrong, and rule 18 is the
  * hard part of that predicate rather than the comparison.
+ *
+ * `EFFORT_LABEL` moved here in S5, one move behind the other two. It lived in
+ * `issue-row.tsx` while the list and the case header were the only readers, and
+ * both of those are components. "Copy as ticket" is the third reader and it is
+ * not — it builds a string in a plain module, and a lib importing a `.tsx` to
+ * find out that `hours` is spelled "Hours" would drag React into the one place
+ * that has no use for it. `issue-row` re-exports it, so the list keeps one name.
  */
 
 /**
@@ -45,6 +52,37 @@ export function formatImpact(impactMs: number): { text: string; measured: boolea
   return { text: `${rounded} s`, measured: true };
 }
 
+/**
+ * The reading one case is worth, before it is worded.
+ *
+ * The worst reading on a page this case counts — never a sum (rule 19), because
+ * adding four pages' savings would invent a figure no run produced, and never a
+ * reading from a page the case has excluded, because an excluded page is one the
+ * work is not about.
+ *
+ * This is a function rather than four lines in a component because S5 gave the
+ * figure a second reader that is not on screen. "Copy as ticket" writes the
+ * saving into a string that leaves the app, and a ticket quoting 1.9 s beside a
+ * case showing 2.1 s is the audit's "same finding explained four different ways"
+ * arriving by post. One derivation, so the two cannot part.
+ */
+export function caseImpactMs(issue: IssueCase, impactByPage?: Record<string, number>): number {
+  const readings = includedPages(issue).map((pageId) => impactByPage?.[pageId] ?? 0);
+  const worst = readings.length ? Math.max(...readings, 0) : issue.impactMs;
+  // `|| issue.impactMs` catches the case whose per-page readings are all absent:
+  // 0 here means nothing was measured per page, not that the case is worth
+  // nothing, so the case's own figure is the better answer (rule 18).
+  return worst || issue.impactMs;
+}
+
+/** The same reading, worded. Every surface that shows a case's saving calls this. */
+export function formatCaseImpact(
+  issue: IssueCase,
+  impactByPage?: Record<string, number>,
+): { text: string; measured: boolean } {
+  return formatImpact(caseImpactMs(issue, impactByPage));
+}
+
 /**
  * The same reading, on a group of cases rather than one.
  *
@@ -57,6 +95,23 @@ export function formatGroupImpact(impactMs: number): { text: string; measured: b
   return impact.measured ? { text: `up to ${impact.text}`, measured: true } : impact;
 }
 
+/* ── Effort ────────────────────────────────────────────────────── */
+
+/**
+ * Effort is a band on the case rather than a registry concept, so its words live
+ * here beside impact — the two are read together everywhere they are read at
+ * all, and a ticket that quoted one from the registry and the other from a
+ * component would be quoting two vocabularies.
+ */
+export const EFFORT_LABEL: Record<Effort, string> = {
+  minutes: "Minutes",
+  hours: "Hours",
+  days: "Days",
+  // Not a dash. The stored estimate said "Needs review", which is the absence of
+  // a band, and rule 18's reasoning applies to any missing reading: say so.
+  unknown: "No estimate",
+};
+
 /* ── The savings gate ──────────────────────────────────────────── */
 
 /**
diff --git a/src/lib/issue-case.ts b/src/lib/issue-case.ts
index db34338..c980938 100644
--- a/src/lib/issue-case.ts
+++ b/src/lib/issue-case.ts
@@ -53,7 +53,7 @@ import {
   type Queue,
   type WorkState,
 } from "./vocabulary";
-import type { Caller } from "./caller";
+import { attributionOf, type Caller } from "./caller";
 import { historyExcluded, historyIncluded } from "./case-copy";
 import { isFieldRecommendationActionable, fieldRecommendationLifecycleStatus } from "./fieldOnlyRecommendations";
 import { parseMarkerDate } from "./ui";
@@ -197,9 +197,49 @@ export interface IssueCase {
   evidence: EvidenceEntry[];
   // 9 history — every transition, append-only
   history: HistoryEntry[];
-  // work view (D4) — added in place, never a copy
+  /* ── The work view — two fields, and no hand on either ──────────────── */
+  /**
+   * Who picked this up — the identity `attributionOf` gives their caller.
+   * Written by `start` and by nothing else.
+   *
+   * There is no setter for this and no input bound to it, which is the whole
+   * design rather than an omission. An owner a person can retype is an owner
+   * that disagrees with the history entry beside it the first time somebody
+   * corrects a spelling, and then the case has two answers to "who has this"
+   * — the same defect, one field smaller, that the four merged lifecycles
+   * were. Whoever fired `start` is the owner; if that is wrong, the remedy is
+   * a transition, not a text field.
+   *
+   * An identity rather than a `Caller`, because F4 split the two on purpose:
+   * the class is a permission and this is the record of who. `start` is
+   * person-only, so the class here is already known and constant, and a field
+   * typed to admit `{ kind: "system" }` is a field that eventually holds one.
+   *
+   * Absent is common and is a real answer. A legacy record that arrives
+   * already `in_progress` through `stateFromTaskStatus` never passed through
+   * `start`; a migrated person caller carries `UNKNOWN_USER`, which recorded
+   * the class and threw the identity away. Rule 18 applies to a name as much
+   * as to a reading — the queue says there is no owner rather than inventing
+   * one or printing a sentinel.
+   */
   owner?: string;
-  checklist?: { text: string; done: boolean }[];
+  /**
+   * When they picked it up. Written by `start`, alongside `owner`.
+   *
+   * The pair is written together and read together. This is the only date the
+   * fix queue nudges with — past thirty days it renders amber, which is a
+   * statement of fact and not an alert. There is no due date and no second
+   * threshold behind it.
+   */
+  startedAt?: string;
+  /**
+   * Free text for whoever picks this up.
+   *
+   * No schema, no required fields, nothing derived from it. A note is the one
+   * place on a case where the app does not have an opinion about the shape of
+   * what you write, which is what makes it usable for the thing that did not
+   * fit any of the other eight sections.
+   */
   notes?: string;
 }
 
@@ -521,6 +561,14 @@ export function checkpointsAgree(checkpoints: readonly Checkpoint[]): boolean {
  * nothing offers a Resolve button. Reaching this throw means a caller was
  * written against a permission it does not have, so it names the transition,
  * the classes the registry permits, and the class it was handed.
+ *
+ * Two transitions write more than a state and a history line, and both write it
+ * here rather than in their named wrapper below. `mark_fixed` schedules the
+ * checkpoints that will settle the case; `start` stamps the owner and the start
+ * date. Putting both on this function is what makes "no other path writes
+ * either" true of the codebase rather than merely intended: `start` is a
+ * one-line call to `applyAction`, so there is no second door into `in_progress`
+ * that could reach it without the stamp.
  */
 export function applyAction(issue: IssueCase, action: IssueAction, options: TransitionOptions): IssueCase {
   const transition = ISSUE_TRANSITIONS[action];
@@ -562,7 +610,37 @@ export function applyAction(issue: IssueCase, action: IssueAction, options: Tran
     state: transition.to,
     history: [...issue.history, entry],
   };
-  return action === "mark_fixed" ? { ...moved, checkpoints: scheduleCheckpoints(at) } : moved;
+  if (action === "mark_fixed") return { ...moved, checkpoints: scheduleCheckpoints(at) };
+  /**
+   * Starting is what assigns the case. Whoever fired the transition is the
+   * owner, and the instant they fired it is the start date — the same `at` the
+   * history entry above carries, so the two can never disagree about when this
+   * began.
+   *
+   * The identity comes through `attributionOf` rather than off `options.by`
+   * directly, so the owner field and the attribution column in history are the
+   * same answer to the same question and cannot part (rule 20). It also means
+   * the two identities F4 declines to render are the two this declines to
+   * store: a system caller, and the migrated person nobody can name. Both leave
+   * the field absent, and the row then says there is no owner rather than
+   * printing a class or a sentinel as though it were a person.
+   *
+   * `start` is person-only in the registry, so the system arm is unreachable
+   * today. It is handled anyway because `attributionOf` is what decides, not a
+   * belief here about who is permitted — widening `action.start.actor` must not
+   * silently start writing "grouping" into an owner field.
+   *
+   * A second `start` cannot happen: the registry allows it only from `todo`,
+   * and a case that has been started is `in_progress`. So these are written
+   * once and are not overwritten by any later move. Reopening a case sends it
+   * back to `reopened`, which has to be accepted and started again — and that
+   * start, from the new owner, is the one that stamps it.
+   */
+  if (action === "start") {
+    const owner = attributionOf(options.by);
+    return { ...moved, ...(owner ? { owner } : {}), startedAt: at };
+  }
+  return moved;
 }
 
 export function accept(issue: IssueCase, options: TransitionOptions): IssueCase {
@@ -585,6 +663,21 @@ export function reopen(issue: IssueCase, options: TransitionOptions): IssueCase
   return applyAction(issue, "reopen", options);
 }
 
+/**
+ * When a case last entered a state, read off its history.
+ *
+ * Read rather than stored, which is what keeps the date a surface shows and the
+ * date the transition happened the same fact. The LAST such entry wins: a case
+ * that came back and was accepted again was accepted on the second date, and a
+ * row saying otherwise would be quoting a decision that has since been retaken.
+ *
+ * Undefined is a real answer — a state the case never entered, and a migrated
+ * case whose history begins mid-lifecycle. Rule 18: callers say so rather than
+ * substituting `detectedAt`, which is a different date about a different event.
+ */
+export function enteredAt(issue: IssueCase, state: IssueState): string | undefined {
+  return [...issue.history].reverse().find((entry) => entry.to === state)?.at;
+}
 
 /**
  * The checks that decide whether a fixed case becomes resolved.
diff --git a/src/lib/webflowPerformance.ts b/src/lib/webflowPerformance.ts
index 02b8498..6724b27 100644
--- a/src/lib/webflowPerformance.ts
+++ b/src/lib/webflowPerformance.ts
@@ -400,10 +400,6 @@ export function effortLabel(item: { estTime: string; id: string; title?: string;
   return item.estTime;
 }
 
-export function triageActionLabel(item: { id: string; title?: string; webflow?: WebflowPerformanceClassification }): string {
-  return customerActionabilityFor(item) === "workaround" ? "Add workaround to tasks" : "Add to tasks";
-}
-
 export function classificationForPage(
   item: { id: string; title?: string },
   webflowGenerated: boolean,

From b35a5eba23e03c722c670febb20e0f5ff222e3d3 Mon Sep 17 00:00:00 2001
From: Matthew P Munger <matthew@webflow.com>
Date: Thu, 27 Aug 2026 09:28:08 -0500
Subject: [PATCH 2/2] fix: catch S5 up to F4's caller split
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Three test files still passed the retired actor option where
TransitionOptions now takes by: Caller; each gains the PERSON constant
the migrated suites already use. personActionsFor still tested the
permission list against a bare word, which the guard in caller.test.ts
flags — port main's actorPermits helper verbatim so both it and
applyAction read the table the same way, and so the eventual merge is
clean.
---
 src/lib/__tests__/digest-arrival.test.ts | 12 ++++++++----
 src/lib/__tests__/digest.test.ts         | 10 +++++++---
 src/lib/__tests__/webhook.test.ts        |  6 +++++-
 src/lib/issue-case.ts                    | 22 ++++++++++++++++++++--
 4 files changed, 40 insertions(+), 10 deletions(-)

diff --git a/src/lib/__tests__/digest-arrival.test.ts b/src/lib/__tests__/digest-arrival.test.ts
index c30c526..286a8ad 100644
--- a/src/lib/__tests__/digest-arrival.test.ts
+++ b/src/lib/__tests__/digest-arrival.test.ts
@@ -22,6 +22,7 @@ import {
   type IssueState,
 } from "../issue-case";
 import { recordCheckpointReading } from "../checkpoint-evaluation";
+import type { Caller } from "../caller";
 import { normalizePerformanceThresholds } from "../performanceThresholds";
 import { ISSUE_TRANSITIONS, QUEUES, WORK_STATES, type IssueAction } from "../vocabulary";
 import { pendingPage } from "../mutations";
@@ -43,6 +44,9 @@ const AT = "2026-08-25T06:00:00.000Z";
 const DATE = "2026-08-25";
 const APP = "https://watch.example.com/page-watch";
 
+/** The person walking the case through its lifecycle below. */
+const PERSON: Caller = { kind: "person", userId: "rae@webflow.com" };
+
 function caseOf(overrides: Partial<IssueCase> = {}): IssueCase {
   return {
     id: "PW-2291",
@@ -129,9 +133,9 @@ describe("the case route", () => {
      */
     const link = digestOf([caseOf()]).sections[0].lines[0].href;
     let issue = caseOf();
-    issue = accept(issue, { actor: "person", at: AT });
-    issue = start(issue, { actor: "person", at: AT });
-    issue = markFixed(issue, { actor: "person", at: AT });
+    issue = accept(issue, { by: PERSON, at: AT });
+    issue = start(issue, { by: PERSON, at: AT });
+    issue = markFixed(issue, { by: PERSON, at: AT });
     issue = recordCheckpointReading(issue, { interval: "7d", outcome: "disagreed", at: AT }).issue;
     expect(issue.state).toBe("reopened");
     expect(issue.id).toBe("PW-2291");
@@ -187,7 +191,7 @@ describe("the context banner", () => {
 
   it("repeats the line the message wrote, because both come from one writer", () => {
     const reopened = recordCheckpointReading(
-      markFixed(caseOf({ state: "in_progress" }), { actor: "person", at: AT }),
+      markFixed(caseOf({ state: "in_progress" }), { by: PERSON, at: AT }),
       { interval: "7d", outcome: "disagreed", at: AT },
     ).issue;
     const digest = digestOf([reopened]);
diff --git a/src/lib/__tests__/digest.test.ts b/src/lib/__tests__/digest.test.ts
index 2326138..e824426 100644
--- a/src/lib/__tests__/digest.test.ts
+++ b/src/lib/__tests__/digest.test.ts
@@ -15,6 +15,7 @@ import { DIGEST_CADENCE_LABEL } from "../digestCadence";
 import { formatImpact } from "../impact-format";
 import { markFixed, scheduleCheckpoints, type IssueCase } from "../issue-case";
 import { recordCheckpointReading } from "../checkpoint-evaluation";
+import type { Caller } from "../caller";
 import { normalizePerformanceThresholds } from "../performanceThresholds";
 import { casePath } from "../paths";
 import { DESTINATION_PATH } from "../vocabulary";
@@ -37,6 +38,9 @@ const DATE = "2026-08-25";
 const APP = "https://watch.example.com/page-watch";
 const SCHEDULE = { localTime: "00:00", timeZone: "America/Chicago", overridden: true };
 
+/** The person who shipped the fixes these digests report on. */
+const PERSON: Caller = { kind: "person", userId: "rae@webflow.com" };
+
 function caseOf(overrides: Partial<IssueCase> = {}): IssueCase {
   return {
     id: "PW-1",
@@ -63,13 +67,13 @@ function caseOf(overrides: Partial<IssueCase> = {}): IssueCase {
 
 /** A case the system brought back, produced by the evaluator rather than posed. */
 function cameBackCase(overrides: Partial<IssueCase> = {}): IssueCase {
-  const fixed = markFixed(caseOf({ state: "in_progress", ...overrides }), { actor: "person", at: AT });
+  const fixed = markFixed(caseOf({ state: "in_progress", ...overrides }), { by: PERSON, at: AT });
   return recordCheckpointReading(fixed, { interval: "7d", outcome: "disagreed", at: AT }).issue;
 }
 
 /** A fixed case still waiting: three checkpoints scheduled, nothing read. */
 function heldCase(overrides: Partial<IssueCase> = {}): IssueCase {
-  return markFixed(caseOf({ state: "in_progress", ...overrides }), { actor: "person", at: AT });
+  return markFixed(caseOf({ state: "in_progress", ...overrides }), { by: PERSON, at: AT });
 }
 
 /** A fixed case whose three checks all failed to read — evaluation rule 4. */
@@ -81,7 +85,7 @@ function unreadableCase(overrides: Partial<IssueCase> = {}): IssueCase {
       attempts: 2,
       result: "unavailable" as const,
     })),
-    history: [{ at: AT, from: "in_progress", to: "fixed", actor: "person" }],
+    history: [{ at: AT, from: "in_progress", to: "fixed", by: PERSON }],
     ...overrides,
   });
 }
diff --git a/src/lib/__tests__/webhook.test.ts b/src/lib/__tests__/webhook.test.ts
index a3e3887..da3517a 100644
--- a/src/lib/__tests__/webhook.test.ts
+++ b/src/lib/__tests__/webhook.test.ts
@@ -8,6 +8,7 @@ import { buildDigest, type Digest } from "../digest";
 import { renderDigestMessage } from "../digest-email";
 import { markFixed, type IssueCase } from "../issue-case";
 import { recordCheckpointReading } from "../checkpoint-evaluation";
+import type { Caller } from "../caller";
 import { normalizePerformanceThresholds } from "../performanceThresholds";
 import { pendingPage } from "../mutations";
 
@@ -18,6 +19,9 @@ afterEach(() => {
 
 const AT = "2026-08-04T06:00:00.000Z";
 
+/** The person who marked the case fixed before the checkpoint disagreed. */
+const PERSON: Caller = { kind: "person", userId: "rae@webflow.com" };
+
 function caseOf(overrides: Partial<IssueCase> = {}): IssueCase {
   return {
     id: "PW-1",
@@ -71,7 +75,7 @@ describe("alert webhook", () => {
      * sections, same sentences.
      */
     const digest = digestOf([
-      recordCheckpointReading(markFixed(caseOf(), { actor: "person", at: AT }), {
+      recordCheckpointReading(markFixed(caseOf(), { by: PERSON, at: AT }), {
         interval: "7d",
         outcome: "disagreed",
         at: AT,
diff --git a/src/lib/issue-case.ts b/src/lib/issue-case.ts
index c980938..eeebed6 100644
--- a/src/lib/issue-case.ts
+++ b/src/lib/issue-case.ts
@@ -440,6 +440,19 @@ export function actionsFor(state: IssueState): IssueAction[] {
     .filter((action) => ISSUE_TRANSITIONS[action].from.includes(state));
 }
 
+/**
+ * Whether the registry lets a caller of this class fire this action.
+ *
+ * The one place the permission set is read, so the guard in `applyAction` and
+ * the affordance in `personActionsFor` cannot come to different conclusions
+ * about the same table. It takes a `kind` and never an identity: F4's whole
+ * point is that permission is decided on the class, and a function that could
+ * be handed a name is one that could be made to answer on the strength of it.
+ */
+function actorPermits(action: IssueAction, by: Pick<Caller, "kind">): boolean {
+  return ISSUE_TRANSITIONS[action].actor.includes(by.kind);
+}
+
 /**
  * The actions a person may fire from a state — the ones that can be a button.
  *
@@ -448,9 +461,14 @@ export function actionsFor(state: IssueState): IssueAction[] {
  * this is what makes that true of the UI rather than merely written down. A
  * transition added with `person` in its actor list appears here without anyone
  * remembering to add it.
+ *
+ * Asked through `actorPermits` with a class rather than by testing the list
+ * against a bare word, so this reads the permission set exactly the way the
+ * runtime guard does — which is what `caller`'s "never compare an identity
+ * against a permission list" rule is protecting.
  */
 export function personActionsFor(state: IssueState): IssueAction[] {
-  return actionsFor(state).filter((action) => ISSUE_TRANSITIONS[action].actor.includes("person"));
+  return actionsFor(state).filter((action) => actorPermits(action, { kind: "person" }));
 }
 
 /**
@@ -577,7 +595,7 @@ export function applyAction(issue: IssueCase, action: IssueAction, options: Tran
       `applyAction: ${action} is not legal from ${issue.state} (legal from ${transition.from.join(", ")}).`,
     );
   }
-  if (!transition.actor.includes(options.by.kind)) {
+  if (!actorPermits(action, options.by)) {
     throw new IssueCaseError(
       `applyAction: ${action} may be fired by ${transition.actor.join(", ")}; the caller offered ${options.by.kind}.`,
     );