@tablation/crew 0.82.0 → 0.83.0

package/dist/cli.js

@@ -1448,6 +1448,7 @@ var HOOK_NAMES = [
   "ports",
   "isolate",
   "handoff",
+  "preview",
   "ci_status",
   "version",
   "bump",
@@ -2316,6 +2317,7 @@ function parseResolved(raw, m, where) {
     areaId: raw.areaId,
     shipsModelId: raw.shipsModelId,
     epicsModelId: raw.epicsModelId,
+    periscopesModelId: raw.periscopesModelId,
     locksModelId: raw.locksModelId,
     recordLinkViewId: raw.recordLinkViewId,
     reposModelId: raw.reposModelId,
@@ -4215,6 +4217,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 +4598,1455 @@ 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`);
+  pause(role) {
+    writeFileSync7(role ? this.path(`.role-paused-${role}`) : this.path(".crew-paused"), "");
   }
-  if (c.statuses.reviewing && !open.has(c.statuses.reviewing)) {
-    problems.push(`statuses.reviewing ("${c.statuses.reviewing}") is not listed in statuses.open`);
+  resume(role) {
+    rmSync6(role ? this.path(`.role-paused-${role}`) : this.path(".crew-paused"), { force: true });
   }
-  if (!resolved.has(c.statuses.deployed)) {
-    problems.push(`statuses.deployed ("${c.statuses.deployed}") 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 (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`
-    );
+  setReleasePaused(paused) {
+    if (paused) writeFileSync7(this.path(".release-paused"), "");
+    else rmSync6(this.path(".release-paused"), { force: true });
   }
-  if (!resolved.has(c.statuses.wontFix)) {
-    problems.push(`statuses.wontFix ("${c.statuses.wontFix}") is not listed in statuses.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.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`
-    );
+  /**
+   * 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, "_");
   }
-  if (resolved.has(c.statuses.approved)) {
-    problems.push(`statuses.approved ("${c.statuses.approved}") is listed as resolved`);
-  }
-  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");
-  }
-  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");
-  }
-  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`);
-  }
-  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;
-  }
-};
-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);
-  }
-  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) {
+  acquire(rawName) {
+    const name = _State.safe(rawName);
+    const file = this.path(`.${name}.lock`);
     try {
-      ticketRecordId = await findTicketRecord(target, target.tickets, run2.ticketReference);
+      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 {
     }
-  }
-  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) {
+    writeFileSync7(file, `${process.pid}
+`);
     return {
-      warning: `could not add run spend to ${run2.ticketReference}: ${e.message}`,
-      ...isRetryable(e) ? { retry: write } : {}
+      ok: true,
+      release: () => {
+        try {
+          rmSync6(file, { force: true });
+        } catch {
+        }
+      }
     };
   }
-}
-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;
+  /**
+   * 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 {
-      q = JSON.parse(readFileSync11(path, "utf8"));
+      names = readdirSync4(this.dir);
     } catch {
-      continue;
+      return false;
     }
-    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}`);
+    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;
       }
-      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`);
+      if (!Number.isFinite(pid) || pid <= 0) continue;
+      try {
+        process.kill(pid, 0);
+        return true;
+      } catch {
+      }
     }
-  }
-  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 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).
-   */
-  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);
+    return false;
   }
   /**
-   * 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.
+   * 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.
    */
-  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;
+  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 };
   }
   /**
-   * 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.
+   * 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.
    */
-  decide(hint, opts = {}) {
-    for (const by of ["handoff", "claim", "comment"]) {
-      const ticket = this.#lastBy[by];
-      if (ticket) return { ticket, by };
+  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 (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" };
+    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(", ")})`
+      };
     }
-    return { ticket: hint, by: "hint" };
+    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();
+    } };
   }
   /**
-   * 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.
+   * 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.
    */
-  winner(fallback) {
-    let best = fallback;
-    let bestTokens = -1;
-    for (const [ticket, tokens] of this.#tokensByTicket) {
-      if (tokens > bestTokens) {
-        best = ticket;
-        bestTokens = tokens;
-      }
-    }
-    return best;
-  }
-};
-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 };
+  acquireTicket(recordId) {
+    return this.acquire(`crew-ticket-${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) {
+  /** 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 {
-      const doc = JSON.parse(text);
-      if (doc && typeof doc === "object") {
-        const code = doc.statusCode;
-        return typeof code === "number" && code >= 500;
-      }
+      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;
     }
   }
-  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);
-        }
-      }
+  /**
+   * 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 {
+      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}
+`);
+      }
+    };
+  }
+  /**
+   * 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 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");
+        }
+      }
+    };
+  }
+  /**
+   * 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.
+   */
+  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));
+      }
+    };
+  }
+  /**
+   * 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));
+      }
+    };
+  }
+  /**
+   * 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.
+   */
+  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));
+      }
+    };
+  }
+  /**
+   * 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.
+   */
+  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;
+    }
+  }
+};
+
+// 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"],
+  ["preview", "start this worktree's dev server for a viewer, bound to CREW_PREVIEW_HOST, detached; its last stdout line is the URL"],
+  ["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."
+    );
+  }
+  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."
+    );
+  }
+  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)`] : []
+    );
+  }
+  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."
+      );
+    }
+  }
+  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);
+// 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`);
   }
