@tablation/crew 0.81.0 → 0.82.1

package/dist/cli.js

@@ -4215,6 +4215,15 @@ function baseAttention(repo, outcome, remote, base, nowIso = (/* @__PURE__ */ ne
   if (outcome.action === "level" || outcome.action === "fast-forwarded") return { clear: baseUnsafeKey(repo) };
   return null;
 }
+var agentLogRefusedKey = (route) => `agent_log_refused:${route}`;
+function agentLogRefusedItem(route, role, status2, nowIso = (/* @__PURE__ */ new Date()).toISOString()) {
+  return {
+    kind: "agent_log_refused",
+    key: agentLogRefusedKey(route),
+    since: nowIso,
+    message: `${route}: the tracker refused the ${role} seat's run report (${status2}) \u2014 runs and ticket spend are not being recorded; check the seat key's role`
+  };
+}
 var diskLowKey = (repo) => `disk_low:${repo}`;
 var LOW_DISK_BYTES = 2 * 1024 ** 3;
 var gib = (bytes) => (bytes / 1024 ** 3).toFixed(1);
@@ -4587,1431 +4596,1441 @@ import { finished } from "stream/promises";
 import { join as join19, dirname as dirname7, basename as basename7 } from "path";
 import { createHash as createHash3 } from "crypto";
 
-// src/environment.ts
-import { basename as basename5 } from "path";
-var API_KEY_VAR = "CREW_API_KEY";
-function authorshipBullets(a, contract) {
-  if (!a) return [];
-  return [
-    ...a.issueAuthor ? [`- \`${contract.columns.author}\`: your own Crew row id, from "Your crew" above \u2014 who filed it`] : [],
-    ...a.issueShip && a.shipId ? [`- \`${contract.columns.ship}\`: \`${a.shipId}\` \u2014 this ship, where it was filed from`] : [],
-    ...a.commentShip && a.shipId ? [`- \`${contract.comments.ship}\` on every comment you post: \`${a.shipId}\` \u2014 this ship`] : []
-  ];
-}
-var HOOK_PURPOSE = [
-  ["setup", "make a fresh worktree usable \u2014 dependencies, generated clients"],
-  ["isolate", "point this worktree at state of its own; prints KEY=value overrides to export"],
-  ["ports", "this worktree's port assignments; prints KEY=value overrides to export"],
-  ["handoff", "leave the operator able to open what you built; put its output in your progress comment"],
-  ["test", "run the suite"],
-  ["build", "build it"],
-  ["ci_status", "after you push and before you hand off: exit 0 means CI is green for your branch; on failure fix and push again, and say in your progress comment if it is still pending"]
-];
-function hookTable(repo) {
-  const declared = HOOK_PURPOSE.filter(([name]) => repo.hooks[name]);
-  if (declared.length === 0) {
-    return "This repository declares no hooks. Do not guess commands for it \u2014 say so in your progress comment and stop.\n";
+// src/state.ts
+import { readFileSync as readFileSync11, writeFileSync as writeFileSync7, existsSync as existsSync11, mkdirSync as mkdirSync6, rmSync as rmSync6, statSync as statSync4, readdirSync as readdirSync4 } from "fs";
+import { join as join12 } from "path";
+var EPOCH = "1970-01-01T00:00:00.000Z";
+var State = class _State {
+  dir;
+  constructor(dir) {
+    this.dir = dir;
+    mkdirSync6(dir, { recursive: true });
   }
-  const inline = (cmd) => cmd.includes("\n") ? "_(below)_" : `\`${cmd}\``;
-  const blocks = declared.filter(([name]) => repo.hooks[name].includes("\n")).map(([name]) => [`### \`${name}\``, "", "```sh", repo.hooks[name].trimEnd(), "```", ""].join("\n"));
-  const undeclared = HOOK_PURPOSE.filter(([n]) => !repo.hooks[n]);
-  return [
-    "| hook | what it is for | what it runs |",
-    "| --- | --- | --- |",
-    ...declared.map(([name, purpose]) => `| \`${name}\` | ${purpose} | ${inline(repo.hooks[name])} |`),
-    "",
-    "Run these **verbatim**, from the worktree. They come from the repository's own",
-    "configuration, which is the only thing that knows them. A command you invented",
-    "yourself is wrong even when it works, because the next repository will differ.",
-    "",
-    ...blocks,
-    ...undeclared.length ? [`Not declared here, so there is nothing to run for them: ${undeclared.map(([n]) => `\`${n}\``).join(", ")}.`, ""] : []
-  ].join("\n");
-}
-function repoPrefix(repo) {
-  return repo.provenance["worktrees.prefix"] !== "default" ? repo.worktrees.prefix.replace(/-$/, "") : void 0;
-}
-function branchExample(repo, key) {
-  const prefix = repoPrefix(repo);
-  const template = effectiveBranchTemplate(repo, prefix);
-  return renderBranchName(template, { key, title: "Fix the widget", role: "dev", prefix, lowercase: repo.branch.lowercase });
-}
-function repoSection(r, key, heading) {
-  const repo = r.config;
-  const branchTemplate = effectiveBranchTemplate(repo, repoPrefix(repo));
-  const branchName = branchExample(repo, key);
-  const checkoutName = basename5(r.dir.replace(/[/\\]+$/, ""));
-  const worktreeName = effectiveWorktreeDirName(
-    repo,
-    r.dir,
-    branchName,
-    key.replace(/^\D+/, ""),
-    // The example ticket has no tag of its own, so `{issue}` is the key.
-    (template) => renderWorktreeName(template, { dir: checkoutName, key, title: "Fix the widget", role: "dev", prefix: repoPrefix(repo) })
-  );
-  const worktreePattern = repo.worktrees.name ?? (repo.provenance["worktrees.prefix"] !== "default" ? `${repo.worktrees.prefix}<number>` : `${checkoutName}-<branch>`);
-  const lines = [
-    "",
-    heading,
-    "",
-    `- Cut it from \`${repo.branch.base}\`, beside the checkout, at`,
-    `  \`../${worktreePattern}\` \u2014 for ${key} that is \`../${worktreeName}\`.`,
-    `- Name the branch the way this repository names branches: \`${branchTemplate}\``,
-    `  \u2014 for ${key} that is \`${branchName}\`.`,
-    "- Never work in the main checkout. It is the operator's, and the release phase",
-    "  uses it.",
-    "",
-    `${key} above is a placeholder, not a real ticket: this section is rendered`,
-    "before any ticket is chosen, so it cannot know a specific ticket's own",
-    "project prefix. Once you have a ticket, its digest row's `branch` and",
-    "`worktree` columns are the real, per-ticket values \u2014 use those verbatim",
-    "over this section's worked example if the two ever disagree."
-  ];
-  if (repo.worktrees.copy.length) {
-    lines.push(
-      "",
-      "A worktree is a clean checkout, so it is missing exactly the files git ignores.",
-      "Copy these across from the main checkout before running anything:",
-      "",
-      ...repo.worktrees.copy.map((c) => `- \`${c}\``)
-    );
+  path(...parts) {
+    return join12(this.dir, ...parts);
   }
-  if (repo.docs.designGuide) {
-    lines.push(
-      "",
-      "## This project's design brief",
-      "",
-      `\`${repo.docs.designGuide}\`, in the repository. Read it from the primary`,
-      "checkout before you `cd` into any worktree \u2014 a worktree cut from the base",
-      "branch only has it once it has been committed there."
-    );
+  /**
+   * The timestamp every "new since last poll" check is measured against.
+   *
+   * Read once per cycle and advanced only AFTER every role has been
+   * evaluated: bumping it inside the first role's check would hide that
+   * role's new comments from the second.
+   */
+  watermark() {
+    try {
+      const v = readFileSync11(this.path(".poll-watermark"), "utf8").trim();
+      return v || EPOCH;
+    } catch {
+      return EPOCH;
+    }
   }
-  if (repo.docs.triagePolicy) {
-    lines.push(
-      "",
-      "## This project's triage policy",
-      "",
-      `\`${repo.docs.triagePolicy}\`, in the repository. Where it and any brief`,
-      "disagree about what a status means or when a ticket may be accepted, the",
-      "policy document wins: it is the project's own decision, and the brief is",
-      "shared with projects that decided differently."
-    );
+  setWatermark(at) {
+    writeFileSync7(this.path(".poll-watermark"), `${at}
+`);
   }
-  return lines;
-}
-function renderEnvironment(i) {
-  const { route, contract } = i;
-  const repos = i.repos;
-  const only = repos.length === 1 ? repos[0] : void 0;
-  const models = route.resolved?.models;
-  const epicsModelId = route.resolved?.epicsModelId;
-  const mediaLibraryModelId = i.attachments?.mediaLibraryModelId ?? null;
-  const key = "ISSUE-000";
-  const lines = [
-    "# Your environment",
-    "",
-    "Supplied by the crew for THIS run. The brief below is shared by every project",
-    "the crew works on and deliberately names nothing specific; this section is where",
-    "those names come from. Where the two appear to disagree, this section wins.",
-    "",
-    "## The board",
-    "",
-    `- Base URL: \`${route.baseUrl}\``,
-    `- Your key is in the \`${API_KEY_VAR}\` environment variable. Send it as`,
-    `  \`Authorization: Bearer $${API_KEY_VAR}\`. **Do not read it out of any file**,`,
-    "  and never write it into a comment, a commit or a log line.",
-    `- Send \`User-Agent: ${i.userAgent}\` on every request.`
-  ];
-  if (models) {
-    lines.push(
-      "",
-      "Tables, by id \u2014 use these directly rather than listing the workspace to find them:",
-      "",
-      `- Issues: \`${models.issues}\``,
-      `- Comments: \`${models.comments}\``,
-      `- Crew: \`${models.crew}\``,
-      ...epicsModelId ? [`- Epics: \`${epicsModelId}\``] : [],
-      ...mediaLibraryModelId ? [`- Media Library: \`${mediaLibraryModelId}\` (what a ticket's \`${contract.columns.attachments}\` ids point into)`] : []
-    );
+  /**
+   * Advance to the newest thing this cycle actually saw, never to "now".
+   *
+   * Using the clock would silently skip any comment written between the fetch
+   * and the write — a race that loses work rather than repeating it, which is
+   * the wrong way round. Repeating a cycle is free; missing one is not.
+   */
+  advanceWatermark(seen) {
+    const stamps = seen.flatMap((s) => [s.created_at, s.updated_at]).filter((v) => typeof v === "string" && v.length > 0);
+    const next = stamps.length ? stamps.reduce((a, b) => a > b ? a : b) : this.watermark();
+    this.setWatermark(next);
+    return next;
   }
-  const workspaceId = route.resolved?.workspaceId;
-  if (workspaceId) {
-    const base = route.baseUrl.replace(/\/+$/, "");
-    lines.push(
-      "",
-      `- Workspace id: \`${workspaceId}\``,
-      "",
-      "## Attaching a file to a comment",
-      "",
-      "A screenshot or mockup goes on a comment's `attachments` field, which holds",
-      "Media Library record ids, not URLs. Upload the file first, then put the",
-      "returned `id` in the comment's `attachments` array:",
-      "",
-      "```sh",
-      `curl -s -H "Authorization: Bearer $${API_KEY_VAR}" -H "User-Agent: ${i.userAgent}" \\`,
-      `  -X POST "${base}/api/workspaces/${workspaceId}/files" \\`,
-      '  -F "file=@shot.png;type=image/png" -F targetMediaLibrary=true',
-      "```",
-      "",
-      "The response is JSON with `id` and `storageKey`. `targetMediaLibrary=true`",
-      "means no field type id has to be looked up. If the upload fails, post the HTTP",
-      "status and response body in your comment \u2014 do not write that uploads are",
-      "impossible."
-    );
-    if (mediaLibraryModelId) {
-      lines.push(
-        "",
-        "## Opening a ticket's attachments",
-        "",
-        `A ticket's or a comment's \`${contract.columns.attachments}\` value is a list of Media Library`,
-        "**record ids** \u2014 not file ids and not URLs. `files/<id>`, `files/<id>/download` and",
-        "`media-library/<id>/...` do not exist for such an id and return 404. For each id,",
-        "read the record, then fetch the file by its storage key:",
-        "",
-        "```sh",
-        `curl -s -H "Authorization: Bearer $${API_KEY_VAR}" -H "User-Agent: ${i.userAgent}" \\`,
-        `  "${base}/api/workspaces/${workspaceId}/data-models/${mediaLibraryModelId}/records/<attachment id>"`,
-        '# \u2192 JSON with `storage_key` ("<uuid>/<filename>") and `mime_type`',
-        `curl -s -o <scratch dir>/<filename> -H "Authorization: Bearer $${API_KEY_VAR}" -H "User-Agent: ${i.userAgent}" \\`,
-        `  "${base}/api/workspaces/${workspaceId}/files/<storage_key>"`,
-        "```",
-        "",
-        "The MCP forms are `records_controller_find_one` (`dataModelId` = the Media Library",
-        "id above) and `files_controller_download` (`uuid` and `filename` = the two halves",
-        "of the storage key). Save the file outside the repository and open it; where it",
-        "disagrees with the description, the picture is the reproduction."
-      );
-    }
+  /** Whole-crew pause, and the per-role sentinels one level down. */
+  isPaused() {
+    return existsSync11(this.path(".crew-paused"));
   }
-  if (i.shipName) {
-    lines.push(
-      "",
-      "## Ships",
-      "",
-      `This run is on the ship **${i.shipName}**. When a comment names a ship \u2014 this one or`,
-      "another (the digest prints other ships by name) \u2014 write its name, never a Ships row id."
-    );
+  isRolePaused(role) {
+    return existsSync11(this.path(`.role-paused-${role}`));
   }
-  const seatIds = Object.entries(route.resolved?.seats ?? {}).filter(([, id]) => !!id);
-  if (seatIds.length > 0) {
-    lines.push(
-      "",
-      "## Seats on this ship",
-      "",
-      "The Crew row id of each role's seat on this ship, to write verbatim where a hand-off",
-      "assigns the next lane (a ticket whose digest `mode` is `hybrid`):",
-      "",
-      ...seatIds.map(([role, id]) => `- ${role}: \`${id}\``)
-    );
+  pausedRoles(roles) {
+    return new Set(roles.filter((r) => this.isRolePaused(r)));
   }
-  lines.push(
-    "",
-    "## What the columns are called here",
-    "",
-    "Every workspace names these itself. Use these names, not the ones you would",
-    "guess, and not the ones another project used.",
-    "",
-    "| meaning | column |",
-    "| --- | --- |",
-    `| ticket key | \`${contract.columns.key}\` |`,
-    `| status | \`${contract.columns.status}\` |`,
-    `| assignee | \`${contract.columns.assignee}\` |`,
-    `| severity | \`${contract.columns.severity}\` |`,
-    `| priority | \`${contract.columns.priority}\` |`,
-    `| blocked by | \`${contract.columns.blockedBy}\` |`,
-    `| needs design | \`${contract.columns.needsDesign}\` |`,
-    `| project | \`${contract.columns.slice}\` |`,
-    `| repo | \`${contract.columns.repo}\` |`,
-    ...epicsModelId ? [`| epic | \`${contract.columns.epic}\` |`] : [],
-    "",
-    ...epicsModelId ? [
-      "An epic is a body of work a ticket belongs to. Set it when a ticket clearly",
-      "fits an existing epic; proposing a new one is a taxonomy decision \u2014 leave it",
-      "to a person rather than inventing one yourself.",
-      "",
-      "An epic's own status is kept by the crew runner, from its tickets: done once",
-      "every one of them is closed, in progress while any is being worked. Do not",
-      "set it yourself.",
-      ""
-    ] : [],
-    "Statuses that matter to you:",
-    "",
-    `- Work you may pick up: \`${contract.statuses.approved}\``,
-    `- While you are working it: \`${contract.statuses.building}\``,
-    `- When you hand it on to be checked: \`${contract.statuses.handoff}\``,
-    `- Being checked: \`${contract.statuses.verifying}\``,
-    `- Waiting on a person to answer something: \`${contract.statuses.needsHuman}\``,
-    `- Parked on an unresolved dependency, set by the crew and not by you: \`${contract.statuses.parked}\``,
-    "",
-    `\`${contract.statuses.verified}\` and the closed statuses are **never yours to set**.`
-  );
-  const areaId = route.resolved?.areaId;
-  if (areaId || repos.some((r) => r.id)) {
-    lines.push(
-      "",
-      "## Filing a new ticket",
-      "",
-      "Something broken that is out of scope for the ticket you are working is not",
-      "yours to fix inline \u2014 file it as its own new ticket instead, and keep working",
-      "the one you were on. A ticket filed without its project and repo sits unrouted",
-      "until a person notices and fixes it by hand, so always set:",
-      "",
-      ...areaId ? [`- \`${contract.columns.slice}\`: \`${areaId}\` (this route's project, for every ticket you file)`] : [],
-      ...only?.id ? [`- \`${contract.columns.repo}\`: \`${only.id}\` (this repository)`] : repos.filter((r) => r.id).map(
-        (r) => `- \`${contract.columns.repo}\`: \`${r.id}\` \u2014 when the new ticket belongs to ${r.name}`
-      ),
-      ...authorshipBullets(i.authorship, contract),
-      "",
-      ...i.sourceTicket ? [
-        `Name ${i.sourceTicket} \u2014 the ticket you were working when you noticed this \u2014 in the new`,
-        "ticket's description. Only put it in the new ticket's `blockedBy` if your own ticket",
-        "genuinely cannot proceed without the new one being fixed first; merely having noticed it",
-        "nearby is not a dependency.",
-        ""
-      ] : []
-    );
-  }
-  if (only) {
-    lines.push(...repoSection(only, key, "## Your worktree"));
-  } else {
-    lines.push(
-      "",
-      "## The repositories this board covers",
-      "",
-      "This board spans several repositories, and they do not share a branch name,",
-      "a worktree location or a test command. **The `repo` column of your queue",
-      "says which one your ticket belongs to** \u2014 read the section for THAT one and",
-      "ignore the others. A ticket whose repo is not listed here has no checkout on",
-      "this machine and is not yours to work."
-    );
-    for (const r of repos) {
-      lines.push(...repoSection(r, key, `### ${r.name} \u2014 \`${r.dir}\``));
-      lines.push("", `Hooks for ${r.name} \u2014 the only commands you should run here:`, "", hookTable(r.config));
-    }
-  }
-  if (i.repoDir) {
-    lines.push("", `This ticket's work happens in \`${i.repoDir}\`.`);
-  }
-  if (only) lines.push("", "## Hooks \u2014 the only commands you should run", "", hookTable(only.config));
-  return lines.join("\n");
-}
-
-// src/contract.ts
-var DEFAULT_CONTRACT = {
-  columns: {
-    key: "issue_id",
-    tag: "issue_tag",
-    title: "title",
-    status: "status",
-    assignee: "assignee_id",
-    priority: "priority",
-    severity: "severity",
-    slice: "project_id",
-    repo: "repo_id",
-    parent: "parent_id",
-    blockedBy: "blocked_by",
-    updatedAt: "updated_at",
-    needsDesign: "needs_design",
-    attachments: "attachments",
-    workMode: "work_mode",
-    reportType: "report_type",
-    epic: "epic_id",
-    author: "filed_by_id",
-    ship: "ship_id",
-    heldBy: "held_by_ship_id",
-    resolutionNote: "resolution_note",
-    verifiedSha: "verified_sha",
-    prRef: "pr_ref",
-    externalId: "external_id",
-    position: "position",
-    agentRuns: "agent_runs",
-    tokensIn: "tokens_in",
-    tokensOut: "tokens_out",
-    cacheReadTokens: "cache_read_tokens",
-    cacheWriteTokens: "cache_write_tokens",
-    costUsd: "cost_usd"
-  },
-  comments: {
-    parent: "ticket_id",
-    body: "body",
-    author: "team_member_id",
-    createdAt: "created_at",
-    ship: "ship_id",
-    publicReply: "is_public_reply",
-    authorName: "author_name"
-  },
-  statuses: {
-    open: ["new", "accepted", "blocked", "in_progress", "needs_info", "fixed", "qa", "verified"],
-    resolved: [
-      "verified",
-      "closed_deployed",
-      "closed_wont_fix",
-      "closed_duplicate",
-      "closed_completed",
-      "closed_cant_reproduce"
-    ],
-    approved: "accepted",
-    parked: "blocked",
-    building: "in_progress",
-    handoff: "fixed",
-    verifying: "qa",
-    verified: "verified",
-    deployed: "closed_deployed",
-    needsHuman: "needs_info",
-    reviewing: null,
-    wontFix: "closed_wont_fix",
-    draft: "draft"
-  },
-  epics: {
-    statusColumn: "status",
-    keyColumn: "epic_id",
-    statuses: { planned: "planned", building: "in_progress", done: "done", cancelled: "cancelled" }
-  },
-  priorityOrder: ["p0", "p1", "p2", "p3"],
-  severityOrder: ["s1", "s2", "s3", "s4"],
-  unknownPriorityRank: 2,
-  coordinatingValue: "coordinating",
-  manualWorkMode: "manual",
-  hybridWorkMode: "hybrid",
-  repoExemptReportTypes: ["coordinating", "question", "investigation"]
-};
-function closedStatuses(c) {
-  return c.statuses.resolved.filter((s) => s !== c.statuses.verified);
-}
-function resolveContract(override) {
-  if (!override) return DEFAULT_CONTRACT;
-  return {
-    columns: { ...DEFAULT_CONTRACT.columns, ...override.columns },
-    comments: { ...DEFAULT_CONTRACT.comments, ...override.comments },
-    statuses: { ...DEFAULT_CONTRACT.statuses, ...override.statuses },
-    epics: {
-      ...DEFAULT_CONTRACT.epics,
-      ...override.epics,
-      statuses: { ...DEFAULT_CONTRACT.epics.statuses, ...override.epics?.statuses }
-    },
-    priorityOrder: override.priorityOrder ?? DEFAULT_CONTRACT.priorityOrder,
-    severityOrder: override.severityOrder ?? DEFAULT_CONTRACT.severityOrder,
-    unknownPriorityRank: override.unknownPriorityRank ?? DEFAULT_CONTRACT.unknownPriorityRank,
-    coordinatingValue: override.coordinatingValue ?? DEFAULT_CONTRACT.coordinatingValue,
-    manualWorkMode: override.manualWorkMode ?? DEFAULT_CONTRACT.manualWorkMode,
-    hybridWorkMode: override.hybridWorkMode ?? DEFAULT_CONTRACT.hybridWorkMode,
-    // A workspace overriding `coordinatingValue` alone (renaming the rollup
-    // marker) still gets that renamed value exempted here by default,
-    // without also having to repeat it — only an explicit
-    // `repoExemptReportTypes` overrides this derived default.
-    repoExemptReportTypes: override.repoExemptReportTypes ?? (override.coordinatingValue ? [override.coordinatingValue, "question", "investigation"] : DEFAULT_CONTRACT.repoExemptReportTypes)
-  };
-}
-function validateContract(c) {
-  const problems = [];
-  const open = new Set(c.statuses.open);
-  const resolved = new Set(c.statuses.resolved);
-  for (const role of ["approved", "parked", "building", "handoff", "verifying", "needsHuman"]) {
-    const v = c.statuses[role];
-    if (!open.has(v)) problems.push(`statuses.${role} ("${v}") is not listed in statuses.open`);
-  }
-  if (c.statuses.reviewing && !open.has(c.statuses.reviewing)) {
-    problems.push(`statuses.reviewing ("${c.statuses.reviewing}") is not listed in statuses.open`);
-  }
-  if (!resolved.has(c.statuses.deployed)) {
-    problems.push(`statuses.deployed ("${c.statuses.deployed}") is not listed in statuses.resolved`);
+  pause(role) {
+    writeFileSync7(role ? this.path(`.role-paused-${role}`) : this.path(".crew-paused"), "");
   }
-  if (resolved.has(c.statuses.handoff)) {
-    problems.push(
-      `statuses.handoff ("${c.statuses.handoff}") is listed as resolved \u2014 it means built-but-unchecked, so a ticket blocked by it is still blocked; calling it resolved would build on unverified work`
-    );
+  resume(role) {
+    rmSync6(role ? this.path(`.role-paused-${role}`) : this.path(".crew-paused"), { force: true });
   }
-  if (!resolved.has(c.statuses.wontFix)) {
-    problems.push(`statuses.wontFix ("${c.statuses.wontFix}") is not listed in statuses.resolved`);
+  /**
+   * The release phase (merge, deploy, release) has its own sentinel, one
+   * level below the whole-crew pause: `crew pause release` stops shipping
+   * while agents keep working.
+   */
+  isReleasePaused() {
+    return existsSync11(this.path(".release-paused"));
   }
-  if (c.statuses.reviewing && resolved.has(c.statuses.reviewing)) {
-    problems.push(
-      `statuses.reviewing ("${c.statuses.reviewing}") is listed as resolved \u2014 it is unmerged work under review, so a ticket blocked by it is still blocked`
-    );
+  setReleasePaused(paused) {
+    if (paused) writeFileSync7(this.path(".release-paused"), "");
+    else rmSync6(this.path(".release-paused"), { force: true });
   }
-  if (resolved.has(c.statuses.approved)) {
-    problems.push(`statuses.approved ("${c.statuses.approved}") is listed as resolved`);
+  /**
+   * Why a release cycle must not run right now, or null when it may. Every
+   * release entry point checks this first — the release timer, `crew release`,
+   * `crew merge`, `crew deploy` and the inline release a `run` cycle used to
+   * do — so a paused ship cannot merge, deploy, or file release alerts.
+   * A release already in flight when the pause lands finishes; only new
+   * cycles are refused.
+   */
+  releaseSkipReason() {
+    if (this.isPaused()) return "the crew is paused";
+    if (this.isReleasePaused()) return "releases are paused";
+    return null;
   }
-  if (c.statuses.parked === c.statuses.approved) {
-    problems.push("statuses.parked and statuses.approved are the same value \u2014 parking would be a no-op");
+  /**
+   * Take an exclusive lock, or report who holds it.
+   *
+   * A timer fires every couple of minutes and an agent run takes minutes, so
+   * overlapping fires are certain rather than hypothetical — and two agents
+   * on one checkout would fight over the same worktree and the same tickets.
+   *
+   * A lock naming a DEAD pid is stale and taken over: a run killed mid-cycle
+   * (a reboot, a Ctrl-C) must not wedge the crew until someone notices.
+   */
+  /**
+   * Lock names become filenames, so anything that could be read as a path has
+   * to go. A scope like `route/repo` otherwise produced
+   * `.release-route/repo.lock` — a write into a directory that does not exist.
+   */
+  static safe(name) {
+    return name.replace(/[^A-Za-z0-9_-]/g, "_");
   }
-  const epicValues = Object.values(c.epics.statuses);
-  if (new Set(epicValues).size !== epicValues.length) {
-    problems.push("epics.statuses names the same value twice \u2014 the epic sync could not tell those states apart");
+  acquire(rawName) {
+    const name = _State.safe(rawName);
+    const file = this.path(`.${name}.lock`);
+    try {
+      const existing = Number.parseInt(readFileSync11(file, "utf8").trim(), 10);
+      if (Number.isFinite(existing) && existing > 0) {
+        try {
+          process.kill(existing, 0);
+          return { ok: false, heldBy: existing };
+        } catch {
+        }
+      }
+    } catch {
+    }
+    writeFileSync7(file, `${process.pid}
+`);
+    return {
+      ok: true,
+      release: () => {
+        try {
+          rmSync6(file, { force: true });
+        } catch {
+        }
+      }
+    };
   }
-  if (c.priorityOrder.length === 0) problems.push("priorityOrder is empty");
-  if (c.severityOrder.length === 0) problems.push("severityOrder is empty");
-  for (const [name, order] of [["priorityOrder", c.priorityOrder], ["severityOrder", c.severityOrder]]) {
-    if (new Set(order).size !== order.length) problems.push(`${name} contains duplicates`);
+  /**
+   * Whether a release is running right now: any `.release-<scope>.lock` in the
+   * state directory naming a live process (the locks `releasePhase` takes per
+   * scope). A lock naming a dead pid is ignored, as `acquire` ignores it.
+   */
+  releaseInProgress() {
+    let names;
+    try {
+      names = readdirSync4(this.dir);
+    } catch {
+      return false;
+    }
+    for (const n of names) {
+      if (!/^\.release-.+\.lock$/.test(n)) continue;
+      let pid = 0;
+      try {
+        pid = Number.parseInt(readFileSync11(this.path(n), "utf8").trim(), 10);
+      } catch {
+        continue;
+      }
+      if (!Number.isFinite(pid) || pid <= 0) continue;
+      try {
+        process.kill(pid, 0);
+        return true;
+      } catch {
+      }
+    }
+    return false;
   }
-  return problems;
-}
-var EVENT_LOG_MISSING = "the Issues table has no event log \u2014 crew writes its audit trail there (CREW-1574). In the app, open the Issues table's Data & lifecycle tab and turn on Event log, then rerun.";
-
-// src/agent-log.ts
-import { existsSync as existsSync11, mkdirSync as mkdirSync6, readdirSync as readdirSync4, readFileSync as readFileSync11, rmSync as rmSync6, writeFileSync as writeFileSync7 } from "fs";
-import { join as join12 } from "path";
-
-// src/pending-backoff.ts
-var sleepBackoff = (attempts) => Math.min(6e4 * 2 ** Math.max(0, attempts - 1), 30 * 6e4);
-
-// src/agent-log.ts
-var AgentLogUnreachableError = class extends Error {
-};
-var AgentLogHttpError = class extends Error {
-  status;
-  constructor(message, status2) {
-    super(message);
-    this.status = status2;
+  /**
+   * Like `acquire`, but for a resource with `max` interchangeable slots
+   * rather than one exclusive holder — this machine's overall concurrency
+   * capacity (ISSUE-381), which nothing needs to name a particular slot to
+   * use. Takes whichever numbered slot is free first.
+   */
+  acquireN(rawPrefix, max) {
+    const heldBy = [];
+    for (let i = 1; i <= max; i++) {
+      const got = this.acquire(`${rawPrefix}-${i}`);
+      if (got.ok) return got;
+      heldBy.push(got.heldBy);
+    }
+    return { ok: false, heldBy };
   }
-};
-async function request(target, method, path, body) {
-  const url = `${target.baseUrl.replace(/\/+$/, "")}/api${path}`;
-  const res = await fetch(url, {
-    method,
-    headers: {
-      Authorization: `Bearer ${target.apiKey}`,
-      "User-Agent": target.userAgent,
-      ...body === void 0 ? {} : { "Content-Type": "application/json" }
-    },
-    body: body === void 0 ? void 0 : JSON.stringify(body)
-  });
-  if (!res.ok) throw new AgentLogHttpError(`${path}: ${res.status} ${res.statusText}`, res.status);
-  return await res.json();
-}
-var issueColumns = /* @__PURE__ */ new Map();
-function columnsOf(target, modelId) {
-  const key = `${target.baseUrl}|${target.workspaceId}|${modelId}`;
-  let p = issueColumns.get(key);
-  if (!p) {
-    p = request(target, "GET", `/data-models/${modelId}`).then((m) => new Set((m.fields ?? []).map((f) => f.columnName)));
-    p.catch(() => issueColumns.delete(key));
-    issueColumns.set(key, p);
+  /**
+   * The run lock (ISSUE-381, CREW-2821): role-capped AND capacity-limited,
+   * checked together.
+   *
+   * Two sessions of one role must never take the same ticket. Before
+   * CREW-2821 that was guaranteed by an exclusive per-role lock; now the
+   * guarantee is the per-ticket lock (`acquireTicket`), so the role lock is a
+   * counted one: `roleMax` interchangeable slots, default 1. Slot 1 keeps the
+   * historical name `crew-role-<role>` (crew-macos reads it for the live pid),
+   * further slots are `crew-role-<role>-<n>`. `max` is this machine's separate
+   * limit on how many runs of ANY role may overlap; a role that clears its own
+   * lock but finds every slot taken must give its role lock back, or a
+   * locked-but-not-running role would wedge itself out for the rest of the
+   * machine's uptime.
+   */
+  acquireRun(role, max, roleMax = 1) {
+    let roleLock;
+    const roleHolders = [];
+    for (let i = 1; i <= roleMax; i++) {
+      const got = this.acquire(i === 1 ? `crew-role-${role}` : `crew-role-${role}-${i}`);
+      if (got.ok) {
+        roleLock = got;
+        break;
+      }
+      roleHolders.push(got.heldBy);
+    }
+    if (!roleLock) {
+      return {
+        ok: false,
+        reason: roleMax === 1 ? `${role} is already running (pid ${roleHolders[0]})` : `${role} is already running ${roleMax} agents (its roleConcurrency cap; pid${roleHolders.length > 1 ? "s" : ""} ${[...new Set(roleHolders)].join(", ")})`
+      };
+    }
+    const slot = this.acquireN("crew-slot", max);
+    if (!slot.ok) {
+      roleLock.release();
+      return {
+        ok: false,
+        reason: `at capacity \u2014 ${max} agent(s) already running (pid${slot.heldBy.length > 1 ? "s" : ""} ${slot.heldBy.join(", ")})`
+      };
+    }
+    return { ok: true, release: () => {
+      slot.release();
+      roleLock.release();
+    } };
   }
-  return p;
-}
-async function findTicketRecord(target, t, ref) {
-  const filters = {
-    combinator: "OR",
-    conditions: [
-      { columnName: t.keyColumn, operator: "EQ", value: ref },
-      { columnName: t.tagColumn, operator: "EQ", value: ref }
-    ]
-  };
-  const rows = await request(
-    target,
-    "GET",
-    `/data-models/${t.issuesModelId}/records?limit=2&filters=${encodeURIComponent(JSON.stringify(filters))}`
-  );
-  return rows.length === 1 ? rows[0].id : void 0;
-}
-function counterIncrements(run2, cols, have) {
-  const figures = [
-    [cols.agentRuns, 1],
-    [cols.tokensIn, run2.tokensIn],
-    [cols.tokensOut, run2.tokensOut],
-    [cols.cacheReadTokens, run2.cacheReadTokens],
-    [cols.cacheWriteTokens, run2.cacheWriteTokens],
-    [cols.costUsd, run2.costUsd]
-  ];
-  const out = {};
-  for (const [column, value2] of figures) {
-    if (value2 !== void 0 && Number.isFinite(value2) && have.has(column)) out[column] = { $op: "increment", value: value2 };
+  /**
+   * The per-ticket run lock (CREW-2821): held for the life of a run that works
+   * the ticket (`crew-ticket-<record id>`), so a second run of the same role
+   * on this ship walks past it instead of being handed the first run's
+   * ticket. Same stale-pid rule as every lock here.
+   */
+  acquireTicket(recordId) {
+    return this.acquire(`crew-ticket-${recordId}`);
   }
-  return out;
-}
-async function post(target, path, body) {
-  const url = `${target.baseUrl.replace(/\/+$/, "")}/api/workspaces/${target.workspaceId}${path}`;
-  const res = await fetch(url, {
-    method: "POST",
-    headers: {
-      Authorization: `Bearer ${target.apiKey}`,
-      // Cloudflare 403s default agents on this host — same header connect.ts sends.
-      "User-Agent": target.userAgent,
-      "Content-Type": "application/json"
-    },
-    body: JSON.stringify(body)
-  });
-  if (!res.ok) throw new AgentLogHttpError(`${path}: ${res.status} ${res.statusText}`, res.status);
-  return await res.json();
-}
-async function reportAgentRun(target, run2) {
-  let ticketRecordId;
-  if (target.tickets && run2.ticketReference) {
+  /** Whether a live run on this ship holds `recordId`'s ticket lock. */
+  ticketInFlight(recordId) {
+    const file = this.path(`.${_State.safe(`crew-ticket-${recordId}`)}.lock`);
     try {
-      ticketRecordId = await findTicketRecord(target, target.tickets, run2.ticketReference);
+      const pid = Number.parseInt(readFileSync11(file, "utf8").trim(), 10);
+      if (!Number.isFinite(pid) || pid <= 0) return false;
+      process.kill(pid, 0);
+      return true;
     } catch {
+      return false;
     }
   }
-  const body = {
-    agentId: target.agentId,
-    ticketReference: run2.ticketReference,
-    outcome: run2.outcome,
-    startedAt: run2.startedAt,
-    finishedAt: run2.finishedAt,
-    source: "client",
-    client: "crew",
-    model: run2.model,
-    tokensIn: run2.tokensIn,
-    tokensOut: run2.tokensOut,
-    cacheReadTokens: run2.cacheReadTokens,
-    cacheWriteTokens: run2.cacheWriteTokens,
-    costUsd: run2.costUsd,
-    numTurns: run2.numTurns,
-    prefixTokens: run2.prefixTokens,
-    promptVersion: run2.promptVersion,
-    promptSha: run2.promptSha
-  };
-  const workItem = target.tickets && ticketRecordId ? { workItemTable: target.tickets.issuesModelId, workItemRecordId: ticketRecordId } : {};
-  let entry;
-  try {
-    entry = await post(target, "/agents/log", { ...body, ...workItem, harness: run2.harness, provider: run2.provider });
-  } catch (e) {
-    if (!(e instanceof AgentLogHttpError)) throw new AgentLogUnreachableError(e.message);
-    if (e.status >= 500) throw new AgentLogUnreachableError(e.message);
-    if (e.status !== 400 || !run2.harness && !run2.provider && !ticketRecordId) throw e;
-    entry = await post(target, "/agents/log", body);
-  }
-  for (const cycle of run2.cycles) {
-    await post(target, `/agents/log/${entry.id}/cycles`, {
-      cycleIndex: cycle.cycleIndex,
-      occurredAt: cycle.occurredAt,
-      thinking: cycle.thinking,
-      ...cycle.role ? { role: cycle.role } : {}
-    });
-  }
-  const counters = target.tickets && ticketRecordId ? await addRunToTicket(target, target.tickets, ticketRecordId, run2) : void 0;
-  return {
-    agentLogId: entry.id,
-    ...counters?.warning ? { counterWarning: counters.warning } : {},
-    ...counters?.retry ? { counterRetry: counters.retry } : {}
-  };
-}
-var isRetryable = (e) => !(e instanceof AgentLogHttpError) || e.status >= 500;
-async function writeCounters(target, w) {
-  const have = await columnsOf(target, w.issuesModelId);
-  const body = Object.fromEntries(Object.entries(w.body).filter(([column]) => have.has(column)));
-  if (Object.keys(body).length === 0) return;
-  await request(target, "PATCH", `/data-models/${w.issuesModelId}/records/${w.recordId}`, body);
-}
-async function addRunToTicket(target, t, recordId, run2) {
-  const write = {
-    issuesModelId: t.issuesModelId,
-    recordId,
-    ticketReference: run2.ticketReference,
-    counters: t.counters,
-    body: counterIncrements(run2, t.counters, new Set(Object.values(t.counters)))
-  };
-  try {
-    await writeCounters(target, write);
-    return {};
-  } catch (e) {
+  /**
+   * How many consecutive cycles the release phase has refused to deploy.
+   *
+   * Refusing is correct — a dirty tree or a non-main checkout must never be
+   * released — but it used to be SILENT, and eight commits once sat unreleased
+   * behind a single untracked file with nothing saying so (ISSUE-174). One
+   * blocked cycle is normal; the count is what makes a persistent one loud.
+   */
+  /**
+   * Release bookkeeping, scoped to one route.
+   *
+   * Scoped because a ship serves several boards and releases each repo
+   * independently (ISSUE-338). These were single global files, so a deploy
+   * failure on one route suppressed releases on every other one, and a
+   * release blocked in one repo counted cycles for all of them — a dirty tree
+   * in one checkout would have silently held up an unrelated project.
+   */
+  release(route) {
+    const suffix = _State.safe(route);
+    const blocked = `.release-blocked-${suffix}`;
+    const failed = `.deploy-failed-sha-${suffix}`;
+    const gateFailed = `.test-gate-failed-${suffix}`;
+    const gateReported = `.test-gate-reported-${suffix}`;
+    const heldReported = `.release-held-${suffix}`;
+    const read = (f) => {
+      try {
+        return readFileSync11(this.path(f), "utf8").trim() || null;
+      } catch {
+        return null;
+      }
+    };
     return {
-      warning: `could not add run spend to ${run2.ticketReference}: ${e.message}`,
-      ...isRetryable(e) ? { retry: write } : {}
+      blockedCount: () => Number.parseInt(read(blocked) ?? "", 10) || 0,
+      noteBlocked: () => {
+        const n = (Number.parseInt(read(blocked) ?? "", 10) || 0) + 1;
+        writeFileSync7(this.path(blocked), `${n}
+`);
+        return n;
+      },
+      clearBlocked: () => {
+        rmSync6(this.path(blocked), { force: true });
+      },
+      /**
+       * The commit a deploy last failed on.
+       *
+       * Without this the crew retries a broken deploy on every cycle — every
+       * two minutes, indefinitely — hammering the target and burying the
+       * original failure under identical ones. A failed commit is retried
+       * only when a NEW commit lands, or when an operator forces it by hand.
+       */
+      deployFailedSha: () => read(failed),
+      noteDeployFailed: (sha) => {
+        writeFileSync7(this.path(failed), `${sha}
+`);
+      },
+      clearDeployFailed: () => {
+        rmSync6(this.path(failed), { force: true });
+      },
+      /**
+       * Consecutive test-gate failures on the same head (CREW-1368). A failure
+       * on a new head restarts the count. Held on disk because one process is
+       * one cycle, and "failed three cycles running" only exists across them.
+       */
+      noteTestGateFailed: (sha) => {
+        const [prev, n] = (read(gateFailed) ?? "").split(" ");
+        const next = prev === sha ? (Number.parseInt(n ?? "", 10) || 0) + 1 : 1;
+        writeFileSync7(this.path(gateFailed), `${sha} ${next}
+`);
+        return next;
+      },
+      clearTestGateFailed: () => {
+        rmSync6(this.path(gateFailed), { force: true });
+      },
+      /** Whether the board was already told about this head's red gate. */
+      heldReported: () => {
+        try {
+          return readFileSync11(this.path(heldReported), "utf8").replace(/\n$/, "") || null;
+        } catch {
+          return null;
+        }
+      },
+      noteHeldReported: (signature) => {
+        writeFileSync7(this.path(heldReported), `${signature}
+`);
+      },
+      clearHeldReported: () => {
+        rmSync6(this.path(heldReported), { force: true });
+      },
+      testGateReported: (sha) => read(gateReported) === sha,
+      noteTestGateReported: (sha) => {
+        writeFileSync7(this.path(gateReported), `${sha}
+`);
+      }
     };
   }
-}
-var queueDir = (stateDir) => join12(stateDir, "pending-agent-logs");
-function queueAgentRun(stateDir, name, q) {
-  mkdirSync6(queueDir(stateDir), { recursive: true });
-  writeFileSync7(join12(queueDir(stateDir), `${name}.json`), JSON.stringify(q));
-}
-async function replayQueuedAgentRuns(stateDir, route, keyFor, log, now = /* @__PURE__ */ new Date()) {
-  const dir = queueDir(stateDir);
-  if (!existsSync11(dir)) return 0;
-  let sent = 0;
-  for (const f of readdirSync4(dir).filter((n) => n.endsWith(".json")).sort()) {
-    const path = join12(dir, f);
-    let q;
-    try {
-      q = JSON.parse(readFileSync11(path, "utf8"));
-    } catch {
-      continue;
-    }
-    if (q.version !== 1 || q.route !== route || now.toISOString() < q.nextAttemptAt) continue;
-    try {
-      const apiKey = await keyFor(q.role);
-      if (!apiKey) continue;
-      const sentRun = await reportAgentRun({ ...q.target, apiKey }, q.report);
-      if (sentRun.counterWarning) log.warn(sentRun.counterWarning);
-      if (sentRun.counterRetry) queueTicketCounters(stateDir, f.replace(/\.json$/, ""), {
-        version: 1,
-        route: q.route,
-        role: q.role,
-        target: q.target,
-        write: sentRun.counterRetry,
-        attempts: 0,
-        nextAttemptAt: (/* @__PURE__ */ new Date()).toISOString()
-      });
-      rmSync6(path, { force: true });
-      sent += 1;
-      log.emit(`sent a queued Agent Log report (${f})`);
-    } catch (e) {
-      if (!(e instanceof AgentLogUnreachableError)) {
-        rmSync6(path, { force: true });
-        log.warn(`dropped a queued Agent Log report (${f}): ${e.message}`);
-        continue;
+  /**
+   * Starvation bookkeeping, scoped to one route (ISSUE-382).
+   *
+   * `decideFleet` already renders the winner and each role's rank; what it
+   * throws away is the other side — a route that had work and did not
+   * win, and the same ticket sitting at the front of that route's queue
+   * cycle after cycle. This is state, not memory: a single process is one
+   * cycle, so "how long has this been waiting" only exists if it survives
+   * between them.
+   */
+  fairness(route) {
+    const suffix = _State.safe(route);
+    const streakFile = `.fairness-streak-${suffix}`;
+    const ticketFile = `.fairness-ticket-${suffix}`;
+    const sinceFile = `.fairness-since-${suffix}`;
+    const ticketStreakFile = `.fairness-ticket-streak-${suffix}`;
+    const read = (f) => {
+      try {
+        return readFileSync11(this.path(f), "utf8").trim() || null;
+      } catch {
+        return null;
       }
-      const attempts = q.attempts + 1;
-      writeFileSync7(path, JSON.stringify({
-        ...q,
-        attempts,
-        warned: true,
-        nextAttemptAt: new Date(now.getTime() + sleepBackoff(attempts)).toISOString()
-      }));
-      if (!q.warned) log.warn(`a queued Agent Log report could not be sent yet (${e.message}); will retry`);
-    }
-  }
-  return sent;
-}
-var countersDir = (stateDir) => join12(stateDir, "pending-ticket-counters");
-function queueTicketCounters(stateDir, name, q) {
-  mkdirSync6(countersDir(stateDir), { recursive: true });
-  writeFileSync7(join12(countersDir(stateDir), `${name}.json`), JSON.stringify(q));
-}
-async function replayQueuedTicketCounters(stateDir, route, keyFor, log, now = /* @__PURE__ */ new Date()) {
-  const dir = countersDir(stateDir);
-  if (!existsSync11(dir)) return 0;
-  let sent = 0;
-  for (const f of readdirSync4(dir).filter((n) => n.endsWith(".json")).sort()) {
-    const path = join12(dir, f);
-    let q;
-    try {
-      q = JSON.parse(readFileSync11(path, "utf8"));
-    } catch {
-      continue;
-    }
-    if (q.version !== 1 || q.route !== route || now.toISOString() < q.nextAttemptAt) continue;
-    try {
-      const apiKey = await keyFor(q.role);
-      if (!apiKey) continue;
-      await writeCounters({ ...q.target, apiKey }, q.write);
-      rmSync6(path, { force: true });
-      sent += 1;
-      log.emit(`added a queued run's spend to ${q.write.ticketReference ?? q.write.recordId} (${f})`);
-    } catch (e) {
-      if (!isRetryable(e)) {
-        rmSync6(path, { force: true });
-        log.warn(`dropped a queued ticket counter update (${f}): ${e.message}`);
-        continue;
+    };
+    const clear2 = () => {
+      for (const f of [streakFile, ticketFile, sinceFile, ticketStreakFile]) rmSync6(this.path(f), { force: true });
+    };
+    return {
+      /** Consecutive cycles this route had actionable work and did not win. */
+      streak: () => Number.parseInt(read(streakFile) ?? "", 10) || 0,
+      /**
+       * The ticket sitting at the front of this route's queue, how long
+       * it has been there and its own consecutive-passed-over count — or
+       * undefined if nothing is waiting.
+       */
+      waiting: () => {
+        const ticket = read(ticketFile);
+        const since2 = read(sinceFile);
+        if (!ticket || !since2) return void 0;
+        return { ticket, since: since2, streak: Number.parseInt(read(ticketStreakFile) ?? "", 10) || 0 };
+      },
+      /**
+       * Record what one cycle saw for this route: how many tickets were
+       * actionable, which one was most urgent, and whether this route
+       * won. Winning or running dry both reset the streak — there is nothing
+       * left being passed over.
+       */
+      record: (actionable, topTicket, won) => {
+        if (won || actionable === 0) {
+          clear2();
+          return;
+        }
+        writeFileSync7(this.path(streakFile), `${this.readInt(streakFile) + 1}
+`);
+        const prior = read(ticketFile);
+        if (topTicket && topTicket === prior) {
+          writeFileSync7(this.path(ticketStreakFile), `${this.readInt(ticketStreakFile) + 1}
+`);
+        } else if (topTicket) {
+          writeFileSync7(this.path(ticketFile), `${topTicket}
+`);
+          writeFileSync7(this.path(sinceFile), `${(/* @__PURE__ */ new Date()).toISOString()}
+`);
+          writeFileSync7(this.path(ticketStreakFile), "1\n");
+        }
       }
-      const attempts = q.attempts + 1;
-      writeFileSync7(path, JSON.stringify({
-        ...q,
-        attempts,
-        warned: true,
-        nextAttemptAt: new Date(now.getTime() + sleepBackoff(attempts)).toISOString()
-      }));
-      if (!q.warned) log.warn(`a queued ticket counter update could not be sent yet (${e.message}); will retry`);
-    }
+    };
   }
-  return sent;
-}
-
-// src/ticket-attribution.ts
-var TICKET_KEY_RE = /\b[A-Z][A-Z0-9]{1,9}-\d+\b/g;
-function ticketMentions(text) {
-  return [...text.matchAll(TICKET_KEY_RE)].map((m) => m[0]);
-}
-var TicketAttributionTracker = class {
-  #tokensByTicket = /* @__PURE__ */ new Map();
-  #turns = 0;
-  #current;
-  /** Tracker record uuid → ticket key, learned when a write names both (a claim resolves the key from the last mention). */
-  #keyByRecord = /* @__PURE__ */ new Map();
-  #lastBy = {};
   /**
-   * The ticket key most recently named in the transcript, or undefined before any.
-   * Only the FIRST key in a turn counts: a closing summary names its own
-   * ticket first and then lists others ("Other tickets", "Blocked by", "See
-   * also"), and those trailing keys are not what the run worked (CREW-2598).
+   * The previous cycle's "needs a person" set, scoped to one route
+   * (ISSUE-928) — `{ ticketId: [reason, ...] }`. `poll.ts` reads it once
+   * per cycle to compute transitions and the caller (`cli.ts`'s run path,
+   * `fleet.ts`'s per-route loop) persists the new set afterward, beside the
+   * existing `fairness(route).record(...)` call — never inside `decideCycle`
+   * itself, which does no writes. A corrupt or missing file reads as empty,
+   * which is also deliberately what a fresh install sees: everything
+   * currently needing a person emits once, rather than being silently
+   * skipped as though already notified.
    */
-  get current() {
-    return this.#current;
-  }
-  /** Record the mentions in `text` without crediting tokens (a claim needs "which ticket" before the turn's usage line arrives). */
-  note(text) {
-    const mentions = ticketMentions(text);
-    if (mentions.length > 0) this.#current = mentions[0];
+  attention(route) {
+    const file = `.attention-${_State.safe(route)}.json`;
+    return {
+      previous: () => {
+        try {
+          const parsed = JSON.parse(readFileSync11(this.path(file), "utf8"));
+          return parsed && typeof parsed === "object" ? parsed : {};
+        } catch {
+          return {};
+        }
+      },
+      persist: (next) => {
+        writeFileSync7(this.path(file), JSON.stringify(next));
+      }
+    };
   }
-  /** One assistant turn: its combined visible text (thinking + text blocks) and its own token cost. */
-  add(text, tokens) {
-    const mentions = ticketMentions(text);
-    if (mentions.length > 0) this.#current = mentions[0];
-    if (this.#current === void 0 || tokens <= 0) return;
-    this.#turns++;
-    this.#tokensByTicket.set(this.#current, (this.#tokensByTicket.get(this.#current) ?? 0) + tokens);
+  /**
+   * The previous cycle's unroutable ticket ids for one route (CREW-2548): open
+   * tickets with no repository that are not exempt. `poll.ts` diffs against it
+   * so each ticket warns once when it becomes unroutable, not every cycle; the
+   * caller persists the new set beside `attention(route).persist(...)`. A
+   * missing or corrupt file reads as empty, so a fresh install warns once.
+   */
+  unroutable(route) {
+    const file = `.unroutable-${_State.safe(route)}.json`;
+    return {
+      previous: () => {
+        try {
+          const parsed = JSON.parse(readFileSync11(this.path(file), "utf8"));
+          return Array.isArray(parsed) ? parsed.filter((x) => typeof x === "string") : [];
+        } catch {
+          return [];
+        }
+      },
+      persist: (next) => {
+        writeFileSync7(this.path(file), JSON.stringify(next));
+      }
+    };
   }
   /**
-   * Record a tool call if it is a ticket-targeted tracker write (claim,
-   * hand-off or comment). The ticket key comes from a record uuid seen on an
-   * earlier write when known, else from the key last named in the transcript
-   * (a claim or hand-off announces its ticket). A comment on a record never
-   * seen before is ignored: its uuid cannot be resolved to a key.
+   * Open ship-level attention items (CREW-1373), ship-wide rather than
+   * per-route: a parked role or a missing hook command is about this
+   * machine. A corrupt or missing file reads as empty.
    */
-  noteWrite(tool, input) {
-    const w = classifyWrite(tool, input);
-    if (!w) return;
-    let key = w.recordId ? this.#keyByRecord.get(w.recordId) : void 0;
-    if (w.kind !== "comment") key ??= this.#current;
-    if (!key) return;
-    if (w.kind !== "comment" && w.recordId) this.#keyByRecord.set(w.recordId, key);
-    this.#lastBy[w.kind] = key;
+  shipAttention() {
+    const file = ".ship-attention.json";
+    return {
+      previous: () => {
+        try {
+          const parsed = JSON.parse(readFileSync11(this.path(file), "utf8"));
+          return Array.isArray(parsed) ? parsed : [];
+        } catch {
+          return [];
+        }
+      },
+      persist: (next) => {
+        writeFileSync7(this.path(file), JSON.stringify(next));
+      }
+    };
   }
   /**
-   * How the attribution is decided: a hand-off write beats a claim, a claim
-   * beats a comment (so a follow-up ticket filed or commented on while
-   * working never displaces the claimed one), and any write beats everything
-   * below. Next, `hintMoved` — the post-run read-back showed the hinted
-   * ticket changed status or assignee during the run — is a hand-off signal
-   * for a run that wrote through MCP tools crew cannot see. Then the
-   * mention-token heuristic, which with a hint may override it only when a
-   * different ticket holds a strict majority of the credited tokens (a single
-   * credited turn, like a lone end-of-run summary naming another ticket,
-   * must not). A run with no hint
-   * keeps the plain winner. The pre-run hint is last.
+   * When the release phase last ran a cycle (CREW-1373), as the mtime of a
+   * marker file. `touch()` is called at the start and the end of every cycle
+   * so a long deploy does not read as a stopped timer.
    */
-  decide(hint, opts = {}) {
-    for (const by of ["handoff", "claim", "comment"]) {
-      const ticket = this.#lastBy[by];
-      if (ticket) return { ticket, by };
-    }
-    if (hint && opts.hintMoved) return { ticket: hint, by: "readback" };
-    if (this.#tokensByTicket.size > 0) {
-      if (!hint) return { ticket: this.winner(), by: "mentions" };
-      const winner = this.winner(hint);
-      if (winner === hint) return { ticket: hint, by: "mentions" };
-      let total = 0;
-      for (const n of this.#tokensByTicket.values()) total += n;
-      const share = (this.#tokensByTicket.get(winner) ?? 0) / total;
-      return share > 0.5 && this.#turns > 1 ? { ticket: winner, by: "mentions" } : { ticket: hint, by: "hint" };
+  releaseHeartbeat() {
+    const file = ".release-last-run";
+    return {
+      touch: () => {
+        writeFileSync7(this.path(file), (/* @__PURE__ */ new Date()).toISOString());
+      },
+      at: () => {
+        try {
+          return statSync4(this.path(file)).mtimeMs;
+        } catch {
+          return null;
+        }
+      }
+    };
+  }
+  readInt(file) {
+    try {
+      return Number.parseInt(readFileSync11(this.path(file), "utf8").trim(), 10) || 0;
+    } catch {
+      return 0;
     }
-    return { ticket: hint, by: "hint" };
   }
-  /**
-   * The ticket key the run spent the most tokens on, or `fallback` (the
-   * pre-run poll hint) when the transcript never named one — an
-   * administrative run that touches the tracker without discussing a
-   * specific ticket in its visible text still has to cite something.
-   */
-  winner(fallback) {
-    let best = fallback;
-    let bestTokens = -1;
-    for (const [ticket, tokens] of this.#tokensByTicket) {
-      if (tokens > bestTokens) {
-        best = ticket;
-        bestTokens = tokens;
-      }
-    }
-    return best;
+};
+
+// src/environment.ts
+import { basename as basename5 } from "path";
+var API_KEY_VAR = "CREW_API_KEY";
+function authorshipBullets(a, contract) {
+  if (!a) return [];
+  return [
+    ...a.issueAuthor ? [`- \`${contract.columns.author}\`: your own Crew row id, from "Your crew" above \u2014 who filed it`] : [],
+    ...a.issueShip && a.shipId ? [`- \`${contract.columns.ship}\`: \`${a.shipId}\` \u2014 this ship, where it was filed from`] : [],
+    ...a.commentShip && a.shipId ? [`- \`${contract.comments.ship}\` on every comment you post: \`${a.shipId}\` \u2014 this ship`] : []
+  ];
+}
+var HOOK_PURPOSE = [
+  ["setup", "make a fresh worktree usable \u2014 dependencies, generated clients"],
+  ["isolate", "point this worktree at state of its own; prints KEY=value overrides to export"],
+  ["ports", "this worktree's port assignments; prints KEY=value overrides to export"],
+  ["handoff", "leave the operator able to open what you built; put its output in your progress comment"],
+  ["test", "run the suite"],
+  ["build", "build it"],
+  ["ci_status", "after you push and before you hand off: exit 0 means CI is green for your branch; on failure fix and push again, and say in your progress comment if it is still pending"]
+];
+function hookTable(repo) {
+  const declared = HOOK_PURPOSE.filter(([name]) => repo.hooks[name]);
+  if (declared.length === 0) {
+    return "This repository declares no hooks. Do not guess commands for it \u2014 say so in your progress comment and stop.\n";
+  }
+  const inline = (cmd) => cmd.includes("\n") ? "_(below)_" : `\`${cmd}\``;
+  const blocks = declared.filter(([name]) => repo.hooks[name].includes("\n")).map(([name]) => [`### \`${name}\``, "", "```sh", repo.hooks[name].trimEnd(), "```", ""].join("\n"));
+  const undeclared = HOOK_PURPOSE.filter(([n]) => !repo.hooks[n]);
+  return [
+    "| hook | what it is for | what it runs |",
+    "| --- | --- | --- |",
+    ...declared.map(([name, purpose]) => `| \`${name}\` | ${purpose} | ${inline(repo.hooks[name])} |`),
+    "",
+    "Run these **verbatim**, from the worktree. They come from the repository's own",
+    "configuration, which is the only thing that knows them. A command you invented",
+    "yourself is wrong even when it works, because the next repository will differ.",
+    "",
+    ...blocks,
+    ...undeclared.length ? [`Not declared here, so there is nothing to run for them: ${undeclared.map(([n]) => `\`${n}\``).join(", ")}.`, ""] : []
+  ].join("\n");
+}
+function repoPrefix(repo) {
+  return repo.provenance["worktrees.prefix"] !== "default" ? repo.worktrees.prefix.replace(/-$/, "") : void 0;
+}
+function branchExample(repo, key) {
+  const prefix = repoPrefix(repo);
+  const template = effectiveBranchTemplate(repo, prefix);
+  return renderBranchName(template, { key, title: "Fix the widget", role: "dev", prefix, lowercase: repo.branch.lowercase });
+}
+function repoSection(r, key, heading) {
+  const repo = r.config;
+  const branchTemplate = effectiveBranchTemplate(repo, repoPrefix(repo));
+  const branchName = branchExample(repo, key);
+  const checkoutName = basename5(r.dir.replace(/[/\\]+$/, ""));
+  const worktreeName = effectiveWorktreeDirName(
+    repo,
+    r.dir,
+    branchName,
+    key.replace(/^\D+/, ""),
+    // The example ticket has no tag of its own, so `{issue}` is the key.
+    (template) => renderWorktreeName(template, { dir: checkoutName, key, title: "Fix the widget", role: "dev", prefix: repoPrefix(repo) })
+  );
+  const worktreePattern = repo.worktrees.name ?? (repo.provenance["worktrees.prefix"] !== "default" ? `${repo.worktrees.prefix}<number>` : `${checkoutName}-<branch>`);
+  const lines = [
+    "",
+    heading,
+    "",
+    `- Cut it from \`${repo.branch.base}\`, beside the checkout, at`,
+    `  \`../${worktreePattern}\` \u2014 for ${key} that is \`../${worktreeName}\`.`,
+    `- Name the branch the way this repository names branches: \`${branchTemplate}\``,
+    `  \u2014 for ${key} that is \`${branchName}\`.`,
+    "- Never work in the main checkout. It is the operator's, and the release phase",
+    "  uses it.",
+    "",
+    `${key} above is a placeholder, not a real ticket: this section is rendered`,
+    "before any ticket is chosen, so it cannot know a specific ticket's own",
+    "project prefix. Once you have a ticket, its digest row's `branch` and",
+    "`worktree` columns are the real, per-ticket values \u2014 use those verbatim",
+    "over this section's worked example if the two ever disagree."
+  ];
+  if (repo.worktrees.copy.length) {
+    lines.push(
+      "",
+      "A worktree is a clean checkout, so it is missing exactly the files git ignores.",
+      "Copy these across from the main checkout before running anything:",
+      "",
+      ...repo.worktrees.copy.map((c) => `- \`${c}\``)
+    );
+  }
+  if (repo.docs.designGuide) {
+    lines.push(
+      "",
+      "## This project's design brief",
+      "",
+      `\`${repo.docs.designGuide}\`, in the repository. Read it from the primary`,
+      "checkout before you `cd` into any worktree \u2014 a worktree cut from the base",
+      "branch only has it once it has been committed there."
+    );
   }
-};
-function isClaimWrite(tool, input) {
-  if (!tool || !/records_controller_update$/.test(tool)) return false;
-  const body = input?.body;
-  return typeof body === "object" && body !== null && body.status === "in_progress";
-}
-var HANDOFF_STATUSES = /* @__PURE__ */ new Set(["fixed", "verified", "needs_info", "accepted"]);
-function classifyWrite(tool, input) {
-  if (!tool) return void 0;
-  const body = input?.body;
-  if (typeof body !== "object" || body === null) return void 0;
-  const b = body;
-  if (/records_controller_update$/.test(tool)) {
-    const recordId = typeof input?.recordId === "string" ? input.recordId : void 0;
-    if (b.status === "in_progress" || b.status === "qa") return { kind: "claim", recordId };
-    if (typeof b.status === "string" && HANDOFF_STATUSES.has(b.status)) return { kind: "handoff", recordId };
+  if (repo.docs.triagePolicy) {
+    lines.push(
+      "",
+      "## This project's triage policy",
+      "",
+      `\`${repo.docs.triagePolicy}\`, in the repository. Where it and any brief`,
+      "disagree about what a status means or when a ticket may be accepted, the",
+      "policy document wins: it is the project's own decision, and the brief is",
+      "shared with projects that decided differently."
+    );
   }
-  if (/records_controller_create$/.test(tool) && typeof b.ticket_id === "string") return { kind: "comment", recordId: b.ticket_id };
-  return void 0;
-}
-
-// src/handoff-transcript.ts
-var TRANSPORT_FAILURE = /\b50[0-4]\b|<!doctype|<html|unexpected token '?<|fetch failed|econn(reset|refused)|etimedout|socket hang up|timed out|bad gateway|service unavailable/i;
-function resultText(content) {
-  if (typeof content === "string") return content;
-  if (Array.isArray(content)) return content.map((c) => c && typeof c.text === "string" ? c.text : "").join("\n");
-  return "";
+  return lines;
 }
-function isTransportFailure(isError, text) {
-  if (!isError) {
-    try {
-      const doc = JSON.parse(text);
-      if (doc && typeof doc === "object") {
-        const code = doc.statusCode;
-        return typeof code === "number" && code >= 500;
-      }
-    } catch {
+function renderEnvironment(i) {
+  const { route, contract } = i;
+  const repos = i.repos;
+  const only = repos.length === 1 ? repos[0] : void 0;
+  const models = route.resolved?.models;
+  const epicsModelId = route.resolved?.epicsModelId;
+  const mediaLibraryModelId = i.attachments?.mediaLibraryModelId ?? null;
+  const key = "ISSUE-000";
+  const lines = [
+    "# Your environment",
+    "",
+    "Supplied by the crew for THIS run. The brief below is shared by every project",
+    "the crew works on and deliberately names nothing specific; this section is where",
+    "those names come from. Where the two appear to disagree, this section wins.",
+    "",
+    "## The board",
+    "",
+    `- Base URL: \`${route.baseUrl}\``,
+    `- Your key is in the \`${API_KEY_VAR}\` environment variable. Send it as`,
+    `  \`Authorization: Bearer $${API_KEY_VAR}\`. **Do not read it out of any file**,`,
+    "  and never write it into a comment, a commit or a log line.",
+    `- Send \`User-Agent: ${i.userAgent}\` on every request.`
+  ];
+  if (models) {
+    lines.push(
+      "",
+      "Tables, by id \u2014 use these directly rather than listing the workspace to find them:",
+      "",
+      `- Issues: \`${models.issues}\``,
+      `- Comments: \`${models.comments}\``,
+      `- Crew: \`${models.crew}\``,
+      ...epicsModelId ? [`- Epics: \`${epicsModelId}\``] : [],
+      ...mediaLibraryModelId ? [`- Media Library: \`${mediaLibraryModelId}\` (what a ticket's \`${contract.columns.attachments}\` ids point into)`] : []
+    );
+  }
+  const workspaceId = route.resolved?.workspaceId;
+  if (workspaceId) {
+    const base = route.baseUrl.replace(/\/+$/, "");
+    lines.push(
+      "",
+      `- Workspace id: \`${workspaceId}\``,
+      "",
+      "## Attaching a file to a comment",
+      "",
+      "A screenshot or mockup goes on a comment's `attachments` field, which holds",
+      "Media Library record ids, not URLs. Upload the file first, then put the",
+      "returned `id` in the comment's `attachments` array:",
+      "",
+      "```sh",
+      `curl -s -H "Authorization: Bearer $${API_KEY_VAR}" -H "User-Agent: ${i.userAgent}" \\`,
+      `  -X POST "${base}/api/workspaces/${workspaceId}/files" \\`,
+      '  -F "file=@shot.png;type=image/png" -F targetMediaLibrary=true',
+      "```",
+      "",
+      "The response is JSON with `id` and `storageKey`. `targetMediaLibrary=true`",
+      "means no field type id has to be looked up. If the upload fails, post the HTTP",
+      "status and response body in your comment \u2014 do not write that uploads are",
+      "impossible."
+    );
+    if (mediaLibraryModelId) {
+      lines.push(
+        "",
+        "## Opening a ticket's attachments",
+        "",
+        `A ticket's or a comment's \`${contract.columns.attachments}\` value is a list of Media Library`,
+        "**record ids** \u2014 not file ids and not URLs. `files/<id>`, `files/<id>/download` and",
+        "`media-library/<id>/...` do not exist for such an id and return 404. For each id,",
+        "read the record, then fetch the file by its storage key:",
+        "",
+        "```sh",
+        `curl -s -H "Authorization: Bearer $${API_KEY_VAR}" -H "User-Agent: ${i.userAgent}" \\`,
+        `  "${base}/api/workspaces/${workspaceId}/data-models/${mediaLibraryModelId}/records/<attachment id>"`,
+        '# \u2192 JSON with `storage_key` ("<uuid>/<filename>") and `mime_type`',
+        `curl -s -o <scratch dir>/<filename> -H "Authorization: Bearer $${API_KEY_VAR}" -H "User-Agent: ${i.userAgent}" \\`,
+        `  "${base}/api/workspaces/${workspaceId}/files/<storage_key>"`,
+        "```",
+        "",
+        "The MCP forms are `records_controller_find_one` (`dataModelId` = the Media Library",
+        "id above) and `files_controller_download` (`uuid` and `filename` = the two halves",
+        "of the storage key). Save the file outside the repository and open it; where it",
+        "disagrees with the description, the picture is the reproduction."
+      );
     }
   }
-  return TRANSPORT_FAILURE.test(text);
-}
-var HandoffTranscriptTracker = class {
-  open = /* @__PURE__ */ new Map();
-  /** Per ticket record: the last hand-off status write's outcome. */
-  status = /* @__PURE__ */ new Map();
-  /** Per ticket record: the last hand-off comment that failed after the status write's turn. */
-  comment = /* @__PURE__ */ new Map();
-  landed = /* @__PURE__ */ new Set();
-  lastText = "";
-  resultLine = "";
-  feed(parsed) {
-    const line = parsed;
-    if (!line || typeof line !== "object") return;
-    if (line.type === "result" && typeof line.result === "string") this.resultLine = line.result;
-    const content = line.message?.content;
-    if (!Array.isArray(content)) return;
-    for (const b of content) {
-      if (line.type === "assistant" && b.type === "text" && b.text?.trim()) this.lastText = b.text.trim();
-      else if (line.type === "assistant" && b.type === "tool_use" && b.id) {
-        const w = classifyWrite(b.name, b.input);
-        const body = b.input?.body;
-        if (w?.recordId && (w.kind === "handoff" || w.kind === "comment") && body && typeof body === "object") {
-          this.open.set(b.id, { kind: w.kind, recordId: w.recordId, body });
-        }
-      } else if (line.type === "user" && b.type === "tool_result" && b.tool_use_id) {
-        const w = this.open.get(b.tool_use_id);
-        if (!w) continue;
-        this.open.delete(b.tool_use_id);
-        const failed = isTransportFailure(b.is_error === true, resultText(b.content));
-        if (w.kind === "handoff") this.status.set(w.recordId, { ok: !failed, patch: w.body });
-        else if (failed && typeof w.body.body === "string") this.comment.set(w.recordId, w.body.body);
-        else if (!failed) {
-          this.comment.delete(w.recordId);
-          this.landed.add(w.recordId);
-        }
-      }
+  if (i.shipName) {
+    lines.push(
+      "",
+      "## Ships",
+      "",
+      `This run is on the ship **${i.shipName}**. When a comment names a ship \u2014 this one or`,
+      "another (the digest prints other ships by name) \u2014 write its name, never a Ships row id."
+    );
+  }
+  const seatIds = Object.entries(route.resolved?.seats ?? {}).filter(([, id]) => !!id);
+  if (seatIds.length > 0) {
+    lines.push(
+      "",
+      "## Seats on this ship",
+      "",
+      "The Crew row id of each role's seat on this ship, to write verbatim where a hand-off",
+      "assigns the next lane (a ticket whose digest `mode` is `hybrid`):",
+      "",
+      ...seatIds.map(([role, id]) => `- ${role}: \`${id}\``)
+    );
+  }
+  lines.push(
+    "",
+    "## What the columns are called here",
+    "",
+    "Every workspace names these itself. Use these names, not the ones you would",
+    "guess, and not the ones another project used.",
+    "",
+    "| meaning | column |",
+    "| --- | --- |",
+    `| ticket key | \`${contract.columns.key}\` |`,
+    `| status | \`${contract.columns.status}\` |`,
+    `| assignee | \`${contract.columns.assignee}\` |`,
+    `| severity | \`${contract.columns.severity}\` |`,
+    `| priority | \`${contract.columns.priority}\` |`,
+    `| blocked by | \`${contract.columns.blockedBy}\` |`,
+    `| needs design | \`${contract.columns.needsDesign}\` |`,
+    `| project | \`${contract.columns.slice}\` |`,
+    `| repo | \`${contract.columns.repo}\` |`,
+    ...epicsModelId ? [`| epic | \`${contract.columns.epic}\` |`] : [],
+    "",
+    ...epicsModelId ? [
+      "An epic is a body of work a ticket belongs to. Set it when a ticket clearly",
+      "fits an existing epic; proposing a new one is a taxonomy decision \u2014 leave it",
+      "to a person rather than inventing one yourself.",
+      "",
+      "An epic's own status is kept by the crew runner, from its tickets: done once",
+      "every one of them is closed, in progress while any is being worked. Do not",
+      "set it yourself.",
+      ""
+    ] : [],
+    "Statuses that matter to you:",
+    "",
+    `- Work you may pick up: \`${contract.statuses.approved}\``,
+    `- While you are working it: \`${contract.statuses.building}\``,
+    `- When you hand it on to be checked: \`${contract.statuses.handoff}\``,
+    `- Being checked: \`${contract.statuses.verifying}\``,
+    `- Waiting on a person to answer something: \`${contract.statuses.needsHuman}\``,
+    `- Parked on an unresolved dependency, set by the crew and not by you: \`${contract.statuses.parked}\``,
+    "",
+    `\`${contract.statuses.verified}\` and the closed statuses are **never yours to set**.`
+  );
+  const areaId = route.resolved?.areaId;
+  if (areaId || repos.some((r) => r.id)) {
+    lines.push(
+      "",
+      "## Filing a new ticket",
+      "",
+      "Something broken that is out of scope for the ticket you are working is not",
+      "yours to fix inline \u2014 file it as its own new ticket instead, and keep working",
+      "the one you were on. A ticket filed without its project and repo sits unrouted",
+      "until a person notices and fixes it by hand, so always set:",
+      "",
+      ...areaId ? [`- \`${contract.columns.slice}\`: \`${areaId}\` (this route's project, for every ticket you file)`] : [],
+      ...only?.id ? [`- \`${contract.columns.repo}\`: \`${only.id}\` (this repository)`] : repos.filter((r) => r.id).map(
+        (r) => `- \`${contract.columns.repo}\`: \`${r.id}\` \u2014 when the new ticket belongs to ${r.name}`
+      ),
+      ...authorshipBullets(i.authorship, contract),
+      "",
+      ...i.sourceTicket ? [
+        `Name ${i.sourceTicket} \u2014 the ticket you were working when you noticed this \u2014 in the new`,
+        "ticket's description. Only put it in the new ticket's `blockedBy` if your own ticket",
+        "genuinely cannot proceed without the new one being fixed first; merely having noticed it",
+        "nearby is not a dependency.",
+        ""
+      ] : []
+    );
+  }
+  if (only) {
+    lines.push(...repoSection(only, key, "## Your worktree"));
+  } else {
+    lines.push(
+      "",
+      "## The repositories this board covers",
+      "",
+      "This board spans several repositories, and they do not share a branch name,",
+      "a worktree location or a test command. **The `repo` column of your queue",
+      "says which one your ticket belongs to** \u2014 read the section for THAT one and",
+      "ignore the others. A ticket whose repo is not listed here has no checkout on",
+      "this machine and is not yours to work."
+    );
+    for (const r of repos) {
+      lines.push(...repoSection(r, key, `### ${r.name} \u2014 \`${r.dir}\``));
+      lines.push("", `Hooks for ${r.name} \u2014 the only commands you should run here:`, "", hookTable(r.config));
     }
   }
-  /** The hand-off that did not land, or null when every hand-off write succeeded (or none was tried). */
-  pending() {
-    const failed = [...this.status].filter(([, s2]) => !s2.ok).at(-1);
-    if (!failed) return null;
-    const [ticketRecordId, s] = failed;
-    return {
-      ticketRecordId,
-      patch: s.patch,
-      ...this.comment.has(ticketRecordId) ? { comment: this.comment.get(ticketRecordId) } : {},
-      ...this.landed.has(ticketRecordId) ? { commentLanded: true } : {},
-      finalText: this.lastText || this.resultLine
-    };
+  if (i.repoDir) {
+    lines.push("", `This ticket's work happens in \`${i.repoDir}\`.`);
   }
-};
-
-// src/pending-handoff.ts
-import { existsSync as existsSync15, mkdirSync as mkdirSync8, readdirSync as readdirSync6, readFileSync as readFileSync13, rmSync as rmSync8, writeFileSync as writeFileSync9 } from "fs";
-import { join as join16 } from "path";
-
-// src/ticket-branch.ts
-import { basename as basename6 } from "path";
-
-// src/tracker.ts
-import { hostname } from "os";
-import { TablationClient } from "@tablation/client";
+  if (only) lines.push("", "## Hooks \u2014 the only commands you should run", "", hookTable(only.config));
+  return lines.join("\n");
+}
 
-// src/state.ts
-import { readFileSync as readFileSync12, writeFileSync as writeFileSync8, existsSync as existsSync12, mkdirSync as mkdirSync7, rmSync as rmSync7, statSync as statSync4, readdirSync as readdirSync5 } from "fs";
-import { join as join13 } from "path";
-var EPOCH = "1970-01-01T00:00:00.000Z";
-var State = class _State {
-  dir;
-  constructor(dir) {
-    this.dir = dir;
-    mkdirSync7(dir, { recursive: true });
-  }
-  path(...parts) {
-    return join13(this.dir, ...parts);
-  }
-  /**
-   * The timestamp every "new since last poll" check is measured against.
-   *
-   * Read once per cycle and advanced only AFTER every role has been
-   * evaluated: bumping it inside the first role's check would hide that
-   * role's new comments from the second.
-   */
-  watermark() {
-    try {
-      const v = readFileSync12(this.path(".poll-watermark"), "utf8").trim();
-      return v || EPOCH;
-    } catch {
-      return EPOCH;
-    }
-  }
-  setWatermark(at) {
-    writeFileSync8(this.path(".poll-watermark"), `${at}
-`);
+// src/contract.ts
+var DEFAULT_CONTRACT = {
+  columns: {
+    key: "issue_id",
+    tag: "issue_tag",
+    title: "title",
+    status: "status",
+    assignee: "assignee_id",
+    priority: "priority",
+    severity: "severity",
+    slice: "project_id",
+    repo: "repo_id",
+    parent: "parent_id",
+    blockedBy: "blocked_by",
+    updatedAt: "updated_at",
+    needsDesign: "needs_design",
+    attachments: "attachments",
+    workMode: "work_mode",
+    reportType: "report_type",
+    epic: "epic_id",
+    author: "filed_by_id",
+    ship: "ship_id",
+    heldBy: "held_by_ship_id",
+    resolutionNote: "resolution_note",
+    verifiedSha: "verified_sha",
+    prRef: "pr_ref",
+    externalId: "external_id",
+    position: "position",
+    agentRuns: "agent_runs",
+    tokensIn: "tokens_in",
+    tokensOut: "tokens_out",
+    cacheReadTokens: "cache_read_tokens",
+    cacheWriteTokens: "cache_write_tokens",
+    costUsd: "cost_usd"
+  },
+  comments: {
+    parent: "ticket_id",
+    body: "body",
+    author: "team_member_id",
+    createdAt: "created_at",
+    ship: "ship_id",
+    publicReply: "is_public_reply",
+    authorName: "author_name"
+  },
+  statuses: {
+    open: ["new", "accepted", "blocked", "in_progress", "needs_info", "fixed", "qa", "verified"],
+    resolved: [
+      "verified",
+      "closed_deployed",
+      "closed_wont_fix",
+      "closed_duplicate",
+      "closed_completed",
+      "closed_cant_reproduce"
+    ],
+    approved: "accepted",
+    parked: "blocked",
+    building: "in_progress",
+    handoff: "fixed",
+    verifying: "qa",
+    verified: "verified",
+    deployed: "closed_deployed",
+    needsHuman: "needs_info",
+    reviewing: null,
+    wontFix: "closed_wont_fix",
+    draft: "draft"
+  },
+  epics: {
+    statusColumn: "status",
+    keyColumn: "epic_id",
+    statuses: { planned: "planned", building: "in_progress", done: "done", cancelled: "cancelled" }
+  },
+  priorityOrder: ["p0", "p1", "p2", "p3"],
+  severityOrder: ["s1", "s2", "s3", "s4"],
+  unknownPriorityRank: 2,
+  coordinatingValue: "coordinating",
+  manualWorkMode: "manual",
+  hybridWorkMode: "hybrid",
+  repoExemptReportTypes: ["coordinating", "question", "investigation"]
+};
+function closedStatuses(c) {
+  return c.statuses.resolved.filter((s) => s !== c.statuses.verified);
+}
+function resolveContract(override) {
+  if (!override) return DEFAULT_CONTRACT;
+  return {
+    columns: { ...DEFAULT_CONTRACT.columns, ...override.columns },
+    comments: { ...DEFAULT_CONTRACT.comments, ...override.comments },
+    statuses: { ...DEFAULT_CONTRACT.statuses, ...override.statuses },
+    epics: {
+      ...DEFAULT_CONTRACT.epics,
+      ...override.epics,
+      statuses: { ...DEFAULT_CONTRACT.epics.statuses, ...override.epics?.statuses }
+    },
+    priorityOrder: override.priorityOrder ?? DEFAULT_CONTRACT.priorityOrder,
+    severityOrder: override.severityOrder ?? DEFAULT_CONTRACT.severityOrder,
+    unknownPriorityRank: override.unknownPriorityRank ?? DEFAULT_CONTRACT.unknownPriorityRank,
+    coordinatingValue: override.coordinatingValue ?? DEFAULT_CONTRACT.coordinatingValue,
+    manualWorkMode: override.manualWorkMode ?? DEFAULT_CONTRACT.manualWorkMode,
+    hybridWorkMode: override.hybridWorkMode ?? DEFAULT_CONTRACT.hybridWorkMode,
+    // A workspace overriding `coordinatingValue` alone (renaming the rollup
+    // marker) still gets that renamed value exempted here by default,
+    // without also having to repeat it — only an explicit
+    // `repoExemptReportTypes` overrides this derived default.
+    repoExemptReportTypes: override.repoExemptReportTypes ?? (override.coordinatingValue ? [override.coordinatingValue, "question", "investigation"] : DEFAULT_CONTRACT.repoExemptReportTypes)
+  };
+}
+function validateContract(c) {
+  const problems = [];
+  const open = new Set(c.statuses.open);
+  const resolved = new Set(c.statuses.resolved);
+  for (const role of ["approved", "parked", "building", "handoff", "verifying", "needsHuman"]) {
+    const v = c.statuses[role];
+    if (!open.has(v)) problems.push(`statuses.${role} ("${v}") is not listed in statuses.open`);
   }
-  /**
-   * Advance to the newest thing this cycle actually saw, never to "now".
-   *
-   * Using the clock would silently skip any comment written between the fetch
-   * and the write — a race that loses work rather than repeating it, which is
-   * the wrong way round. Repeating a cycle is free; missing one is not.
-   */
-  advanceWatermark(seen) {
-    const stamps = seen.flatMap((s) => [s.created_at, s.updated_at]).filter((v) => typeof v === "string" && v.length > 0);
-    const next = stamps.length ? stamps.reduce((a, b) => a > b ? a : b) : this.watermark();
-    this.setWatermark(next);
-    return next;
+  if (c.statuses.reviewing && !open.has(c.statuses.reviewing)) {
+    problems.push(`statuses.reviewing ("${c.statuses.reviewing}") is not listed in statuses.open`);
   }
-  /** Whole-crew pause, and the per-role sentinels one level down. */
-  isPaused() {
-    return existsSync12(this.path(".crew-paused"));
+  if (!resolved.has(c.statuses.deployed)) {
+    problems.push(`statuses.deployed ("${c.statuses.deployed}") is not listed in statuses.resolved`);
   }
-  isRolePaused(role) {
-    return existsSync12(this.path(`.role-paused-${role}`));
+  if (resolved.has(c.statuses.handoff)) {
+    problems.push(
+      `statuses.handoff ("${c.statuses.handoff}") is listed as resolved \u2014 it means built-but-unchecked, so a ticket blocked by it is still blocked; calling it resolved would build on unverified work`
+    );
   }
-  pausedRoles(roles) {
-    return new Set(roles.filter((r) => this.isRolePaused(r)));
+  if (!resolved.has(c.statuses.wontFix)) {
+    problems.push(`statuses.wontFix ("${c.statuses.wontFix}") is not listed in statuses.resolved`);
   }
-  pause(role) {
-    writeFileSync8(role ? this.path(`.role-paused-${role}`) : this.path(".crew-paused"), "");
+  if (c.statuses.reviewing && resolved.has(c.statuses.reviewing)) {
+    problems.push(
+      `statuses.reviewing ("${c.statuses.reviewing}") is listed as resolved \u2014 it is unmerged work under review, so a ticket blocked by it is still blocked`
+    );
   }
-  resume(role) {
-    rmSync7(role ? this.path(`.role-paused-${role}`) : this.path(".crew-paused"), { force: true });
+  if (resolved.has(c.statuses.approved)) {
+    problems.push(`statuses.approved ("${c.statuses.approved}") is listed as resolved`);
   }
-  /**
-   * The release phase (merge, deploy, release) has its own sentinel, one
-   * level below the whole-crew pause: `crew pause release` stops shipping
-   * while agents keep working.
-   */
-  isReleasePaused() {
-    return existsSync12(this.path(".release-paused"));
+  if (c.statuses.parked === c.statuses.approved) {
+    problems.push("statuses.parked and statuses.approved are the same value \u2014 parking would be a no-op");
   }
-  setReleasePaused(paused) {
-    if (paused) writeFileSync8(this.path(".release-paused"), "");
-    else rmSync7(this.path(".release-paused"), { force: true });
+  const epicValues = Object.values(c.epics.statuses);
+  if (new Set(epicValues).size !== epicValues.length) {
+    problems.push("epics.statuses names the same value twice \u2014 the epic sync could not tell those states apart");
   }
-  /**
-   * Why a release cycle must not run right now, or null when it may. Every
-   * release entry point checks this first — the release timer, `crew release`,
-   * `crew merge`, `crew deploy` and the inline release a `run` cycle used to
-   * do — so a paused ship cannot merge, deploy, or file release alerts.
-   * A release already in flight when the pause lands finishes; only new
-   * cycles are refused.
-   */
-  releaseSkipReason() {
-    if (this.isPaused()) return "the crew is paused";
-    if (this.isReleasePaused()) return "releases are paused";
-    return null;
+  if (c.priorityOrder.length === 0) problems.push("priorityOrder is empty");
+  if (c.severityOrder.length === 0) problems.push("severityOrder is empty");
+  for (const [name, order] of [["priorityOrder", c.priorityOrder], ["severityOrder", c.severityOrder]]) {
+    if (new Set(order).size !== order.length) problems.push(`${name} contains duplicates`);
   }
-  /**
-   * Take an exclusive lock, or report who holds it.
-   *
-   * A timer fires every couple of minutes and an agent run takes minutes, so
-   * overlapping fires are certain rather than hypothetical — and two agents
-   * on one checkout would fight over the same worktree and the same tickets.
-   *
-   * A lock naming a DEAD pid is stale and taken over: a run killed mid-cycle
-   * (a reboot, a Ctrl-C) must not wedge the crew until someone notices.
-   */
-  /**
-   * Lock names become filenames, so anything that could be read as a path has
-   * to go. A scope like `route/repo` otherwise produced
-   * `.release-route/repo.lock` — a write into a directory that does not exist.
-   */
-  static safe(name) {
-    return name.replace(/[^A-Za-z0-9_-]/g, "_");
+  return problems;
+}
+var EVENT_LOG_MISSING = "the Issues table has no event log \u2014 crew writes its audit trail there (CREW-1574). In the app, open the Issues table's Data & lifecycle tab and turn on Event log, then rerun.";
+
+// src/agent-log.ts
+import { existsSync as existsSync12, mkdirSync as mkdirSync7, readdirSync as readdirSync5, readFileSync as readFileSync12, rmSync as rmSync7, writeFileSync as writeFileSync8 } from "fs";
+import { join as join13 } from "path";
+
+// src/pending-backoff.ts
+var sleepBackoff = (attempts) => Math.min(6e4 * 2 ** Math.max(0, attempts - 1), 30 * 6e4);
+
+// src/agent-log.ts
+var AgentLogUnreachableError = class extends Error {
+};
+var AgentLogHttpError = class extends Error {
+  status;
+  /** True when the refusal was of the Agent Log row itself (not a later cycle post): the tracker is not taking this seat's reports (CREW-2832). */
+  row = false;
+  constructor(message, status2) {
+    super(message);
+    this.status = status2;
   }
-  acquire(rawName) {
-    const name = _State.safe(rawName);
-    const file = this.path(`.${name}.lock`);
-    try {
-      const existing = Number.parseInt(readFileSync12(file, "utf8").trim(), 10);
-      if (Number.isFinite(existing) && existing > 0) {
-        try {
-          process.kill(existing, 0);
-          return { ok: false, heldBy: existing };
-        } catch {
-        }
-      }
-    } catch {
-    }
-    writeFileSync8(file, `${process.pid}
-`);
-    return {
-      ok: true,
-      release: () => {
-        try {
-          rmSync7(file, { force: true });
-        } catch {
-        }
-      }
-    };
+};
+async function request(target, method, path, body) {
+  const url = `${target.baseUrl.replace(/\/+$/, "")}/api${path}`;
+  const res = await fetch(url, {
+    method,
+    headers: {
+      Authorization: `Bearer ${target.apiKey}`,
+      "User-Agent": target.userAgent,
+      ...body === void 0 ? {} : { "Content-Type": "application/json" }
+    },
+    body: body === void 0 ? void 0 : JSON.stringify(body)
+  });
+  if (!res.ok) throw new AgentLogHttpError(`${path}: ${res.status} ${res.statusText}`, res.status);
+  return await res.json();
+}
+var issueColumns = /* @__PURE__ */ new Map();
+function columnsOf(target, modelId) {
+  const key = `${target.baseUrl}|${target.workspaceId}|${modelId}`;
+  let p = issueColumns.get(key);
+  if (!p) {
+    p = request(target, "GET", `/data-models/${modelId}`).then((m) => new Set((m.fields ?? []).map((f) => f.columnName)));
+    p.catch(() => issueColumns.delete(key));
+    issueColumns.set(key, p);
   }
-  /**
-   * Whether a release is running right now: any `.release-<scope>.lock` in the
-   * state directory naming a live process (the locks `releasePhase` takes per
-   * scope). A lock naming a dead pid is ignored, as `acquire` ignores it.
-   */
-  releaseInProgress() {
-    let names;
+  return p;
+}
+async function findTicketRecord(target, t, ref) {
+  const filters = {
+    combinator: "OR",
+    conditions: [
+      { columnName: t.keyColumn, operator: "EQ", value: ref },
+      { columnName: t.tagColumn, operator: "EQ", value: ref }
+    ]
+  };
+  const rows = await request(
+    target,
+    "GET",
+    `/data-models/${t.issuesModelId}/records?limit=2&filters=${encodeURIComponent(JSON.stringify(filters))}`
+  );
+  return rows.length === 1 ? rows[0].id : void 0;
+}
+function counterIncrements(run2, cols, have) {
+  const figures = [
+    [cols.agentRuns, 1],
+    [cols.tokensIn, run2.tokensIn],
+    [cols.tokensOut, run2.tokensOut],
+    [cols.cacheReadTokens, run2.cacheReadTokens],
+    [cols.cacheWriteTokens, run2.cacheWriteTokens],
+    [cols.costUsd, run2.costUsd]
+  ];
+  const out = {};
+  for (const [column, value2] of figures) {
+    if (value2 !== void 0 && Number.isFinite(value2) && have.has(column)) out[column] = { $op: "increment", value: value2 };
+  }
+  return out;
+}
+async function post(target, path, body) {
+  const url = `${target.baseUrl.replace(/\/+$/, "")}/api/workspaces/${target.workspaceId}${path}`;
+  const res = await fetch(url, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${target.apiKey}`,
+      // Cloudflare 403s default agents on this host — same header connect.ts sends.
+      "User-Agent": target.userAgent,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(body)
+  });
+  if (!res.ok) throw new AgentLogHttpError(`${path}: ${res.status} ${res.statusText}`, res.status);
+  return await res.json();
+}
+async function reportAgentRun(target, run2) {
+  let ticketRecordId;
+  if (target.tickets && run2.ticketReference) {
     try {
-      names = readdirSync5(this.dir);
+      ticketRecordId = await findTicketRecord(target, target.tickets, run2.ticketReference);
     } catch {
-      return false;
-    }
-    for (const n of names) {
-      if (!/^\.release-.+\.lock$/.test(n)) continue;
-      let pid = 0;
-      try {
-        pid = Number.parseInt(readFileSync12(this.path(n), "utf8").trim(), 10);
-      } catch {
-        continue;
-      }
-      if (!Number.isFinite(pid) || pid <= 0) continue;
-      try {
-        process.kill(pid, 0);
-        return true;
-      } catch {
-      }
-    }
-    return false;
-  }
-  /**
-   * Like `acquire`, but for a resource with `max` interchangeable slots
-   * rather than one exclusive holder — this machine's overall concurrency
-   * capacity (ISSUE-381), which nothing needs to name a particular slot to
-   * use. Takes whichever numbered slot is free first.
-   */
-  acquireN(rawPrefix, max) {
-    const heldBy = [];
-    for (let i = 1; i <= max; i++) {
-      const got = this.acquire(`${rawPrefix}-${i}`);
-      if (got.ok) return got;
-      heldBy.push(got.heldBy);
     }
-    return { ok: false, heldBy };
   }
-  /**
-   * The run lock (ISSUE-381, CREW-2821): role-capped AND capacity-limited,
-   * checked together.
-   *
-   * Two sessions of one role must never take the same ticket. Before
-   * CREW-2821 that was guaranteed by an exclusive per-role lock; now the
-   * guarantee is the per-ticket lock (`acquireTicket`), so the role lock is a
-   * counted one: `roleMax` interchangeable slots, default 1. Slot 1 keeps the
-   * historical name `crew-role-<role>` (crew-macos reads it for the live pid),
-   * further slots are `crew-role-<role>-<n>`. `max` is this machine's separate
-   * limit on how many runs of ANY role may overlap; a role that clears its own
-   * lock but finds every slot taken must give its role lock back, or a
-   * locked-but-not-running role would wedge itself out for the rest of the
-   * machine's uptime.
-   */
-  acquireRun(role, max, roleMax = 1) {
-    let roleLock;
-    const roleHolders = [];
-    for (let i = 1; i <= roleMax; i++) {
-      const got = this.acquire(i === 1 ? `crew-role-${role}` : `crew-role-${role}-${i}`);
-      if (got.ok) {
-        roleLock = got;
-        break;
-      }
-      roleHolders.push(got.heldBy);
-    }
-    if (!roleLock) {
-      return {
-        ok: false,
-        reason: roleMax === 1 ? `${role} is already running (pid ${roleHolders[0]})` : `${role} is already running ${roleMax} agents (its roleConcurrency cap; pid${roleHolders.length > 1 ? "s" : ""} ${[...new Set(roleHolders)].join(", ")})`
-      };
+  const body = {
+    agentId: target.agentId,
+    ticketReference: run2.ticketReference,
+    outcome: run2.outcome,
+    startedAt: run2.startedAt,
+    finishedAt: run2.finishedAt,
+    source: "client",
+    client: "crew",
+    model: run2.model,
+    tokensIn: run2.tokensIn,
+    tokensOut: run2.tokensOut,
+    cacheReadTokens: run2.cacheReadTokens,
+    cacheWriteTokens: run2.cacheWriteTokens,
+    costUsd: run2.costUsd,
+    numTurns: run2.numTurns,
+    prefixTokens: run2.prefixTokens,
+    promptVersion: run2.promptVersion,
+    promptSha: run2.promptSha
+  };
+  const workItem = target.tickets && ticketRecordId ? { workItemTable: target.tickets.issuesModelId, workItemRecordId: ticketRecordId } : {};
+  let entry;
+  try {
+    entry = await post(target, "/agents/log", { ...body, ...workItem, harness: run2.harness, provider: run2.provider });
+  } catch (e) {
+    if (!(e instanceof AgentLogHttpError)) throw new AgentLogUnreachableError(e.message);
+    if (e.status >= 500) throw new AgentLogUnreachableError(e.message);
+    if (e.status !== 400 || !run2.harness && !run2.provider && !ticketRecordId) {
+      e.row = true;
+      throw e;
     }
-    const slot = this.acquireN("crew-slot", max);
-    if (!slot.ok) {
-      roleLock.release();
-      return {
-        ok: false,
-        reason: `at capacity \u2014 ${max} agent(s) already running (pid${slot.heldBy.length > 1 ? "s" : ""} ${slot.heldBy.join(", ")})`
-      };
+    try {
+      entry = await post(target, "/agents/log", body);
+    } catch (e2) {
+      if (e2 instanceof AgentLogHttpError && e2.status < 500) e2.row = true;
+      throw e2;
     }
-    return { ok: true, release: () => {
-      slot.release();
-      roleLock.release();
-    } };
   }
-  /**
-   * The per-ticket run lock (CREW-2821): held for the life of a run that works
-   * the ticket (`crew-ticket-<record id>`), so a second run of the same role
-   * on this ship walks past it instead of being handed the first run's
-   * ticket. Same stale-pid rule as every lock here.
-   */
-  acquireTicket(recordId) {
-    return this.acquire(`crew-ticket-${recordId}`);
+  for (const cycle of run2.cycles) {
+    await post(target, `/agents/log/${entry.id}/cycles`, {
+      cycleIndex: cycle.cycleIndex,
+      occurredAt: cycle.occurredAt,
+      thinking: cycle.thinking,
+      ...cycle.role ? { role: cycle.role } : {}
+    });
   }
-  /** Whether a live run on this ship holds `recordId`'s ticket lock. */
-  ticketInFlight(recordId) {
-    const file = this.path(`.${_State.safe(`crew-ticket-${recordId}`)}.lock`);
+  const counters = target.tickets && ticketRecordId ? await addRunToTicket(target, target.tickets, ticketRecordId, run2) : void 0;
+  return {
+    agentLogId: entry.id,
+    ...counters?.warning ? { counterWarning: counters.warning } : {},
+    ...counters?.retry ? { counterRetry: counters.retry } : {}
+  };
+}
+var isRetryable = (e) => !(e instanceof AgentLogHttpError) || e.status >= 500;
+async function writeCounters(target, w) {
+  const have = await columnsOf(target, w.issuesModelId);
+  const body = Object.fromEntries(Object.entries(w.body).filter(([column]) => have.has(column)));
+  if (Object.keys(body).length === 0) return;
+  await request(target, "PATCH", `/data-models/${w.issuesModelId}/records/${w.recordId}`, body);
+}
+async function addRunToTicket(target, t, recordId, run2) {
+  const write = {
+    issuesModelId: t.issuesModelId,
+    recordId,
+    ticketReference: run2.ticketReference,
+    counters: t.counters,
+    body: counterIncrements(run2, t.counters, new Set(Object.values(t.counters)))
+  };
+  try {
+    await writeCounters(target, write);
+    return {};
+  } catch (e) {
+    return {
+      warning: `could not add run spend to ${run2.ticketReference}: ${e.message}`,
+      ...isRetryable(e) ? { retry: write } : {}
+    };
+  }
+}
+var queueDir = (stateDir) => join13(stateDir, "pending-agent-logs");
+function queueAgentRun(stateDir, name, q) {
+  mkdirSync7(queueDir(stateDir), { recursive: true });
+  writeFileSync8(join13(queueDir(stateDir), `${name}.json`), JSON.stringify(q));
+}
+async function replayQueuedAgentRuns(stateDir, route, keyFor, log, now = /* @__PURE__ */ new Date()) {
+  const dir = queueDir(stateDir);
+  if (!existsSync12(dir)) return 0;
+  let sent = 0;
+  for (const f of readdirSync5(dir).filter((n) => n.endsWith(".json")).sort()) {
+    const path = join13(dir, f);
+    let q;
     try {
-      const pid = Number.parseInt(readFileSync12(file, "utf8").trim(), 10);
-      if (!Number.isFinite(pid) || pid <= 0) return false;
-      process.kill(pid, 0);
-      return true;
+      q = JSON.parse(readFileSync12(path, "utf8"));
     } catch {
-      return false;
+      continue;
     }
-  }
-  /**
-   * How many consecutive cycles the release phase has refused to deploy.
-   *
-   * Refusing is correct — a dirty tree or a non-main checkout must never be
-   * released — but it used to be SILENT, and eight commits once sat unreleased
-   * behind a single untracked file with nothing saying so (ISSUE-174). One
-   * blocked cycle is normal; the count is what makes a persistent one loud.
-   */
-  /**
-   * Release bookkeeping, scoped to one route.
-   *
-   * Scoped because a ship serves several boards and releases each repo
-   * independently (ISSUE-338). These were single global files, so a deploy
-   * failure on one route suppressed releases on every other one, and a
-   * release blocked in one repo counted cycles for all of them — a dirty tree
-   * in one checkout would have silently held up an unrelated project.
-   */
-  release(route) {
-    const suffix = _State.safe(route);
-    const blocked = `.release-blocked-${suffix}`;
-    const failed = `.deploy-failed-sha-${suffix}`;
-    const gateFailed = `.test-gate-failed-${suffix}`;
-    const gateReported = `.test-gate-reported-${suffix}`;
-    const heldReported = `.release-held-${suffix}`;
-    const read = (f) => {
-      try {
-        return readFileSync12(this.path(f), "utf8").trim() || null;
-      } catch {
-        return null;
-      }
-    };
-    return {
-      blockedCount: () => Number.parseInt(read(blocked) ?? "", 10) || 0,
-      noteBlocked: () => {
-        const n = (Number.parseInt(read(blocked) ?? "", 10) || 0) + 1;
-        writeFileSync8(this.path(blocked), `${n}
-`);
-        return n;
-      },
-      clearBlocked: () => {
-        rmSync7(this.path(blocked), { force: true });
-      },
-      /**
-       * The commit a deploy last failed on.
-       *
-       * Without this the crew retries a broken deploy on every cycle — every
-       * two minutes, indefinitely — hammering the target and burying the
-       * original failure under identical ones. A failed commit is retried
-       * only when a NEW commit lands, or when an operator forces it by hand.
-       */
-      deployFailedSha: () => read(failed),
-      noteDeployFailed: (sha) => {
-        writeFileSync8(this.path(failed), `${sha}
-`);
-      },
-      clearDeployFailed: () => {
-        rmSync7(this.path(failed), { force: true });
-      },
-      /**
-       * Consecutive test-gate failures on the same head (CREW-1368). A failure
-       * on a new head restarts the count. Held on disk because one process is
-       * one cycle, and "failed three cycles running" only exists across them.
-       */
-      noteTestGateFailed: (sha) => {
-        const [prev, n] = (read(gateFailed) ?? "").split(" ");
-        const next = prev === sha ? (Number.parseInt(n ?? "", 10) || 0) + 1 : 1;
-        writeFileSync8(this.path(gateFailed), `${sha} ${next}
-`);
-        return next;
-      },
-      clearTestGateFailed: () => {
-        rmSync7(this.path(gateFailed), { force: true });
-      },
-      /** Whether the board was already told about this head's red gate. */
-      heldReported: () => {
-        try {
-          return readFileSync12(this.path(heldReported), "utf8").replace(/\n$/, "") || null;
-        } catch {
-          return null;
-        }
-      },
-      noteHeldReported: (signature) => {
-        writeFileSync8(this.path(heldReported), `${signature}
-`);
-      },
-      clearHeldReported: () => {
-        rmSync7(this.path(heldReported), { force: true });
-      },
-      testGateReported: (sha) => read(gateReported) === sha,
-      noteTestGateReported: (sha) => {
-        writeFileSync8(this.path(gateReported), `${sha}
-`);
+    if (q.version !== 1 || q.route !== route || now.toISOString() < q.nextAttemptAt) continue;
+    try {
+      const apiKey = await keyFor(q.role);
+      if (!apiKey) continue;
+      const sentRun = await reportAgentRun({ ...q.target, apiKey }, q.report);
+      if (sentRun.counterWarning) log.warn(sentRun.counterWarning);
+      if (sentRun.counterRetry) queueTicketCounters(stateDir, f.replace(/\.json$/, ""), {
+        version: 1,
+        route: q.route,
+        role: q.role,
+        target: q.target,
+        write: sentRun.counterRetry,
+        attempts: 0,
+        nextAttemptAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      rmSync7(path, { force: true });
+      sent += 1;
+      log.emit(`sent a queued Agent Log report (${f})`);
+    } catch (e) {
+      if (!(e instanceof AgentLogUnreachableError)) {
+        rmSync7(path, { force: true });
+        log.warn(`dropped a queued Agent Log report (${f}): ${e.message}`);
+        continue;
       }
-    };
+      const attempts = q.attempts + 1;
+      writeFileSync8(path, JSON.stringify({
+        ...q,
+        attempts,
+        warned: true,
+        nextAttemptAt: new Date(now.getTime() + sleepBackoff(attempts)).toISOString()
+      }));
+      if (!q.warned) log.warn(`a queued Agent Log report could not be sent yet (${e.message}); will retry`);
+    }
   }
-  /**
-   * Starvation bookkeeping, scoped to one route (ISSUE-382).
-   *
-   * `decideFleet` already renders the winner and each role's rank; what it
-   * throws away is the other side — a route that had work and did not
-   * win, and the same ticket sitting at the front of that route's queue
-   * cycle after cycle. This is state, not memory: a single process is one
-   * cycle, so "how long has this been waiting" only exists if it survives
-   * between them.
-   */
-  fairness(route) {
-    const suffix = _State.safe(route);
-    const streakFile = `.fairness-streak-${suffix}`;
-    const ticketFile = `.fairness-ticket-${suffix}`;
-    const sinceFile = `.fairness-since-${suffix}`;
-    const ticketStreakFile = `.fairness-ticket-streak-${suffix}`;
-    const read = (f) => {
-      try {
-        return readFileSync12(this.path(f), "utf8").trim() || null;
-      } catch {
-        return null;
-      }
-    };
-    const clear2 = () => {
-      for (const f of [streakFile, ticketFile, sinceFile, ticketStreakFile]) rmSync7(this.path(f), { force: true });
-    };
-    return {
-      /** Consecutive cycles this route had actionable work and did not win. */
-      streak: () => Number.parseInt(read(streakFile) ?? "", 10) || 0,
-      /**
-       * The ticket sitting at the front of this route's queue, how long
-       * it has been there and its own consecutive-passed-over count — or
-       * undefined if nothing is waiting.
-       */
-      waiting: () => {
-        const ticket = read(ticketFile);
-        const since2 = read(sinceFile);
-        if (!ticket || !since2) return void 0;
-        return { ticket, since: since2, streak: Number.parseInt(read(ticketStreakFile) ?? "", 10) || 0 };
-      },
-      /**
-       * Record what one cycle saw for this route: how many tickets were
-       * actionable, which one was most urgent, and whether this route
-       * won. Winning or running dry both reset the streak — there is nothing
-       * left being passed over.
-       */
-      record: (actionable, topTicket, won) => {
-        if (won || actionable === 0) {
-          clear2();
-          return;
-        }
-        writeFileSync8(this.path(streakFile), `${this.readInt(streakFile) + 1}
-`);
-        const prior = read(ticketFile);
-        if (topTicket && topTicket === prior) {
-          writeFileSync8(this.path(ticketStreakFile), `${this.readInt(ticketStreakFile) + 1}
-`);
-        } else if (topTicket) {
-          writeFileSync8(this.path(ticketFile), `${topTicket}
-`);
-          writeFileSync8(this.path(sinceFile), `${(/* @__PURE__ */ new Date()).toISOString()}
-`);
-          writeFileSync8(this.path(ticketStreakFile), "1\n");
-        }
+  return sent;
+}
+var countersDir = (stateDir) => join13(stateDir, "pending-ticket-counters");
+function queueTicketCounters(stateDir, name, q) {
+  mkdirSync7(countersDir(stateDir), { recursive: true });
+  writeFileSync8(join13(countersDir(stateDir), `${name}.json`), JSON.stringify(q));
+}
+async function replayQueuedTicketCounters(stateDir, route, keyFor, log, now = /* @__PURE__ */ new Date()) {
+  const dir = countersDir(stateDir);
+  if (!existsSync12(dir)) return 0;
+  let sent = 0;
+  for (const f of readdirSync5(dir).filter((n) => n.endsWith(".json")).sort()) {
+    const path = join13(dir, f);
+    let q;
+    try {
+      q = JSON.parse(readFileSync12(path, "utf8"));
+    } catch {
+      continue;
+    }
+    if (q.version !== 1 || q.route !== route || now.toISOString() < q.nextAttemptAt) continue;
+    try {
+      const apiKey = await keyFor(q.role);
+      if (!apiKey) continue;
+      await writeCounters({ ...q.target, apiKey }, q.write);
+      rmSync7(path, { force: true });
+      sent += 1;
+      log.emit(`added a queued run's spend to ${q.write.ticketReference ?? q.write.recordId} (${f})`);
+    } catch (e) {
+      if (!isRetryable(e)) {
+        rmSync7(path, { force: true });
+        log.warn(`dropped a queued ticket counter update (${f}): ${e.message}`);
+        continue;
       }
-    };
+      const attempts = q.attempts + 1;
+      writeFileSync8(path, JSON.stringify({
+        ...q,
+        attempts,
+        warned: true,
+        nextAttemptAt: new Date(now.getTime() + sleepBackoff(attempts)).toISOString()
+      }));
+      if (!q.warned) log.warn(`a queued ticket counter update could not be sent yet (${e.message}); will retry`);
+    }
   }
+  return sent;
+}
+
+// src/ticket-attribution.ts
+var TICKET_KEY_RE = /\b[A-Z][A-Z0-9]{1,9}-\d+\b/g;
+function ticketMentions(text) {
+  return [...text.matchAll(TICKET_KEY_RE)].map((m) => m[0]);
+}
+var TicketAttributionTracker = class {
+  #tokensByTicket = /* @__PURE__ */ new Map();
+  #turns = 0;
+  #current;
+  /** Tracker record uuid → ticket key, learned when a write names both (a claim resolves the key from the last mention). */
+  #keyByRecord = /* @__PURE__ */ new Map();
+  #lastBy = {};
   /**
-   * The previous cycle's "needs a person" set, scoped to one route
-   * (ISSUE-928) — `{ ticketId: [reason, ...] }`. `poll.ts` reads it once
-   * per cycle to compute transitions and the caller (`cli.ts`'s run path,
-   * `fleet.ts`'s per-route loop) persists the new set afterward, beside the
-   * existing `fairness(route).record(...)` call — never inside `decideCycle`
-   * itself, which does no writes. A corrupt or missing file reads as empty,
-   * which is also deliberately what a fresh install sees: everything
-   * currently needing a person emits once, rather than being silently
-   * skipped as though already notified.
+   * The ticket key most recently named in the transcript, or undefined before any.
+   * Only the FIRST key in a turn counts: a closing summary names its own
+   * ticket first and then lists others ("Other tickets", "Blocked by", "See
+   * also"), and those trailing keys are not what the run worked (CREW-2598).
    */
-  attention(route) {
-    const file = `.attention-${_State.safe(route)}.json`;
-    return {
-      previous: () => {
-        try {
-          const parsed = JSON.parse(readFileSync12(this.path(file), "utf8"));
-          return parsed && typeof parsed === "object" ? parsed : {};
-        } catch {
-          return {};
-        }
-      },
-      persist: (next) => {
-        writeFileSync8(this.path(file), JSON.stringify(next));
-      }
-    };
+  get current() {
+    return this.#current;
+  }
+  /** Record the mentions in `text` without crediting tokens (a claim needs "which ticket" before the turn's usage line arrives). */
+  note(text) {
+    const mentions = ticketMentions(text);
+    if (mentions.length > 0) this.#current = mentions[0];
+  }
+  /** One assistant turn: its combined visible text (thinking + text blocks) and its own token cost. */
+  add(text, tokens) {
+    const mentions = ticketMentions(text);
+    if (mentions.length > 0) this.#current = mentions[0];
+    if (this.#current === void 0 || tokens <= 0) return;
+    this.#turns++;
+    this.#tokensByTicket.set(this.#current, (this.#tokensByTicket.get(this.#current) ?? 0) + tokens);
   }
   /**
-   * The previous cycle's unroutable ticket ids for one route (CREW-2548): open
-   * tickets with no repository that are not exempt. `poll.ts` diffs against it
-   * so each ticket warns once when it becomes unroutable, not every cycle; the
-   * caller persists the new set beside `attention(route).persist(...)`. A
-   * missing or corrupt file reads as empty, so a fresh install warns once.
+   * Record a tool call if it is a ticket-targeted tracker write (claim,
+   * hand-off or comment). The ticket key comes from a record uuid seen on an
+   * earlier write when known, else from the key last named in the transcript
+   * (a claim or hand-off announces its ticket). A comment on a record never
+   * seen before is ignored: its uuid cannot be resolved to a key.
    */
-  unroutable(route) {
-    const file = `.unroutable-${_State.safe(route)}.json`;
-    return {
-      previous: () => {
-        try {
-          const parsed = JSON.parse(readFileSync12(this.path(file), "utf8"));
-          return Array.isArray(parsed) ? parsed.filter((x) => typeof x === "string") : [];
-        } catch {
-          return [];
-        }
-      },
-      persist: (next) => {
-        writeFileSync8(this.path(file), JSON.stringify(next));
-      }
-    };
+  noteWrite(tool, input) {
+    const w = classifyWrite(tool, input);
+    if (!w) return;
+    let key = w.recordId ? this.#keyByRecord.get(w.recordId) : void 0;
+    if (w.kind !== "comment") key ??= this.#current;
+    if (!key) return;
+    if (w.kind !== "comment" && w.recordId) this.#keyByRecord.set(w.recordId, key);
+    this.#lastBy[w.kind] = key;
   }
   /**
-   * Open ship-level attention items (CREW-1373), ship-wide rather than
-   * per-route: a parked role or a missing hook command is about this
-   * machine. A corrupt or missing file reads as empty.
+   * How the attribution is decided: a hand-off write beats a claim, a claim
+   * beats a comment (so a follow-up ticket filed or commented on while
+   * working never displaces the claimed one), and any write beats everything
+   * below. Next, `hintMoved` — the post-run read-back showed the hinted
+   * ticket changed status or assignee during the run — is a hand-off signal
+   * for a run that wrote through MCP tools crew cannot see. Then the
+   * mention-token heuristic, which with a hint may override it only when a
+   * different ticket holds a strict majority of the credited tokens (a single
+   * credited turn, like a lone end-of-run summary naming another ticket,
+   * must not). A run with no hint
+   * keeps the plain winner. The pre-run hint is last.
    */
-  shipAttention() {
-    const file = ".ship-attention.json";
-    return {
-      previous: () => {
-        try {
-          const parsed = JSON.parse(readFileSync12(this.path(file), "utf8"));
-          return Array.isArray(parsed) ? parsed : [];
-        } catch {
-          return [];
-        }
-      },
-      persist: (next) => {
-        writeFileSync8(this.path(file), JSON.stringify(next));
-      }
-    };
+  decide(hint, opts = {}) {
+    for (const by of ["handoff", "claim", "comment"]) {
+      const ticket = this.#lastBy[by];
+      if (ticket) return { ticket, by };
+    }
+    if (hint && opts.hintMoved) return { ticket: hint, by: "readback" };
+    if (this.#tokensByTicket.size > 0) {
+      if (!hint) return { ticket: this.winner(), by: "mentions" };
+      const winner = this.winner(hint);
+      if (winner === hint) return { ticket: hint, by: "mentions" };
+      let total = 0;
+      for (const n of this.#tokensByTicket.values()) total += n;
+      const share = (this.#tokensByTicket.get(winner) ?? 0) / total;
+      return share > 0.5 && this.#turns > 1 ? { ticket: winner, by: "mentions" } : { ticket: hint, by: "hint" };
+    }
+    return { ticket: hint, by: "hint" };
   }
   /**
-   * When the release phase last ran a cycle (CREW-1373), as the mtime of a
-   * marker file. `touch()` is called at the start and the end of every cycle
-   * so a long deploy does not read as a stopped timer.
+   * The ticket key the run spent the most tokens on, or `fallback` (the
+   * pre-run poll hint) when the transcript never named one — an
+   * administrative run that touches the tracker without discussing a
+   * specific ticket in its visible text still has to cite something.
    */
-  releaseHeartbeat() {
-    const file = ".release-last-run";
-    return {
-      touch: () => {
-        writeFileSync8(this.path(file), (/* @__PURE__ */ new Date()).toISOString());
-      },
-      at: () => {
-        try {
-          return statSync4(this.path(file)).mtimeMs;
-        } catch {
-          return null;
-        }
+  winner(fallback) {
+    let best = fallback;
+    let bestTokens = -1;
+    for (const [ticket, tokens] of this.#tokensByTicket) {
+      if (tokens > bestTokens) {
+        best = ticket;
+        bestTokens = tokens;
       }
-    };
+    }
+    return best;
   }
-  readInt(file) {
+};
+function isClaimWrite(tool, input) {
+  if (!tool || !/records_controller_update$/.test(tool)) return false;
+  const body = input?.body;
+  return typeof body === "object" && body !== null && body.status === "in_progress";
+}
+var HANDOFF_STATUSES = /* @__PURE__ */ new Set(["fixed", "verified", "needs_info", "accepted"]);
+function classifyWrite(tool, input) {
+  if (!tool) return void 0;
+  const body = input?.body;
+  if (typeof body !== "object" || body === null) return void 0;
+  const b = body;
+  if (/records_controller_update$/.test(tool)) {
+    const recordId = typeof input?.recordId === "string" ? input.recordId : void 0;
+    if (b.status === "in_progress" || b.status === "qa") return { kind: "claim", recordId };
+    if (typeof b.status === "string" && HANDOFF_STATUSES.has(b.status)) return { kind: "handoff", recordId };
+  }
+  if (/records_controller_create$/.test(tool) && typeof b.ticket_id === "string") return { kind: "comment", recordId: b.ticket_id };
+  return void 0;
+}
+
+// src/handoff-transcript.ts
+var TRANSPORT_FAILURE = /\b50[0-4]\b|<!doctype|<html|unexpected token '?<|fetch failed|econn(reset|refused)|etimedout|socket hang up|timed out|bad gateway|service unavailable/i;
+function resultText(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) return content.map((c) => c && typeof c.text === "string" ? c.text : "").join("\n");
+  return "";
+}
+function isTransportFailure(isError, text) {
+  if (!isError) {
     try {
-      return Number.parseInt(readFileSync12(this.path(file), "utf8").trim(), 10) || 0;
+      const doc = JSON.parse(text);
+      if (doc && typeof doc === "object") {
+        const code = doc.statusCode;
+        return typeof code === "number" && code >= 500;
+      }
     } catch {
-      return 0;
     }
   }
+  return TRANSPORT_FAILURE.test(text);
+}
+var HandoffTranscriptTracker = class {
+  open = /* @__PURE__ */ new Map();
+  /** Per ticket record: the last hand-off status write's outcome. */
+  status = /* @__PURE__ */ new Map();
+  /** Per ticket record: the last hand-off comment that failed after the status write's turn. */
+  comment = /* @__PURE__ */ new Map();
+  landed = /* @__PURE__ */ new Set();
+  lastText = "";
+  resultLine = "";
+  feed(parsed) {
+    const line = parsed;
+    if (!line || typeof line !== "object") return;
+    if (line.type === "result" && typeof line.result === "string") this.resultLine = line.result;
+    const content = line.message?.content;
+    if (!Array.isArray(content)) return;
+    for (const b of content) {
+      if (line.type === "assistant" && b.type === "text" && b.text?.trim()) this.lastText = b.text.trim();
+      else if (line.type === "assistant" && b.type === "tool_use" && b.id) {
+        const w = classifyWrite(b.name, b.input);
+        const body = b.input?.body;
+        if (w?.recordId && (w.kind === "handoff" || w.kind === "comment") && body && typeof body === "object") {
+          this.open.set(b.id, { kind: w.kind, recordId: w.recordId, body });
+        }
+      } else if (line.type === "user" && b.type === "tool_result" && b.tool_use_id) {
+        const w = this.open.get(b.tool_use_id);
+        if (!w) continue;
+        this.open.delete(b.tool_use_id);
+        const failed = isTransportFailure(b.is_error === true, resultText(b.content));
+        if (w.kind === "handoff") this.status.set(w.recordId, { ok: !failed, patch: w.body });
+        else if (failed && typeof w.body.body === "string") this.comment.set(w.recordId, w.body.body);
+        else if (!failed) {
+          this.comment.delete(w.recordId);
+          this.landed.add(w.recordId);
+        }
+      }
+    }
+  }
+  /** The hand-off that did not land, or null when every hand-off write succeeded (or none was tried). */
+  pending() {
+    const failed = [...this.status].filter(([, s2]) => !s2.ok).at(-1);
+    if (!failed) return null;
+    const [ticketRecordId, s] = failed;
+    return {
+      ticketRecordId,
+      patch: s.patch,
+      ...this.comment.has(ticketRecordId) ? { comment: this.comment.get(ticketRecordId) } : {},
+      ...this.landed.has(ticketRecordId) ? { commentLanded: true } : {},
+      finalText: this.lastText || this.resultLine
+    };
+  }
 };
 
+// src/pending-handoff.ts
+import { existsSync as existsSync15, mkdirSync as mkdirSync8, readdirSync as readdirSync6, readFileSync as readFileSync13, rmSync as rmSync8, writeFileSync as writeFileSync9 } from "fs";
+import { join as join16 } from "path";
+
+// src/ticket-branch.ts
+import { basename as basename6 } from "path";
+
+// src/tracker.ts
+import { hostname } from "os";
+import { TablationClient } from "@tablation/client";
+
 // src/work-mode.ts
 function projectWorkModes(rows, contract) {
   const out = /* @__PURE__ */ new Map();
@@ -6479,7 +6498,7 @@ var Tracker = class {
    * `beatIdle` in a `finally` — the same shape as `setCrewStatus`'s
    * working/idle pair, one level up (ship, not seat).
    */
-  async beatEngaged(shipName2, connectionName, ticketRecordId) {
+  async beatEngaged(shipName2, connectionName, ticketRecordId, since2) {
     const row = await this.myShipRow(shipName2);
     if (!row) return;
     await this.client.records.update(this.route.resolved.shipsModelId, row.id, {
@@ -6487,7 +6506,7 @@ var Tracker = class {
       host: hostname(),
       pid: process.pid,
       engaged: true,
-      engaged_since: (/* @__PURE__ */ new Date()).toISOString(),
+      engaged_since: since2 ?? (/* @__PURE__ */ new Date()).toISOString(),
       engaged_connection: connectionName,
       engaged_ticket_id: ticketRecordId,
       ...this.attentionPatch(row)
@@ -8561,6 +8580,8 @@ function planAgentRun(o) {
     eventsPath: join19(streamsDir, `${base}.events.jsonl`),
     ticket: o.ticket,
     ticketRecordId: o.ticketRecordId ?? null,
+    repo: o.repo ?? null,
+    routeName: o.route.route,
     agentLog,
     promptVersion: o.route.resolved?.agentPersonas?.[o.role]?.historyId,
     promptSha
@@ -8905,6 +8926,10 @@ async function finishRun(id, obs, emit, startedAt, end, agentLogKey, hintMoved)
     };
     try {
       const sent = await reportAgentRun({ ...id.agentLog, apiKey: agentLogKey }, report);
+      try {
+        clearShipAttention(new State(stateDirOfStream(id.streamPath)), agentLogRefusedKey(id.route));
+      } catch {
+      }
       if (sent.counterWarning) emit.warn(sent.counterWarning, { step: "agent" });
       if (sent.counterRetry) {
         try {
@@ -8937,6 +8962,15 @@ async function finishRun(id, obs, emit, startedAt, end, agentLogKey, hintMoved)
         } catch {
         }
       }
+      if (e instanceof AgentLogHttpError && e.row && e.status >= 400 && e.status < 500) {
+        try {
+          await raiseShipAttention(
+            { state: new State(stateDirOfStream(id.streamPath)), emit },
+            agentLogRefusedItem(id.route, id.role, e.status)
+          );
+        } catch {
+        }
+      }
       emit.warn(`could not report agent log: ${e.message}`, { step: "agent" });
     }
   }
@@ -8975,6 +9009,8 @@ function spawnAgent(plan, emit, hintMoved) {
         route: plan.route,
         ticket: plan.ticket ?? null,
         ticketRecordId: plan.ticketRecordId ?? null,
+        repo: plan.repo ?? null,
+        routeName: plan.routeName,
         model: plan.model,
         toolchain: id.toolchain,
         harness: id.harness,
@@ -9546,7 +9582,7 @@ function doctorSelftestLines(stored, toolchains) {
 }
 
 // src/cli.ts
-import { resolve as resolve5, dirname as dirname20, join as join37, basename as basename12 } from "path";
+import { resolve as resolve5, dirname as dirname20, join as join38, basename as basename12 } from "path";
 import { fileURLToPath } from "url";
 import { hostname as hostname2, homedir as homedir10 } from "os";
 import { spawnSync as spawnSync7 } from "child_process";
@@ -13379,6 +13415,164 @@ Passed: ${passed}.${willClose ? " Closing this alert." : ""}`,
   return out;
 }
 
+// src/live-runs.ts
+import { existsSync as existsSync24, readdirSync as readdirSync10 } from "fs";
+import { join as join28 } from "path";
+
+// src/interrupted.ts
+import { existsSync as existsSync23, readdirSync as readdirSync9, readFileSync as readFileSync21 } from "fs";
+import { join as join27 } from "path";
+var INTERRUPTED_MARKER = calloutHeader("NOTE", "Interrupted");
+function interruptedComment(b) {
+  const tree = b.dirty === null ? "The worktree could not be checked." : b.dirty ? "The worktree has uncommitted changes \u2014 they are this seat's own, from that run." : "The worktree is clean.";
+  return `${INTERRUPTED_MARKER}
+
+The agent run on this ticket was cut short (${b.reason}) before it handed on${b.branch ? `; its branch is \`${b.branch}\`` : ""}. ${tree} The next run on this seat resumes from the worktree rather than starting over.`;
+}
+var handled = /* @__PURE__ */ new Set();
+var pidAlive = (pid) => {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (e) {
+    return e.code === "EPERM";
+  }
+};
+function runFinished(streamPath) {
+  const path = `${streamPath}.meta.json`;
+  if (!existsSync23(path)) return false;
+  try {
+    return JSON.parse(readFileSync21(path, "utf8")).running !== true;
+  } catch {
+    return true;
+  }
+}
+function orphanedStreams(o) {
+  const dir = join27(o.stateDir, "streams");
+  if (!existsSync23(dir)) return [];
+  const ownerAlive = o.isOwnerAlive ?? pidAlive;
+  const out = [];
+  for (const name of readdirSync9(dir)) {
+    if (!name.endsWith(".jsonl") || name.endsWith(".events.jsonl")) continue;
+    const streamPath = join27(dir, name);
+    if (runFinished(streamPath)) continue;
+    const sidecar = readRunSidecar(streamPath);
+    if (!sidecar || sidecar.route !== o.routeLabel) continue;
+    if (ownerAlive(sidecar.ownerPid)) continue;
+    out.push({ streamPath, sidecar });
+  }
+  return out;
+}
+async function reconcileRuns(o) {
+  let adopted = 0;
+  let interrupted = 0;
+  for (const { streamPath, sidecar } of orphanedStreams(o)) {
+    if (handled.has(streamPath)) continue;
+    handled.add(streamPath);
+    const isAlive = o.isAlive ?? runIsAlive;
+    const lock = isAlive(sidecar) ? o.state.acquireRun(sidecar.role, o.maxConcurrentAgents, o.roleConcurrency?.[sidecar.role] ?? 1) : null;
+    const ticketLock = isAlive(sidecar) && sidecar.ticketRecordId ? o.state.acquireTicket(sidecar.ticketRecordId) : null;
+    const work = (async () => {
+      try {
+        const result = await reattachRun(streamPath, sidecar, o.emit, {
+          agentLogKey: await o.agentLogKey?.(sidecar.role).catch(() => void 0),
+          isAlive: o.isAlive,
+          pollMs: o.pollMs,
+          onAdopted: () => o.emit.emit(`adopted ${sidecar.role} run (pid ${sidecar.pid}) left by a previous crew process`, { step: "agent", role: sidecar.role })
+        });
+        if (result.adopted) adopted++;
+        else interrupted++;
+        try {
+          await o.afterRun?.(sidecar, result);
+        } catch (e) {
+          o.emit.warn(`could not follow up on ${sidecar.role} run ${streamPath}: ${e.message}`, { step: "agent" });
+        }
+      } catch (e) {
+        o.emit.warn(`could not reattach ${sidecar.role} run ${streamPath}: ${e.message}`, { step: "agent" });
+      } finally {
+        if (lock?.ok) lock.release();
+        if (ticketLock?.ok) ticketLock.release();
+      }
+    })();
+    if (isAlive(sidecar)) {
+      if (o.inFlight) {
+        o.inFlight.add(work);
+        void work.finally(() => o.inFlight.delete(work));
+      }
+    } else {
+      await work;
+    }
+  }
+  return { adopted, interrupted };
+}
+
+// src/live-runs.ts
+function liveRuns(stateDir, isAlive = runIsAlive) {
+  const dir = join28(stateDir, "streams");
+  if (!existsSync24(dir)) return [];
+  const out = [];
+  for (const name of readdirSync10(dir)) {
+    if (!name.endsWith(".jsonl") || name.endsWith(".events.jsonl")) continue;
+    const streamPath = join28(dir, name);
+    if (runFinished(streamPath)) continue;
+    const sidecar = readRunSidecar(streamPath);
+    if (!sidecar || !isAlive(sidecar)) continue;
+    out.push({ ...sidecar, streamPath });
+  }
+  return out.sort((a, b) => a.spawnedAt.localeCompare(b.spawnedAt));
+}
+function siblingRuns(runs, ownTicketRecordId) {
+  return runs.filter((r) => !ownTicketRecordId || r.ticketRecordId !== ownTicketRecordId);
+}
+async function settleRunEnd(o) {
+  const { tracker, emit } = o;
+  const all = o.runs ?? liveRuns(o.stateDir);
+  const slug = routeSlug(o.route.route);
+  const seatSiblings = siblingRuns(all.filter((r) => r.role === o.role && r.route === slug), o.ownTicketRecordId);
+  const shipSiblings = siblingRuns(all, o.ownTicketRecordId);
+  const newest = (rs) => rs[rs.length - 1];
+  if (o.memberId) {
+    try {
+      if (seatSiblings.length) await tracker.setCrewStatus(o.memberId, "working", newest(seatSiblings).ticketRecordId);
+      else await tracker.setCrewStatus(o.memberId, "idle");
+    } catch (e) {
+      emit.warn(`could not clear crew status: ${e.message}`, { step: "agent" });
+    }
+  }
+  try {
+    if (shipSiblings.length) {
+      const n = newest(shipSiblings);
+      await tracker.beatEngaged(o.shipName, n.routeName ?? n.route, n.ticketRecordId, n.spawnedAt);
+    } else {
+      await tracker.beatIdle(o.shipName);
+    }
+  } catch (e) {
+    emit.warn(`could not beat ship idle: ${e.message}`, { step: "agent" });
+  }
+}
+function describeRun(run2, route, seatIds, worktreeOf = (d, n) => {
+  try {
+    return worktreeForNumber(d, n)?.path ?? null;
+  } catch {
+    return null;
+  }
+}) {
+  const ownRoute = run2.route === routeSlug(route.route);
+  const repoDir = run2.repo ? reposOf(route).find((t) => t.name === run2.repo)?.dir : void 0;
+  const num = run2.ticket?.replace(/^\D+/, "") ?? "";
+  return {
+    role: run2.role,
+    seat: ownRoute ? seatIds[run2.role] ?? null : null,
+    ticket: run2.ticket,
+    ticketRecordId: run2.ticketRecordId,
+    repo: run2.repo ?? null,
+    worktree: repoDir && num ? worktreeOf(repoDir, num) : null,
+    stream: run2.streamPath,
+    pid: run2.pid,
+    startedAt: run2.spawnedAt
+  };
+}
+
 // src/projects-cmd.ts
 async function buildProjectsReport(routes, open) {
   return Promise.all(routes.map(async (r) => {
@@ -13588,7 +13782,7 @@ function missingReleaserWarning(repo, release, ships, now = Date.now()) {
 }
 
 // src/watch.ts
-import { watch as watchFile, existsSync as existsSync23, statSync as statSync7, openSync as openSync4, readSync as readSync2, closeSync as closeSync4 } from "fs";
+import { watch as watchFile, existsSync as existsSync25, statSync as statSync7, openSync as openSync4, readSync as readSync2, closeSync as closeSync4 } from "fs";
 var E = "\x1B[";
 var dim = (s) => `${E}2m${s}${E}0m`;
 var bold = (s) => `${E}1m${s}${E}0m`;
@@ -13689,7 +13883,7 @@ function renderHeaders(states, now = Date.now()) {
   return states.map((s) => renderHeader(s, now)).join("");
 }
 function readFrom(file, from) {
-  if (!existsSync23(file)) return { events: [], offset: from };
+  if (!existsSync25(file)) return { events: [], offset: from };
   const size = statSync7(file).size;
   if (size < from) return readFrom(file, 0);
   if (size === from) return { events: [], offset: from };
@@ -13932,17 +14126,17 @@ function nextRoles(decision, ran) {
 }
 
 // src/ship-name.ts
-import { existsSync as existsSync25, mkdirSync as mkdirSync16, readFileSync as readFileSync22, renameSync as renameSync2, writeFileSync as writeFileSync18 } from "fs";
+import { existsSync as existsSync27, mkdirSync as mkdirSync16, readFileSync as readFileSync23, renameSync as renameSync2, writeFileSync as writeFileSync18 } from "fs";
 import { dirname as dirname14 } from "path";
 import { parseDocument } from "yaml";
 
 // src/machine-id.ts
 import { execFileSync as execFileSync4 } from "child_process";
 import { createHash as createHash4 } from "crypto";
-import { existsSync as existsSync24, mkdirSync as mkdirSync15, readFileSync as readFileSync21, writeFileSync as writeFileSync17 } from "fs";
-import { dirname as dirname13, join as join27 } from "path";
+import { existsSync as existsSync26, mkdirSync as mkdirSync15, readFileSync as readFileSync22, writeFileSync as writeFileSync17 } from "fs";
+import { dirname as dirname13, join as join29 } from "path";
 function machineIdPathFor(stateDir) {
-  return join27(stateDir, "machine-id");
+  return join29(stateDir, "machine-id");
 }
 var sha256 = (s) => createHash4("sha256").update(s).digest("hex");
 function readRawMachineId(platform2 = process.platform) {
@@ -13955,8 +14149,8 @@ function readRawMachineId(platform2 = process.platform) {
       return /"IOPlatformUUID"\s*=\s*"([^"]+)"/.exec(out)?.[1];
     }
     for (const p of ["/etc/machine-id", "/var/lib/dbus/machine-id"]) {
-      if (existsSync24(p)) {
-        const id = readFileSync21(p, "utf8").trim();
+      if (existsSync26(p)) {
+        const id = readFileSync22(p, "utf8").trim();
         if (id) return id;
       }
     }
@@ -13967,8 +14161,8 @@ function readRawMachineId(platform2 = process.platform) {
 function ensureMachineId(stateDir, opts = {}) {
   if (opts.override?.trim()) return sha256(opts.override.trim());
   const path = machineIdPathFor(stateDir);
-  if (existsSync24(path)) {
-    const cached = readFileSync21(path, "utf8").trim();
+  if (existsSync26(path)) {
+    const cached = readFileSync22(path, "utf8").trim();
     if (/^[0-9a-f]{64}$/.test(cached)) return cached;
   }
   const raw = (opts.read ?? readRawMachineId)();
@@ -14046,19 +14240,19 @@ async function syncRouteName(i) {
   return { status: "ok", ...base, action, name: i.local };
 }
 function readSyncedName(resolvedFile) {
-  if (!existsSync25(resolvedFile)) return void 0;
+  if (!existsSync27(resolvedFile)) return void 0;
   try {
-    const v = JSON.parse(readFileSync22(resolvedFile, "utf8")).shipName;
+    const v = JSON.parse(readFileSync23(resolvedFile, "utf8")).shipName;
     return typeof v === "string" ? v : void 0;
   } catch {
     return void 0;
   }
 }
 function writeSyncedName(resolvedFile, name) {
-  if (!existsSync25(resolvedFile)) return;
+  if (!existsSync27(resolvedFile)) return;
   let raw;
   try {
-    raw = JSON.parse(readFileSync22(resolvedFile, "utf8"));
+    raw = JSON.parse(readFileSync23(resolvedFile, "utf8"));
   } catch {
     return;
   }
@@ -14073,7 +14267,7 @@ function writeSyncedName(resolvedFile, name) {
 async function reconcileShipName(i) {
   let local = i.ship.name;
   try {
-    local = shipNameOfYaml(readFileSync22(i.configFile, "utf8")) ?? local;
+    local = shipNameOfYaml(readFileSync23(i.configFile, "utf8")) ?? local;
   } catch {
   }
   const resolvedFile = resolvedPathFor(i.stateDir, i.route);
@@ -14097,7 +14291,7 @@ async function reconcileShipName(i) {
   }
   if (result.status !== "ok") return result;
   if (result.action === "adopt" || result.action === "row-wins") {
-    const text = readFileSync22(i.configFile, "utf8");
+    const text = readFileSync23(i.configFile, "utf8");
     writeFileSync18(i.configFile, setShipNameInYaml(text, result.name));
     i.ship.name = result.name;
     if (result.action === "row-wins") {
@@ -14743,7 +14937,7 @@ function describeCapability(i) {
 }
 
 // src/agents-sync-run.ts
-import { existsSync as existsSync26, mkdirSync as mkdirSync17, readFileSync as readFileSync23, writeFileSync as writeFileSync19 } from "fs";
+import { existsSync as existsSync28, mkdirSync as mkdirSync17, readFileSync as readFileSync24, writeFileSync as writeFileSync19 } from "fs";
 import { dirname as dirname15 } from "path";
 async function runAgentsSync(target, o) {
   const dryRun = o.dryRun ?? false;
@@ -14777,7 +14971,7 @@ async function runAgentsSync(target, o) {
   for (const s of skillResult?.outcomes ?? []) o.say(describeSkillSyncOutcome(s));
   if (!dryRun) {
     const resolvedPath = resolvedPathFor(o.stateDir, target.route);
-    const raw = existsSync26(resolvedPath) ? JSON.parse(readFileSync23(resolvedPath, "utf8")) : {};
+    const raw = existsSync28(resolvedPath) ? JSON.parse(readFileSync24(resolvedPath, "utf8")) : {};
     raw.agentPersonas = personaResult.agentPersonas;
     if (skillResult) raw.agentSkills = skillResult.agentSkills;
     if (personaResult.releaseAgentId) raw.releaseAgentId = personaResult.releaseAgentId;
@@ -14886,7 +15080,7 @@ async function showLogEntry(route, entryId, opts = {}) {
 
 // src/repos-check.ts
 import { spawnSync as spawnSync6 } from "child_process";
-import { readFileSync as readFileSync24 } from "fs";
+import { readFileSync as readFileSync25 } from "fs";
 import { basename as basename8 } from "path";
 var POSIX_SHELL = /^(?:ba|z|da|k|a|mk)?sh$|^fish$/;
 function checkHookSyntax(script, shell) {
@@ -14927,7 +15121,7 @@ function checkRepoSpec(dir, opts = {}) {
   }
   let parsed;
   try {
-    parsed = parseRepoConfig(readFileSync24(file, "utf8"), file);
+    parsed = parseRepoConfig(readFileSync25(file, "utf8"), file);
   } catch (e) {
     if (!(e instanceof RepoConfigError)) throw e;
     return { ...empty, file, error: e.message, exitCode: 1 };
@@ -14984,7 +15178,7 @@ import { isMap as isMap2, parseDocument as parseDocument3, YAMLMap } from "yaml"
 
 // src/repos-cmd.ts
 import { homedir as homedir9 } from "os";
-import { basename as basename9, join as join28, resolve as resolve3 } from "path";
+import { basename as basename9, join as join30, resolve as resolve3 } from "path";
 import { isMap, isSeq, parseDocument as parseDocument2, stringify as stringify2 } from "yaml";
 var ReposError = class extends Error {
 };
@@ -15262,7 +15456,7 @@ function planRepoClone(i) {
   }
   const ship = doc.get("ship", true);
   const basePath = String(m.get("reposBasePath") ?? (isMap(ship) ? ship.get("reposBasePath") : void 0) ?? "~/Crew");
-  const target = i.dir ? expandDir(i.dir, i.base) : join28(expandDir(basePath, i.base), i.route.split("/")[0], name);
+  const target = i.dir ? expandDir(i.dir, i.base) : join30(expandDir(basePath, i.base), i.route.split("/")[0], name);
   const add = planRepoAdd({ text: i.text, base: i.base, route: i.route, path: target, origin: remote, resolved: i.resolved, name, isCheckout: i.isCheckout });
   return { ...add, remote, target };
 }
@@ -15661,7 +15855,7 @@ ${run2.err}` });
 }
 
 // src/sample-ticket.ts
-import { basename as basename10, dirname as dirname17, join as join29 } from "path";
+import { basename as basename10, dirname as dirname17, join as join31 } from "path";
 var SAMPLE_REPO = "crew-sample";
 var SAMPLE_REMOTE = `local/${SAMPLE_REPO}`;
 var SAMPLE_MARKER = "sample: true";
@@ -15684,8 +15878,8 @@ has something safe to work on: its test and build hooks always pass, it has no
 remote, and \`crew sample-ticket --remove\` deletes it.
 `;
 function sampleDir(existing, reposBase, workspace) {
-  if (existing.length > 0) return join29(dirname17(existing[0]), SAMPLE_REPO);
-  return join29(reposBase, workspace, SAMPLE_REPO);
+  if (existing.length > 0) return join31(dirname17(existing[0]), SAMPLE_REPO);
+  return join31(reposBase, workspace, SAMPLE_REPO);
 }
 var SAMPLE_TITLE = "Sample: add a documented `greet` function with a test";
 function sampleDescription() {
@@ -15777,8 +15971,8 @@ function schedulerInstalled(plan, exists, crontab) {
 }
 
 // src/worktree-sweep.ts
-import { existsSync as existsSync27, readFileSync as readFileSync25, readdirSync as readdirSync9 } from "fs";
-import { basename as basename11, dirname as dirname18, join as join30, resolve as resolve4 } from "path";
+import { existsSync as existsSync29, readFileSync as readFileSync26, readdirSync as readdirSync11 } from "fs";
+import { basename as basename11, dirname as dirname18, join as join32, resolve as resolve4 } from "path";
 function planWorktreeSweep(target, tickets, contract) {
   const terminal = new Set(contract.statuses.resolved.filter((s) => s !== contract.statuses.verified));
   const verified = contract.statuses.verified;
@@ -15837,7 +16031,7 @@ function siblingWorktreeDirs(target) {
   const registered = new Set(worktrees(target.dir).map((w) => resolve4(w.path)));
   let names;
   try {
-    names = readdirSync9(parent);
+    names = readdirSync11(parent);
   } catch {
     return [];
   }
@@ -15845,7 +16039,7 @@ function siblingWorktreeDirs(target) {
   for (const name of names) {
     if (!name.startsWith(stem)) continue;
     const m = DIR_NUMBER_SUFFIXED.exec(name);
-    const path = join30(parent, name);
+    const path = join32(parent, name);
     if (m && !registered.has(resolve4(path))) out.push({ path, number: m[1] });
   }
   return out;
@@ -15880,7 +16074,7 @@ async function applyWorktreeSweep(cwd, actions, dryRun, log, remote = "origin",
   let removed = 0;
   let keptBranches = 0;
   for (const a of actions) {
-    if (!dryRun && base && !a.keepBranch && existsSync27(a.path) && isHandBackMerge(a.path, base)) {
+    if (!dryRun && base && !a.keepBranch && existsSync29(a.path) && isHandBackMerge(a.path, base)) {
       if (gitOk(a.path, ["merge", "--abort"]) !== null) {
         log.emit(
           `abandoned the hand-back merge of ${base} in ${a.path}: ${a.ticket.issue_id} deployed without it`,
@@ -15888,7 +16082,7 @@ async function applyWorktreeSweep(cwd, actions, dryRun, log, remote = "origin",
         );
       }
     }
-    if (!dryRun && existsSync27(a.path)) {
+    if (!dryRun && existsSync29(a.path)) {
       let dirty = false;
       try {
         dirty = status(a.path).length > 0;
@@ -15899,7 +16093,7 @@ async function applyWorktreeSweep(cwd, actions, dryRun, log, remote = "origin",
         continue;
       }
     }
-    if (!dryRun && a.requirePushed && a.branch && existsSync27(a.path) && remoteConfigured(cwd, remote) && worktreeHoldsUnpushed(a.path, remote)) {
+    if (!dryRun && a.requirePushed && a.branch && existsSync29(a.path) && remoteConfigured(cwd, remote) && worktreeHoldsUnpushed(a.path, remote)) {
       refuse(a, "unpushed commits", `${a.branch} has commits that are not on ${remote}`);
       continue;
     }
@@ -15948,7 +16142,7 @@ function isHandBackMerge(path, base) {
   if (!msgPath) return false;
   let first;
   try {
-    first = readFileSync25(resolve4(path, msgPath), "utf8").split("\n")[0] ?? "";
+    first = readFileSync26(resolve4(path, msgPath), "utf8").split("\n")[0] ?? "";
   } catch {
     return false;
   }
@@ -16053,14 +16247,14 @@ function applyRemoteBranchCleanup(cwd, remote, branches2, dryRun, log) {
 }
 
 // src/stream-sweep.ts
-import { existsSync as existsSync28, readdirSync as readdirSync10, rmSync as rmSync13, statSync as statSync8 } from "fs";
-import { join as join31 } from "path";
+import { existsSync as existsSync30, readdirSync as readdirSync12, rmSync as rmSync13, statSync as statSync8 } from "fs";
+import { join as join33 } from "path";
 var DAY_MS2 = 24 * 60 * 60 * 1e3;
 function planStreamSweep(stateDir, retentionDays, now = Date.now()) {
-  const dir = join31(stateDir, "streams");
-  if (!existsSync28(dir)) return [];
+  const dir = join33(stateDir, "streams");
+  if (!existsSync30(dir)) return [];
   const cutoff = now - retentionDays * DAY_MS2;
-  return readdirSync10(dir).map((name) => join31(dir, name)).filter((path) => {
+  return readdirSync12(dir).map((name) => join33(dir, name)).filter((path) => {
     try {
       return statSync8(path).mtimeMs < cutoff;
     } catch {
@@ -16086,9 +16280,9 @@ function applyStreamSweep(paths, dryRun, log) {
   return removed;
 }
 function planEventsSweep(stateDir, retentionDays, now = Date.now()) {
-  if (!existsSync28(stateDir)) return [];
+  if (!existsSync30(stateDir)) return [];
   const cutoff = now - retentionDays * DAY_MS2;
-  return readdirSync10(stateDir).filter((name) => ROTATED_EVENTS_RE.test(name)).map((name) => join31(stateDir, name)).filter((path) => {
+  return readdirSync12(stateDir).filter((name) => ROTATED_EVENTS_RE.test(name)).map((name) => join33(stateDir, name)).filter((path) => {
     try {
       return statSync8(path).mtimeMs < cutoff;
     } catch {
@@ -16098,23 +16292,23 @@ function planEventsSweep(stateDir, retentionDays, now = Date.now()) {
 }
 
 // src/cli.ts
-import { realpathSync as realpathSync3, readFileSync as readFileSync31, existsSync as existsSync34, mkdirSync as mkdirSync22, writeFileSync as writeFileSync23, rmSync as rmSync15, unlinkSync as unlinkSync5, copyFileSync as copyFileSync2, renameSync as renameSync3, statSync as statSync10, readdirSync as readdirSync15 } from "fs";
+import { realpathSync as realpathSync3, readFileSync as readFileSync31, existsSync as existsSync35, mkdirSync as mkdirSync22, writeFileSync as writeFileSync23, rmSync as rmSync15, unlinkSync as unlinkSync5, copyFileSync as copyFileSync2, renameSync as renameSync3, statSync as statSync10, readdirSync as readdirSync16 } from "fs";
 import { createInterface } from "readline/promises";
 import { dirname as dirOf, resolve as resolvePath } from "path";
 
 // src/ssh-keys.ts
 import { execFileSync as execFileSync6 } from "child_process";
-import { existsSync as existsSync29, mkdirSync as mkdirSync18, readFileSync as readFileSync26, chmodSync } from "fs";
-import { dirname as dirname19, join as join32 } from "path";
+import { existsSync as existsSync31, mkdirSync as mkdirSync18, readFileSync as readFileSync27, chmodSync } from "fs";
+import { dirname as dirname19, join as join34 } from "path";
 var SshKeyError = class extends Error {
 };
 function shipSshKeyPathFor(stateDir) {
-  return join32(stateDir, "ssh", "id_ed25519");
+  return join34(stateDir, "ssh", "id_ed25519");
 }
 function ensureShipSshKeypair(stateDir) {
   const privateKeyPath = shipSshKeyPathFor(stateDir);
   const publicKeyPath = `${privateKeyPath}.pub`;
-  if (!existsSync29(privateKeyPath)) {
+  if (!existsSync31(privateKeyPath)) {
     mkdirSync18(dirname19(privateKeyPath), { recursive: true });
     try {
       execFileSync6("ssh-keygen", [
@@ -16135,10 +16329,10 @@ function ensureShipSshKeypair(stateDir) {
     }
     chmodSync(privateKeyPath, 384);
   }
-  if (!existsSync29(publicKeyPath)) {
+  if (!existsSync31(publicKeyPath)) {
     throw new SshKeyError(`${privateKeyPath} exists but ${publicKeyPath} does not \u2014 regenerate or restore it`);
   }
-  const publicKey = readFileSync26(publicKeyPath, "utf8").trim();
+  const publicKey = readFileSync27(publicKeyPath, "utf8").trim();
   return { privateKeyPath, publicKeyPath, publicKey };
 }
 function sshKeygenAvailable() {
@@ -16355,9 +16549,9 @@ function syncAllPassengerCheckouts(cfg) {
 
 // src/tunnel.ts
 import { spawn as spawn5 } from "child_process";
-import { existsSync as existsSync30, mkdirSync as mkdirSync19, readFileSync as readFileSync27, writeFileSync as writeFileSync20, unlinkSync as unlinkSync3, readdirSync as readdirSync11 } from "fs";
+import { existsSync as existsSync32, mkdirSync as mkdirSync19, readFileSync as readFileSync28, writeFileSync as writeFileSync20, unlinkSync as unlinkSync3, readdirSync as readdirSync13 } from "fs";
 import { randomInt } from "crypto";
-import { join as join33 } from "path";
+import { join as join35 } from "path";
 var DEFAULT_SPAWN_OPTIONS = { stdio: "ignore", detached: true };
 var defaultSpawn = (cmd, args) => spawn5(cmd, args, DEFAULT_SPAWN_OPTIONS);
 var SLUG_ALPHABET = "abcdefghijklmnopqrstuvwxyz0123456789";
@@ -16424,20 +16618,20 @@ function startTunnel(opts) {
   };
 }
 function tunnelStatePath(stateDir, workspaceId) {
-  return join33(stateDir, "passengers", `${workspaceId}.json`);
+  return join35(stateDir, "passengers", `${workspaceId}.json`);
 }
 function readPersistedTunnel(stateDir, workspaceId) {
   const path = tunnelStatePath(stateDir, workspaceId);
-  if (!existsSync30(path)) return void 0;
+  if (!existsSync32(path)) return void 0;
   try {
-    return JSON.parse(readFileSync27(path, "utf8"));
+    return JSON.parse(readFileSync28(path, "utf8"));
   } catch {
     return void 0;
   }
 }
 function writePersistedTunnel(stateDir, state) {
   const path = tunnelStatePath(stateDir, state.workspaceId);
-  mkdirSync19(join33(stateDir, "passengers"), { recursive: true });
+  mkdirSync19(join35(stateDir, "passengers"), { recursive: true });
   writeFileSync20(path, `${JSON.stringify(state, null, 2)}
 `);
 }
@@ -16535,9 +16729,9 @@ function syncPassengerTunnels(plans, relayHost, relayPort, privateKeyPath, state
   }
 }
 function readAllPersistedWorkspaceIds(stateDir) {
-  const dir = join33(stateDir, "passengers");
-  if (!existsSync30(dir)) return [];
-  return readdirSync11(dir).filter((f) => f.endsWith(".json") && !f.endsWith("-sync.json")).map((f) => f.slice(0, -".json".length));
+  const dir = join35(stateDir, "passengers");
+  if (!existsSync32(dir)) return [];
+  return readdirSync13(dir).filter((f) => f.endsWith(".json") && !f.endsWith("-sync.json")).map((f) => f.slice(0, -".json".length));
 }
 
 // src/mcp-endpoint-registry.ts
@@ -16657,8 +16851,8 @@ async function unregisterEndpoint(workspaceId, info, d) {
 import { createServer as createHttpServer } from "http";
 import { spawn as spawn6 } from "child_process";
 import { randomBytes } from "crypto";
-import { existsSync as existsSync31, mkdirSync as mkdirSync20, readFileSync as readFileSync28, writeFileSync as writeFileSync21, unlinkSync as unlinkSync4, readdirSync as readdirSync12 } from "fs";
-import { join as join34 } from "path";
+import { existsSync as existsSync33, mkdirSync as mkdirSync20, readFileSync as readFileSync29, writeFileSync as writeFileSync21, unlinkSync as unlinkSync4, readdirSync as readdirSync14 } from "fs";
+import { join as join36 } from "path";
 
 // src/secret-compare.ts
 import { timingSafeEqual } from "crypto";
@@ -16747,20 +16941,20 @@ var defaultSpawn2 = (cmd, args, env) => {
   return child;
 };
 function syncDaemonStatePath(stateDir, workspaceId) {
-  return join34(stateDir, "passengers", `${workspaceId}-sync.json`);
+  return join36(stateDir, "passengers", `${workspaceId}-sync.json`);
 }
 function readPersistedSyncDaemon(stateDir, workspaceId) {
   const path = syncDaemonStatePath(stateDir, workspaceId);
-  if (!existsSync31(path)) return void 0;
+  if (!existsSync33(path)) return void 0;
   try {
-    return JSON.parse(readFileSync28(path, "utf8"));
+    return JSON.parse(readFileSync29(path, "utf8"));
   } catch {
     return void 0;
   }
 }
 function writePersistedSyncDaemon(stateDir, state) {
   const path = syncDaemonStatePath(stateDir, state.workspaceId);
-  mkdirSync20(join34(stateDir, "passengers"), { recursive: true });
+  mkdirSync20(join36(stateDir, "passengers"), { recursive: true });
   writeFileSync21(path, `${JSON.stringify(state, null, 2)}
 `);
 }
@@ -16781,10 +16975,10 @@ function waitForExit(pid, alive, timeoutMs = 5e3) {
   }
 }
 function readAllPersistedSyncWorkspaceIds(stateDir) {
-  const dir = join34(stateDir, "passengers");
-  if (!existsSync31(dir)) return [];
+  const dir = join36(stateDir, "passengers");
+  if (!existsSync33(dir)) return [];
   const suffix = "-sync.json";
-  return readdirSync12(dir).filter((f) => f.endsWith(suffix)).map((f) => f.slice(0, -suffix.length));
+  return readdirSync14(dir).filter((f) => f.endsWith(suffix)).map((f) => f.slice(0, -suffix.length));
 }
 function syncPassengerSyncDaemons(plans, cfg, stateDir, deps = {}) {
   const alive = deps.isPidAlive ?? isPidAlive;
@@ -16870,98 +17064,9 @@ function describeCause(err) {
 }
 
 // src/daemon.ts
-import { existsSync as existsSync33, mkdirSync as mkdirSync21, readFileSync as readFileSync30, readdirSync as readdirSync14, rmSync as rmSync14, statSync as statSync9, writeFileSync as writeFileSync22 } from "fs";
-import { join as join36 } from "path";
+import { existsSync as existsSync34, mkdirSync as mkdirSync21, readFileSync as readFileSync30, readdirSync as readdirSync15, rmSync as rmSync14, statSync as statSync9, writeFileSync as writeFileSync22 } from "fs";
+import { join as join37 } from "path";
 import { randomBytes as randomBytes2 } from "crypto";
-
-// src/interrupted.ts
-import { existsSync as existsSync32, readdirSync as readdirSync13, readFileSync as readFileSync29 } from "fs";
-import { join as join35 } from "path";
-var INTERRUPTED_MARKER = calloutHeader("NOTE", "Interrupted");
-function interruptedComment(b) {
-  const tree = b.dirty === null ? "The worktree could not be checked." : b.dirty ? "The worktree has uncommitted changes \u2014 they are this seat's own, from that run." : "The worktree is clean.";
-  return `${INTERRUPTED_MARKER}
-
-The agent run on this ticket was cut short (${b.reason}) before it handed on${b.branch ? `; its branch is \`${b.branch}\`` : ""}. ${tree} The next run on this seat resumes from the worktree rather than starting over.`;
-}
-var handled = /* @__PURE__ */ new Set();
-var pidAlive = (pid) => {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (e) {
-    return e.code === "EPERM";
-  }
-};
-function runFinished(streamPath) {
-  const path = `${streamPath}.meta.json`;
-  if (!existsSync32(path)) return false;
-  try {
-    return JSON.parse(readFileSync29(path, "utf8")).running !== true;
-  } catch {
-    return true;
-  }
-}
-function orphanedStreams(o) {
-  const dir = join35(o.stateDir, "streams");
-  if (!existsSync32(dir)) return [];
-  const ownerAlive = o.isOwnerAlive ?? pidAlive;
-  const out = [];
-  for (const name of readdirSync13(dir)) {
-    if (!name.endsWith(".jsonl") || name.endsWith(".events.jsonl")) continue;
-    const streamPath = join35(dir, name);
-    if (runFinished(streamPath)) continue;
-    const sidecar = readRunSidecar(streamPath);
-    if (!sidecar || sidecar.route !== o.routeLabel) continue;
-    if (ownerAlive(sidecar.ownerPid)) continue;
-    out.push({ streamPath, sidecar });
-  }
-  return out;
-}
-async function reconcileRuns(o) {
-  let adopted = 0;
-  let interrupted = 0;
-  for (const { streamPath, sidecar } of orphanedStreams(o)) {
-    if (handled.has(streamPath)) continue;
-    handled.add(streamPath);
-    const isAlive = o.isAlive ?? runIsAlive;
-    const lock = isAlive(sidecar) ? o.state.acquireRun(sidecar.role, o.maxConcurrentAgents, o.roleConcurrency?.[sidecar.role] ?? 1) : null;
-    const ticketLock = isAlive(sidecar) && sidecar.ticketRecordId ? o.state.acquireTicket(sidecar.ticketRecordId) : null;
-    const work = (async () => {
-      try {
-        const result = await reattachRun(streamPath, sidecar, o.emit, {
-          agentLogKey: await o.agentLogKey?.(sidecar.role).catch(() => void 0),
-          isAlive: o.isAlive,
-          pollMs: o.pollMs,
-          onAdopted: () => o.emit.emit(`adopted ${sidecar.role} run (pid ${sidecar.pid}) left by a previous crew process`, { step: "agent", role: sidecar.role })
-        });
-        if (result.adopted) adopted++;
-        else interrupted++;
-        try {
-          await o.afterRun?.(sidecar, result);
-        } catch (e) {
-          o.emit.warn(`could not follow up on ${sidecar.role} run ${streamPath}: ${e.message}`, { step: "agent" });
-        }
-      } catch (e) {
-        o.emit.warn(`could not reattach ${sidecar.role} run ${streamPath}: ${e.message}`, { step: "agent" });
-      } finally {
-        if (lock?.ok) lock.release();
-        if (ticketLock?.ok) ticketLock.release();
-      }
-    })();
-    if (isAlive(sidecar)) {
-      if (o.inFlight) {
-        o.inFlight.add(work);
-        void work.finally(() => o.inFlight.delete(work));
-      }
-    } else {
-      await work;
-    }
-  }
-  return { adopted, interrupted };
-}
-
-// src/daemon.ts
 var DEFAULT_FLOOR_MS = 5e3;
 var DEFAULT_CEILING_MS = INTERVAL_SECONDS * 1e3;
 var defaultSleep = (ms2) => new Promise((resolve6) => setTimeout(resolve6, ms2));
@@ -17030,8 +17135,8 @@ function latestMtime(path) {
   if (stat.isFile()) return stat.mtimeMs;
   if (!stat.isDirectory()) return 0;
   let latest = stat.mtimeMs;
-  for (const entry of readdirSync14(path, { withFileTypes: true })) {
-    latest = Math.max(latest, latestMtime(join36(path, entry.name)));
+  for (const entry of readdirSync15(path, { withFileTypes: true })) {
+    latest = Math.max(latest, latestMtime(join37(path, entry.name)));
   }
   return latest;
 }
@@ -17040,13 +17145,13 @@ function computeTreeSignature(paths) {
 }
 function makeStaleChecker(paths, opts = {}) {
   const initial = computeTreeSignature(paths);
-  return () => computeTreeSignature(paths) !== initial || opts.reloadSentinel !== void 0 && existsSync33(opts.reloadSentinel);
+  return () => computeTreeSignature(paths) !== initial || opts.reloadSentinel !== void 0 && existsSync34(opts.reloadSentinel);
 }
 function reloadSentinelFor(stateDir) {
-  return join36(stateDir, "reload-requested");
+  return join37(stateDir, "reload-requested");
 }
 function daemonStampFor(stateDir) {
-  return join36(stateDir, "daemon.started");
+  return join37(stateDir, "daemon.started");
 }
 function noteDaemonStarted(stateDir, now = Date.now()) {
   mkdirSync21(stateDir, { recursive: true });
@@ -17309,13 +17414,15 @@ async function reconcileForRoute(ctx, o) {
           await guardRunHandoff(route, ship, tracker, sc.role, sc.ticketRecordId, emit, sc.spawnedAt);
         }
       } finally {
-        if (memberId) {
-          await tracker.setCrewStatus(memberId, "idle").catch((e) => {
-            emit.warn(`could not clear crew status: ${e.message}`, { step: "agent" });
-          });
-        }
-        await tracker.beatIdle(ship.name).catch((e) => {
-          emit.warn(`could not beat ship idle: ${e.message}`, { step: "agent" });
+        await settleRunEnd({
+          tracker,
+          shipName: ship.name,
+          route,
+          role: sc.role,
+          memberId,
+          ownTicketRecordId: sc.ticketRecordId,
+          stateDir: ship.stateDir,
+          emit
         });
       }
     }
@@ -17469,18 +17576,16 @@ async function runRoleAgentLocked(role, decision, ctx, hooks, held) {
     await spawnAgent(plan, emit, hintMoved);
     await guardRunHandoff(route, ship, tracker, role, workingId, emit, runStart);
   } finally {
-    if (memberId) {
-      try {
-        await tracker.setCrewStatus(memberId, "idle");
-      } catch (e) {
-        emit.warn(`could not clear crew status: ${e.message}`, { step: "agent" });
-      }
-    }
-    try {
-      await tracker.beatIdle(ship.name);
-    } catch (e) {
-      emit.warn(`could not beat ship idle: ${e.message}`, { step: "agent" });
-    }
+    await settleRunEnd({
+      tracker,
+      shipName: ship.name,
+      route,
+      role,
+      memberId,
+      ownTicketRecordId: workingId,
+      stateDir: ship.stateDir,
+      emit
+    });
   }
 }
 async function buildEnvironment(route, ship, ticket) {
@@ -17922,7 +18027,7 @@ if (command === "passenger-sync-daemon") {
     } else {
       const toleratesNoRoutes = command === "repos" || command === "ship" || command === "disconnect" && flag("reset") || command === "connect" && flag("sign-out");
       const configless = command === "connect" && flag("sign-out") || command === "disconnect" && flag("reset");
-      if (configless && !existsSync34(findConfigFile(CREW_HOME))) {
+      if (configless && !existsSync35(findConfigFile(CREW_HOME))) {
         cfg = loadConfig(CREW_HOME, firstRunConfigPath(), { text: "ship: {}\n", allowNoRoutes: true });
       } else {
         cfg = loadConfig(CREW_HOME, void 0, toleratesNoRoutes ? { allowNoRoutes: true } : {});
@@ -18160,8 +18265,8 @@ if (command === "passenger-sync-daemon") {
     }
     if (host === "linux" && hasSystemd) {
       const label = labelFor(CREW_HOME, "run");
-      const staleTimer = join37(homedir10(), ".config", "systemd", "user", `${label}.timer`);
-      if (existsSync34(staleTimer)) {
+      const staleTimer = join38(homedir10(), ".config", "systemd", "user", `${label}.timer`);
+      if (existsSync35(staleTimer)) {
         process.stdout.write(
           `removing stale run timer from before the persistent-service cutover: ${staleTimer}${dryRun ? " (dry run)" : ""}
 `
@@ -18188,7 +18293,7 @@ if (command === "passenger-sync-daemon") {
     const tracker = new Tracker(c, cfg.ship);
     problems.push(...validateContract(tracker.contract).map((p) => `contract: ${p}`));
     for (const r of await resolvedRepos(c)) {
-      if (!existsSync34(r.dir)) problems.push(`repo ${r.name}: ${r.dir} is missing on disk`);
+      if (!existsSync35(r.dir)) problems.push(`repo ${r.name}: ${r.dir} is missing on disk`);
       if (!satisfies(host, r.config.platform)) problems.push(`repo ${r.name}: requires ${r.config.platform}, this host is ${host}`);
       readiness.push(...validateEffective(r.config).map((p) => `repo ${r.name}: ${p}`));
     }
@@ -18206,7 +18311,7 @@ if (command === "passenger-sync-daemon") {
   }
   async function doctorFix(o) {
     const routes = await Promise.all(routesInScope(cfg.routes, named).map((c) => gatherHealth({ route: c.route, enabled: c.enabled, hasRepos: reposOf(c).length > 0 }, () => routeProblems(c))));
-    const unitExists = (p) => existsSync34(p);
+    const unitExists = (p) => existsSync35(p);
     const crontab = o.host === "linux" ? spawnSync7("crontab", ["-l"], { encoding: "utf8" }).stdout ?? "" : "";
     const schedulerAbsent = o.host !== "windows" ? !schedulerInstalled(planInstall(cfg.ship, CREW_HOME, o.host, detectSystemd(), "run"), unitExists, crontab) : true;
     const plan = planFix({ routes, schedulerAbsent, host: o.host });
@@ -18995,18 +19100,16 @@ ${cu.tail.trimEnd()}
           await guardRunHandoff(w.route, cfg.ship, fleetTracker, w.role, fleetWorkingId, wemit, runStart);
         } finally {
           dropLock();
-          if (fleetMemberId) {
-            try {
-              await fleetTracker.setCrewStatus(fleetMemberId, "idle");
-            } catch (e) {
-              wemit.warn(`could not clear crew status: ${e.message}`, { step: "agent" });
-            }
-          }
-          try {
-            await fleetTracker.beatIdle(cfg.ship.name);
-          } catch (e) {
-            wemit.warn(`could not beat ship idle: ${e.message}`, { step: "agent" });
-          }
+          await settleRunEnd({
+            tracker: fleetTracker,
+            shipName: cfg.ship.name,
+            route: w.route,
+            role: w.role,
+            memberId: fleetMemberId,
+            ownTicketRecordId: fleetWorkingId,
+            stateDir: cfg.ship.stateDir,
+            emit: wemit
+          });
         }
         if (!skipInlineRelease) await releaseFleet();
         break;
@@ -19236,18 +19339,16 @@ ${cu.tail.trimEnd()}
           await guardRunHandoff(route, cfg.ship, tracker2, current, workingId, emit, runStart);
         } finally {
           dropLock();
-          if (memberId) {
-            try {
-              await tracker2.setCrewStatus(memberId, "idle");
-            } catch (e) {
-              emit.warn(`could not clear crew status: ${e.message}`, { step: "agent" });
-            }
-          }
-          try {
-            await tracker2.beatIdle(cfg.ship.name);
-          } catch (e) {
-            emit.warn(`could not beat ship idle: ${e.message}`, { step: "agent" });
-          }
+          await settleRunEnd({
+            tracker: tracker2,
+            shipName: cfg.ship.name,
+            route,
+            role: current,
+            memberId,
+            ownTicketRecordId: workingId,
+            stateDir: cfg.ship.stateDir,
+            emit
+          });
         }
         ran.push(current);
         if (ran.length >= maxRoles || explicitRole) break;
@@ -19331,7 +19432,7 @@ ${cu.tail.trimEnd()}
         process.exit(1);
       }
       requireArmed("run the daemon loop");
-      const watchPaths = isCompiledBinary(import.meta.url) ? [process.execPath] : [join37(CREW_HOME, "src"), join37(CREW_HOME, "dist"), join37(CREW_HOME, "bin")];
+      const watchPaths = isCompiledBinary(import.meta.url) ? [process.execPath] : [join38(CREW_HOME, "src"), join38(CREW_HOME, "dist"), join38(CREW_HOME, "bin")];
       const configPaths = daemonConfigPaths(cfg);
       watchPaths.push(...configPaths);
       noteDaemonStarted(cfg.ship.stateDir);
@@ -19560,7 +19661,7 @@ ${cu.tail.trimEnd()}
 `);
       if (!dryRun) {
         const resolvedPath = resolvedPathFor(cfg.ship.stateDir, target.route);
-        const raw = existsSync34(resolvedPath) ? JSON.parse(readFileSync31(resolvedPath, "utf8")) : {};
+        const raw = existsSync35(resolvedPath) ? JSON.parse(readFileSync31(resolvedPath, "utf8")) : {};
         raw.agentSkills = result.agentSkills;
         mkdirSync22(dirOf(resolvedPath), { recursive: true });
         writeFileSync23(resolvedPath, `${JSON.stringify(raw, null, 2)}
@@ -19664,10 +19765,10 @@ ${cu.tail.trimEnd()}
         try {
           const a = parseHooksArgs(positional.slice(2), routeNamesOf(configText));
           const dir = repoDirOf(configText, dirname20(cfg.configFile), a.route, a.name);
-          if (!existsSync34(dir)) throw new ReposError(`${dir} does not exist on disk`);
-          const files = { exists: (r) => existsSync34(resolvePath(dir, r)), list: (r) => {
+          if (!existsSync35(dir)) throw new ReposError(`${dir} does not exist on disk`);
+          const files = { exists: (r) => existsSync35(resolvePath(dir, r)), list: (r) => {
             try {
-              return readdirSync15(resolvePath(dir, r));
+              return readdirSync16(resolvePath(dir, r));
             } catch {
               return [];
             }
@@ -19783,7 +19884,7 @@ ${cu.tail.trimEnd()}
       if (sub === "list" && !routeName) usage2();
       if (sub === "add") {
         try {
-          const a = parseAddArgs(positional.slice(2), routeNamesOf(configText), (p) => existsSync34(resolvePath(p.replace(/^~(?=\/|$)/, homedir10()))));
+          const a = parseAddArgs(positional.slice(2), routeNamesOf(configText), (p) => existsSync35(resolvePath(p.replace(/^~(?=\/|$)/, homedir10()))));
           routeName = a.route;
           addPath = a.path;
           addName = a.name;
@@ -19812,7 +19913,7 @@ ${cu.tail.trimEnd()}
       }
       const resolvedFile = resolvedPathFor(cfg.ship.stateDir, routeName);
       let resolvedRemotes;
-      if (existsSync34(resolvedFile)) {
+      if (existsSync35(resolvedFile)) {
         try {
           resolvedRemotes = JSON.parse(readFileSync31(resolvedFile, "utf8"));
         } catch {
@@ -19821,7 +19922,7 @@ ${cu.tail.trimEnd()}
       const originOf = (dir) => gitOk(dir, ["remote", "get-url", "origin"]) ?? void 0;
       const text = configText;
       const base = dirname20(cfg.configFile);
-      const isCheckout = (d) => existsSync34(`${d}/.git`);
+      const isCheckout = (d) => existsSync35(`${d}/.git`);
       try {
         if (sub === "list") {
           if (flag("json")) {
@@ -19831,7 +19932,7 @@ ${cu.tail.trimEnd()}
               base,
               resolved: resolvedRemotes,
               originOf,
-              exists: (d) => existsSync34(d),
+              exists: (d) => existsSync35(d),
               isCheckout,
               repoHasHooks: (d) => REPO_CONFIG_FILENAMES.some((f) => {
                 try {
@@ -19852,7 +19953,7 @@ ${cu.tail.trimEnd()}
           for (const r of repos) {
             const origin2 = originOf(r.dir);
             const row = matchRepoName(origin2, resolvedRemotes);
-            const note = !existsSync34(r.dir) ? "missing on disk" : row ? `Repos row: ${row}` : `no Repos row matches ${normalizeRemote(origin2) ?? "this checkout (no origin remote)"}`;
+            const note = !existsSync35(r.dir) ? "missing on disk" : row ? `Repos row: ${row}` : `no Repos row matches ${normalizeRemote(origin2) ?? "this checkout (no origin remote)"}`;
             process.stdout.write(`${r.name}	${r.dir}	${note}
 `);
           }
@@ -19864,9 +19965,9 @@ ${cu.tail.trimEnd()}
 ` : `${human}
 `);
           const plan2 = planRepoClone({ text, base, route: routeName, name: addName, resolved: resolvedRemotes, dir: value("dir"), isCheckout });
-          if (existsSync34(plan2.target) && (existsSync34(`${plan2.target}/.git`) || readdirSync15(plan2.target).length > 0)) {
+          if (existsSync35(plan2.target) && (existsSync35(`${plan2.target}/.git`) || readdirSync16(plan2.target).length > 0)) {
             throw new ReposError(
-              existsSync34(`${plan2.target}/.git`) ? `${plan2.target} is already a checkout \u2014 attach it with \`crew repos add ${routeName} ${plan2.name} ${plan2.target}\`` : `${plan2.target} exists and is not empty \u2014 pass --dir to clone somewhere else`
+              existsSync35(`${plan2.target}/.git`) ? `${plan2.target} is already a checkout \u2014 attach it with \`crew repos add ${routeName} ${plan2.name} ${plan2.target}\`` : `${plan2.target} exists and is not empty \u2014 pass --dir to clone somewhere else`
             );
           }
           if (dryRun) {
@@ -19891,7 +19992,7 @@ ${cu.tail.trimEnd()}
           break;
         }
         const target = resolvePath(addPath.replace(/^~(?=\/|$)/, homedir10()));
-        const top = existsSync34(target) ? gitOk(target, ["rev-parse", "--show-toplevel"]) : null;
+        const top = existsSync35(target) ? gitOk(target, ["rev-parse", "--show-toplevel"]) : null;
         if (!top) throw new ReposError(`${target} is not a git checkout`);
         const origin = originOf(top);
         const plan = planRepoAdd({
@@ -19943,7 +20044,7 @@ ${cu.tail.trimEnd()}
           const created = await rowTracker.createRepoRow(rowPayload);
           process.stdout.write(`created Repos row ${String(rowPayload.name)} (${String(rowPayload.remote)}) ${created.id}
 `);
-          if (existsSync34(resolvedFile)) {
+          if (existsSync35(resolvedFile)) {
             const raw = JSON.parse(readFileSync31(resolvedFile, "utf8"));
             raw.repoNames = { ...raw.repoNames, [created.id]: String(rowPayload.name) };
             raw.repoRemotes = { ...raw.repoRemotes, [created.id]: String(rowPayload.remote) };
@@ -20360,7 +20461,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
           }
         }
         let previous;
-        const hadPreviousFile = existsSync34(resolvedPath);
+        const hadPreviousFile = existsSync35(resolvedPath);
         if (hadPreviousFile) {
           try {
             previous = JSON.parse(readFileSync31(resolvedPath, "utf8"));
@@ -21402,7 +21503,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
         }
         if (row) {
           await tracker.deleteRepoRow(row.id);
-          if (existsSync34(resolvedFile)) {
+          if (existsSync35(resolvedFile)) {
             const raw = JSON.parse(readFileSync31(resolvedFile, "utf8"));
             if (raw.repoNames) delete raw.repoNames[row.id];
             if (raw.repoRemotes) delete raw.repoRemotes[row.id];
@@ -21410,21 +21511,21 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
 `);
           }
         }
-        if (existsSync34(join37(dir, ".git")) && basename12(dir) === SAMPLE_REPO) rmSync15(dir, { recursive: true, force: true });
+        if (existsSync35(join38(dir, ".git")) && basename12(dir) === SAMPLE_REPO) rmSync15(dir, { recursive: true, force: true });
         say("removed", { dir, closed }, `removed the sample repo${closed.length ? `, closed ${closed.join(", ")}` : ""}`);
         break;
       }
       const projectId = route.resolved.areaId ?? resolveRepoProject(await tracker.projectRows(), value("project"));
-      const fresh = !existsSync34(join37(dir, ".git"));
-      if (existsSync34(dir) && fresh && readdirSync15(dir).length > 0) fail(`${dir} exists and is not a git checkout \u2014 move it aside`);
+      const fresh = !existsSync35(join38(dir, ".git"));
+      if (existsSync35(dir) && fresh && readdirSync16(dir).length > 0) fail(`${dir} exists and is not a git checkout \u2014 move it aside`);
       if (dryRun) {
         say("dry-run", { dir, newCheckout: fresh, repoRow: row?.id ?? null }, `would ${fresh ? "create" : "reuse"} ${dir}${row ? "" : ", create the Repos row"}, and file one ${tracker.contract.statuses.approved} ticket`);
         break;
       }
       if (fresh) {
         mkdirSync22(dir, { recursive: true });
-        writeFileSync23(join37(dir, "README.md"), SAMPLE_README);
-        writeFileSync23(join37(dir, ".crew.yaml"), SAMPLE_CREW_YAML);
+        writeFileSync23(join38(dir, "README.md"), SAMPLE_README);
+        writeFileSync23(join38(dir, ".crew.yaml"), SAMPLE_CREW_YAML);
         const g = (...a) => {
           const r = spawnSync7("git", a, { cwd: dir, encoding: "utf8" });
           if (r.status !== 0) fail(`git ${a[0]} failed in ${dir}: ${(r.stderr || r.stdout).trim()}`);
@@ -21442,7 +21543,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
           spec: { platform: "unix", releaseMode: "integrate", ciProvider: "none" }
         });
         repoId = (await tracker.createRepoRow(payload)).id;
-        if (existsSync34(resolvedFile)) {
+        if (existsSync35(resolvedFile)) {
           const raw = JSON.parse(readFileSync31(resolvedFile, "utf8"));
           raw.repoNames = { ...raw.repoNames, [repoId]: SAMPLE_REPO };
           raw.repoRemotes = { ...raw.repoRemotes, [repoId]: SAMPLE_REMOTE };
@@ -21573,6 +21674,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
       const todo = await statusTracker.openTickets().then((open) => operatorTodo(open, statusTracker.contract, route.resolved?.operator ?? "")).catch(() => []);
       const projects = projectModeLabels(await statusTracker.projectRowsWithModes().catch(() => []));
       const crewMinVersion = await readCrewFloor(route, cfg.ship) ?? null;
+      const runs = liveRuns(cfg.ship.stateDir);
       if (flag("json")) {
         const nameSync = await reconcileRouteShipName({ route, ship: cfg.ship, configFile: cfg.configFile, readOnly: true });
         const repos = await resolvedRepos(route);
@@ -21590,7 +21692,9 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
             label: ROLE_LABEL[r],
             crewId: seatId ?? null,
             name: crewRow?.name ?? null,
-            personaName
+            personaName,
+            // Additive (CREW-2822): how many runs this seat has live right now.
+            running: runs.filter((x) => x.role === r && x.route === routeSlug(route.route)).length
           };
         });
         process.stdout.write(`${JSON.stringify({
@@ -21633,6 +21737,8 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
             roles: ROLE_NAMES.map((r) => ({ name: r, label: ROLE_LABEL[r], paused: state.isRolePaused(r) })),
             seats: seats2
           },
+          // Additive (CREW-2822): every live run on this ship. `version` stays 1.
+          runs: runs.map((x) => describeRun(x, route, seatIds)),
           watermark: state.watermark(),
           route: {
             name: route.route,
@@ -21745,6 +21851,10 @@ watermark:  ${state.watermark()}
 `
         );
       }
+      for (const x of runs) {
+        process.stdout.write(`running:    ${x.role} \u2014 ${x.ticket ?? "(no ticket)"}${x.repo ? ` in ${x.repo}` : ""} (pid ${x.pid}, since ${x.spawnedAt})
+`);
+      }
       if (shipRows.length) {
         process.stdout.write("ships:\n");
         for (const s of shipRows) {
@@ -21773,7 +21883,7 @@ watermark:  ${state.watermark()}
           }
           for (const r of repos) {
             const remote = r.config.branch.remote;
-            if (existsSync34(r.dir)) {
+            if (existsSync35(r.dir)) {
               pushAuth.push({
                 route: c.route,
                 repo: r.name,
@@ -21834,7 +21944,7 @@ routes:            ${cfg.routes.map((c) => c.route).join(", ")}
 `);
       try {
         const evFile = eventFileFor(cfg.ship.stateDir);
-        const evSize = existsSync34(evFile) ? statSync10(evFile).size : 0;
+        const evSize = existsSync35(evFile) ? statSync10(evFile).size : 0;
         process.stdout.write(
           evSize > cfg.ship.eventsRotateBytes * 4 ? `events log:        WARN ${evFile} is ${Math.round(evSize / 1048576)} MB (> 4x eventsRotateBytes); run \`crew reap\` to rotate it
 ` : "events log:        ok\n"