@tablation/crew 0.14.1 → 0.15.0

package/dist/cli.js

@@ -2038,7 +2038,10 @@ function describeRelease(o, route) {
     return {
       level: "fail",
       headline: `${route}: deploy FAILED`,
-      detail: withHookTail("nothing new is live", o.hookFailure)
+      detail: withHookTail(
+        "the version is merged to the base branch but not live \u2014 run `crew deploy` to retry; do not re-release",
+        o.hookFailure
+      )
     };
   }
   if (o.stopped === "build failed") {
@@ -2570,1793 +2573,1808 @@ function detectSystemd() {
   return !res.error;
 }
 
-// src/ship-attention.ts
-var RELEASE_STALE_AFTER_INTERVALS = 3;
-function upsert(items, item) {
-  const existing = items.find((i) => i.key === item.key);
-  if (!existing) return [...items, item];
-  return items.map((i) => i.key === item.key ? { ...item, since: existing.since } : i);
+// src/git.ts
+import { execFileSync } from "child_process";
+import {
+  existsSync as existsSync6,
+  mkdirSync as mkdirSync4,
+  openSync,
+  closeSync,
+  writeSync,
+  statSync as statSync3,
+  unlinkSync as unlinkSync2
+} from "fs";
+import { dirname as dirname4, basename as basename3 } from "path";
+var GitError = class extends Error {
+};
+function gitRaw(cwd, args) {
+  try {
+    return execFileSync("git", args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
+  } catch (e) {
+    const err = e;
+    const why = [err.stderr, err.stdout].map((x) => (x ?? "").trim()).filter(Boolean).join(" / ");
+    throw new GitError(`git ${args.join(" ")}: ${why || err.message.trim()}`);
+  }
 }
-function clear(items, key) {
-  return items.filter((i) => i.key !== key);
+function git(cwd, args) {
+  try {
+    return execFileSync("git", args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }).trim();
+  } catch (e) {
+    const err = e;
+    const why = [err.stderr, err.stdout].map((x) => (x ?? "").trim()).filter(Boolean).join(" / ");
+    throw new GitError(`git ${args.join(" ")}: ${why || err.message.trim()}`);
+  }
 }
-function transitions(previous, current) {
-  const before = new Set(previous.map((i) => i.key));
-  return current.filter((i) => !before.has(i.key));
+function gitOk(cwd, args) {
+  try {
+    return git(cwd, args);
+  } catch {
+    return null;
+  }
 }
-function staleRelease(lastRunMs, nowMs, intervalSeconds = INTERVAL_SECONDS) {
-  if (lastRunMs === null) return null;
-  const limitMs = RELEASE_STALE_AFTER_INTERVALS * intervalSeconds * 1e3;
-  const ageMs = nowMs - lastRunMs;
-  if (ageMs <= limitMs) return null;
-  const minutes = Math.round(ageMs / 6e4);
-  return {
-    kind: "release_stale",
-    key: "release_stale",
-    message: `This ship has not run a release cycle for ${minutes} minute${minutes === 1 ? "" : "s"} \u2014 check its release timer`,
-    since: new Date(lastRunMs + limitMs).toISOString()
-  };
+function commitDate(cwd, sha) {
+  const out = gitOk(cwd, ["show", "-s", "--format=%cI", sha]);
+  if (!out) return null;
+  const t = new Date(out);
+  return Number.isNaN(t.getTime()) ? null : t.toISOString();
 }
-function openShipAttention(state, nowMs = Date.now()) {
-  const stale = staleRelease(state.releaseHeartbeat().at(), nowMs);
-  const stored = state.shipAttention().previous();
-  return stale ? [...stored, stale] : stored;
+var currentBranch = (cwd) => git(cwd, ["rev-parse", "--abbrev-ref", "HEAD"]);
+var headSha = (cwd) => git(cwd, ["rev-parse", "HEAD"]);
+function status(cwd) {
+  return gitRaw(cwd, ["status", "--porcelain"]).split("\n").filter((l) => l.length > 3).map((l) => ({
+    code: l.slice(0, 2),
+    path: l.slice(3),
+    untracked: l.startsWith("??")
+  }));
 }
-function announce(emit, item) {
-  emit.warn(item.message, {
-    step: "sweep",
-    data: { attention: [`ship:${item.kind}`], title: item.message }
-  });
+function branches(cwd, pattern) {
+  const out = git(cwd, ["branch", "--list", pattern, "--format=%(refname:short)"]);
+  return out ? out.split("\n").filter(Boolean) : [];
 }
-async function raiseShipAttention(o, item) {
-  const store = o.state.shipAttention();
-  const previous = store.previous();
-  const next = upsert(previous, item);
-  store.persist(next);
-  if (transitions(previous, next).length === 0) return false;
-  announce(o.emit, item);
-  if (o.route && o.ship) {
-    await notify(o.route, o.ship, { level: "warn", headline: item.message }, o.emit);
+function branchForIssue(cwd, issueKey, templates = { name: "issue-{number}" }, render2 = (t) => t.replace(/\{number\}/g, issueKey.replace(/^\D+/, ""))) {
+  for (const c of branchCandidates(issueKey, templates, render2)) {
+    const found = branches(cwd, c);
+    if (found.length) return found[0];
   }
-  return true;
+  return null;
 }
-function clearShipAttention(state, key) {
-  const store = state.shipAttention();
-  const previous = store.previous();
-  const next = clear(previous, key);
-  if (next.length !== previous.length) store.persist(next);
+function branchCandidates(issueKey, templates, render2) {
+  const num = issueKey.replace(/^\D+/, "");
+  const unpadded = String(Number.parseInt(num, 10));
+  const candidates = [];
+  for (const template of [templates.name, templates.push].filter(Boolean)) {
+    const exact = render2(template);
+    candidates.push(exact);
+    if (num !== unpadded) candidates.push(exact.replace(num, unpadded));
+    if (template.includes("{slug}")) {
+      const prefix = render2(template.slice(0, template.indexOf("{slug}")));
+      if (prefix) candidates.push(`${prefix}*`);
+    }
+  }
+  candidates.push(`issue-${num}`);
+  if (num !== unpadded) candidates.push(`issue-${unpadded}`);
+  return [...new Set(candidates)];
 }
-function hookCommand(script) {
-  for (const raw of script.split("\n")) {
-    const line = raw.trim();
-    if (!line || line.startsWith("#")) continue;
-    const word = line.split(/\s+/)[0];
-    if (/^[A-Za-z_][A-Za-z0-9_]*=/.test(word)) continue;
-    if (!/^[A-Za-z0-9._+-]+$/.test(word)) return null;
-    if (SHELL_WORDS.has(word)) return null;
-    return word;
+function remoteBranchForIssue(cwd, remote, issueKey, templates = { name: "issue-{number}" }, render2 = (t) => t.replace(/\{number\}/g, issueKey.replace(/^\D+/, ""))) {
+  const prefix = `refs/remotes/${remote}/`;
+  for (const c of branchCandidates(issueKey, templates, render2)) {
+    const out = gitOk(cwd, ["for-each-ref", "--format=%(refname)", `${prefix}${c}`]);
+    const hit = out?.split("\n").filter((r) => r.startsWith(prefix) && r !== `${prefix}HEAD`)[0];
+    if (hit) return hit.slice(prefix.length);
   }
   return null;
 }
-var SHELL_WORDS = /* @__PURE__ */ new Set([
-  "if",
-  "then",
-  "else",
-  "elif",
-  "fi",
-  "for",
-  "while",
-  "until",
-  "do",
-  "done",
-  "case",
-  "esac",
-  "cd",
-  "echo",
-  "export",
-  "set",
-  "exit",
-  "test",
-  "true",
-  "false",
-  "source",
-  ".",
-  "eval",
-  "exec",
-  "ok"
-]);
-
-// src/board-lock.ts
-import { StaleWriteError } from "@tablation/client";
-function releaseLockScope(route, repo) {
-  return `${route}/${repo}`;
-}
-async function acquireBoardLock(client2, modelId, scope, holderLabel, ttlMs) {
-  if (!modelId) return { ok: true, release: async () => {
-  } };
-  const filters = JSON.stringify([{ columnName: "scope", operator: "EQ", value: scope }]);
-  const rows = await client2.list(modelId, { filters, limit: 1 });
-  const row = rows[0];
-  if (!row) return { ok: false, reason: "missing" };
-  const age = Date.now() - new Date(row.updated_at).getTime();
-  const free = !row.holder || row.holder === holderLabel || age > ttlMs;
-  if (!free) return { ok: false, heldBy: row.holder ?? void 0, reason: "held" };
-  let claimed;
-  try {
-    claimed = await client2.update(modelId, row.id, { holder: holderLabel }, row.updated_at);
-  } catch (e) {
-    if (e instanceof StaleWriteError) return { ok: false, reason: "contended" };
-    throw e;
+function materializeRemoteBranch(cwd, remote, branch) {
+  if (!remoteBranchExists(cwd, remote, branch)) {
+    return gitOk(cwd, ["rev-parse", "-q", "--verify", `refs/heads/${branch}`]) !== null;
   }
-  return {
-    ok: true,
-    release: async () => {
-      try {
-        await client2.update(modelId, row.id, { holder: "" }, claimed.updated_at);
-      } catch {
-      }
-    }
-  };
-}
-async function lockRowState(client2, modelId, scope) {
-  const rows = await client2.list(modelId, { filters: scopeFilter(scope), limit: 1 });
-  const row = rows[0];
-  if (!row) return { exists: false };
-  return { exists: true, ...row.holder ? { holder: row.holder, since: row.updated_at } : {} };
-}
-var scopeFilter = (scope) => JSON.stringify([{ columnName: "scope", operator: "EQ", value: scope }]);
-async function ensureLockRows(client2, modelId, scopes) {
-  const created = [];
-  for (const scope of scopes) {
-    const filters = scopeFilter(scope);
-    if ((await client2.list(modelId, { filters, limit: 1 })).length > 0) continue;
-    let mine;
-    try {
-      mine = await client2.create(modelId, { scope, holder: "" });
-    } catch (e) {
-      const status2 = e.status;
-      if (status2 === 409 || status2 === 400) {
-        if ((await client2.list(modelId, { filters, limit: 1 })).length > 0) continue;
-      }
-      throw e;
-    }
-    const all = await client2.list(modelId, { filters, limit: 20 });
-    const keeper = [...all].sort((a, b) => (a.created_at ?? "").localeCompare(b.created_at ?? "") || a.id.localeCompare(b.id))[0];
-    if (keeper && keeper.id !== mine.id) {
-      await client2.remove(modelId, mine.id).catch(() => {
-      });
-      continue;
-    }
-    created.push(scope);
+  if (gitOk(cwd, ["rev-parse", "-q", "--verify", `refs/heads/${branch}`]) === null) {
+    return gitOk(cwd, ["branch", "--track", branch, `${remote}/${branch}`]) !== null;
   }
-  return created;
-}
-
-// src/tracker.ts
-function ticketBranchContext(t) {
-  const tag = t.issue_tag ?? void 0;
-  if (!tag) return {};
-  const prefix = t.project_issue_prefix ? t.project_issue_prefix.toLowerCase() : void 0;
-  return { tag, prefix };
+  gitOk(cwd, ["fetch", "--quiet", remote, `${branch}:${branch}`]);
+  return true;
 }
-function displayKey(t) {
-  return t.issue_tag ?? t.issue_id;
+function deleteRemoteBranch(cwd, remote, branch) {
+  if (!remoteBranchExists(cwd, remote, branch)) return true;
+  return gitOk(cwd, ["push", remote, "--delete", branch]) !== null;
 }
-function referenceKeys(t) {
-  return t.issue_tag && t.issue_tag !== t.issue_id ? [t.issue_id, t.issue_tag] : [t.issue_id];
+function worktreeForNumber(cwd, num) {
+  const re = new RegExp(`(?:^|-)${num}$`);
+  return worktrees(cwd).find((w) => re.test(basename3(w.path))) ?? null;
 }
-var RESOLVED_STATUSES = new Set(DEFAULT_CONTRACT.statuses.resolved);
-var encodeFilters = (f) => JSON.stringify(f);
-var encodeSort = (s) => JSON.stringify(s);
-var Tracker = class {
-  // NB: explicit fields, not TypeScript parameter properties — node's
-  // --experimental-strip-types cannot transform those, and the test runner
-  // uses it. The same rule applies everywhere in src/.
-  route;
-  /** This workspace's rules. A ship holds several, one per route. */
-  contract;
-  client;
-  models;
-  userAgent;
-  shipName;
-  /**
-   * The once-per-process authorship probe (CREW-1371), memoised as a promise
-   * so concurrent first writes share one round of field-metadata reads.
-   */
-  authorship;
-  stateDir;
-  constructor(route, ship) {
-    this.route = route;
-    if (!route.resolved) {
-      throw new ConfigError(
-        `route "${route.route}" has no resolved ids \u2014 run \`crew connect\` to discover them from the project`
-      );
-    }
-    this.models = route.resolved.models;
-    this.contract = resolveContract(route.contract);
-    this.userAgent = ship.userAgent;
-    this.shipName = ship.name;
-    this.stateDir = ship.stateDir;
-    this.client = new TablationClient({
-      baseUrl: `${route.baseUrl}/api`,
-      apiKey: resolveApiKey(route),
-      // Cloudflare 403s (error 1010) default agents on this host.
-      headers: { "User-Agent": ship.userAgent }
-    });
+var commitBodies = (cwd, range) => gitOk(cwd, ["log", range, "--format=%B"]) ?? "";
+var resolve2 = (cwd, ref) => gitOk(cwd, ["rev-parse", "-q", "--verify", `${ref}^{commit}`]);
+var countCommits = (cwd, range) => Number.parseInt(gitOk(cwd, ["rev-list", "--count", range]) ?? "0", 10);
+function latestReleaseTag(cwd, pattern = "v*", ref = "HEAD") {
+  return gitOk(cwd, ["describe", "--tags", "--abbrev=0", "--match", pattern, ref]);
+}
+function firstReleaseTagContaining(cwd, sha, pattern = "v*") {
+  const out = gitOk(cwd, ["tag", "--contains", sha, "--list", pattern, "--sort=creatordate"]);
+  return out?.split("\n").map((l) => l.trim()).find(Boolean) ?? null;
+}
+var tagCommit = (cwd, tag) => resolve2(cwd, tag);
+function createReleaseTag(cwd, tag, sha, message) {
+  git(cwd, ["tag", "-a", tag, sha, "-m", message]);
+}
+var tagExists = (cwd, tag) => gitOk(cwd, ["rev-parse", "-q", "--verify", `refs/tags/${tag}`]) !== null;
+function pushTag(cwd, remote, tag) {
+  git(cwd, ["push", remote, tag]);
+}
+function fetchRemote(cwd, remote = "origin") {
+  return gitOk(cwd, ["fetch", "--prune", "--quiet", remote]) !== null;
+}
+function remoteConfigured(cwd, remote = "origin") {
+  return gitOk(cwd, ["remote", "get-url", remote]) !== null;
+}
+function remoteBranchExists(cwd, remote, branch) {
+  return gitOk(cwd, ["rev-parse", "-q", "--verify", `refs/remotes/${remote}/${branch}`]) !== null;
+}
+function findKeyInRange(cwd, key, range) {
+  return keyCommitsInRange(cwd, key, range)[0] ?? null;
+}
+function keyCommitsInRange(cwd, key, range) {
+  const keys = Array.isArray(key) ? key : [key];
+  const escaped = keys.map((k) => k.replace(/[.[\]{}()*+?^$|\\]/g, "\\$&"));
+  const pattern = `(^|[^0-9A-Za-z_-])(${escaped.join("|")})([^0-9]|$)`;
+  const out = gitOk(cwd, ["log", range, "--format=%H %s", "--extended-regexp", `--grep=${pattern}`]);
+  if (!out) return [];
+  return out.split("\n").map((l) => l.split(" ")[0]).filter(Boolean);
+}
+function patchIdOf(cwd, from, to) {
+  try {
+    const diff = execFileSync("git", ["diff", from, to], { cwd, encoding: "utf8", maxBuffer: 256 * 1024 * 1024 });
+    if (!diff) return null;
+    const out = execFileSync("git", ["patch-id", "--stable"], { cwd, encoding: "utf8", input: diff });
+    return out.split(" ")[0]?.trim() || null;
+  } catch {
+    return null;
   }
-  /**
-   * Every non-terminal ticket for this route's area, in one call.
-   *
-   * The area filter is what keeps two routes on one tracker out of each
-   * other's queue: a ship working `synthesis` and `tablation-js` from the same
-   * Issues project must not have either seat pick up the other's tickets. A
-   * route with no area sees everything, which is right for a tracker
-   * nobody has sliced yet.
-   */
-  async openTickets() {
-    const c = this.contract;
-    const filters = [
-      { columnName: c.columns.status, operator: "IN", value: c.statuses.open }
-    ];
-    const areaId = this.route.resolved?.areaId;
-    if (areaId) filters.push({ columnName: c.columns.slice, operator: "EQ", value: areaId });
-    return this.client.records.list(this.models.issues, {
-      filters: encodeFilters(filters),
-      limit: 500
-    });
+}
+function findSquashOfBranch(cwd, key, branch, base, range) {
+  const candidates = keyCommitsInRange(cwd, key, range);
+  if (candidates.length === 0) return null;
+  const mb = gitOk(cwd, ["merge-base", base, branch]);
+  const branchPatch = mb ? patchIdOf(cwd, mb, branch) : null;
+  for (const sha of candidates) {
+    if (gitOk(cwd, ["diff", "--quiet", branch, sha]) !== null) return sha;
+    if (branchPatch && gitOk(cwd, ["rev-parse", "--verify", "-q", `${sha}^`]) !== null && patchIdOf(cwd, `${sha}^`, sha) === branchPatch) return sha;
   }
-  /**
-   * Tickets at a terminal, no-longer-open status — the worktree sweep's
-   * input (ISSUE-346).
-   *
-   * The exact complement of `openTickets()`: `closed_deployed`,
-   * `closed_wont_fix`, `closed_duplicate`. `verified` is excluded even
-   * though the contract counts it as resolved for a *blocker*'s purposes —
-   * it is still pre-release, and its worktree is exactly what the release
-   * phase is about to merge.
-   *
-   * Sorted most-recently-updated first: a board can hold far more than
-   * `limit` closed tickets (this one already has), and an unordered fetch
-   * has no guarantee which ones a truncated page contains. Ordering by
-   * `updatedAt` descending means a truncated page still holds the tickets
-   * most likely to need their worktree swept — the ones that closed most
-   * recently — rather than an arbitrary, possibly stale slice (ISSUE-403).
-   */
-  async terminalTickets() {
-    const c = this.contract;
-    const statuses = closedStatuses(c);
-    if (!statuses.length) return [];
-    const filters = [
-      { columnName: c.columns.status, operator: "IN", value: statuses }
-    ];
-    const areaId = this.route.resolved?.areaId;
-    if (areaId) filters.push({ columnName: c.columns.slice, operator: "EQ", value: areaId });
-    const params = {
-      filters: encodeFilters(filters),
-      limit: 500,
-      sort: encodeSort([{ columnName: c.columns.updatedAt, direction: "desc" }])
+  return null;
+}
+function isAncestor(cwd, ancestor, descendant) {
+  return gitOk(cwd, ["merge-base", "--is-ancestor", ancestor, descendant]) !== null;
+}
+function fileAtRef(cwd, ref, path) {
+  return gitOk(cwd, ["show", `${ref}:${path}`]);
+}
+function findKeyOnBase(cwd, key, remote, base, since2) {
+  const range = since2 ? `${since2}..${remote}/${base}` : `${remote}/${base}`;
+  return findKeyInRange(cwd, key, range);
+}
+function detectClosureHeuristically(cwd, key, pushedBranch, remote = "origin", base = "main", since2, aliases = []) {
+  const merged = findKeyOnBase(cwd, [key, ...aliases], remote, base, since2);
+  if (merged) {
+    return {
+      state: "merged",
+      confidence: "heuristic",
+      mergedAt: merged,
+      detail: `${key} appears on ${remote}/${base} at ${merged.slice(0, 8)}`
     };
-    return this.client.records.list(this.models.issues, params);
-  }
-  /**
-   * Tickets by id, for blockers that have already closed and so are absent
-   * from the open set. Bounded to the ids actually referenced.
-   */
-  async ticketsByIds(ids) {
-    if (ids.length === 0) return [];
-    return this.client.records.list(this.models.issues, {
-      filters: encodeFilters([{ columnName: "id", operator: "IN", value: ids }]),
-      limit: 500
-    });
-  }
-  async ticket(id) {
-    return this.client.records.get(this.models.issues, id);
-  }
-  async comments(limit = 500) {
-    return this.client.records.list(this.models.comments, { limit });
   }
-  async crewRows() {
-    return this.client.records.list(this.models.crew, { limit: 200 });
+  if (remoteBranchExists(cwd, remote, pushedBranch)) {
+    return {
+      state: "open",
+      confidence: "heuristic",
+      detail: `${remote}/${pushedBranch} still exists and ${key} is not on ${base}`
+    };
   }
-  /**
-   * One row of the `Repos` table, for whatever it can tell the crew that
-   * isn't in `.crew.yaml` — which `Projects` (area) row it belongs to, in
-   * particular. `undefined` on a workspace with no Repos table, or if the
-   * row is gone; neither is fatal to the caller.
-   */
-  async repoRow(id) {
-    const model = this.route.resolved?.reposModelId;
-    if (!model) return void 0;
-    try {
-      return await this.client.records.get(model, id);
-    } catch {
-      return void 0;
+  return {
+    state: "abandoned",
+    confidence: "heuristic",
+    detail: `${remote}/${pushedBranch} no longer exists and ${key} never reached ${base} \u2014 this is also what a squash merge with a rewritten subject looks like`
+  };
+}
+async function detectClosure(o) {
+  const remote = o.remote ?? "origin";
+  const base = o.base ?? "main";
+  const aliases = o.aliases ?? [];
+  if (o.mergedHook) {
+    const code = await o.mergedHook({
+      CREW_TICKET: o.key,
+      CREW_BRANCH: o.pushedBranch,
+      CREW_BASE: base
+    });
+    if (code === 0) {
+      const mergedAt = findKeyOnBase(o.cwd, [o.key, ...aliases], remote, base, o.since) ?? void 0;
+      return {
+        state: "merged",
+        confidence: "definitive",
+        mergedAt,
+        detail: `the repo's merged hook says ${o.key} landed`
+      };
     }
+    return remoteBranchExists(o.cwd, remote, o.pushedBranch) ? { state: "open", confidence: "definitive", detail: `the repo's merged hook says ${o.key} has not landed` } : { state: "abandoned", confidence: "definitive", detail: `${o.key} has not landed and ${remote}/${o.pushedBranch} is gone` };
   }
-  /**
-   * One row of the `Projects` (area) table. `undefined` on a workspace
-   * with no such table, or if the row is gone.
-   */
-  async projectRow(id) {
-    const model = this.route.resolved?.areaModelId;
-    if (!model) return void 0;
-    try {
-      return await this.client.records.get(model, id);
-    } catch {
-      return void 0;
-    }
+  return detectClosureHeuristically(o.cwd, o.key, o.pushedBranch, remote, base, o.since, aliases);
+}
+function upstreamOf(cwd, branch) {
+  return gitOk(cwd, ["rev-parse", "--abbrev-ref", "--symbolic-full-name", `${branch}@{upstream}`]);
+}
+function syncState(cwd, branch) {
+  const upstream = upstreamOf(cwd, branch);
+  if (!upstream) {
+    return {
+      branch,
+      upstream: null,
+      ahead: 0,
+      behind: 0,
+      dirty: status(cwd).length > 0,
+      canFastForward: false,
+      detail: `${branch} tracks no remote branch`
+    };
   }
-  /** Every `Projects` (area) row — what `crew repos add` offers when a new Repos row needs one. */
-  async projectRows() {
-    const model = this.route.resolved?.areaModelId;
-    if (!model) return [];
-    return this.client.records.list(model, { limit: 200 });
-  }
-  /** Create a `Repos` row. Throws when the workspace has no Repos table. */
-  async createRepoRow(fields) {
-    const model = this.route.resolved?.reposModelId;
-    if (!model) throw new Error("this workspace has no Repos table");
-    return this.client.records.create(model, fields);
+  const counts = gitOk(cwd, ["rev-list", "--left-right", "--count", `${upstream}...${branch}`]) ?? "0	0";
+  const [behindStr, aheadStr] = counts.split(/\s+/);
+  const behind = Number.parseInt(behindStr ?? "0", 10);
+  const ahead = Number.parseInt(aheadStr ?? "0", 10);
+  const dirty = status(cwd).length > 0;
+  let detail;
+  if (behind === 0 && ahead === 0) detail = `level with ${upstream}`;
+  else if (dirty) detail = `${behind} behind ${upstream}, but the worktree is dirty \u2014 not touching it`;
+  else if (ahead > 0 && behind > 0) detail = `diverged from ${upstream} (${ahead} ahead, ${behind} behind) \u2014 needs a human`;
+  else if (behind > 0) detail = `${behind} behind ${upstream} \u2014 fast-forwardable`;
+  else detail = `${ahead} ahead of ${upstream}, nothing to take`;
+  return {
+    branch,
+    upstream,
+    ahead,
+    behind,
+    dirty,
+    canFastForward: behind > 0 && ahead === 0 && !dirty,
+    detail
+  };
+}
+function fastForward(cwd, branch) {
+  const s = syncState(cwd, branch);
+  if (!s.canFastForward) return false;
+  return gitOk(cwd, ["merge", "--ff-only", s.upstream]) !== null;
+}
+function baseBranchUnsafe(r) {
+  return r.action === "diverged" || r.action === "ahead" || r.action === "ff-failed";
+}
+function describeUnsafeBase(r, remote, base) {
+  const counts = r.action === "diverged" ? `${r.ahead} ahead, ${r.behind} behind ${remote}/${base}` : r.action === "ahead" ? `${r.ahead} ahead of ${remote}/${base}` : `${r.behind} behind ${remote}/${base}, cannot fast-forward`;
+  return `${r.detail} [${counts}] \u2014 reconcile it (\`crew sync\` afterwards), or \`git reset --hard ${remote}/${base}\` if the local commits duplicate a release`;
+}
+function refreshBaseBranch(cwd, remote, base, dryRun = false) {
+  if (currentBranch(cwd) !== base || status(cwd).length > 0) {
+    return { action: "not-applicable", detail: `${cwd} is not on a clean ${base}` };
   }
-  /**
-   * The Ships rows of this workspace, if it has a Ships table.
-   *
-   * Optional by design: a workspace that has not adopted ships still works,
-   * and the crew must not require a table it did not create.
-   */
-  async shipRows() {
-    const model = this.route.resolved?.shipsModelId;
-    if (!model) return [];
-    try {
-      return await this.client.records.list(model, { limit: 200 });
-    } catch {
-      return [];
-    }
+  if (!remoteConfigured(cwd, remote)) {
+    return { action: "not-applicable", detail: `${remote} is not configured` };
   }
-  /**
-   * This ship's own row on the `Ships` table, matched by name — the same
-   * exact-string match `doctor` has always used (see the callsign comment
-   * on ISSUE-380: name is what an operator recognises on the board).
-   * `undefined` when the workspace has no Ships table, no row named for
-   * this ship, or more than one — ambiguous is not a row to write to.
-   */
-  async myShipRow(shipName2) {
-    const rows = await this.shipRows();
-    const mine = rows.filter((r) => (r.name ?? "").trim() === shipName2.trim());
-    return mine.length === 1 ? mine[0] : void 0;
+  if (!fetchRemote(cwd, remote)) {
+    return { action: "fetch-failed", detail: `could not fetch ${remote}` };
   }
-  /**
-   * The `attention` field of a Ships-row patch (CREW-1373): this ship's open
-   * items, so every heartbeat carries the current set and a cleared item
-   * disappears from the board on the next one. Empty when there is nothing
-   * to write: no state directory to read, or a Ships table without the
-   * column (probed by the key's absence from the row, the way `owner_id` is
-   * skipped on an install that has not taken the template update).
-   */
-  attentionPatch(row) {
-    if (!this.stateDir || !("attention" in row)) return {};
-    const items = openShipAttention(new State(this.stateDir));
-    return { attention: items.length ? items : null };
+  if (!remoteBranchExists(cwd, remote, base)) {
+    return { action: "not-applicable", detail: `${remote}/${base} does not exist` };
   }
-  /**
-   * Writes this ship's attention items on their own, without touching
-   * `last_seen` — for the daemon, which raises one between heartbeats and
-   * should not wait for the next engaged/idle beat to show it. Skips the
-   * write when the row already holds the same set.
-   */
-  async publishShipAttention(shipName2) {
-    const row = await this.myShipRow(shipName2);
-    if (!row) return;
-    const patch2 = this.attentionPatch(row);
-    if (!("attention" in patch2)) return;
-    if (JSON.stringify(patch2.attention) === JSON.stringify(row.attention ?? null)) return;
-    await this.client.records.update(this.route.resolved.shipsModelId, row.id, patch2);
+  const upstream = `${remote}/${base}`;
+  const counts = gitOk(cwd, ["rev-list", "--left-right", "--count", `${upstream}...${base}`]) ?? "0	0";
+  const [behindStr, aheadStr] = counts.split(/\s+/);
+  const behind = Number.parseInt(behindStr ?? "0", 10);
+  const ahead = Number.parseInt(aheadStr ?? "0", 10);
+  const named = () => {
+    const subjects = (gitOk(cwd, ["log", "--format=%h %s", "-5", `${upstream}..${base}`]) ?? "").split("\n").filter(Boolean);
+    return subjects.length ? `: ${subjects.join("; ")}${ahead > subjects.length ? "; \u2026" : ""}` : "";
+  };
+  if (ahead > 0 && behind > 0) {
+    return {
+      action: "diverged",
+      ahead,
+      behind,
+      detail: `${base} has diverged from ${upstream} (${ahead} ahead, ${behind} behind)${named()}`
+    };
   }
-  /**
-   * Ship-level heartbeat (ISSUE-380): "is this ship online" — independent
-   * of any one seat's Working/Idle status (`setCrewStatus`), which only
-   * exists for the duration of an actual agent run. This one fires once
-   * per `crew run`/`poll` cycle **regardless of outcome**, including a
-   * cycle that finds nothing to do, so a ship that stops firing (powered
-   * off, asleep, closed for the weekend) simply stops updating `last_seen`
-   * — silence then means exactly one thing, rather than being ambiguous
-   * with "idle".
-   *
-   * Does not touch the `engaged*` columns — those are set only by
-   * `beatEngaged`/`beatIdle`, paired around the part of the cycle that
-   * actually spawns an agent, so a plain heartbeat mid-engagement can't
-   * blow away `engaged_since`.
-   *
-   * A no-op, like `shipRows()`, on a workspace with no Ships table or no
-   * row for this ship's name.
-   */
-  async beatShip(shipName2) {
-    const row = await this.myShipRow(shipName2);
-    if (!row) return;
-    await this.client.records.update(this.route.resolved.shipsModelId, row.id, {
-      last_seen: (/* @__PURE__ */ new Date()).toISOString(),
-      host: hostname(),
-      pid: process.pid,
-      ...this.attentionPatch(row)
-    });
+  if (behind === 0 && ahead > 0) {
+    return { action: "ahead", ahead, detail: `${base} has ${ahead} commit(s) ${upstream} does not${named()}` };
   }
-  /**
-   * Marks this ship's row engaged, naming what it's working and since when
-   * (ISSUE-380's "an engaged ship names what it is working and since
-   * when"). Call once, right before `spawnAgent`, paired with
-   * `beatIdle` in a `finally` — the same shape as `setCrewStatus`'s
-   * working/idle pair, one level up (ship, not seat).
-   */
-  async beatEngaged(shipName2, connectionName, ticketRecordId) {
-    const row = await this.myShipRow(shipName2);
-    if (!row) return;
-    await this.client.records.update(this.route.resolved.shipsModelId, row.id, {
-      last_seen: (/* @__PURE__ */ new Date()).toISOString(),
-      host: hostname(),
-      pid: process.pid,
-      engaged: true,
-      engaged_since: (/* @__PURE__ */ new Date()).toISOString(),
-      engaged_connection: connectionName,
-      engaged_ticket_id: ticketRecordId,
-      ...this.attentionPatch(row)
-    });
+  if (behind === 0) return { action: "level", detail: `${base} is level with ${upstream}` };
+  if (dryRun) {
+    return { action: "would-fast-forward", behind, detail: `would fast-forward ${base}: ${behind} behind ${upstream}` };
   }
-  /**
-   * Writes this ship's own tunnel state for Host Passengers (ISSUE-553):
-   * `tunnel_status` (disconnected/connecting/connected), as
-   * the tunnel client (`tunnel.ts`) brings a workspace's container's tunnel
-   * up or down. A no-op, like every other `myShipRow`-backed write here, on
-   * a workspace with no Ships table or no row for this ship's name — the
-   * tunnel client itself still runs the tunnel either way, it just has
-   * nowhere on the board to report the state.
-   */
-  async updateTunnelState(shipName2, patch2) {
-    const row = await this.myShipRow(shipName2);
-    if (!row) return;
-    await this.client.records.update(this.route.resolved.shipsModelId, row.id, patch2);
+  if (gitOk(cwd, ["merge", "--ff-only", upstream]) === null) {
+    return { action: "ff-failed", behind, detail: `${base} is ${behind} behind ${upstream} and would not fast-forward` };
   }
-  /** The other half of `beatEngaged` — clears engagement back to idle. */
-  async beatIdle(shipName2) {
-    const row = await this.myShipRow(shipName2);
-    if (!row) return;
-    await this.client.records.update(this.route.resolved.shipsModelId, row.id, {
-      last_seen: (/* @__PURE__ */ new Date()).toISOString(),
-      host: hostname(),
-      pid: process.pid,
-      engaged: false,
-      engaged_since: null,
-      engaged_connection: null,
-      engaged_ticket_id: null,
-      ...this.attentionPatch(row)
-    });
+  return {
+    action: "fast-forwarded",
+    behind,
+    detail: `fast-forwarded ${base} to ${upstream} (${behind} commit(s) from elsewhere)`
+  };
+}
+function recoverStrandedReleaseCheckouts(cwd) {
+  gitOk(cwd, ["worktree", "prune"]);
+  const out = gitOk(cwd, ["worktree", "list", "--porcelain"]) ?? "";
+  let path = "";
+  for (const line of out.split("\n")) {
+    if (line.startsWith("worktree ")) path = line.slice("worktree ".length);
+    else if (line.startsWith("branch refs/heads/crew/release-") && path) {
+      gitOk(cwd, ["worktree", "remove", "--force", path]);
+    }
   }
-  /**
-   * The Epics rows of this workspace, if it has an Epics table (ISSUE-384).
-   *
-   * Optional by design, the same way `shipRows()` is: a workspace that has
-   * not adopted epics still works, and the crew must not require a table it
-   * did not create.
-   */
-  async epicRows() {
-    const model = this.route.resolved?.epicsModelId;
-    if (!model) return [];
-    try {
-      return await this.client.records.list(model, { limit: 500 });
-    } catch {
-      return [];
+  const stranded = (gitOk(cwd, ["for-each-ref", "--format=%(refname:short)", "refs/heads/crew/release-*"]) ?? "").split("\n").filter(Boolean);
+  for (const b of stranded) gitOk(cwd, ["branch", "-q", "-D", b]);
+  return stranded;
+}
+function pushBranch(cwd, remote, branch, dst = branch) {
+  git(cwd, ["push", remote, `${branch}:${dst}`]);
+}
+function worktrees(cwd) {
+  const out = gitOk(cwd, ["worktree", "list", "--porcelain"]) ?? "";
+  const list = [];
+  let current = {};
+  for (const line of out.split("\n")) {
+    if (line.startsWith("worktree ")) {
+      if (current.path) list.push({ path: current.path, branch: current.branch ?? null, prunable: current.prunable ?? false });
+      current = { path: line.slice("worktree ".length) };
+    } else if (line.startsWith("branch ")) {
+      current.branch = line.slice("branch refs/heads/".length);
+    } else if (line === "detached") {
+      current.branch = null;
+    } else if (line.startsWith("prunable ")) {
+      current.prunable = true;
     }
   }
-  /**
-   * The tickets of these epics that are closed (`closed: true`) or not
-   * (`closed: false`), for the epic sync (CREW-1255).
-   *
-   * **Not area-filtered, unlike `openTickets()`**: an epic spans areas, so
-   * whether it is finished can only be judged across all of them. Also not
-   * limited to `statuses.open` — a status this contract has never heard of
-   * (a pre-triage `draft`, say) is still a ticket that is not closed.
-   *
-   * Paged, because an epic's history is unbounded and a truncated page
-   * would silently read as "nothing else outstanding".
-   */
-  async epicTickets(epicIds, o) {
-    if (epicIds.length === 0) return [];
-    const c = this.contract;
-    const statuses = closedStatuses(c);
-    if (!statuses.length) return [];
-    const filters = encodeFilters([
-      { columnName: c.columns.epic, operator: "IN", value: epicIds },
-      { columnName: c.columns.status, operator: o.closed ? "IN" : "NOT_IN", value: statuses }
-    ]);
-    const pageSize = 500;
-    const out = [];
-    for (let page = 0; page < 20; page++) {
-      const rows = await this.client.records.list(this.models.issues, {
-        filters,
-        limit: pageSize,
-        offset: page * pageSize
-      });
-      out.push(...rows);
-      if (rows.length < pageSize) break;
-    }
-    return out;
-  }
-  /** Conditional on `expectedUpdatedAt`, exactly as `updateTicket` is. */
-  async updateEpic(id, patch2, expectedUpdatedAt) {
-    const model = this.route.resolved?.epicsModelId;
-    if (!model) throw new ConfigError(`route "${this.route.route}" has no Epics table`);
-    return this.client.records.update(model, id, patch2, expectedUpdatedAt);
-  }
-  /**
-   * `expectedUpdatedAt` makes this a conditional write (ISSUE-395, the same
-   * `RecordsResource.update` primitive board-lock.ts uses): pass the
-   * `updated_at` this caller last read, and the write throws
-   * `StaleWriteError` instead of applying if the row has moved since —
-   * exactly what claim.ts needs to let a contended ticket claim fail loudly
-   * rather than silently overwrite a winning ship's write.
-   */
-  async updateTicket(id, patch2, expectedUpdatedAt) {
-    return this.client.records.update(this.models.issues, id, patch2, expectedUpdatedAt);
-  }
-  /**
-   * Claim a board-visible lock for `scope` (ISSUE-394) — see board-lock.ts
-   * for the CAS mechanics. Resolves to `{ ok: true }` immediately, with a
-   * no-op release, only when this workspace has no Locks table at all. A
-   * Locks table with no row for `scope` is `{ ok: false, reason: 'missing' }`
-   * (CREW-1384): `crew connect` provisions the row.
-   */
-  acquireBoardLock(scope, holderLabel, ttlMs) {
-    return acquireBoardLock(this.client.records, this.route.resolved?.locksModelId, scope, holderLabel, ttlMs);
-  }
-  /** The Locks row for `scope` — present? held by whom? Undefined when this workspace has no Locks table. */
-  async lockState(scope) {
-    const model = this.route.resolved?.locksModelId;
-    return model ? lockRowState(this.client.records, model, scope) : void 0;
-  }
-  /**
-   * Reports one crew member's live status (ISSUE-325) — "Working" for the
-   * duration of an agent run, "Idle" once it ends.
-   *
-   * `ticketRecordId` is the ticket's own row id (`Ticket.id`), not its
-   * `issue_id` label — the field it fills is a Reference, not text.
-   * Omitted (as on the idle transition) leaves the column alone, so it
-   * keeps reading as "current/last issue" rather than clearing to blank
-   * the moment a run ends.
-   */
-  async setCrewStatus(memberId, status2, ticketRecordId) {
-    const patch2 = { status: status2, status_updated_at: (/* @__PURE__ */ new Date()).toISOString() };
-    if (ticketRecordId !== void 0) patch2.current_issue_id = ticketRecordId;
-    await this.client.records.update(this.models.crew, memberId, patch2);
+  if (current.path) list.push({ path: current.path, branch: current.branch ?? null, prunable: current.prunable ?? false });
+  return list;
+}
+function cloneUrlFor(remote) {
+  return `git@github.com:${remote}.git`;
+}
+function ensureRepoCheckout(dir, remote) {
+  if (existsSync6(`${dir}/.git`)) return false;
+  if (!remote) {
+    throw new GitError(
+      `${dir} does not exist and this repo has no discovered remote to clone from \u2014 re-run \`crew connect\`, or check out the repository yourself and point \`repos:\` at it`
+    );
   }
-  /**
-   * An `event` comment — the runner's own audit trail, distinct from a
-   * seat's prose. `kind` is what keeps these out of the "new comment from
-   * someone else" wake signal.
-   */
-  async postEvent(ticketId, body, memberId) {
-    const auth = await this.authorshipProbe();
-    await this.client.records.create(this.models.comments, {
-      ticket_id: ticketId,
-      body,
-      team_member_id: memberId,
-      kind: "event",
-      ...auth.commentShip && auth.shipId ? { [this.contract.comments.ship]: auth.shipId } : {}
-    });
+  mkdirSync4(dirname4(dir), { recursive: true });
+  try {
+    execFileSync("git", ["clone", cloneUrlFor(remote), dir], { stdio: ["ignore", "pipe", "pipe"] });
+  } catch (e) {
+    const err = e;
+    const why = [err.stderr, err.stdout].map((x) => (x ?? "").trim()).filter(Boolean).join(" / ");
+    throw new GitError(`git clone ${cloneUrlFor(remote)} ${dir}: ${why || err.message.trim()}`);
   }
-  /**
-   * Ship affinity for a claim (CREW-1386): stamp this ship's Ships row on the
-   * ticket in the claim's own write, in the `held_by_ship_id` column (not
-   * `ship_id`, which means "filed from"). `undefined` — claim exactly as
-   * before — when the Issues table has no hold column or this ship has no row.
-   */
-  async claimAffinity() {
-    const auth = await this.authorshipProbe();
-    if (!auth.issueHeld || !auth.shipId) return void 0;
-    return {
-      column: this.contract.columns.heldBy,
-      shipId: auth.shipId
-    };
+  return true;
+}
+var CHECKOUT_LOCK_STALE_MS = 5 * 60 * 1e3;
+function checkoutLockPath(dir) {
+  return `${dir}.sync.lock`;
+}
+function sleepSync(ms) {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+function acquireCheckoutLock(dir, timeoutMs = 3e4) {
+  const lockPath = checkoutLockPath(dir);
+  mkdirSync4(dirname4(lockPath), { recursive: true });
+  const deadline = Date.now() + timeoutMs;
+  for (; ; ) {
+    try {
+      const fd = openSync(lockPath, "wx");
+      writeSync(fd, `${process.pid}
+`);
+      closeSync(fd);
+      return () => {
+        try {
+          unlinkSync2(lockPath);
+        } catch {
+        }
+      };
+    } catch (e) {
+      const err = e;
+      if (err.code !== "EEXIST") throw err;
+      try {
+        if (Date.now() - statSync3(lockPath).mtimeMs > CHECKOUT_LOCK_STALE_MS) {
+          try {
+            unlinkSync2(lockPath);
+          } catch {
+          }
+          continue;
+        }
+      } catch {
+      }
+      if (Date.now() > deadline) {
+        throw new GitError(`timed out waiting for the sync lock on ${dir} (held by another sync)`);
+      }
+      sleepSync(50);
+    }
   }
-  /**
-   * The authorship probe (CREW-1371), read once per process: which optional
-   * `filed_by_id`/`ship_id` columns exist on Issues and Comments, and this
-   * ship's own Ships row id. Memoised as a promise so concurrent first writes
-   * share one round of metadata reads. A table whose metadata cannot be read
-   * reads as "column absent", the same way `connect.ts`'s `owner_id` probe does.
-   */
-  authorshipProbe() {
-    this.authorship ??= this.probeAuthorship();
-    return this.authorship;
+}
+function syncPassengerCheckout(dir, githubRemote, gitRemoteName, base) {
+  const release = acquireCheckoutLock(dir);
+  try {
+    if (ensureRepoCheckout(dir, githubRemote)) {
+      if (currentBranch(dir) !== base) git(dir, ["checkout", base]);
+      return { action: "cloned", detail: `cloned ${githubRemote} into ${dir}` };
+    }
+    return refreshBaseBranch(dir, gitRemoteName, base);
+  } finally {
+    release();
   }
-  async probeAuthorship() {
-    const [issueFields, commentFields, shipRow] = await Promise.all([
-      this.columnNames(this.models.issues),
-      this.columnNames(this.models.comments),
-      // No name (a caller that only beats or patches, never stamps) means no row to find.
-      this.shipName ? this.myShipRow(this.shipName) : Promise.resolve(void 0)
-    ]);
+}
+
+// src/ship-attention.ts
+var RELEASE_STALE_AFTER_INTERVALS = 3;
+function upsert(items, item) {
+  const existing = items.find((i) => i.key === item.key);
+  if (!existing) return [...items, item];
+  return items.map((i) => i.key === item.key ? { ...item, since: existing.since } : i);
+}
+function clear(items, key) {
+  return items.filter((i) => i.key !== key);
+}
+function transitions(previous, current) {
+  const before = new Set(previous.map((i) => i.key));
+  return current.filter((i) => !before.has(i.key));
+}
+function staleRelease(lastRunMs, nowMs, intervalSeconds = INTERVAL_SECONDS) {
+  if (lastRunMs === null) return null;
+  const limitMs = RELEASE_STALE_AFTER_INTERVALS * intervalSeconds * 1e3;
+  const ageMs = nowMs - lastRunMs;
+  if (ageMs <= limitMs) return null;
+  const minutes = Math.round(ageMs / 6e4);
+  return {
+    kind: "release_stale",
+    key: "release_stale",
+    message: `This ship has not run a release cycle for ${minutes} minute${minutes === 1 ? "" : "s"} \u2014 check its release timer`,
+    since: new Date(lastRunMs + limitMs).toISOString()
+  };
+}
+var baseUnsafeKey = (repo) => `base_unsafe:${repo}`;
+function baseAttention(repo, outcome, remote, base, nowIso = (/* @__PURE__ */ new Date()).toISOString()) {
+  if (baseBranchUnsafe(outcome)) {
     return {
-      issueAuthor: issueFields.has(this.contract.columns.author),
-      issueShip: issueFields.has(this.contract.columns.ship),
-      issueHeld: issueFields.has(this.contract.columns.heldBy),
-      commentShip: commentFields.has(this.contract.comments.ship),
-      shipId: shipRow?.id ?? null
+      raise: {
+        kind: "base_unsafe",
+        key: baseUnsafeKey(repo),
+        since: nowIso,
+        message: `${repo}: no worktree can be cut until the primary checkout's ${base} is reconciled \u2014 ${describeUnsafeBase(outcome, remote, base)}. Resumes automatically once it is level with ${remote}/${base}`
+      }
     };
   }
-  async columnNames(modelId) {
-    try {
-      const model = await this.client.dataModels.get(modelId);
-      return new Set(model.fields.map((f) => f.columnName));
-    } catch {
-      return /* @__PURE__ */ new Set();
-    }
+  if (outcome.action === "level" || outcome.action === "fast-forwarded") return { clear: baseUnsafeKey(repo) };
+  return null;
+}
+function openShipAttention(state, nowMs = Date.now()) {
+  const stale = staleRelease(state.releaseHeartbeat().at(), nowMs);
+  const stored = state.shipAttention().previous();
+  return stale ? [...stored, stale] : stored;
+}
+function announce(emit, item) {
+  emit.warn(item.message, {
+    step: "sweep",
+    data: { attention: [`ship:${item.kind}`], title: item.message }
+  });
+}
+async function raiseShipAttention(o, item) {
+  const store = o.state.shipAttention();
+  const previous = store.previous();
+  const next = upsert(previous, item);
+  store.persist(next);
+  if (transitions(previous, next).length === 0) return false;
+  announce(o.emit, item);
+  if (o.route && o.ship) {
+    await notify(o.route, o.ship, { level: "warn", headline: item.message }, o.emit);
   }
-  /**
-   * The authorship columns this workspace is missing, as `table.column` names
-   * for `crew doctor` to report (CREW-1371). Empty on a fully updated install.
-   */
-  async missingAuthorshipColumns() {
-    const auth = await this.authorshipProbe();
-    const missing = [];
-    if (!auth.issueAuthor) missing.push(`Issues.${this.contract.columns.author}`);
-    if (!auth.issueShip) missing.push(`Issues.${this.contract.columns.ship}`);
-    if (!auth.issueHeld) missing.push(`Issues.${this.contract.columns.heldBy}`);
-    if (!auth.commentShip) missing.push(`Comments.${this.contract.comments.ship}`);
-    return missing;
-  }
-  /**
-   * The public `/v/<slug>/r/<token>` link for one ticket (ISSUE-928) —
-   * fetch-or-create via `POST /views/:viewId/record-links`, so a repeated
-   * call for the same (view, model, record) returns the same URL and even
-   * un-retires a retired one — right for a ticket that just went back to
-   * `needs_info` after having been resolved once before.
-   *
-   * `undefined` when this route has no `recordLinkViewId` resolved, or the
-   * mint call fails for any reason (network, 404, an unexpected response
-   * shape) — the caller (poll.ts's attention sweep) still emits its
-   * notification event without a link rather than losing the whole event.
-   */
-  async recordLinkUrl(recordId) {
-    const viewId = this.route.resolved?.recordLinkViewId;
-    if (!viewId) return void 0;
-    try {
-      const res = await fetch(`${this.route.baseUrl}/api/views/${viewId}/record-links`, {
-        method: "POST",
-        headers: {
-          Authorization: `Bearer ${resolveApiKey(this.route)}`,
-          "User-Agent": this.userAgent,
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify({ dataModelId: this.models.issues, recordId })
-      });
-      if (!res.ok) return void 0;
-      const body = await res.json();
-      return typeof body.url === "string" ? body.url : void 0;
-    } catch {
-      return void 0;
-    }
-  }
-  /**
-   * File a brand new ticket. Unlike every other write on this class, the
-   * field names are the fixed Bug Reports schema (`title`, `description`,
-   * `report_type`, `severity`, `reporter_name`) rather than anything in
-   * `Contract.columns` — that contract only names the lifecycle fields a
-   * workspace can rename, and creation-only fields like `description` are
-   * not among them (`postEvent` above hardcodes its own fields the same
-   * way).
-   */
-  async fileTicket(fields, memberId) {
-    const auth = await this.authorshipProbe();
-    return this.client.records.create(this.models.issues, {
-      ...fields,
-      ...auth.issueAuthor && memberId ? { [this.contract.columns.author]: memberId } : {},
-      ...auth.issueShip && auth.shipId ? { [this.contract.columns.ship]: auth.shipId } : {}
-    });
+  return true;
+}
+function clearShipAttention(state, key) {
+  const store = state.shipAttention();
+  const previous = store.previous();
+  const next = clear(previous, key);
+  if (next.length !== previous.length) store.persist(next);
+}
+function hookCommand(script) {
+  for (const raw of script.split("\n")) {
+    const line = raw.trim();
+    if (!line || line.startsWith("#")) continue;
+    const word = line.split(/\s+/)[0];
+    if (/^[A-Za-z_][A-Za-z0-9_]*=/.test(word)) continue;
+    if (!/^[A-Za-z0-9._+-]+$/.test(word)) return null;
+    if (SHELL_WORDS.has(word)) return null;
+    return word;
   }
-};
+  return null;
+}
+var SHELL_WORDS = /* @__PURE__ */ new Set([
+  "if",
+  "then",
+  "else",
+  "elif",
+  "fi",
+  "for",
+  "while",
+  "until",
+  "do",
+  "done",
+  "case",
+  "esac",
+  "cd",
+  "echo",
+  "export",
+  "set",
+  "exit",
+  "test",
+  "true",
+  "false",
+  "source",
+  ".",
+  "eval",
+  "exec",
+  "ok"
+]);
 
-// src/blocked.ts
-import { StaleWriteError as StaleWriteError2 } from "@tablation/client";
-function missingBlockerIds(tickets) {
-  const known = new Set(tickets.map((t) => t.id));
-  const missing = /* @__PURE__ */ new Set();
-  for (const t of tickets) for (const id of t.blocked_by ?? []) if (!known.has(id)) missing.add(id);
-  return [...missing];
+// src/board-lock.ts
+import { StaleWriteError } from "@tablation/client";
+function releaseLockScope(route, repo) {
+  return `${route}/${repo}`;
 }
-function blockerInfoMap(tickets, extra = []) {
-  const info = {};
-  for (const t of [...tickets, ...extra]) {
-    info[t.id] = { issue_id: t.issue_id, issue_tag: t.issue_tag, status: t.status };
+async function acquireBoardLock(client2, modelId, scope, holderLabel, ttlMs) {
+  if (!modelId) return { ok: true, release: async () => {
+  } };
+  const filters = JSON.stringify([{ columnName: "scope", operator: "EQ", value: scope }]);
+  const rows = await client2.list(modelId, { filters, limit: 1 });
+  const row = rows[0];
+  if (!row) return { ok: false, reason: "missing" };
+  const age = Date.now() - new Date(row.updated_at).getTime();
+  const free = !row.holder || row.holder === holderLabel || age > ttlMs;
+  if (!free) return { ok: false, heldBy: row.holder ?? void 0, reason: "held" };
+  let claimed;
+  try {
+    claimed = await client2.update(modelId, row.id, { holder: holderLabel }, row.updated_at);
+  } catch (e) {
+    if (e instanceof StaleWriteError) return { ok: false, reason: "contended" };
+    throw e;
   }
-  return info;
+  return {
+    ok: true,
+    release: async () => {
+      try {
+        await client2.update(modelId, row.id, { holder: "" }, claimed.updated_at);
+      } catch {
+      }
+    }
+  };
 }
-function computeBlockedIds(tickets, info) {
-  const blocked = /* @__PURE__ */ new Set();
-  for (const t of tickets) {
-    const unresolved = (t.blocked_by ?? []).some((id) => {
-      const status2 = info[id]?.status;
-      return status2 !== void 0 && !RESOLVED_STATUSES.has(status2);
-    });
-    if (unresolved) blocked.add(t.id);
-  }
-  return blocked;
+async function lockRowState(client2, modelId, scope) {
+  const rows = await client2.list(modelId, { filters: scopeFilter(scope), limit: 1 });
+  const row = rows[0];
+  if (!row) return { exists: false };
+  return { exists: true, ...row.holder ? { holder: row.holder, since: row.updated_at } : {} };
 }
-function sweepDiagnostics(tickets, info) {
-  const dangling = [];
-  const selfBlocked = [];
-  for (const t of tickets) {
-    for (const id of t.blocked_by ?? []) {
-      if (info[id] === void 0) dangling.push(`${t.issue_id} -> ${id}`);
-      if (id === t.id) selfBlocked.push(t.issue_id);
+var scopeFilter = (scope) => JSON.stringify([{ columnName: "scope", operator: "EQ", value: scope }]);
+async function ensureLockRows(client2, modelId, scopes) {
+  const created = [];
+  for (const scope of scopes) {
+    const filters = scopeFilter(scope);
+    if ((await client2.list(modelId, { filters, limit: 1 })).length > 0) continue;
+    let mine;
+    try {
+      mine = await client2.create(modelId, { scope, holder: "" });
+    } catch (e) {
+      const status2 = e.status;
+      if (status2 === 409 || status2 === 400) {
+        if ((await client2.list(modelId, { filters, limit: 1 })).length > 0) continue;
+      }
+      throw e;
     }
-  }
-  return { dangling, selfBlocked: [...new Set(selfBlocked)] };
-}
-var describeBlockers = (t, info) => (t.blocked_by ?? []).map((id) => `${info[id]?.issue_id ?? "?"} (${info[id]?.status ?? "unknown"})`).join(", ");
-function planSweep(tickets, info, blocked) {
-  const steps = [];
-  for (const t of tickets) {
-    if (t.status === "accepted" && blocked.has(t.id)) {
-      steps.push({ action: "park", ticket: t, blockers: describeBlockers(t, info), to: "blocked" });
-    } else if (t.status === "blocked" && !blocked.has(t.id)) {
-      steps.push({ action: "restore", ticket: t, blockers: describeBlockers(t, info), to: "accepted" });
+    const all = await client2.list(modelId, { filters, limit: 20 });
+    const keeper = [...all].sort((a, b) => (a.created_at ?? "").localeCompare(b.created_at ?? "") || a.id.localeCompare(b.id))[0];
+    if (keeper && keeper.id !== mine.id) {
+      await client2.remove(modelId, mine.id).catch(() => {
+      });
+      continue;
     }
+    created.push(scope);
   }
-  return steps;
+  return created;
 }
-function strandedNeedsInfo(tickets, blocked, holds2 = /* @__PURE__ */ new Set()) {
-  return tickets.filter(
-    (t) => t.status === "needs_info" && (t.blocked_by ?? []).length > 0 && !blocked.has(t.id) && !(t.assignee_id && holds2.has(t.assignee_id))
-  );
+
+// src/tracker.ts
+function ticketBranchContext(t) {
+  const tag = t.issue_tag ?? void 0;
+  if (!tag) return {};
+  const prefix = t.project_issue_prefix ? t.project_issue_prefix.toLowerCase() : void 0;
+  return { tag, prefix };
 }
-var COORDINATING_DEFAULTS = {
-  reportTypeColumn: "report_type",
-  coordinatingValue: "coordinating"
-};
-var isCoordinating = (t, opts) => t[opts.reportTypeColumn] === opts.coordinatingValue;
-var FILING_ERROR_DEFAULT_EXEMPT = ["coordinating", "question", "investigation"];
-function rollUpParents(tickets, done = RESOLVED_STATUSES, opts = {}) {
-  const resolved = { ...COORDINATING_DEFAULTS, ...opts };
-  const byParent = /* @__PURE__ */ new Map();
-  for (const t of tickets) {
-    const p = t.parent_id;
-    if (!p) continue;
-    const list = byParent.get(p);
-    if (list) list.push(t);
-    else byParent.set(p, [t]);
-  }
-  const rollups = [];
-  for (const t of tickets) {
-    const children = byParent.get(t.id);
-    if (!isCoordinating(t, resolved) || !children) continue;
-    const outstanding = children.filter((c) => !done.has(c.status));
-    rollups.push({ parent: t, children, outstanding, complete: outstanding.length === 0 });
-  }
-  return rollups;
+function displayKey(t) {
+  return t.issue_tag ?? t.issue_id;
 }
-function filingErrors(tickets, opts = {}) {
-  const reportTypeColumn = opts.reportTypeColumn ?? COORDINATING_DEFAULTS.reportTypeColumn;
-  const coordinatingValue = opts.coordinatingValue ?? COORDINATING_DEFAULTS.coordinatingValue;
-  const exempt = new Set(
-    opts.repoExemptValues ?? [coordinatingValue, ...FILING_ERROR_DEFAULT_EXEMPT.filter((v) => v !== "coordinating")]
-  );
-  return tickets.filter((t) => {
-    if (t.repo_id) return false;
-    return !exempt.has(t[reportTypeColumn]);
-  });
+function referenceKeys(t) {
+  return t.issue_tag && t.issue_tag !== t.issue_id ? [t.issue_id, t.issue_tag] : [t.issue_id];
 }
-function sweepComment(step) {
-  return step.action === "park" ? `Parked as **Blocked** by the crew \u2014 waiting on: ${step.blockers}.
-
-This is automatic and reversible: an approved ticket whose \`Blocked by\` entries are not all resolved is parked out of the queue, and restored on the first poll after the last one resolves. Nothing else about the ticket changes. A blocker counts as resolved at \`verified\`, \`closed_deployed\`, \`closed_wont_fix\` or \`closed_duplicate\` \u2014 not at \`fixed\`, which is still an unmerged branch awaiting QA.` : `Restored to **Approved** by the crew \u2014 every blocker has resolved${step.blockers && step.blockers !== "\u2014" ? ` (${step.blockers})` : ""}.
-
-This restores the status it was approved at before being parked; it is back in the queue and a role may pick it up. If a blocker resolved as \`closed_wont_fix\` or \`closed_duplicate\` this ticket may still not be buildable as written \u2014 that is a call for a human, not the crew.`;
-}
-async function applySweep(writer, steps, memberId, log) {
-  let parked = 0;
-  let restored = 0;
-  let failed = 0;
-  let contended = 0;
-  for (const step of steps) {
-    try {
-      await writer.updateTicket(step.ticket.id, { status: step.to }, step.ticket.updated_at);
-      if (step.action === "park") parked++;
-      else restored++;
-      log.emit(
-        step.action === "park" ? `parked (waiting on ${step.blockers})` : `restored to ${step.to} (blockers resolved: ${step.blockers || "none"})`,
-        { ticket: step.ticket.issue_id, step: "sweep" }
+var RESOLVED_STATUSES = new Set(DEFAULT_CONTRACT.statuses.resolved);
+var encodeFilters = (f) => JSON.stringify(f);
+var encodeSort = (s) => JSON.stringify(s);
+var Tracker = class {
+  // NB: explicit fields, not TypeScript parameter properties — node's
+  // --experimental-strip-types cannot transform those, and the test runner
+  // uses it. The same rule applies everywhere in src/.
+  route;
+  /** This workspace's rules. A ship holds several, one per route. */
+  contract;
+  client;
+  models;
+  userAgent;
+  shipName;
+  /**
+   * The once-per-process authorship probe (CREW-1371), memoised as a promise
+   * so concurrent first writes share one round of field-metadata reads.
+   */
+  authorship;
+  stateDir;
+  constructor(route, ship) {
+    this.route = route;
+    if (!route.resolved) {
+      throw new ConfigError(
+        `route "${route.route}" has no resolved ids \u2014 run \`crew connect\` to discover them from the project`
       );
-      try {
-        await writer.postEvent(step.ticket.id, sweepComment(step), memberId);
-      } catch {
-        log.warn("status changed but the note failed to post", { ticket: step.ticket.issue_id, step: "sweep" });
-      }
-    } catch (e) {
-      if (e instanceof StaleWriteError2) {
-        contended++;
-        log.warn(`skipped ${step.action} \u2014 ticket changed since the sweep was planned`, {
-          ticket: step.ticket.issue_id,
-          step: "sweep"
-        });
-        continue;
-      }
-      failed++;
-      log.warn(`could not ${step.action}: ${e.message}`, { ticket: step.ticket.issue_id, step: "sweep" });
     }
+    this.models = route.resolved.models;
+    this.contract = resolveContract(route.contract);
+    this.userAgent = ship.userAgent;
+    this.shipName = ship.name;
+    this.stateDir = ship.stateDir;
+    this.client = new TablationClient({
+      baseUrl: `${route.baseUrl}/api`,
+      apiKey: resolveApiKey(route),
+      // Cloudflare 403s (error 1010) default agents on this host.
+      headers: { "User-Agent": ship.userAgent }
+    });
   }
-  return { parked, restored, failed, contended };
-}
-
-// src/priority.ts
-var indexOf = (order) => Object.fromEntries(order.map((v, i) => [v, i]));
-function derivedPriority(t, c = DEFAULT_CONTRACT) {
-  return indexOf(c.severityOrder)[t.severity ?? ""] ?? c.unknownPriorityRank;
-}
-function explicitPriority(t, c = DEFAULT_CONTRACT) {
-  return indexOf(c.priorityOrder)[t.priority ?? ""] ?? null;
-}
-function effectivePriority(t, c = DEFAULT_CONTRACT) {
-  const explicit = explicitPriority(t, c);
-  const derived = derivedPriority(t, c);
-  return explicit === null ? derived : Math.min(explicit, derived);
-}
-function severityRank(t, c = DEFAULT_CONTRACT) {
-  return indexOf(c.severityOrder)[t.severity ?? ""] ?? c.severityOrder.length;
-}
-function issueNumber(t) {
-  const id = t.issue_id ?? "ISSUE-0";
-  const n = Number.parseInt(id.split("-")[1] ?? "0", 10);
-  return Number.isNaN(n) ? 0 : n;
-}
-function epicRank(t) {
-  return t.epicInProgress ? 0 : 1;
-}
-function rank(t, c = DEFAULT_CONTRACT) {
-  return [effectivePriority(t, c), severityRank(t, c), epicRank(t), issueNumber(t)];
-}
-function compareRank(a, b, c = DEFAULT_CONTRACT) {
-  const ra = rank(a, c);
-  const rb = rank(b, c);
-  for (let i = 0; i < ra.length; i++) {
-    const d = ra[i] - rb[i];
-    if (d !== 0) return d;
+  /**
+   * Every non-terminal ticket for this route's area, in one call.
+   *
+   * The area filter is what keeps two routes on one tracker out of each
+   * other's queue: a ship working `synthesis` and `tablation-js` from the same
+   * Issues project must not have either seat pick up the other's tickets. A
+   * route with no area sees everything, which is right for a tracker
+   * nobody has sliced yet.
+   */
+  async openTickets() {
+    const c = this.contract;
+    const filters = [
+      { columnName: c.columns.status, operator: "IN", value: c.statuses.open }
+    ];
+    const areaId = this.route.resolved?.areaId;
+    if (areaId) filters.push({ columnName: c.columns.slice, operator: "EQ", value: areaId });
+    return this.client.records.list(this.models.issues, {
+      filters: encodeFilters(filters),
+      limit: 500
+    });
   }
-  return 0;
-}
-function rankScalar(t, c = DEFAULT_CONTRACT) {
-  const [p, s, e, n] = rank(t, c);
-  return p * 1e9 + s * 1e7 + e * 1e6 + n;
-}
-var NOTHING_ACTIONABLE = 999999999999;
-var AGE_HOURS_TO_ERODE = 48;
-function agedRankScalar(rawRank, aging, now) {
-  if (!aging) return rawRank;
-  const elapsedHours = Math.max(0, (now - Date.parse(aging.since)) / 36e5);
-  const weight = aging.weight ?? 1;
-  const fraction = Math.min(1, elapsedHours * weight / AGE_HOURS_TO_ERODE);
-  return Math.round(rawRank * (1 - fraction));
-}
-
-// src/ship-affinity.ts
-var CYCLE_SECONDS = 120;
-var SHIP_DEAD_AFTER_CYCLES = 10;
-function shipIsAlive(ship, now) {
-  if (!ship?.last_seen) return false;
-  const seen = Date.parse(ship.last_seen);
-  return Number.isFinite(seen) && now - seen <= SHIP_DEAD_AFTER_CYCLES * CYCLE_SECONDS * 1e3;
-}
-function ticketHolderShipId(t, contract) {
-  const v = t[contract.columns.heldBy];
-  return typeof v === "string" && v ? v : null;
-}
-function heldByOtherShip(t, a) {
-  const statuses = a.contract.statuses;
-  if (t.status === statuses.handoff) return false;
-  return heldByLiveOtherShip(t, a);
-}
-function heldByLiveOtherShip(t, a) {
-  if (!a.myShipId) return false;
-  const holder = ticketHolderShipId(t, a.contract);
-  if (!holder || holder === a.myShipId) return false;
-  const owner = a.ships.find((s) => s.id === holder);
-  return shipIsAlive(owner, a.now ?? Date.now());
-}
-function shipName(ships, id) {
-  if (!id) return "an unknown ship";
-  return ships.find((s) => s.id === id)?.name?.trim() || id;
-}
-function shipIdByName(ships, name) {
-  const mine = ships.filter((r) => (r.name ?? "").trim() === name.trim());
-  return mine.length === 1 ? mine[0].id : null;
-}
-async function noteReaccepted(tracker, result, seat, shipLabel) {
-  if (!result.reaccepted || !result.ticket) return;
-  try {
-    await tracker.postEvent(
-      result.ticket.id,
-      `Re-accepted while held by ${shipLabel}; resuming there, not re-claiming. Setting a held ticket back to \`accepted\` is not needed \u2014 to move it to another ship, clear \`held_by_ship_id\`.`,
-      seat
-    );
-  } catch {
+  /**
+   * Tickets at a terminal, no-longer-open status — the worktree sweep's
+   * input (ISSUE-346).
+   *
+   * The exact complement of `openTickets()`: `closed_deployed`,
+   * `closed_wont_fix`, `closed_duplicate`. `verified` is excluded even
+   * though the contract counts it as resolved for a *blocker*'s purposes —
+   * it is still pre-release, and its worktree is exactly what the release
+   * phase is about to merge.
+   *
+   * Sorted most-recently-updated first: a board can hold far more than
+   * `limit` closed tickets (this one already has), and an unordered fetch
+   * has no guarantee which ones a truncated page contains. Ordering by
+   * `updatedAt` descending means a truncated page still holds the tickets
+   * most likely to need their worktree swept — the ones that closed most
+   * recently — rather than an arbitrary, possibly stale slice (ISSUE-403).
+   */
+  async terminalTickets() {
+    const c = this.contract;
+    const statuses = closedStatuses(c);
+    if (!statuses.length) return [];
+    const filters = [
+      { columnName: c.columns.status, operator: "IN", value: statuses }
+    ];
+    const areaId = this.route.resolved?.areaId;
+    if (areaId) filters.push({ columnName: c.columns.slice, operator: "EQ", value: areaId });
+    const params = {
+      filters: encodeFilters(filters),
+      limit: 500,
+      sort: encodeSort([{ columnName: c.columns.updatedAt, direction: "desc" }])
+    };
+    return this.client.records.list(this.models.issues, params);
   }
-}
-function planHoldReleases(tickets, contract) {
-  const ends = [contract.statuses.handoff, contract.statuses.verified];
-  return tickets.filter((t) => ends.includes(t.status) && ticketHolderShipId(t, contract) !== null);
-}
-async function applyHoldReleases(writer, tickets, contract, emit) {
-  let cleared = 0;
-  for (const t of tickets) {
-    try {
-      await writer.updateTicket(t.id, { [contract.columns.heldBy]: null }, t.updated_at);
-      cleared++;
-      emit.emit(`released ship hold (${t.status})`, { ticket: t.issue_id, step: "sweep" });
-    } catch (e) {
-      emit.warn(`could not release ship hold: ${e.message}`, { ticket: t.issue_id, step: "sweep" });
-    }
+  /**
+   * Tickets by id, for blockers that have already closed and so are absent
+   * from the open set. Bounded to the ids actually referenced.
+   */
+  async ticketsByIds(ids) {
+    if (ids.length === 0) return [];
+    return this.client.records.list(this.models.issues, {
+      filters: encodeFilters([{ columnName: "id", operator: "IN", value: ids }]),
+      limit: 500
+    });
   }
-  return cleared;
-}
-async function noteTakeover(tracker, result, seat, ships, myShipName, continuingFrom) {
-  if (!result.tookOverFrom || !result.ticket) return;
-  let sha = null;
-  try {
-    sha = continuingFrom(result.ticket);
-  } catch {
+  async ticket(id) {
+    return this.client.records.get(this.models.issues, id);
   }
-  try {
-    await tracker.postEvent(
-      result.ticket.id,
-      `Taken over from ${shipName(ships, result.tookOverFrom)} (not seen recently) by ${myShipName}; ` + (sha ? `continuing from \`${sha}\` on origin.` : "no branch commit was found on origin to continue from."),
-      seat
-    );
-  } catch {
+  async comments(limit = 500) {
+    return this.client.records.list(this.models.comments, { limit });
   }
-}
-function originBranchSha(dir, t, rev) {
-  const num = (t.issue_tag ?? t.issue_id).replace(/^\D+/, "");
-  const names = [...new Set([(t.issue_tag ?? "").toLowerCase(), `issue-${num}`].filter(Boolean))];
-  for (const n of names) {
-    const sha = rev(dir, `origin/${n}`);
-    if (sha) return sha.slice(0, 7);
+  async crewRows() {
+    return this.client.records.list(this.models.crew, { limit: 200 });
   }
-  return null;
-}
-function holdWarnings(tickets, ships, contract, humanHolds, now = Date.now()) {
-  const inFlight = [contract.statuses.building, contract.statuses.verifying];
-  const out = [];
-  for (const t of tickets) {
-    if (!inFlight.includes(t.status)) continue;
-    if (t.assignee_id && humanHolds.has(t.assignee_id)) continue;
-    const holder = ticketHolderShipId(t, contract);
-    if (!holder) {
-      out.push(`${t.issue_id} (${t.status}) has no ${contract.columns.heldBy} \u2014 any ship may take it`);
-    } else if (!shipIsAlive(ships.find((s) => s.id === holder), now)) {
-      out.push(`${t.issue_id} (${t.status}) is held by ${shipName(ships, holder)}, which has not been seen for ${SHIP_DEAD_AFTER_CYCLES}+ cycles`);
+  /**
+   * One row of the `Repos` table, for whatever it can tell the crew that
+   * isn't in `.crew.yaml` — which `Projects` (area) row it belongs to, in
+   * particular. `undefined` on a workspace with no Repos table, or if the
+   * row is gone; neither is fatal to the caller.
+   */
+  async repoRow(id) {
+    const model = this.route.resolved?.reposModelId;
+    if (!model) return void 0;
+    try {
+      return await this.client.records.get(model, id);
+    } catch {
+      return void 0;
     }
   }
-  return out;
-}
-
-// src/select.ts
-var qaSlice = (tickets) => tickets.filter((t) => t.status === "fixed" || t.status === "qa");
-var buildingSlice = (tickets, role) => tickets.filter((t) => role === "design" ? t.needs_design === true : t.needs_design !== true);
-var triageSlice = (tickets, triageSeat) => triageSeat ? tickets.filter((t) => t.assignee_id === triageSeat) : [];
-function sliceFor(tickets, role) {
-  if (role === "qa") return qaSlice(tickets);
-  if (role === "triage") return triageSlice(tickets);
-  if (role === "pair") return [];
-  return buildingSlice(tickets, role);
-}
-var isHeld = (t, holds2) => !!t.assignee_id && holds2.has(t.assignee_id);
-function affinityContext(i) {
-  return i.ships ? { myShipId: i.ships.myShipId, ships: i.ships.rows, contract: i.contract ?? DEFAULT_CONTRACT, now: i.ships.now } : null;
-}
-function withHoldCheck(affinity, i) {
-  if (!affinity) return void 0;
-  const a = affinityContext(i);
-  return a ? { ...affinity, isHeldElsewhere: (t) => heldByOtherShip(t, a), isLiveHoldElsewhere: (t) => heldByLiveOtherShip(t, a) } : affinity;
-}
-function notHeldByOtherShip(slice, i) {
-  if (!i.ships) return slice;
-  const a = { myShipId: i.ships.myShipId, ships: i.ships.rows, contract: i.contract ?? DEFAULT_CONTRACT, now: i.ships.now };
-  return slice.filter((t) => !heldByOtherShip(t, a));
-}
-function buildingRoleHasWork(role, i) {
-  const me = i.seats[role];
-  if (!me) return { hasWork: false, reason: "this ship does not crew that role" };
-  const mine = notHeldByOtherShip(sliceFor(i.tickets, role), i);
-  const startable = mine.filter(
-    (t) => (t.status === "accepted" || t.status === "blocked") && !i.blocked.has(t.id) && !isHeld(t, i.holds)
-  );
-  const watched = mine.filter(
-    (t) => (t.status === "in_progress" && (t.assignee_id === me || !t.assignee_id) || t.status === "needs_info") && !isHeld(t, i.holds)
-  );
-  const watchedIds = new Set(watched.map((t) => t.id));
-  const newComments = i.comments.filter(
-    (c) => c.created_at > i.watermark && c.team_member_id !== me && (c.kind ?? "comment") !== "event" && watchedIds.has(c.ticket_id)
-  ).length;
-  const unassigned = mine.filter(
-    (t) => t.status === "in_progress" && !t.assignee_id && !i.blocked.has(t.id)
-  ).length;
-  const resumable = mine.filter(
-    (t) => t.status === "in_progress" && t.assignee_id === me && !t.needs_planning && !t.needs_review && !isHeld(t, i.holds)
-  ).length;
-  if (startable.length > 0 || newComments > 0 || unassigned > 0 || resumable > 0) {
-    const parts = [];
-    if (startable.length) parts.push(`${startable.length} startable`);
-    if (newComments) parts.push(`${newComments} new comment(s)`);
-    if (unassigned) parts.push(`${unassigned} unassigned in_progress`);
-    if (resumable) parts.push(`${resumable} resumable in_progress`);
-    return { hasWork: true, reason: parts.join(", ") };
+  /**
+   * One row of the `Projects` (area) table. `undefined` on a workspace
+   * with no such table, or if the row is gone.
+   */
+  async projectRow(id) {
+    const model = this.route.resolved?.areaModelId;
+    if (!model) return void 0;
+    try {
+      return await this.client.records.get(model, id);
+    } catch {
+      return void 0;
+    }
   }
-  return { hasWork: false, reason: "nothing startable and no new comments" };
-}
-function qaRoleHasWork(i) {
-  if (!i.seats.qa) return { hasWork: false, reason: "this ship does not crew that role" };
-  const n = notHeldByOtherShip(qaSlice(i.tickets), i).filter((t) => !isHeld(t, i.holds)).length;
-  return n > 0 ? { hasWork: true, reason: `${n} ticket(s) awaiting or in verification` } : { hasWork: false, reason: "nothing awaiting verification" };
-}
-function triageRoleHasWork(i) {
-  if (!i.seats.triage) return { hasWork: false, reason: "this ship does not crew that role" };
-  const n = triageSlice(i.tickets, i.seats.triage).length;
-  return n > 0 ? { hasWork: true, reason: `${n} report(s) assigned to triage` } : { hasWork: false, reason: "nothing assigned to triage" };
-}
-function roleHasWork(role, i) {
-  if (i.paused?.has(role)) return { hasWork: false, reason: "paused" };
-  if (role === "qa") return qaRoleHasWork(i);
-  if (role === "triage") return triageRoleHasWork(i);
-  if (role === "pair") return { hasWork: false, reason: "pair is interactive, not polled" };
-  return buildingRoleHasWork(role, i);
-}
-function roleCandidates(role, i) {
-  if (role === "qa") return notHeldByOtherShip(qaSlice(i.tickets), i).filter((t) => !isHeld(t, i.holds));
-  if (role === "triage") return triageSlice(i.tickets, i.seats.triage).filter((t) => !isHeld(t, i.holds));
-  if (role === "pair") return [];
-  const me = i.seats[role];
-  if (!me) return [];
-  return notHeldByOtherShip(sliceFor(i.tickets, role), i).filter(
-    (t) => ((t.status === "accepted" || t.status === "blocked") && !i.blocked.has(t.id) || t.status === "in_progress" && (t.assignee_id === me || !t.assignee_id)) && !isHeld(t, i.holds)
-  );
-}
-function claimStatuses(role, c) {
-  return role === "qa" ? { approved: c.statuses.handoff, building: c.statuses.verifying } : { approved: c.statuses.approved, building: c.statuses.building };
-}
-function rankedCandidates(role, i) {
-  const c = i.contract ?? DEFAULT_CONTRACT;
-  return [...roleCandidates(role, i)].sort((a, b) => rankScalar(a, c) - rankScalar(b, c));
-}
-function roleTopRank(role, i) {
-  if (role !== "qa" && role !== "triage" && !i.seats[role]) return NOTHING_ACTIONABLE;
-  const candidates = roleCandidates(role, i);
-  if (candidates.length === 0) return NOTHING_ACTIONABLE;
-  const c = i.contract ?? DEFAULT_CONTRACT;
-  return Math.min(...candidates.map((t) => rankScalar(t, c)));
-}
-function actionableSummary(i, pending) {
-  const c = i.contract ?? DEFAULT_CONTRACT;
-  const all = pending.flatMap((role) => roleCandidates(role, i));
-  if (all.length === 0) return { count: 0 };
-  const top = all.reduce((best, t) => rankScalar(t, c) < rankScalar(best, c) ? t : best);
-  return { count: all.length, top };
-}
-var FIXED_RANK = { qa: -2, triage: -1 };
-function selectRole(i) {
-  const order = ["qa", "triage", "dev", "design"];
-  const pending = [];
-  const ranks = {};
-  const reasons = {};
-  for (const role of order) {
-    const { hasWork, reason } = roleHasWork(role, i);
-    reasons[role] = reason;
-    if (hasWork) pending.push(role);
+  /** Every `Projects` (area) row — what `crew repos add` offers when a new Repos row needs one. */
+  async projectRows() {
+    const model = this.route.resolved?.areaModelId;
+    if (!model) return [];
+    return this.client.records.list(model, { limit: 200 });
   }
-  if (pending.length === 0) return { pending, selected: null, ranks, reasons };
-  let selected = null;
-  let best = Infinity;
-  for (const role of pending) {
-    const rank2 = FIXED_RANK[role] ?? roleTopRank(role, i);
-    ranks[role] = rank2;
-    if (rank2 < best) {
-      best = rank2;
-      selected = role;
+  /** Create a `Repos` row. Throws when the workspace has no Repos table. */
+  async createRepoRow(fields) {
+    const model = this.route.resolved?.reposModelId;
+    if (!model) throw new Error("this workspace has no Repos table");
+    return this.client.records.create(model, fields);
+  }
+  /**
+   * The Ships rows of this workspace, if it has a Ships table.
+   *
+   * Optional by design: a workspace that has not adopted ships still works,
+   * and the crew must not require a table it did not create.
+   */
+  async shipRows() {
+    const model = this.route.resolved?.shipsModelId;
+    if (!model) return [];
+    try {
+      return await this.client.records.list(model, { limit: 200 });
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * This ship's own row on the `Ships` table, matched by name — the same
+   * exact-string match `doctor` has always used (see the callsign comment
+   * on ISSUE-380: name is what an operator recognises on the board).
+   * `undefined` when the workspace has no Ships table, no row named for
+   * this ship, or more than one — ambiguous is not a row to write to.
+   */
+  async myShipRow(shipName2) {
+    const rows = await this.shipRows();
+    const mine = rows.filter((r) => (r.name ?? "").trim() === shipName2.trim());
+    return mine.length === 1 ? mine[0] : void 0;
+  }
+  /**
+   * The `attention` field of a Ships-row patch (CREW-1373): this ship's open
+   * items, so every heartbeat carries the current set and a cleared item
+   * disappears from the board on the next one. Empty when there is nothing
+   * to write: no state directory to read, or a Ships table without the
+   * column (probed by the key's absence from the row, the way `owner_id` is
+   * skipped on an install that has not taken the template update).
+   */
+  attentionPatch(row) {
+    if (!this.stateDir || !("attention" in row)) return {};
+    const items = openShipAttention(new State(this.stateDir));
+    return { attention: items.length ? items : null };
+  }
+  /**
+   * Writes this ship's attention items on their own, without touching
+   * `last_seen` — for the daemon, which raises one between heartbeats and
+   * should not wait for the next engaged/idle beat to show it. Skips the
+   * write when the row already holds the same set.
+   */
+  async publishShipAttention(shipName2) {
+    const row = await this.myShipRow(shipName2);
+    if (!row) return;
+    const patch2 = this.attentionPatch(row);
+    if (!("attention" in patch2)) return;
+    if (JSON.stringify(patch2.attention) === JSON.stringify(row.attention ?? null)) return;
+    await this.client.records.update(this.route.resolved.shipsModelId, row.id, patch2);
+  }
+  /**
+   * Ship-level heartbeat (ISSUE-380): "is this ship online" — independent
+   * of any one seat's Working/Idle status (`setCrewStatus`), which only
+   * exists for the duration of an actual agent run. This one fires once
+   * per `crew run`/`poll` cycle **regardless of outcome**, including a
+   * cycle that finds nothing to do, so a ship that stops firing (powered
+   * off, asleep, closed for the weekend) simply stops updating `last_seen`
+   * — silence then means exactly one thing, rather than being ambiguous
+   * with "idle".
+   *
+   * Does not touch the `engaged*` columns — those are set only by
+   * `beatEngaged`/`beatIdle`, paired around the part of the cycle that
+   * actually spawns an agent, so a plain heartbeat mid-engagement can't
+   * blow away `engaged_since`.
+   *
+   * A no-op, like `shipRows()`, on a workspace with no Ships table or no
+   * row for this ship's name.
+   */
+  async beatShip(shipName2) {
+    const row = await this.myShipRow(shipName2);
+    if (!row) return;
+    await this.client.records.update(this.route.resolved.shipsModelId, row.id, {
+      last_seen: (/* @__PURE__ */ new Date()).toISOString(),
+      host: hostname(),
+      pid: process.pid,
+      ...this.attentionPatch(row)
+    });
+  }
+  /**
+   * Marks this ship's row engaged, naming what it's working and since when
+   * (ISSUE-380's "an engaged ship names what it is working and since
+   * when"). Call once, right before `spawnAgent`, paired with
+   * `beatIdle` in a `finally` — the same shape as `setCrewStatus`'s
+   * working/idle pair, one level up (ship, not seat).
+   */
+  async beatEngaged(shipName2, connectionName, ticketRecordId) {
+    const row = await this.myShipRow(shipName2);
+    if (!row) return;
+    await this.client.records.update(this.route.resolved.shipsModelId, row.id, {
+      last_seen: (/* @__PURE__ */ new Date()).toISOString(),
+      host: hostname(),
+      pid: process.pid,
+      engaged: true,
+      engaged_since: (/* @__PURE__ */ new Date()).toISOString(),
+      engaged_connection: connectionName,
+      engaged_ticket_id: ticketRecordId,
+      ...this.attentionPatch(row)
+    });
+  }
+  /**
+   * Writes this ship's own tunnel state for Host Passengers (ISSUE-553):
+   * `tunnel_status` (disconnected/connecting/connected), as
+   * the tunnel client (`tunnel.ts`) brings a workspace's container's tunnel
+   * up or down. A no-op, like every other `myShipRow`-backed write here, on
+   * a workspace with no Ships table or no row for this ship's name — the
+   * tunnel client itself still runs the tunnel either way, it just has
+   * nowhere on the board to report the state.
+   */
+  async updateTunnelState(shipName2, patch2) {
+    const row = await this.myShipRow(shipName2);
+    if (!row) return;
+    await this.client.records.update(this.route.resolved.shipsModelId, row.id, patch2);
+  }
+  /** The other half of `beatEngaged` — clears engagement back to idle. */
+  async beatIdle(shipName2) {
+    const row = await this.myShipRow(shipName2);
+    if (!row) return;
+    await this.client.records.update(this.route.resolved.shipsModelId, row.id, {
+      last_seen: (/* @__PURE__ */ new Date()).toISOString(),
+      host: hostname(),
+      pid: process.pid,
+      engaged: false,
+      engaged_since: null,
+      engaged_connection: null,
+      engaged_ticket_id: null,
+      ...this.attentionPatch(row)
+    });
+  }
+  /**
+   * The Epics rows of this workspace, if it has an Epics table (ISSUE-384).
+   *
+   * Optional by design, the same way `shipRows()` is: a workspace that has
+   * not adopted epics still works, and the crew must not require a table it
+   * did not create.
+   */
+  async epicRows() {
+    const model = this.route.resolved?.epicsModelId;
+    if (!model) return [];
+    try {
+      return await this.client.records.list(model, { limit: 500 });
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * The tickets of these epics that are closed (`closed: true`) or not
+   * (`closed: false`), for the epic sync (CREW-1255).
+   *
+   * **Not area-filtered, unlike `openTickets()`**: an epic spans areas, so
+   * whether it is finished can only be judged across all of them. Also not
+   * limited to `statuses.open` — a status this contract has never heard of
+   * (a pre-triage `draft`, say) is still a ticket that is not closed.
+   *
+   * Paged, because an epic's history is unbounded and a truncated page
+   * would silently read as "nothing else outstanding".
+   */
+  async epicTickets(epicIds, o) {
+    if (epicIds.length === 0) return [];
+    const c = this.contract;
+    const statuses = closedStatuses(c);
+    if (!statuses.length) return [];
+    const filters = encodeFilters([
+      { columnName: c.columns.epic, operator: "IN", value: epicIds },
+      { columnName: c.columns.status, operator: o.closed ? "IN" : "NOT_IN", value: statuses }
+    ]);
+    const pageSize = 500;
+    const out = [];
+    for (let page = 0; page < 20; page++) {
+      const rows = await this.client.records.list(this.models.issues, {
+        filters,
+        limit: pageSize,
+        offset: page * pageSize
+      });
+      out.push(...rows);
+      if (rows.length < pageSize) break;
+    }
+    return out;
+  }
+  /** Conditional on `expectedUpdatedAt`, exactly as `updateTicket` is. */
+  async updateEpic(id, patch2, expectedUpdatedAt) {
+    const model = this.route.resolved?.epicsModelId;
+    if (!model) throw new ConfigError(`route "${this.route.route}" has no Epics table`);
+    return this.client.records.update(model, id, patch2, expectedUpdatedAt);
+  }
+  /**
+   * `expectedUpdatedAt` makes this a conditional write (ISSUE-395, the same
+   * `RecordsResource.update` primitive board-lock.ts uses): pass the
+   * `updated_at` this caller last read, and the write throws
+   * `StaleWriteError` instead of applying if the row has moved since —
+   * exactly what claim.ts needs to let a contended ticket claim fail loudly
+   * rather than silently overwrite a winning ship's write.
+   */
+  async updateTicket(id, patch2, expectedUpdatedAt) {
+    return this.client.records.update(this.models.issues, id, patch2, expectedUpdatedAt);
+  }
+  /**
+   * Claim a board-visible lock for `scope` (ISSUE-394) — see board-lock.ts
+   * for the CAS mechanics. Resolves to `{ ok: true }` immediately, with a
+   * no-op release, only when this workspace has no Locks table at all. A
+   * Locks table with no row for `scope` is `{ ok: false, reason: 'missing' }`
+   * (CREW-1384): `crew connect` provisions the row.
+   */
+  acquireBoardLock(scope, holderLabel, ttlMs) {
+    return acquireBoardLock(this.client.records, this.route.resolved?.locksModelId, scope, holderLabel, ttlMs);
+  }
+  /** The Locks row for `scope` — present? held by whom? Undefined when this workspace has no Locks table. */
+  async lockState(scope) {
+    const model = this.route.resolved?.locksModelId;
+    return model ? lockRowState(this.client.records, model, scope) : void 0;
+  }
+  /**
+   * Reports one crew member's live status (ISSUE-325) — "Working" for the
+   * duration of an agent run, "Idle" once it ends.
+   *
+   * `ticketRecordId` is the ticket's own row id (`Ticket.id`), not its
+   * `issue_id` label — the field it fills is a Reference, not text.
+   * Omitted (as on the idle transition) leaves the column alone, so it
+   * keeps reading as "current/last issue" rather than clearing to blank
+   * the moment a run ends.
+   */
+  async setCrewStatus(memberId, status2, ticketRecordId) {
+    const patch2 = { status: status2, status_updated_at: (/* @__PURE__ */ new Date()).toISOString() };
+    if (ticketRecordId !== void 0) patch2.current_issue_id = ticketRecordId;
+    await this.client.records.update(this.models.crew, memberId, patch2);
+  }
+  /**
+   * An `event` comment — the runner's own audit trail, distinct from a
+   * seat's prose. `kind` is what keeps these out of the "new comment from
+   * someone else" wake signal.
+   */
+  async postEvent(ticketId, body, memberId) {
+    const auth = await this.authorshipProbe();
+    await this.client.records.create(this.models.comments, {
+      ticket_id: ticketId,
+      body,
+      team_member_id: memberId,
+      kind: "event",
+      ...auth.commentShip && auth.shipId ? { [this.contract.comments.ship]: auth.shipId } : {}
+    });
+  }
+  /**
+   * Ship affinity for a claim (CREW-1386): stamp this ship's Ships row on the
+   * ticket in the claim's own write, in the `held_by_ship_id` column (not
+   * `ship_id`, which means "filed from"). `undefined` — claim exactly as
+   * before — when the Issues table has no hold column or this ship has no row.
+   */
+  async claimAffinity() {
+    const auth = await this.authorshipProbe();
+    if (!auth.issueHeld || !auth.shipId) return void 0;
+    return {
+      column: this.contract.columns.heldBy,
+      shipId: auth.shipId
+    };
+  }
+  /**
+   * The authorship probe (CREW-1371), read once per process: which optional
+   * `filed_by_id`/`ship_id` columns exist on Issues and Comments, and this
+   * ship's own Ships row id. Memoised as a promise so concurrent first writes
+   * share one round of metadata reads. A table whose metadata cannot be read
+   * reads as "column absent", the same way `connect.ts`'s `owner_id` probe does.
+   */
+  authorshipProbe() {
+    this.authorship ??= this.probeAuthorship();
+    return this.authorship;
+  }
+  async probeAuthorship() {
+    const [issueFields, commentFields, shipRow] = await Promise.all([
+      this.columnNames(this.models.issues),
+      this.columnNames(this.models.comments),
+      // No name (a caller that only beats or patches, never stamps) means no row to find.
+      this.shipName ? this.myShipRow(this.shipName) : Promise.resolve(void 0)
+    ]);
+    return {
+      issueAuthor: issueFields.has(this.contract.columns.author),
+      issueShip: issueFields.has(this.contract.columns.ship),
+      issueHeld: issueFields.has(this.contract.columns.heldBy),
+      commentShip: commentFields.has(this.contract.comments.ship),
+      shipId: shipRow?.id ?? null
+    };
+  }
+  async columnNames(modelId) {
+    try {
+      const model = await this.client.dataModels.get(modelId);
+      return new Set(model.fields.map((f) => f.columnName));
+    } catch {
+      return /* @__PURE__ */ new Set();
+    }
+  }
+  /**
+   * The authorship columns this workspace is missing, as `table.column` names
+   * for `crew doctor` to report (CREW-1371). Empty on a fully updated install.
+   */
+  async missingAuthorshipColumns() {
+    const auth = await this.authorshipProbe();
+    const missing = [];
+    if (!auth.issueAuthor) missing.push(`Issues.${this.contract.columns.author}`);
+    if (!auth.issueShip) missing.push(`Issues.${this.contract.columns.ship}`);
+    if (!auth.issueHeld) missing.push(`Issues.${this.contract.columns.heldBy}`);
+    if (!auth.commentShip) missing.push(`Comments.${this.contract.comments.ship}`);
+    return missing;
+  }
+  /**
+   * The public `/v/<slug>/r/<token>` link for one ticket (ISSUE-928) —
+   * fetch-or-create via `POST /views/:viewId/record-links`, so a repeated
+   * call for the same (view, model, record) returns the same URL and even
+   * un-retires a retired one — right for a ticket that just went back to
+   * `needs_info` after having been resolved once before.
+   *
+   * `undefined` when this route has no `recordLinkViewId` resolved, or the
+   * mint call fails for any reason (network, 404, an unexpected response
+   * shape) — the caller (poll.ts's attention sweep) still emits its
+   * notification event without a link rather than losing the whole event.
+   */
+  async recordLinkUrl(recordId) {
+    const viewId = this.route.resolved?.recordLinkViewId;
+    if (!viewId) return void 0;
+    try {
+      const res = await fetch(`${this.route.baseUrl}/api/views/${viewId}/record-links`, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${resolveApiKey(this.route)}`,
+          "User-Agent": this.userAgent,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({ dataModelId: this.models.issues, recordId })
+      });
+      if (!res.ok) return void 0;
+      const body = await res.json();
+      return typeof body.url === "string" ? body.url : void 0;
+    } catch {
+      return void 0;
     }
   }
-  return { pending, selected, ranks, reasons };
-}
-
-// src/epics.ts
-import { StaleWriteError as StaleWriteError3 } from "@tablation/client";
-var epicOf = (t, c) => {
-  const v = t[c.columns.epic];
-  return typeof v === "string" && v ? v : null;
-};
-var statusOf = (e, c) => {
-  const v = e[c.epics.statusColumn];
-  return typeof v === "string" && v ? v : null;
+  /**
+   * File a brand new ticket. Unlike every other write on this class, the
+   * field names are the fixed Bug Reports schema (`title`, `description`,
+   * `report_type`, `severity`, `reporter_name`) rather than anything in
+   * `Contract.columns` — that contract only names the lifecycle fields a
+   * workspace can rename, and creation-only fields like `description` are
+   * not among them (`postEvent` above hardcodes its own fields the same
+   * way).
+   */
+  async fileTicket(fields, memberId) {
+    const auth = await this.authorshipProbe();
+    return this.client.records.create(this.models.issues, {
+      ...fields,
+      ...auth.issueAuthor && memberId ? { [this.contract.columns.author]: memberId } : {},
+      ...auth.issueShip && auth.shipId ? { [this.contract.columns.ship]: auth.shipId } : {}
+    });
+  }
 };
-function epicLabel(e, c) {
-  const v = e[c.epics.keyColumn];
-  return typeof v === "string" && v ? v : e.id;
-}
-function trackedEpics(epics, c) {
-  const s = c.epics.statuses;
-  const movable = /* @__PURE__ */ new Set([s.planned, s.building, s.done]);
-  return epics.filter((e) => {
-    const status2 = statusOf(e, c);
-    return status2 !== null && movable.has(status2);
-  });
-}
-function workedStatuses(c) {
-  const s = c.statuses;
-  return new Set(
-    [s.building, s.handoff, s.verifying, s.verified, s.reviewing].filter((v) => !!v)
-  );
-}
-function epicsNeedingClosedCheck(epics, outstanding, c) {
-  const hasOutstanding = new Set(outstanding.map((t) => epicOf(t, c)));
-  return trackedEpics(epics, c).filter((e) => statusOf(e, c) !== c.epics.statuses.done && !hasOutstanding.has(e.id)).map((e) => e.id);
+
+// src/blocked.ts
+import { StaleWriteError as StaleWriteError2 } from "@tablation/client";
+function missingBlockerIds(tickets) {
+  const known = new Set(tickets.map((t) => t.id));
+  const missing = /* @__PURE__ */ new Set();
+  for (const t of tickets) for (const id of t.blocked_by ?? []) if (!known.has(id)) missing.add(id);
+  return [...missing];
 }
-function planEpicSync(epics, outstanding, closed, c) {
-  const s = c.epics.statuses;
-  const isClosed = new Set(closedStatuses(c));
-  const worked = workedStatuses(c);
-  const openByEpic = /* @__PURE__ */ new Map();
-  for (const t of outstanding) {
-    const id = epicOf(t, c);
-    if (!id || isClosed.has(t.status)) continue;
-    openByEpic.set(id, [...openByEpic.get(id) ?? [], t]);
+function blockerInfoMap(tickets, extra = []) {
+  const info = {};
+  for (const t of [...tickets, ...extra]) {
+    info[t.id] = { issue_id: t.issue_id, issue_tag: t.issue_tag, status: t.status };
   }
-  const closedCount = /* @__PURE__ */ new Map();
-  for (const t of closed) {
-    const id = epicOf(t, c);
-    if (!id || !isClosed.has(t.status)) continue;
-    closedCount.set(id, (closedCount.get(id) ?? 0) + 1);
+  return info;
+}
+function computeBlockedIds(tickets, info) {
+  const blocked = /* @__PURE__ */ new Set();
+  for (const t of tickets) {
+    const unresolved = (t.blocked_by ?? []).some((id) => {
+      const status2 = info[id]?.status;
+      return status2 !== void 0 && !RESOLVED_STATUSES.has(status2);
+    });
+    if (unresolved) blocked.add(t.id);
   }
-  const steps = [];
-  for (const epic of trackedEpics(epics, c)) {
-    const from = statusOf(epic, c);
-    const open = openByEpic.get(epic.id) ?? [];
-    const label = epicLabel(epic, c);
-    if (open.length === 0) {
-      const n = closedCount.get(epic.id) ?? 0;
-      if (from !== s.done && n > 0) {
-        steps.push({
-          action: "complete",
-          epic,
-          label,
-          from,
-          to: s.done,
-          reason: n === 1 ? "its only ticket is closed" : `all ${n} tickets closed`
-        });
-      }
-      continue;
-    }
-    const active = open.filter((t) => worked.has(t.status));
-    if (active.length && from !== s.building) {
-      steps.push({
-        action: from === s.done ? "reopen" : "start",
-        epic,
-        label,
-        from,
-        to: s.building,
-        reason: active.map((t) => `${t.issue_tag ?? t.issue_id} (${t.status})`).join(", ")
-      });
+  return blocked;
+}
+function sweepDiagnostics(tickets, info) {
+  const dangling = [];
+  const selfBlocked = [];
+  for (const t of tickets) {
+    for (const id of t.blocked_by ?? []) {
+      if (info[id] === void 0) dangling.push(`${t.issue_id} -> ${id}`);
+      if (id === t.id) selfBlocked.push(t.issue_id);
     }
   }
-  return steps;
+  return { dangling, selfBlocked: [...new Set(selfBlocked)] };
 }
-var describeEpicStep = (s) => `epic ${s.label}: ${s.from} -> ${s.to} (${s.reason})`;
-async function applyEpicSync(writer, steps, c, log) {
-  let updated = 0;
-  let contended = 0;
-  let failed = 0;
-  for (const step of steps) {
-    const data = { epic: step.label, from: step.from, to: step.to };
-    try {
-      await writer.updateEpic(step.epic.id, { [c.epics.statusColumn]: step.to }, step.epic.updated_at);
-      updated++;
-      log.emit(describeEpicStep(step), { step: "sweep", data });
-    } catch (e) {
-      if (e instanceof StaleWriteError3) {
-        contended++;
-        log.emit(`epic ${step.label} changed since it was read \u2014 left for the next cycle`, { step: "sweep", data });
-        continue;
-      }
-      failed++;
-      log.warn(`could not move epic ${step.label} to ${step.to}: ${e.message}`, { step: "sweep", data });
+var describeBlockers = (t, info) => (t.blocked_by ?? []).map((id) => `${info[id]?.issue_id ?? "?"} (${info[id]?.status ?? "unknown"})`).join(", ");
+function planSweep(tickets, info, blocked) {
+  const steps = [];
+  for (const t of tickets) {
+    if (t.status === "accepted" && blocked.has(t.id)) {
+      steps.push({ action: "park", ticket: t, blockers: describeBlockers(t, info), to: "blocked" });
+    } else if (t.status === "blocked" && !blocked.has(t.id)) {
+      steps.push({ action: "restore", ticket: t, blockers: describeBlockers(t, info), to: "accepted" });
     }
   }
-  return { updated, contended, failed };
+  return steps;
 }
-
-// src/attention.ts
-function attentionReasons(ticket, contract) {
-  const reasons = [];
-  if (ticket.status === contract.statuses.needsHuman) reasons.push("needs_info");
-  if (ticket.needs_planning === true) reasons.push("needs_planning");
-  if (ticket.needs_review === true) reasons.push("needs_review");
-  return reasons;
+function strandedNeedsInfo(tickets, blocked, holds2 = /* @__PURE__ */ new Set()) {
+  return tickets.filter(
+    (t) => t.status === "needs_info" && (t.blocked_by ?? []).length > 0 && !blocked.has(t.id) && !(t.assignee_id && holds2.has(t.assignee_id))
+  );
 }
-function attentionTransitions(previous, current) {
-  const out = [];
-  for (const [ticketId, reasons] of Object.entries(current)) {
-    const before = new Set(previous[ticketId] ?? []);
-    const newReasons = reasons.filter((r) => !before.has(r));
-    if (newReasons.length > 0) out.push({ ticketId, reasons: newReasons });
+var COORDINATING_DEFAULTS = {
+  reportTypeColumn: "report_type",
+  coordinatingValue: "coordinating"
+};
+var isCoordinating = (t, opts) => t[opts.reportTypeColumn] === opts.coordinatingValue;
+var FILING_ERROR_DEFAULT_EXEMPT = ["coordinating", "question", "investigation"];
+function rollUpParents(tickets, done = RESOLVED_STATUSES, opts = {}) {
+  const resolved = { ...COORDINATING_DEFAULTS, ...opts };
+  const byParent = /* @__PURE__ */ new Map();
+  for (const t of tickets) {
+    const p = t.parent_id;
+    if (!p) continue;
+    const list = byParent.get(p);
+    if (list) list.push(t);
+    else byParent.set(p, [t]);
   }
-  return out;
+  const rollups = [];
+  for (const t of tickets) {
+    const children = byParent.get(t.id);
+    if (!isCoordinating(t, resolved) || !children) continue;
+    const outstanding = children.filter((c) => !done.has(c.status));
+    rollups.push({ parent: t, children, outstanding, complete: outstanding.length === 0 });
+  }
+  return rollups;
 }
+function filingErrors(tickets, opts = {}) {
+  const reportTypeColumn = opts.reportTypeColumn ?? COORDINATING_DEFAULTS.reportTypeColumn;
+  const coordinatingValue = opts.coordinatingValue ?? COORDINATING_DEFAULTS.coordinatingValue;
+  const exempt = new Set(
+    opts.repoExemptValues ?? [coordinatingValue, ...FILING_ERROR_DEFAULT_EXEMPT.filter((v) => v !== "coordinating")]
+  );
+  return tickets.filter((t) => {
+    if (t.repo_id) return false;
+    return !exempt.has(t[reportTypeColumn]);
+  });
+}
+function sweepComment(step) {
+  return step.action === "park" ? `Parked as **Blocked** by the crew \u2014 waiting on: ${step.blockers}.
 
-// src/digest.ts
-function displayKey2(t) {
-  return t.issue_tag ?? t.issue_id ?? "?";
+This is automatic and reversible: an approved ticket whose \`Blocked by\` entries are not all resolved is parked out of the queue, and restored on the first poll after the last one resolves. Nothing else about the ticket changes. A blocker counts as resolved at \`verified\`, \`closed_deployed\`, \`closed_wont_fix\` or \`closed_duplicate\` \u2014 not at \`fixed\`, which is still an unmerged branch awaiting QA.` : `Restored to **Approved** by the crew \u2014 every blocker has resolved${step.blockers && step.blockers !== "\u2014" ? ` (${step.blockers})` : ""}.
+
+This restores the status it was approved at before being parked; it is back in the queue and a role may pick it up. If a blocker resolved as \`closed_wont_fix\` or \`closed_duplicate\` this ticket may still not be buildable as written \u2014 that is a call for a human, not the crew.`;
 }
-function author(c, i) {
-  const { me, roster } = i;
-  if (c.team_member_id === me) return "you";
-  if (c.team_member_id === null || c.team_member_id === void 0) {
-    const byIdentity = memberByIdentity(roster, c.created_by_id);
-    if (byIdentity) return byIdentity.id === me ? "you" : crewLabel(byIdentity) ?? byIdentity.name;
-    return `${c.reporter_name ?? "anon"} (no identity)`;
+async function applySweep(writer, steps, memberId, log) {
+  let parked = 0;
+  let restored = 0;
+  let failed = 0;
+  let contended = 0;
+  for (const step of steps) {
+    try {
+      await writer.updateTicket(step.ticket.id, { status: step.to }, step.ticket.updated_at);
+      if (step.action === "park") parked++;
+      else restored++;
+      log.emit(
+        step.action === "park" ? `parked (waiting on ${step.blockers})` : `restored to ${step.to} (blockers resolved: ${step.blockers || "none"})`,
+        { ticket: step.ticket.issue_id, step: "sweep" }
+      );
+      try {
+        await writer.postEvent(step.ticket.id, sweepComment(step), memberId);
+      } catch {
+        log.warn("status changed but the note failed to post", { ticket: step.ticket.issue_id, step: "sweep" });
+      }
+    } catch (e) {
+      if (e instanceof StaleWriteError2) {
+        contended++;
+        log.warn(`skipped ${step.action} \u2014 ticket changed since the sweep was planned`, {
+          ticket: step.ticket.issue_id,
+          step: "sweep"
+        });
+        continue;
+      }
+      failed++;
+      log.warn(`could not ${step.action}: ${e.message}`, { ticket: step.ticket.issue_id, step: "sweep" });
+    }
   }
-  return (crewLabel(roster.get(c.team_member_id)) ?? "someone off this ship") + shipSuffix(c, i);
-}
-function shipSuffix(c, i) {
-  if (!c.ship_id || c.ship_id === i.myShipId) return "";
-  const name = i.ships?.find((s) => s.id === c.ship_id)?.name;
-  return name ? ` (${name})` : "";
+  return { parked, restored, failed, contended };
 }
-function filedBy(t, i) {
-  const member = (t.filed_by_id ? i.roster.get(t.filed_by_id) : void 0) ?? memberByIdentity(i.roster, t.created_by_id);
-  if (member) {
-    if (member.id === i.me) return "you";
-    const label = crewLabel(member) ?? member.name;
-    const ship = t.ship_id && t.ship_id !== i.myShipId ? i.ships?.find((s) => s.id === t.ship_id)?.name : void 0;
-    return ship ? `${label} (${ship})` : label;
-  }
-  return t.reporter_name ? `${t.reporter_name} (unverified)` : "\u2014";
+
+// src/priority.ts
+var indexOf = (order) => Object.fromEntries(order.map((v, i) => [v, i]));
+function derivedPriority(t, c = DEFAULT_CONTRACT) {
+  return indexOf(c.severityOrder)[t.severity ?? ""] ?? c.unknownPriorityRank;
 }
-function lastComment(i, ticketId) {
-  const forTicket = i.comments.filter((c) => c.ticket_id === ticketId).sort((a, b) => a.created_at < b.created_at ? -1 : a.created_at > b.created_at ? 1 : 0);
-  const last = forTicket[forTicket.length - 1];
-  if (!last) return "\u2014";
-  return `${last.created_at.slice(0, 16)}Z ${author(last, i)}`;
+function explicitPriority(t, c = DEFAULT_CONTRACT) {
+  return indexOf(c.priorityOrder)[t.priority ?? ""] ?? null;
 }
-function newFromOthers(i, ticketId) {
-  return i.comments.filter(
-    (c) => c.ticket_id === ticketId && c.team_member_id !== i.me && c.created_at > i.watermark && (c.kind ?? "comment") !== "event"
-  ).length;
+function effectivePriority(t, c = DEFAULT_CONTRACT) {
+  const explicit = explicitPriority(t, c);
+  const derived = derivedPriority(t, c);
+  return explicit === null ? derived : Math.min(explicit, derived);
 }
-function who(t, i) {
-  return whoAssigned(t, i) + heldBySuffix(t, i);
+function severityRank(t, c = DEFAULT_CONTRACT) {
+  return indexOf(c.severityOrder)[t.severity ?? ""] ?? c.severityOrder.length;
 }
-function heldBySuffix(t, i) {
-  if (!t.held_by_ship_id || t.held_by_ship_id === i.myShipId) return "";
-  const name = i.ships?.find((s) => s.id === t.held_by_ship_id)?.name?.trim();
-  return ` (held by ${name || "an unknown ship"})`;
+function issueNumber(t) {
+  const id = t.issue_id ?? "ISSUE-0";
+  const n = Number.parseInt(id.split("-")[1] ?? "0", 10);
+  return Number.isNaN(n) ? 0 : n;
 }
-function whoAssigned(t, i) {
-  if (!t.assignee_id) return "unassigned";
-  if (t.assignee_id === i.me) return "you";
-  const label = crewLabel(i.roster.get(t.assignee_id));
-  if (label === null) return "someone off this ship";
-  return isHold(i.roster, t.assignee_id) ? `**${label} \u2014 HOLD**` : label;
+function epicRank(t) {
+  return t.epicInProgress ? 0 : 1;
 }
-function blockers(t, i) {
-  const list = (t.blocked_by ?? []).map((id) => {
-    const info = i.blockerInfo[id];
-    return `${info ? displayKey2(info) : "?"} (${info?.status ?? "unknown"})`;
-  });
-  return list.length === 0 ? "\u2014" : list.join(", ");
+function rank(t, c = DEFAULT_CONTRACT) {
+  return [effectivePriority(t, c), severityRank(t, c), epicRank(t), issueNumber(t)];
 }
-var sorted = (ts) => [...ts].sort(compareRank);
-var stream = (segments) => `${segments.join("\n")}
-`;
-function table(ts, i, header, row) {
-  if (ts.length === 0) return "\n_None._\n";
-  return `
-${header}
-${sorted(ts).map(row).join("\n")}
-`;
+function compareRank(a, b, c = DEFAULT_CONTRACT) {
+  const ra = rank(a, c);
+  const rb = rank(b, c);
+  for (let i = 0; i < ra.length; i++) {
+    const d = ra[i] - rb[i];
+    if (d !== 0) return d;
+  }
+  return 0;
 }
-function buildingDigest(i) {
-  const header = "| ticket | repo | branch | worktree | status | assignee | filed by | sev | pri | eff | updated | last comment | new since last poll |\n|---|---|---|---|---|---|---|---|---|---|---|---|---|";
-  const row = (t) => {
-    const n = newFromOthers(i, t.id);
-    const branch = i.branchFor ? i.branchFor(t) : "";
-    const worktree = i.worktreeFor ? i.worktreeFor(t) : "";
-    const dir = i.dirFor ? i.dirFor(t) : null;
-    const repo = i.dirFor ? dir ?? "**NO CHECKOUT**" : "";
-    return `| ${displayKey2(t)} | ${repo} | ${branch} | ${worktree} | ${t.status} | ${who(t, i)} | ${filedBy(t, i)} | ${t.severity ?? "\u2014"} | ${t.priority ?? "\u2014"} | p${effectivePriority(t)} | ${t.updated_at.slice(0, 16)}Z | ${lastComment(i, t.id)} | ${n > 0 ? `**${n} new**` : "\u2014"} |`;
-  };
-  const blockedRow = (t) => `| ${displayKey2(t)} | ${t.status} | ${who(t, i)} | p${effectivePriority(t)} | ${blockers(t, i)} |`;
-  const blockedTable = (ts) => ts.length === 0 ? "\n_None._\n" : `
-| ticket | status | assignee | eff | blocked by |
-|---|---|---|---|---|
-${sorted(ts).map(blockedRow).join("\n")}
-`;
-  const isBlocked = (t) => i.blocked.has(t.id);
-  const step1 = i.tickets.filter(
-    (t) => t.status === "in_progress" && (t.assignee_id === i.me || !t.assignee_id) || t.status === "needs_info"
-  );
-  const step2 = i.tickets.filter(
-    (t) => (t.status === "accepted" || t.status === "blocked") && !isBlocked(t)
-  );
-  return stream([
-    "## Current queue \u2014 built for you by the poll\n",
-    "\nAlready filtered to your lane, and already ordered by the Step 2 rule.\nTicket bodies are deliberately omitted: fetch the full record of only the\nticket you actually pick up. **Do not re-fetch the whole tracker.** This\ndigest comes from the same API call the poll just made, moments ago.\n",
-    '\n"new since last poll" counts comments from someone other than you since\nthe poll watermark \u2014 the same signal that woke this run.\n',
-    "\n**`repo` is the checkout a ticket's work happens in** \u2014 an area spans\nseveral repositories, so cut the worktree beside THAT directory, not beside\nwhichever one you started in. A ticket marked **NO CHECKOUT** is not yours:\nthis ship has no clone of its repository, and another ship may serve it.\n\n**Use the `branch` and `worktree` columns verbatim.** They are that\nrepository's own naming convention, rendered for THIS ticket \u2014 cut the\nworktree at `<repo>/../<worktree>`, on branch `<branch>`. Do not derive\neither yourself, and prefer these over the Environment section's own worked\nexample if the two ever disagree \u2014 that example is illustrative only,\nrendered before any ticket is picked.\n",
-    "\n### Step 1 \u2014 open tickets that may be yours to act on\n",
-    "\n`fixed` tickets are deliberately absent: they belong to the QA lane.\n",
-    table(step1, i, header, row),
-    "\n### Step 2 \u2014 accepted tickets, in pick order\n",
-    "\nWork the first one you are not required to skip. Tickets waiting on an\nunresolved dependency are already out of this table \u2014 see Blocked below.\n",
-    table(step2, i, header, row),
-    "\n### Blocked \u2014 waiting on a dependency, not yours to start\n",
-    '\nListed rather than hidden so "nothing to do" stays distinguishable from\n"everything is parked". The loop parks and restores these itself, on every\npoll: an approved ticket whose `Blocked by` entries are unresolved moves to\n`blocked`, and back to `accepted` once the last one resolves. **Do not pick\none up, do not set or clear `blocked` by hand, and do not "unblock" one by\nediting its `Blocked by` field** \u2014 if a blocker looks wrong, say so in your\nrun summary. A blocker counts as resolved at `verified`, `closed_deployed`,\n`closed_wont_fix` or `closed_duplicate`; `fixed` is still an unmerged branch\nawaiting QA, so it does not count.\n',
-    blockedTable(i.tickets.filter(isBlocked))
-  ]);
+function rankScalar(t, c = DEFAULT_CONTRACT) {
+  const [p, s, e, n] = rank(t, c);
+  return p * 1e9 + s * 1e7 + e * 1e6 + n;
 }
-function qaDigest(i) {
-  const header = "| ticket | repo | status | built by | assignee | filed by | sev | pri | eff | branch | worktree | updated | last comment | new since last poll |\n|---|---|---|---|---|---|---|---|---|---|---|---|---|---|";
-  const branchCell = (t) => {
-    if (i.dirFor && i.dirFor(t) === null) return "\u2014";
-    if (!i.existingBranchFor) return "";
-    return i.existingBranchFor(t) ?? "**MISSING**";
-  };
-  const worktreeCell = (t) => {
-    if (i.dirFor && i.dirFor(t) === null) return "\u2014";
-    return i.worktreeFor ? i.worktreeFor(t) : "";
-  };
-  const builtBy = (t) => t.needs_design === true ? "design" : "dev";
-  const row = (t) => {
-    const n = newFromOthers(i, t.id);
-    const dir = i.dirFor ? i.dirFor(t) : null;
-    const repo = i.dirFor ? dir ?? "**NO CHECKOUT**" : "";
-    return `| ${displayKey2(t)} | ${repo} | ${t.status} | ${builtBy(t)} | ${who(t, i)} | ${filedBy(t, i)} | ${t.severity ?? "\u2014"} | ${t.priority ?? "\u2014"} | p${effectivePriority(t)} | ${branchCell(t)} | ${worktreeCell(t)} | ${t.updated_at.slice(0, 16)}Z | ${lastComment(i, t.id)} | ${n > 0 ? `**${n} new**` : "\u2014"} |`;
-  };
-  return stream([
-    "## Current queue \u2014 built for you by the poll\n",
-    '\nAlready filtered to your lane: every ticket at `qa` ("Verification" \u2014\nyours, unfinished) or `fixed` (nobody has checked it yet), from both\nbuilding lanes. Ticket bodies are deliberately omitted: fetch the full\nrecord and the comments of the one ticket you actually pick up. **Do not\nre-fetch the whole tracker.** This digest comes from the same API call the\npoll just made, moments ago.\n',
-    '\n"new since last poll" counts comments from someone other than you since\nthe poll watermark \u2014 the same signal that woke this run.\n',
-    "\n**`repo` is the checkout the ticket's work happens in** \u2014 an area spans\nseveral repositories, so the worktree you verify in sits beside THAT\ndirectory, not beside whichever one this session started in. A ticket\nmarked **NO CHECKOUT** is not yours: this ship has no clone of its\nrepository, and another ship may serve it.\n\n**`branch` is that repository's own branch for the ticket**, found there\nrather than derived. **`<name> (on origin only)`** means another ship built it\nand pushed it: it is testable \u2014 cut a worktree from the remote branch\n(`git worktree add <worktree> <name>`). **MISSING** means the branch is gone\nlocally AND on the remote, so there is nothing left to verify \u2014 say so on the ticket. A `\u2014` means the branch\ncould not be looked for at all, because the repo has no checkout here.\n\n**`worktree` is where that branch should be checked out**, `<repo>/../<worktree>`\n\u2014 rendered the same way the dev/design digest computes it, so you land in\nthe same directory the building lane used.\n",
-    "\n### Still in verification \u2014 yours, unfinished (take these first)\n",
-    table(i.tickets.filter((t) => t.status === "qa"), i, header, row),
-    "\n### Awaiting verification, in pick order\n",
-    table(i.tickets.filter((t) => t.status === "fixed"), i, header, row)
-  ]);
+var NOTHING_ACTIONABLE = 999999999999;
+var AGE_HOURS_TO_ERODE = 48;
+function agedRankScalar(rawRank, aging, now) {
+  if (!aging) return rawRank;
+  const elapsedHours = Math.max(0, (now - Date.parse(aging.since)) / 36e5);
+  const weight = aging.weight ?? 1;
+  const fraction = Math.min(1, elapsedHours * weight / AGE_HOURS_TO_ERODE);
+  return Math.round(rawRank * (1 - fraction));
 }
 
-// src/git.ts
-import { execFileSync } from "child_process";
-import {
-  existsSync as existsSync6,
-  mkdirSync as mkdirSync4,
-  openSync,
-  closeSync,
-  writeSync,
-  statSync as statSync3,
-  unlinkSync as unlinkSync2
-} from "fs";
-import { dirname as dirname4, basename as basename3 } from "path";
-var GitError = class extends Error {
-};
-function gitRaw(cwd, args) {
-  try {
-    return execFileSync("git", args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
-  } catch (e) {
-    const err = e;
-    const why = [err.stderr, err.stdout].map((x) => (x ?? "").trim()).filter(Boolean).join(" / ");
-    throw new GitError(`git ${args.join(" ")}: ${why || err.message.trim()}`);
-  }
+// src/ship-affinity.ts
+var CYCLE_SECONDS = 120;
+var SHIP_DEAD_AFTER_CYCLES = 10;
+function shipIsAlive(ship, now) {
+  if (!ship?.last_seen) return false;
+  const seen = Date.parse(ship.last_seen);
+  return Number.isFinite(seen) && now - seen <= SHIP_DEAD_AFTER_CYCLES * CYCLE_SECONDS * 1e3;
 }
-function git(cwd, args) {
-  try {
-    return execFileSync("git", args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }).trim();
-  } catch (e) {
-    const err = e;
-    const why = [err.stderr, err.stdout].map((x) => (x ?? "").trim()).filter(Boolean).join(" / ");
-    throw new GitError(`git ${args.join(" ")}: ${why || err.message.trim()}`);
-  }
+function ticketHolderShipId(t, contract) {
+  const v = t[contract.columns.heldBy];
+  return typeof v === "string" && v ? v : null;
 }
-function gitOk(cwd, args) {
-  try {
-    return git(cwd, args);
-  } catch {
-    return null;
-  }
+function heldByOtherShip(t, a) {
+  const statuses = a.contract.statuses;
+  if (t.status === statuses.handoff) return false;
+  return heldByLiveOtherShip(t, a);
 }
-function commitDate(cwd, sha) {
-  const out = gitOk(cwd, ["show", "-s", "--format=%cI", sha]);
-  if (!out) return null;
-  const t = new Date(out);
-  return Number.isNaN(t.getTime()) ? null : t.toISOString();
+function heldByLiveOtherShip(t, a) {
+  if (!a.myShipId) return false;
+  const holder = ticketHolderShipId(t, a.contract);
+  if (!holder || holder === a.myShipId) return false;
+  const owner = a.ships.find((s) => s.id === holder);
+  return shipIsAlive(owner, a.now ?? Date.now());
 }
-var currentBranch = (cwd) => git(cwd, ["rev-parse", "--abbrev-ref", "HEAD"]);
-var headSha = (cwd) => git(cwd, ["rev-parse", "HEAD"]);
-function status(cwd) {
-  return gitRaw(cwd, ["status", "--porcelain"]).split("\n").filter((l) => l.length > 3).map((l) => ({
-    code: l.slice(0, 2),
-    path: l.slice(3),
-    untracked: l.startsWith("??")
-  }));
+function shipName(ships, id) {
+  if (!id) return "an unknown ship";
+  return ships.find((s) => s.id === id)?.name?.trim() || id;
 }
-function branches(cwd, pattern) {
-  const out = git(cwd, ["branch", "--list", pattern, "--format=%(refname:short)"]);
-  return out ? out.split("\n").filter(Boolean) : [];
+function shipIdByName(ships, name) {
+  const mine = ships.filter((r) => (r.name ?? "").trim() === name.trim());
+  return mine.length === 1 ? mine[0].id : null;
 }
-function branchForIssue(cwd, issueKey, templates = { name: "issue-{number}" }, render2 = (t) => t.replace(/\{number\}/g, issueKey.replace(/^\D+/, ""))) {
-  for (const c of branchCandidates(issueKey, templates, render2)) {
-    const found = branches(cwd, c);
-    if (found.length) return found[0];
+async function noteReaccepted(tracker, result, seat, shipLabel) {
+  if (!result.reaccepted || !result.ticket) return;
+  try {
+    await tracker.postEvent(
+      result.ticket.id,
+      `Re-accepted while held by ${shipLabel}; resuming there, not re-claiming. Setting a held ticket back to \`accepted\` is not needed \u2014 to move it to another ship, clear \`held_by_ship_id\`.`,
+      seat
+    );
+  } catch {
   }
-  return null;
 }
-function branchCandidates(issueKey, templates, render2) {
-  const num = issueKey.replace(/^\D+/, "");
-  const unpadded = String(Number.parseInt(num, 10));
-  const candidates = [];
-  for (const template of [templates.name, templates.push].filter(Boolean)) {
-    const exact = render2(template);
-    candidates.push(exact);
-    if (num !== unpadded) candidates.push(exact.replace(num, unpadded));
-    if (template.includes("{slug}")) {
-      const prefix = render2(template.slice(0, template.indexOf("{slug}")));
-      if (prefix) candidates.push(`${prefix}*`);
-    }
-  }
-  candidates.push(`issue-${num}`);
-  if (num !== unpadded) candidates.push(`issue-${unpadded}`);
-  return [...new Set(candidates)];
+function planHoldReleases(tickets, contract) {
+  const ends = [contract.statuses.handoff, contract.statuses.verified];
+  return tickets.filter((t) => ends.includes(t.status) && ticketHolderShipId(t, contract) !== null);
 }
-function remoteBranchForIssue(cwd, remote, issueKey, templates = { name: "issue-{number}" }, render2 = (t) => t.replace(/\{number\}/g, issueKey.replace(/^\D+/, ""))) {
-  const prefix = `refs/remotes/${remote}/`;
-  for (const c of branchCandidates(issueKey, templates, render2)) {
-    const out = gitOk(cwd, ["for-each-ref", "--format=%(refname)", `${prefix}${c}`]);
-    const hit = out?.split("\n").filter((r) => r.startsWith(prefix) && r !== `${prefix}HEAD`)[0];
-    if (hit) return hit.slice(prefix.length);
+async function applyHoldReleases(writer, tickets, contract, emit) {
+  let cleared = 0;
+  for (const t of tickets) {
+    try {
+      await writer.updateTicket(t.id, { [contract.columns.heldBy]: null }, t.updated_at);
+      cleared++;
+      emit.emit(`released ship hold (${t.status})`, { ticket: t.issue_id, step: "sweep" });
+    } catch (e) {
+      emit.warn(`could not release ship hold: ${e.message}`, { ticket: t.issue_id, step: "sweep" });
+    }
   }
-  return null;
+  return cleared;
 }
-function materializeRemoteBranch(cwd, remote, branch) {
-  if (!remoteBranchExists(cwd, remote, branch)) {
-    return gitOk(cwd, ["rev-parse", "-q", "--verify", `refs/heads/${branch}`]) !== null;
+async function noteTakeover(tracker, result, seat, ships, myShipName, continuingFrom) {
+  if (!result.tookOverFrom || !result.ticket) return;
+  let sha = null;
+  try {
+    sha = continuingFrom(result.ticket);
+  } catch {
   }
-  if (gitOk(cwd, ["rev-parse", "-q", "--verify", `refs/heads/${branch}`]) === null) {
-    return gitOk(cwd, ["branch", "--track", branch, `${remote}/${branch}`]) !== null;
+  try {
+    await tracker.postEvent(
+      result.ticket.id,
+      `Taken over from ${shipName(ships, result.tookOverFrom)} (not seen recently) by ${myShipName}; ` + (sha ? `continuing from \`${sha}\` on origin.` : "no branch commit was found on origin to continue from."),
+      seat
+    );
+  } catch {
   }
-  gitOk(cwd, ["fetch", "--quiet", remote, `${branch}:${branch}`]);
-  return true;
-}
-function deleteRemoteBranch(cwd, remote, branch) {
-  if (!remoteBranchExists(cwd, remote, branch)) return true;
-  return gitOk(cwd, ["push", remote, "--delete", branch]) !== null;
 }
-function worktreeForNumber(cwd, num) {
-  const re = new RegExp(`(?:^|-)${num}$`);
-  return worktrees(cwd).find((w) => re.test(basename3(w.path))) ?? null;
+function originBranchSha(dir, t, rev) {
+  const num = (t.issue_tag ?? t.issue_id).replace(/^\D+/, "");
+  const names = [...new Set([(t.issue_tag ?? "").toLowerCase(), `issue-${num}`].filter(Boolean))];
+  for (const n of names) {
+    const sha = rev(dir, `origin/${n}`);
+    if (sha) return sha.slice(0, 7);
+  }
+  return null;
 }
-var commitBodies = (cwd, range) => gitOk(cwd, ["log", range, "--format=%B"]) ?? "";
-var resolve2 = (cwd, ref) => gitOk(cwd, ["rev-parse", "-q", "--verify", `${ref}^{commit}`]);
-var countCommits = (cwd, range) => Number.parseInt(gitOk(cwd, ["rev-list", "--count", range]) ?? "0", 10);
-function latestReleaseTag(cwd, pattern = "v*", ref = "HEAD") {
-  return gitOk(cwd, ["describe", "--tags", "--abbrev=0", "--match", pattern, ref]);
+function holdWarnings(tickets, ships, contract, humanHolds, now = Date.now()) {
+  const inFlight = [contract.statuses.building, contract.statuses.verifying];
+  const out = [];
+  for (const t of tickets) {
+    if (!inFlight.includes(t.status)) continue;
+    if (t.assignee_id && humanHolds.has(t.assignee_id)) continue;
+    const holder = ticketHolderShipId(t, contract);
+    if (!holder) {
+      out.push(`${t.issue_id} (${t.status}) has no ${contract.columns.heldBy} \u2014 any ship may take it`);
+    } else if (!shipIsAlive(ships.find((s) => s.id === holder), now)) {
+      out.push(`${t.issue_id} (${t.status}) is held by ${shipName(ships, holder)}, which has not been seen for ${SHIP_DEAD_AFTER_CYCLES}+ cycles`);
+    }
+  }
+  return out;
 }
-function firstReleaseTagContaining(cwd, sha, pattern = "v*") {
-  const out = gitOk(cwd, ["tag", "--contains", sha, "--list", pattern, "--sort=creatordate"]);
-  return out?.split("\n").map((l) => l.trim()).find(Boolean) ?? null;
+
+// src/select.ts
+var qaSlice = (tickets) => tickets.filter((t) => t.status === "fixed" || t.status === "qa");
+var buildingSlice = (tickets, role) => tickets.filter((t) => role === "design" ? t.needs_design === true : t.needs_design !== true);
+var triageSlice = (tickets, triageSeat) => triageSeat ? tickets.filter((t) => t.assignee_id === triageSeat) : [];
+function sliceFor(tickets, role) {
+  if (role === "qa") return qaSlice(tickets);
+  if (role === "triage") return triageSlice(tickets);
+  if (role === "pair") return [];
+  return buildingSlice(tickets, role);
 }
-var tagCommit = (cwd, tag) => resolve2(cwd, tag);
-function createReleaseTag(cwd, tag, sha, message) {
-  git(cwd, ["tag", "-a", tag, sha, "-m", message]);
+var isHeld = (t, holds2) => !!t.assignee_id && holds2.has(t.assignee_id);
+function affinityContext(i) {
+  return i.ships ? { myShipId: i.ships.myShipId, ships: i.ships.rows, contract: i.contract ?? DEFAULT_CONTRACT, now: i.ships.now } : null;
 }
-var tagExists = (cwd, tag) => gitOk(cwd, ["rev-parse", "-q", "--verify", `refs/tags/${tag}`]) !== null;
-function pushTag(cwd, remote, tag) {
-  git(cwd, ["push", remote, tag]);
+function withHoldCheck(affinity, i) {
+  if (!affinity) return void 0;
+  const a = affinityContext(i);
+  return a ? { ...affinity, isHeldElsewhere: (t) => heldByOtherShip(t, a), isLiveHoldElsewhere: (t) => heldByLiveOtherShip(t, a) } : affinity;
 }
-function fetchRemote(cwd, remote = "origin") {
-  return gitOk(cwd, ["fetch", "--prune", "--quiet", remote]) !== null;
+function notHeldByOtherShip(slice, i) {
+  if (!i.ships) return slice;
+  const a = { myShipId: i.ships.myShipId, ships: i.ships.rows, contract: i.contract ?? DEFAULT_CONTRACT, now: i.ships.now };
+  return slice.filter((t) => !heldByOtherShip(t, a));
 }
-function remoteConfigured(cwd, remote = "origin") {
-  return gitOk(cwd, ["remote", "get-url", remote]) !== null;
+function buildingRoleHasWork(role, i) {
+  const me = i.seats[role];
+  if (!me) return { hasWork: false, reason: "this ship does not crew that role" };
+  const mine = notHeldByOtherShip(sliceFor(i.tickets, role), i);
+  const startable = mine.filter(
+    (t) => (t.status === "accepted" || t.status === "blocked") && !i.blocked.has(t.id) && !isHeld(t, i.holds)
+  );
+  const watched = mine.filter(
+    (t) => (t.status === "in_progress" && (t.assignee_id === me || !t.assignee_id) || t.status === "needs_info") && !isHeld(t, i.holds)
+  );
+  const watchedIds = new Set(watched.map((t) => t.id));
+  const newComments = i.comments.filter(
+    (c) => c.created_at > i.watermark && c.team_member_id !== me && (c.kind ?? "comment") !== "event" && watchedIds.has(c.ticket_id)
+  ).length;
+  const unassigned = mine.filter(
+    (t) => t.status === "in_progress" && !t.assignee_id && !i.blocked.has(t.id)
+  ).length;
+  const resumable = mine.filter(
+    (t) => t.status === "in_progress" && t.assignee_id === me && !t.needs_planning && !t.needs_review && !isHeld(t, i.holds)
+  ).length;
+  if (startable.length > 0 || newComments > 0 || unassigned > 0 || resumable > 0) {
+    const parts = [];
+    if (startable.length) parts.push(`${startable.length} startable`);
+    if (newComments) parts.push(`${newComments} new comment(s)`);
+    if (unassigned) parts.push(`${unassigned} unassigned in_progress`);
+    if (resumable) parts.push(`${resumable} resumable in_progress`);
+    return { hasWork: true, reason: parts.join(", ") };
+  }
+  return { hasWork: false, reason: "nothing startable and no new comments" };
 }
-function remoteBranchExists(cwd, remote, branch) {
-  return gitOk(cwd, ["rev-parse", "-q", "--verify", `refs/remotes/${remote}/${branch}`]) !== null;
+function qaRoleHasWork(i) {
+  if (!i.seats.qa) return { hasWork: false, reason: "this ship does not crew that role" };
+  const n = notHeldByOtherShip(qaSlice(i.tickets), i).filter((t) => !isHeld(t, i.holds)).length;
+  return n > 0 ? { hasWork: true, reason: `${n} ticket(s) awaiting or in verification` } : { hasWork: false, reason: "nothing awaiting verification" };
 }
-function findKeyInRange(cwd, key, range) {
-  return keyCommitsInRange(cwd, key, range)[0] ?? null;
+function triageRoleHasWork(i) {
+  if (!i.seats.triage) return { hasWork: false, reason: "this ship does not crew that role" };
+  const n = triageSlice(i.tickets, i.seats.triage).length;
+  return n > 0 ? { hasWork: true, reason: `${n} report(s) assigned to triage` } : { hasWork: false, reason: "nothing assigned to triage" };
 }
-function keyCommitsInRange(cwd, key, range) {
-  const keys = Array.isArray(key) ? key : [key];
-  const escaped = keys.map((k) => k.replace(/[.[\]{}()*+?^$|\\]/g, "\\$&"));
-  const pattern = `(^|[^0-9A-Za-z_-])(${escaped.join("|")})([^0-9]|$)`;
-  const out = gitOk(cwd, ["log", range, "--format=%H %s", "--extended-regexp", `--grep=${pattern}`]);
-  if (!out) return [];
-  return out.split("\n").map((l) => l.split(" ")[0]).filter(Boolean);
+function roleHasWork(role, i) {
+  if (i.paused?.has(role)) return { hasWork: false, reason: "paused" };
+  if (role === "qa") return qaRoleHasWork(i);
+  if (role === "triage") return triageRoleHasWork(i);
+  if (role === "pair") return { hasWork: false, reason: "pair is interactive, not polled" };
+  return buildingRoleHasWork(role, i);
 }
-function patchIdOf(cwd, from, to) {
-  try {
-    const diff = execFileSync("git", ["diff", from, to], { cwd, encoding: "utf8", maxBuffer: 256 * 1024 * 1024 });
-    if (!diff) return null;
-    const out = execFileSync("git", ["patch-id", "--stable"], { cwd, encoding: "utf8", input: diff });
-    return out.split(" ")[0]?.trim() || null;
-  } catch {
-    return null;
-  }
+function roleCandidates(role, i) {
+  if (role === "qa") return notHeldByOtherShip(qaSlice(i.tickets), i).filter((t) => !isHeld(t, i.holds));
+  if (role === "triage") return triageSlice(i.tickets, i.seats.triage).filter((t) => !isHeld(t, i.holds));
+  if (role === "pair") return [];
+  const me = i.seats[role];
+  if (!me) return [];
+  return notHeldByOtherShip(sliceFor(i.tickets, role), i).filter(
+    (t) => ((t.status === "accepted" || t.status === "blocked") && !i.blocked.has(t.id) || t.status === "in_progress" && (t.assignee_id === me || !t.assignee_id)) && !isHeld(t, i.holds)
+  );
 }
-function findSquashOfBranch(cwd, key, branch, base, range) {
-  const candidates = keyCommitsInRange(cwd, key, range);
-  if (candidates.length === 0) return null;
-  const mb = gitOk(cwd, ["merge-base", base, branch]);
-  const branchPatch = mb ? patchIdOf(cwd, mb, branch) : null;
-  for (const sha of candidates) {
-    if (gitOk(cwd, ["diff", "--quiet", branch, sha]) !== null) return sha;
-    if (branchPatch && gitOk(cwd, ["rev-parse", "--verify", "-q", `${sha}^`]) !== null && patchIdOf(cwd, `${sha}^`, sha) === branchPatch) return sha;
-  }
-  return null;
+function claimStatuses(role, c) {
+  return role === "qa" ? { approved: c.statuses.handoff, building: c.statuses.verifying } : { approved: c.statuses.approved, building: c.statuses.building };
 }
-function isAncestor(cwd, ancestor, descendant) {
-  return gitOk(cwd, ["merge-base", "--is-ancestor", ancestor, descendant]) !== null;
+function rankedCandidates(role, i) {
+  const c = i.contract ?? DEFAULT_CONTRACT;
+  return [...roleCandidates(role, i)].sort((a, b) => rankScalar(a, c) - rankScalar(b, c));
 }
-function fileAtRef(cwd, ref, path) {
-  return gitOk(cwd, ["show", `${ref}:${path}`]);
+function roleTopRank(role, i) {
+  if (role !== "qa" && role !== "triage" && !i.seats[role]) return NOTHING_ACTIONABLE;
+  const candidates = roleCandidates(role, i);
+  if (candidates.length === 0) return NOTHING_ACTIONABLE;
+  const c = i.contract ?? DEFAULT_CONTRACT;
+  return Math.min(...candidates.map((t) => rankScalar(t, c)));
 }
-function findKeyOnBase(cwd, key, remote, base, since2) {
-  const range = since2 ? `${since2}..${remote}/${base}` : `${remote}/${base}`;
-  return findKeyInRange(cwd, key, range);
+function actionableSummary(i, pending) {
+  const c = i.contract ?? DEFAULT_CONTRACT;
+  const all = pending.flatMap((role) => roleCandidates(role, i));
+  if (all.length === 0) return { count: 0 };
+  const top = all.reduce((best, t) => rankScalar(t, c) < rankScalar(best, c) ? t : best);
+  return { count: all.length, top };
 }
-function detectClosureHeuristically(cwd, key, pushedBranch, remote = "origin", base = "main", since2, aliases = []) {
-  const merged = findKeyOnBase(cwd, [key, ...aliases], remote, base, since2);
-  if (merged) {
-    return {
-      state: "merged",
-      confidence: "heuristic",
-      mergedAt: merged,
-      detail: `${key} appears on ${remote}/${base} at ${merged.slice(0, 8)}`
-    };
-  }
-  if (remoteBranchExists(cwd, remote, pushedBranch)) {
-    return {
-      state: "open",
-      confidence: "heuristic",
-      detail: `${remote}/${pushedBranch} still exists and ${key} is not on ${base}`
-    };
+var FIXED_RANK = { qa: -2, triage: -1 };
+function selectRole(i) {
+  const order = ["qa", "triage", "dev", "design"];
+  const pending = [];
+  const ranks = {};
+  const reasons = {};
+  for (const role of order) {
+    const { hasWork, reason } = roleHasWork(role, i);
+    reasons[role] = reason;
+    if (hasWork) pending.push(role);
   }
-  return {
-    state: "abandoned",
-    confidence: "heuristic",
-    detail: `${remote}/${pushedBranch} no longer exists and ${key} never reached ${base} \u2014 this is also what a squash merge with a rewritten subject looks like`
-  };
-}
-async function detectClosure(o) {
-  const remote = o.remote ?? "origin";
-  const base = o.base ?? "main";
-  const aliases = o.aliases ?? [];
-  if (o.mergedHook) {
-    const code = await o.mergedHook({
-      CREW_TICKET: o.key,
-      CREW_BRANCH: o.pushedBranch,
-      CREW_BASE: base
-    });
-    if (code === 0) {
-      const mergedAt = findKeyOnBase(o.cwd, [o.key, ...aliases], remote, base, o.since) ?? void 0;
-      return {
-        state: "merged",
-        confidence: "definitive",
-        mergedAt,
-        detail: `the repo's merged hook says ${o.key} landed`
-      };
+  if (pending.length === 0) return { pending, selected: null, ranks, reasons };
+  let selected = null;
+  let best = Infinity;
+  for (const role of pending) {
+    const rank2 = FIXED_RANK[role] ?? roleTopRank(role, i);
+    ranks[role] = rank2;
+    if (rank2 < best) {
+      best = rank2;
+      selected = role;
     }
-    return remoteBranchExists(o.cwd, remote, o.pushedBranch) ? { state: "open", confidence: "definitive", detail: `the repo's merged hook says ${o.key} has not landed` } : { state: "abandoned", confidence: "definitive", detail: `${o.key} has not landed and ${remote}/${o.pushedBranch} is gone` };
   }
-  return detectClosureHeuristically(o.cwd, o.key, o.pushedBranch, remote, base, o.since, aliases);
-}
-function upstreamOf(cwd, branch) {
-  return gitOk(cwd, ["rev-parse", "--abbrev-ref", "--symbolic-full-name", `${branch}@{upstream}`]);
+  return { pending, selected, ranks, reasons };
 }
-function syncState(cwd, branch) {
-  const upstream = upstreamOf(cwd, branch);
-  if (!upstream) {
-    return {
-      branch,
-      upstream: null,
-      ahead: 0,
-      behind: 0,
-      dirty: status(cwd).length > 0,
-      canFastForward: false,
-      detail: `${branch} tracks no remote branch`
-    };
-  }
-  const counts = gitOk(cwd, ["rev-list", "--left-right", "--count", `${upstream}...${branch}`]) ?? "0	0";
-  const [behindStr, aheadStr] = counts.split(/\s+/);
-  const behind = Number.parseInt(behindStr ?? "0", 10);
-  const ahead = Number.parseInt(aheadStr ?? "0", 10);
-  const dirty = status(cwd).length > 0;
-  let detail;
-  if (behind === 0 && ahead === 0) detail = `level with ${upstream}`;
-  else if (dirty) detail = `${behind} behind ${upstream}, but the worktree is dirty \u2014 not touching it`;
-  else if (ahead > 0 && behind > 0) detail = `diverged from ${upstream} (${ahead} ahead, ${behind} behind) \u2014 needs a human`;
-  else if (behind > 0) detail = `${behind} behind ${upstream} \u2014 fast-forwardable`;
-  else detail = `${ahead} ahead of ${upstream}, nothing to take`;
-  return {
-    branch,
-    upstream,
-    ahead,
-    behind,
-    dirty,
-    canFastForward: behind > 0 && ahead === 0 && !dirty,
-    detail
-  };
+
+// src/epics.ts
+import { StaleWriteError as StaleWriteError3 } from "@tablation/client";
+var epicOf = (t, c) => {
+  const v = t[c.columns.epic];
+  return typeof v === "string" && v ? v : null;
+};
+var statusOf = (e, c) => {
+  const v = e[c.epics.statusColumn];
+  return typeof v === "string" && v ? v : null;
+};
+function epicLabel(e, c) {
+  const v = e[c.epics.keyColumn];
+  return typeof v === "string" && v ? v : e.id;
 }
-function fastForward(cwd, branch) {
-  const s = syncState(cwd, branch);
-  if (!s.canFastForward) return false;
-  return gitOk(cwd, ["merge", "--ff-only", s.upstream]) !== null;
+function trackedEpics(epics, c) {
+  const s = c.epics.statuses;
+  const movable = /* @__PURE__ */ new Set([s.planned, s.building, s.done]);
+  return epics.filter((e) => {
+    const status2 = statusOf(e, c);
+    return status2 !== null && movable.has(status2);
+  });
 }
-function baseBranchUnsafe(r) {
-  return r.action === "diverged" || r.action === "ahead" || r.action === "ff-failed";
+function workedStatuses(c) {
+  const s = c.statuses;
+  return new Set(
+    [s.building, s.handoff, s.verifying, s.verified, s.reviewing].filter((v) => !!v)
+  );
 }
-function describeUnsafeBase(r, remote, base) {
-  const counts = r.action === "diverged" ? `${r.ahead} ahead, ${r.behind} behind ${remote}/${base}` : r.action === "ahead" ? `${r.ahead} ahead of ${remote}/${base}` : `${r.behind} behind ${remote}/${base}, cannot fast-forward`;
-  return `${r.detail} [${counts}] \u2014 reconcile it (\`crew sync\` afterwards), or \`git reset --hard ${remote}/${base}\` if the local commits duplicate a release`;
+function epicsNeedingClosedCheck(epics, outstanding, c) {
+  const hasOutstanding = new Set(outstanding.map((t) => epicOf(t, c)));
+  return trackedEpics(epics, c).filter((e) => statusOf(e, c) !== c.epics.statuses.done && !hasOutstanding.has(e.id)).map((e) => e.id);
 }
-function refreshBaseBranch(cwd, remote, base, dryRun = false) {
-  if (currentBranch(cwd) !== base || status(cwd).length > 0) {
-    return { action: "not-applicable", detail: `${cwd} is not on a clean ${base}` };
-  }
-  if (!remoteConfigured(cwd, remote)) {
-    return { action: "not-applicable", detail: `${remote} is not configured` };
-  }
-  if (!fetchRemote(cwd, remote)) {
-    return { action: "fetch-failed", detail: `could not fetch ${remote}` };
-  }
-  if (!remoteBranchExists(cwd, remote, base)) {
-    return { action: "not-applicable", detail: `${remote}/${base} does not exist` };
+function planEpicSync(epics, outstanding, closed, c) {
+  const s = c.epics.statuses;
+  const isClosed = new Set(closedStatuses(c));
+  const worked = workedStatuses(c);
+  const openByEpic = /* @__PURE__ */ new Map();
+  for (const t of outstanding) {
+    const id = epicOf(t, c);
+    if (!id || isClosed.has(t.status)) continue;
+    openByEpic.set(id, [...openByEpic.get(id) ?? [], t]);
   }
-  const upstream = `${remote}/${base}`;
-  const counts = gitOk(cwd, ["rev-list", "--left-right", "--count", `${upstream}...${base}`]) ?? "0	0";
-  const [behindStr, aheadStr] = counts.split(/\s+/);
-  const behind = Number.parseInt(behindStr ?? "0", 10);
-  const ahead = Number.parseInt(aheadStr ?? "0", 10);
-  const named = () => {
-    const subjects = (gitOk(cwd, ["log", "--format=%h %s", "-5", `${upstream}..${base}`]) ?? "").split("\n").filter(Boolean);
-    return subjects.length ? `: ${subjects.join("; ")}${ahead > subjects.length ? "; \u2026" : ""}` : "";
-  };
-  if (ahead > 0 && behind > 0) {
-    return {
-      action: "diverged",
-      ahead,
-      behind,
-      detail: `${base} has diverged from ${upstream} (${ahead} ahead, ${behind} behind)${named()}`
-    };
+  const closedCount = /* @__PURE__ */ new Map();
+  for (const t of closed) {
+    const id = epicOf(t, c);
+    if (!id || !isClosed.has(t.status)) continue;
+    closedCount.set(id, (closedCount.get(id) ?? 0) + 1);
   }
-  if (behind === 0 && ahead > 0) {
-    return { action: "ahead", ahead, detail: `${base} has ${ahead} commit(s) ${upstream} does not${named()}` };
+  const steps = [];
+  for (const epic of trackedEpics(epics, c)) {
+    const from = statusOf(epic, c);
+    const open = openByEpic.get(epic.id) ?? [];
+    const label = epicLabel(epic, c);
+    if (open.length === 0) {
+      const n = closedCount.get(epic.id) ?? 0;
+      if (from !== s.done && n > 0) {
+        steps.push({
+          action: "complete",
+          epic,
+          label,
+          from,
+          to: s.done,
+          reason: n === 1 ? "its only ticket is closed" : `all ${n} tickets closed`
+        });
+      }
+      continue;
+    }
+    const active = open.filter((t) => worked.has(t.status));
+    if (active.length && from !== s.building) {
+      steps.push({
+        action: from === s.done ? "reopen" : "start",
+        epic,
+        label,
+        from,
+        to: s.building,
+        reason: active.map((t) => `${t.issue_tag ?? t.issue_id} (${t.status})`).join(", ")
+      });
+    }
   }
-  if (behind === 0) return { action: "level", detail: `${base} is level with ${upstream}` };
-  if (dryRun) {
-    return { action: "would-fast-forward", behind, detail: `would fast-forward ${base}: ${behind} behind ${upstream}` };
+  return steps;
+}
+var describeEpicStep = (s) => `epic ${s.label}: ${s.from} -> ${s.to} (${s.reason})`;
+async function applyEpicSync(writer, steps, c, log) {
+  let updated = 0;
+  let contended = 0;
+  let failed = 0;
+  for (const step of steps) {
+    const data = { epic: step.label, from: step.from, to: step.to };
+    try {
+      await writer.updateEpic(step.epic.id, { [c.epics.statusColumn]: step.to }, step.epic.updated_at);
+      updated++;
+      log.emit(describeEpicStep(step), { step: "sweep", data });
+    } catch (e) {
+      if (e instanceof StaleWriteError3) {
+        contended++;
+        log.emit(`epic ${step.label} changed since it was read \u2014 left for the next cycle`, { step: "sweep", data });
+        continue;
+      }
+      failed++;
+      log.warn(`could not move epic ${step.label} to ${step.to}: ${e.message}`, { step: "sweep", data });
+    }
   }
-  if (gitOk(cwd, ["merge", "--ff-only", upstream]) === null) {
-    return { action: "ff-failed", behind, detail: `${base} is ${behind} behind ${upstream} and would not fast-forward` };
+  return { updated, contended, failed };
+}
+
+// src/attention.ts
+function attentionReasons(ticket, contract) {
+  const reasons = [];
+  if (ticket.status === contract.statuses.needsHuman) reasons.push("needs_info");
+  if (ticket.needs_planning === true) reasons.push("needs_planning");
+  if (ticket.needs_review === true) reasons.push("needs_review");
+  return reasons;
+}
+function attentionTransitions(previous, current) {
+  const out = [];
+  for (const [ticketId, reasons] of Object.entries(current)) {
+    const before = new Set(previous[ticketId] ?? []);
+    const newReasons = reasons.filter((r) => !before.has(r));
+    if (newReasons.length > 0) out.push({ ticketId, reasons: newReasons });
   }
-  return {
-    action: "fast-forwarded",
-    behind,
-    detail: `fast-forwarded ${base} to ${upstream} (${behind} commit(s) from elsewhere)`
-  };
+  return out;
 }
-function recoverStrandedReleaseCheckouts(cwd) {
-  gitOk(cwd, ["worktree", "prune"]);
-  const out = gitOk(cwd, ["worktree", "list", "--porcelain"]) ?? "";
-  let path = "";
-  for (const line of out.split("\n")) {
-    if (line.startsWith("worktree ")) path = line.slice("worktree ".length);
-    else if (line.startsWith("branch refs/heads/crew/release-") && path) {
-      gitOk(cwd, ["worktree", "remove", "--force", path]);
-    }
+
+// src/digest.ts
+function displayKey2(t) {
+  return t.issue_tag ?? t.issue_id ?? "?";
+}
+function author(c, i) {
+  const { me, roster } = i;
+  if (c.team_member_id === me) return "you";
+  if (c.team_member_id === null || c.team_member_id === void 0) {
+    const byIdentity = memberByIdentity(roster, c.created_by_id);
+    if (byIdentity) return byIdentity.id === me ? "you" : crewLabel(byIdentity) ?? byIdentity.name;
+    return `${c.reporter_name ?? "anon"} (no identity)`;
   }
-  const stranded = (gitOk(cwd, ["for-each-ref", "--format=%(refname:short)", "refs/heads/crew/release-*"]) ?? "").split("\n").filter(Boolean);
-  for (const b of stranded) gitOk(cwd, ["branch", "-q", "-D", b]);
-  return stranded;
+  return (crewLabel(roster.get(c.team_member_id)) ?? "someone off this ship") + shipSuffix(c, i);
 }
-function pushBranch(cwd, remote, branch, dst = branch) {
-  git(cwd, ["push", remote, `${branch}:${dst}`]);
+function shipSuffix(c, i) {
+  if (!c.ship_id || c.ship_id === i.myShipId) return "";
+  const name = i.ships?.find((s) => s.id === c.ship_id)?.name;
+  return name ? ` (${name})` : "";
 }
-function worktrees(cwd) {
-  const out = gitOk(cwd, ["worktree", "list", "--porcelain"]) ?? "";
-  const list = [];
-  let current = {};
-  for (const line of out.split("\n")) {
-    if (line.startsWith("worktree ")) {
-      if (current.path) list.push({ path: current.path, branch: current.branch ?? null, prunable: current.prunable ?? false });
-      current = { path: line.slice("worktree ".length) };
-    } else if (line.startsWith("branch ")) {
-      current.branch = line.slice("branch refs/heads/".length);
-    } else if (line === "detached") {
-      current.branch = null;
-    } else if (line.startsWith("prunable ")) {
-      current.prunable = true;
-    }
+function filedBy(t, i) {
+  const member = (t.filed_by_id ? i.roster.get(t.filed_by_id) : void 0) ?? memberByIdentity(i.roster, t.created_by_id);
+  if (member) {
+    if (member.id === i.me) return "you";
+    const label = crewLabel(member) ?? member.name;
+    const ship = t.ship_id && t.ship_id !== i.myShipId ? i.ships?.find((s) => s.id === t.ship_id)?.name : void 0;
+    return ship ? `${label} (${ship})` : label;
   }
-  if (current.path) list.push({ path: current.path, branch: current.branch ?? null, prunable: current.prunable ?? false });
-  return list;
+  return t.reporter_name ? `${t.reporter_name} (unverified)` : "\u2014";
 }
-function cloneUrlFor(remote) {
-  return `git@github.com:${remote}.git`;
+function lastComment(i, ticketId) {
+  const forTicket = i.comments.filter((c) => c.ticket_id === ticketId).sort((a, b) => a.created_at < b.created_at ? -1 : a.created_at > b.created_at ? 1 : 0);
+  const last = forTicket[forTicket.length - 1];
+  if (!last) return "\u2014";
+  return `${last.created_at.slice(0, 16)}Z ${author(last, i)}`;
 }
-function ensureRepoCheckout(dir, remote) {
-  if (existsSync6(`${dir}/.git`)) return false;
-  if (!remote) {
-    throw new GitError(
-      `${dir} does not exist and this repo has no discovered remote to clone from \u2014 re-run \`crew connect\`, or check out the repository yourself and point \`repos:\` at it`
-    );
-  }
-  mkdirSync4(dirname4(dir), { recursive: true });
-  try {
-    execFileSync("git", ["clone", cloneUrlFor(remote), dir], { stdio: ["ignore", "pipe", "pipe"] });
-  } catch (e) {
-    const err = e;
-    const why = [err.stderr, err.stdout].map((x) => (x ?? "").trim()).filter(Boolean).join(" / ");
-    throw new GitError(`git clone ${cloneUrlFor(remote)} ${dir}: ${why || err.message.trim()}`);
-  }
-  return true;
+function newFromOthers(i, ticketId) {
+  return i.comments.filter(
+    (c) => c.ticket_id === ticketId && c.team_member_id !== i.me && c.created_at > i.watermark && (c.kind ?? "comment") !== "event"
+  ).length;
 }
-var CHECKOUT_LOCK_STALE_MS = 5 * 60 * 1e3;
-function checkoutLockPath(dir) {
-  return `${dir}.sync.lock`;
+function who(t, i) {
+  return whoAssigned(t, i) + heldBySuffix(t, i);
 }
-function sleepSync(ms) {
-  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+function heldBySuffix(t, i) {
+  if (!t.held_by_ship_id || t.held_by_ship_id === i.myShipId) return "";
+  const name = i.ships?.find((s) => s.id === t.held_by_ship_id)?.name?.trim();
+  return ` (held by ${name || "an unknown ship"})`;
 }
-function acquireCheckoutLock(dir, timeoutMs = 3e4) {
-  const lockPath = checkoutLockPath(dir);
-  mkdirSync4(dirname4(lockPath), { recursive: true });
-  const deadline = Date.now() + timeoutMs;
-  for (; ; ) {
-    try {
-      const fd = openSync(lockPath, "wx");
-      writeSync(fd, `${process.pid}
-`);
-      closeSync(fd);
-      return () => {
-        try {
-          unlinkSync2(lockPath);
-        } catch {
-        }
-      };
-    } catch (e) {
-      const err = e;
-      if (err.code !== "EEXIST") throw err;
-      try {
-        if (Date.now() - statSync3(lockPath).mtimeMs > CHECKOUT_LOCK_STALE_MS) {
-          try {
-            unlinkSync2(lockPath);
-          } catch {
-          }
-          continue;
-        }
-      } catch {
-      }
-      if (Date.now() > deadline) {
-        throw new GitError(`timed out waiting for the sync lock on ${dir} (held by another sync)`);
-      }
-      sleepSync(50);
-    }
-  }
+function whoAssigned(t, i) {
+  if (!t.assignee_id) return "unassigned";
+  if (t.assignee_id === i.me) return "you";
+  const label = crewLabel(i.roster.get(t.assignee_id));
+  if (label === null) return "someone off this ship";
+  return isHold(i.roster, t.assignee_id) ? `**${label} \u2014 HOLD**` : label;
 }
-function syncPassengerCheckout(dir, githubRemote, gitRemoteName, base) {
-  const release = acquireCheckoutLock(dir);
-  try {
-    if (ensureRepoCheckout(dir, githubRemote)) {
-      if (currentBranch(dir) !== base) git(dir, ["checkout", base]);
-      return { action: "cloned", detail: `cloned ${githubRemote} into ${dir}` };
-    }
-    return refreshBaseBranch(dir, gitRemoteName, base);
-  } finally {
-    release();
-  }
+function blockers(t, i) {
+  const list = (t.blocked_by ?? []).map((id) => {
+    const info = i.blockerInfo[id];
+    return `${info ? displayKey2(info) : "?"} (${info?.status ?? "unknown"})`;
+  });
+  return list.length === 0 ? "\u2014" : list.join(", ");
+}
+var sorted = (ts) => [...ts].sort(compareRank);
+var stream = (segments) => `${segments.join("\n")}
+`;
+function table(ts, i, header, row) {
+  if (ts.length === 0) return "\n_None._\n";
+  return `
+${header}
+${sorted(ts).map(row).join("\n")}
+`;
+}
+function buildingDigest(i) {
+  const header = "| ticket | repo | branch | worktree | status | assignee | filed by | sev | pri | eff | updated | last comment | new since last poll |\n|---|---|---|---|---|---|---|---|---|---|---|---|---|";
+  const row = (t) => {
+    const n = newFromOthers(i, t.id);
+    const branch = i.branchFor ? i.branchFor(t) : "";
+    const worktree = i.worktreeFor ? i.worktreeFor(t) : "";
+    const dir = i.dirFor ? i.dirFor(t) : null;
+    const repo = i.dirFor ? dir ?? "**NO CHECKOUT**" : "";
+    return `| ${displayKey2(t)} | ${repo} | ${branch} | ${worktree} | ${t.status} | ${who(t, i)} | ${filedBy(t, i)} | ${t.severity ?? "\u2014"} | ${t.priority ?? "\u2014"} | p${effectivePriority(t)} | ${t.updated_at.slice(0, 16)}Z | ${lastComment(i, t.id)} | ${n > 0 ? `**${n} new**` : "\u2014"} |`;
+  };
+  const blockedRow = (t) => `| ${displayKey2(t)} | ${t.status} | ${who(t, i)} | p${effectivePriority(t)} | ${blockers(t, i)} |`;
+  const blockedTable = (ts) => ts.length === 0 ? "\n_None._\n" : `
+| ticket | status | assignee | eff | blocked by |
+|---|---|---|---|---|
+${sorted(ts).map(blockedRow).join("\n")}
+`;
+  const isBlocked = (t) => i.blocked.has(t.id);
+  const step1 = i.tickets.filter(
+    (t) => t.status === "in_progress" && (t.assignee_id === i.me || !t.assignee_id) || t.status === "needs_info"
+  );
+  const step2 = i.tickets.filter(
+    (t) => (t.status === "accepted" || t.status === "blocked") && !isBlocked(t)
+  );
+  return stream([
+    "## Current queue \u2014 built for you by the poll\n",
+    "\nAlready filtered to your lane, and already ordered by the Step 2 rule.\nTicket bodies are deliberately omitted: fetch the full record of only the\nticket you actually pick up. **Do not re-fetch the whole tracker.** This\ndigest comes from the same API call the poll just made, moments ago.\n",
+    '\n"new since last poll" counts comments from someone other than you since\nthe poll watermark \u2014 the same signal that woke this run.\n',
+    "\n**`repo` is the checkout a ticket's work happens in** \u2014 an area spans\nseveral repositories, so cut the worktree beside THAT directory, not beside\nwhichever one you started in. A ticket marked **NO CHECKOUT** is not yours:\nthis ship has no clone of its repository, and another ship may serve it.\n\n**Use the `branch` and `worktree` columns verbatim.** They are that\nrepository's own naming convention, rendered for THIS ticket \u2014 cut the\nworktree at `<repo>/../<worktree>`, on branch `<branch>`. Do not derive\neither yourself, and prefer these over the Environment section's own worked\nexample if the two ever disagree \u2014 that example is illustrative only,\nrendered before any ticket is picked.\n",
+    "\n### Step 1 \u2014 open tickets that may be yours to act on\n",
+    "\n`fixed` tickets are deliberately absent: they belong to the QA lane.\n",
+    table(step1, i, header, row),
+    "\n### Step 2 \u2014 accepted tickets, in pick order\n",
+    "\nWork the first one you are not required to skip. Tickets waiting on an\nunresolved dependency are already out of this table \u2014 see Blocked below.\n",
+    table(step2, i, header, row),
+    "\n### Blocked \u2014 waiting on a dependency, not yours to start\n",
+    '\nListed rather than hidden so "nothing to do" stays distinguishable from\n"everything is parked". The loop parks and restores these itself, on every\npoll: an approved ticket whose `Blocked by` entries are unresolved moves to\n`blocked`, and back to `accepted` once the last one resolves. **Do not pick\none up, do not set or clear `blocked` by hand, and do not "unblock" one by\nediting its `Blocked by` field** \u2014 if a blocker looks wrong, say so in your\nrun summary. A blocker counts as resolved at `verified`, `closed_deployed`,\n`closed_wont_fix` or `closed_duplicate`; `fixed` is still an unmerged branch\nawaiting QA, so it does not count.\n',
+    blockedTable(i.tickets.filter(isBlocked))
+  ]);
+}
+function qaDigest(i) {
+  const header = "| ticket | repo | status | built by | assignee | filed by | sev | pri | eff | branch | worktree | updated | last comment | new since last poll |\n|---|---|---|---|---|---|---|---|---|---|---|---|---|---|";
+  const branchCell = (t) => {
+    if (i.dirFor && i.dirFor(t) === null) return "\u2014";
+    if (!i.existingBranchFor) return "";
+    return i.existingBranchFor(t) ?? "**MISSING**";
+  };
+  const worktreeCell = (t) => {
+    if (i.dirFor && i.dirFor(t) === null) return "\u2014";
+    return i.worktreeFor ? i.worktreeFor(t) : "";
+  };
+  const builtBy = (t) => t.needs_design === true ? "design" : "dev";
+  const row = (t) => {
+    const n = newFromOthers(i, t.id);
+    const dir = i.dirFor ? i.dirFor(t) : null;
+    const repo = i.dirFor ? dir ?? "**NO CHECKOUT**" : "";
+    return `| ${displayKey2(t)} | ${repo} | ${t.status} | ${builtBy(t)} | ${who(t, i)} | ${filedBy(t, i)} | ${t.severity ?? "\u2014"} | ${t.priority ?? "\u2014"} | p${effectivePriority(t)} | ${branchCell(t)} | ${worktreeCell(t)} | ${t.updated_at.slice(0, 16)}Z | ${lastComment(i, t.id)} | ${n > 0 ? `**${n} new**` : "\u2014"} |`;
+  };
+  return stream([
+    "## Current queue \u2014 built for you by the poll\n",
+    '\nAlready filtered to your lane: every ticket at `qa` ("Verification" \u2014\nyours, unfinished) or `fixed` (nobody has checked it yet), from both\nbuilding lanes. Ticket bodies are deliberately omitted: fetch the full\nrecord and the comments of the one ticket you actually pick up. **Do not\nre-fetch the whole tracker.** This digest comes from the same API call the\npoll just made, moments ago.\n',
+    '\n"new since last poll" counts comments from someone other than you since\nthe poll watermark \u2014 the same signal that woke this run.\n',
+    "\n**`repo` is the checkout the ticket's work happens in** \u2014 an area spans\nseveral repositories, so the worktree you verify in sits beside THAT\ndirectory, not beside whichever one this session started in. A ticket\nmarked **NO CHECKOUT** is not yours: this ship has no clone of its\nrepository, and another ship may serve it.\n\n**`branch` is that repository's own branch for the ticket**, found there\nrather than derived. **`<name> (on origin only)`** means another ship built it\nand pushed it: it is testable \u2014 cut a worktree from the remote branch\n(`git worktree add <worktree> <name>`). **MISSING** means the branch is gone\nlocally AND on the remote, so there is nothing left to verify \u2014 say so on the ticket. A `\u2014` means the branch\ncould not be looked for at all, because the repo has no checkout here.\n\n**`worktree` is where that branch should be checked out**, `<repo>/../<worktree>`\n\u2014 rendered the same way the dev/design digest computes it, so you land in\nthe same directory the building lane used.\n",
+    "\n### Still in verification \u2014 yours, unfinished (take these first)\n",
+    table(i.tickets.filter((t) => t.status === "qa"), i, header, row),
+    "\n### Awaiting verification, in pick order\n",
+    table(i.tickets.filter((t) => t.status === "fixed"), i, header, row)
+  ]);
 }
 
 // src/ticket-branch.ts
@@ -6608,6 +6626,30 @@ async function mergeAndRelease(o, decision, fresh, releaseBranch) {
       }
     }
   }
+  if (remoteConfigured(o.cwd, o.repo.branch.remote)) {
+    if (o.dryRun) {
+      o.emit.emit(`would push ${o.repo.branch.base} to ${o.repo.branch.remote}`);
+    } else {
+      try {
+        pushBranch(o.cwd, o.repo.branch.remote, releaseBranch ?? o.repo.branch.base, o.repo.branch.base);
+        o.emit.emit(`pushed ${o.repo.branch.base} to ${o.repo.branch.remote}`);
+      } catch (e) {
+        o.emit.error(
+          `failed to push ${o.repo.branch.base} to ${o.repo.branch.remote} \u2014 ${e.message}; not deploying`
+        );
+        return {
+          merged,
+          conflicts,
+          unbuildable,
+          version,
+          deployed: false,
+          integrated: false,
+          decision,
+          stopped: "base branch push failed"
+        };
+      }
+    }
+  }
   let deployed = false;
   let integrated = false;
   if (o.repo.release.mode === "integrate") {
@@ -6622,7 +6664,9 @@ async function mergeAndRelease(o, decision, fresh, releaseBranch) {
         r = await hook(o, "deploy");
       }
       if (r && r.code !== 0) {
-        o.emit.error(`deploy FAILED (exit ${r.code}) \u2014 the target may be partially deployed`);
+        o.emit.error(
+          `deploy FAILED (exit ${r.code}) \u2014 the target may be partially deployed` + (remoteConfigured(o.cwd, o.repo.branch.remote) ? `; ${version ?? "this release"} is already merged to ${o.repo.branch.remote}/${o.repo.branch.base} but NOT live \u2014 run \`crew deploy\`, do not re-release` : "")
+        );
         o.state?.noteDeployFailed(headSha(o.cwd));
         return { merged, conflicts, unbuildable, version, deployed: false, stopped: "deploy failed", decision, hookFailure: hookFailure(o, "deploy", r.output) };
       }
@@ -6632,30 +6676,6 @@ async function mergeAndRelease(o, decision, fresh, releaseBranch) {
   } else if (o.repo.release.mode !== "local") {
     o.emit.emit(`release.mode is ${o.repo.release.mode} \u2014 CI takes it from here`);
   }
-  if (remoteConfigured(o.cwd, o.repo.branch.remote)) {
-    if (o.dryRun) {
-      o.emit.emit(`would push ${o.repo.branch.base} to ${o.repo.branch.remote}`);
-    } else {
-      try {
-        pushBranch(o.cwd, o.repo.branch.remote, releaseBranch ?? o.repo.branch.base, o.repo.branch.base);
-        o.emit.emit(`pushed ${o.repo.branch.base} to ${o.repo.branch.remote}`);
-      } catch (e) {
-        o.emit.error(
-          `failed to push ${o.repo.branch.base} to ${o.repo.branch.remote} \u2014 ${e.message}`
-        );
-        return {
-          merged,
-          conflicts,
-          unbuildable,
-          version,
-          deployed,
-          integrated,
-          decision,
-          stopped: "base branch push failed"
-        };
-      }
-    }
-  }
   let tag;
   if (!version && o.dryRun && o.repo.hooks.bump && o.repo.release.tag) {
     o.emit.emit(`would then tag using ${o.repo.release.tag}, with whatever version the hook printed`);
@@ -11889,6 +11909,9 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
       let baseUnsafe = 0;
       for (const r of await resolvedRepos(route)) {
         const base = refreshBaseBranch(r.dir, r.config.branch.remote, r.config.branch.base, dryRun);
+        const att = dryRun ? null : baseAttention(r.name, base, r.config.branch.remote, r.config.branch.base);
+        if (att && "raise" in att) await raiseShipAttention({ state, emit, route, ship: cfg.ship }, att.raise);
+        else if (att) clearShipAttention(state, att.clear);
         if (base.action !== "not-applicable") {
           baseChecked++;
           if (base.action === "fetch-failed") emit.warn(base.detail);