-  /**
-   * 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;
-    }
+  if (c.statuses.reviewing && !open.has(c.statuses.reviewing)) {
+    problems.push(`statuses.reviewing ("${c.statuses.reviewing}") is not listed in statuses.open`);
   }
-  setWatermark(at) {
-    writeFileSync8(this.path(".poll-watermark"), `${at}
-`);
+  if (!resolved.has(c.statuses.deployed)) {
+    problems.push(`statuses.deployed ("${c.statuses.deployed}") is not listed in statuses.resolved`);
   }
-  /**
-   * 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 (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`
+    );
   }
-  /** Whole-crew pause, and the per-role sentinels one level down. */
-  isPaused() {
-    return existsSync12(this.path(".crew-paused"));
+  if (!resolved.has(c.statuses.wontFix)) {
+    problems.push(`statuses.wontFix ("${c.statuses.wontFix}") is not listed in statuses.resolved`);
   }
-  isRolePaused(role) {
-    return existsSync12(this.path(`.role-paused-${role}`));
+  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`
+    );
   }
-  pausedRoles(roles) {
-    return new Set(roles.filter((r) => this.isRolePaused(r)));
+  if (resolved.has(c.statuses.approved)) {
+    problems.push(`statuses.approved ("${c.statuses.approved}") is listed as resolved`);
   }
-  pause(role) {
-    writeFileSync8(role ? this.path(`.role-paused-${role}`) : this.path(".crew-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");
   }
-  resume(role) {
-    rmSync7(role ? this.path(`.role-paused-${role}`) : this.path(".crew-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");
   }
-  /**
-   * 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.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`);
   }
-  setReleasePaused(paused) {
-    if (paused) writeFileSync8(this.path(".release-paused"), "");
-    else rmSync7(this.path(".release-paused"), { force: true });
+  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.";
+var PERISCOPE_COLUMNS = [
+  "ticket_id",
+  "ship_id",
+  "url",
+  "host",
+  "worktree",
+  "branch",
+  "state",
+  "isolated",
+  "started_at",
+  "last_activity_at",
+  "expires_at"
+];
+
+// 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;
   }
-  /**
-   * 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;
+};
+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);
   }
-  /**
-   * 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 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 };
   }
-  acquire(rawName) {
-    const name = _State.safe(rawName);
-    const file = this.path(`.${name}.lock`);
+  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 {
-      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 {
-        }
-      }
+      ticketRecordId = await findTicketRecord(target, target.tickets, run2.ticketReference);
     } catch {
     }
-    writeFileSync8(file, `${process.pid}
-`);
-    return {
-      ok: true,
-      release: () => {
-        try {
-          rmSync7(file, { force: true });
-        } catch {
-        }
-      }
-    };
   }
-  /**
-   * 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 = readdirSync5(this.dir);
-    } 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 {
-      }
+  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;
     }
-    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);
+    try {
+      entry = await post(target, "/agents/log", body);
+    } catch (e2) {
+      if (e2 instanceof AgentLogHttpError && e2.status < 500) e2.row = true;
+      throw e2;
     }
-    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 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();
-    } };
+  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 } : {}
+    });
   }
-  /**
-   * 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}`);
+  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 } : {}
+    };
   }
-  /** Whether a live run on this ship holds `recordId`'s ticket lock. */
-  ticketInFlight(recordId) {
-    const file = this.path(`.${_State.safe(`crew-ticket-${recordId}`)}.lock`);
+}
+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`);
+    }
   }
-  /**
-   * 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.
+  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).
    */
-  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();
@@ -6787,6 +6822,19 @@ var Tracker = class {
   async hasPublicReplyColumn() {
     return (await this.authorshipProbe()).commentPublicReply;
   }
+  /**
+   * Whether this workspace has the optional Periscopes table (EPIC-077), and
+   * which of the columns the crew writes (`PERISCOPE_COLUMNS`) it lacks.
+   * `present: false` is a legitimate shape, never a fault. A table whose
+   * metadata cannot be read reports every column missing, as the authorship
+   * probe reads an unreadable table as "column absent".
+   */
+  async periscopesStatus() {
+    const modelId = this.route.resolved?.periscopesModelId;
+    if (!modelId) return { present: false, missing: [] };
+    const have = await this.columnNames(modelId);
+    return { present: true, modelId, missing: PERISCOPE_COLUMNS.filter((c) => !have.has(c)) };
+  }
   /**
    * The authorship columns this workspace is missing, as `table.column` names
    * for `crew doctor` to report (CREW-1371). Empty on a fully updated install.
@@ -8907,6 +8955,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 {
@@ -8939,6 +8991,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" });
     }
   }
@@ -13687,6 +13748,7 @@ function forbiddenDetail(e, route) {
     [r?.shipsModelId, "Ships"],
     [r?.locksModelId, "Locks"],
     [r?.epicsModelId, "Epics"],
+    [r?.periscopesModelId, "Periscopes"],
     [r?.reposModelId, "Repos"]
   ];
   const table2 = modelId ? known.find(([id]) => id && id === modelId)?.[1] ?? `table ${modelId}` : void 0;
@@ -14531,6 +14593,7 @@ async function discover(o) {
   out.reposModelId = find("Repos");
   out.shipsModelId = find("Ships");
   out.epicsModelId = find("Epics");
+  out.periscopesModelId = find("Periscopes");
   out.locksModelId = find("Locks");
   try {
     const views = await get(o, `/views?workspaceId=${ws.id}`);
@@ -14582,6 +14645,7 @@ async function discover(o) {
       shipColumns = new Set((shipsModel.fields ?? []).map((f) => f.columnName));
     } catch {
     }
+    const hostPeriscopes = shipColumns.has("host_periscopes") ? o.ship.hostPeriscopes : void 0;
     let ownerId;
     if (out.meId) {
       if (shipColumns.has("owner_id")) ownerId = out.meId;
@@ -14624,6 +14688,7 @@ async function discover(o) {
       }
       if (writeMachineId) patchBody.machine_id = machineId;
       if ((mine[0].host_passengers ?? false) !== hostPassengers) patchBody.host_passengers = hostPassengers;
+      if (hostPeriscopes !== void 0 && (mine[0].host_periscopes ?? false) !== hostPeriscopes) patchBody.host_periscopes = hostPeriscopes;
       if (sshPublicKey !== void 0 && (mine[0].ssh_public_key ?? "") !== sshPublicKey) {
         patchBody.ssh_public_key = sshPublicKey;
       }
@@ -14631,6 +14696,7 @@ async function discover(o) {
       if (Object.keys(patchBody).length > 0) {
         await patch(o, `/data-models/${out.shipsModelId}/records/${shipRowId}`, patchBody);
         if ("host_passengers" in patchBody) provisioning.push(`synced host_passengers=${hostPassengers} onto Ships row "${o.ship.name}"`);
+        if ("host_periscopes" in patchBody) provisioning.push(`synced host_periscopes=${hostPeriscopes} onto Ships row "${o.ship.name}"`);
         if ("ssh_public_key" in patchBody) provisioning.push(`synced ssh_public_key onto Ships row "${o.ship.name}"`);
         if ("owner_id" in patchBody) provisioning.push(`recorded owner on Ships row "${o.ship.name}"`);
       }
@@ -14639,6 +14705,7 @@ async function discover(o) {
         name: o.ship.name,
         ...o.ship.platform ? { platform: o.ship.platform } : {},
         host_passengers: hostPassengers,
+        ...hostPeriscopes !== void 0 ? { host_periscopes: hostPeriscopes } : {},
         ...sshPublicKey !== void 0 ? { ssh_public_key: sshPublicKey } : {},
         ...ownerId !== void 0 ? { owner_id: ownerId } : {},
         ...writeMachineId ? { machine_id: machineId } : {}
@@ -20529,6 +20596,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
           areaId: found.areaId,
           shipsModelId: found.shipsModelId,
           epicsModelId: found.epicsModelId,
+          periscopesModelId: found.periscopesModelId,
           locksModelId: found.locksModelId,
           recordLinkViewId: found.recordLinkViewId,
           reposModelId: found.reposModelId,
@@ -22011,6 +22079,12 @@ routes:            ${cfg.routes.map((c) => c.route).join(", ")}
       process.stdout.write(
         await tracker.hasPublicReplyColumn() ? `public replies:  Comments.${tracker.contract.comments.publicReply} present \u2014 public reporters are labelled in the digest
 ` : `public replies:  Comments.${tracker.contract.comments.publicReply} absent \u2014 no public intake form, nothing to guard
+`
+      );
+      const periscopes = await tracker.periscopesStatus();
+      process.stdout.write(
+        !periscopes.present ? "periscopes:      Periscopes table absent \u2014 this workspace cannot host periscopes\n" : periscopes.missing.length === 0 ? `periscopes:      Periscopes table present (${periscopes.modelId})
+` : `periscopes:      Periscopes table present (${periscopes.modelId}) but missing ${periscopes.missing.join(", ")} \u2014 update the Issues template
 `
       );
       process.stdout.write(