@tablation/crew 0.88.0 → 0.89.0

package/dist/cli.js

@@ -9803,7 +9803,7 @@ function doctorSelftestLines(stored, toolchains) {
 }
 
 // src/cli.ts
-import { resolve as resolve5, dirname as dirname20, join as join40, basename as basename12 } from "path";
+import { resolve as resolve5, dirname as dirname20, join as join41, basename as basename12 } from "path";
 import { fileURLToPath } from "url";
 import { hostname as hostname2, homedir as homedir10 } from "os";
 import { spawnSync as spawnSync7 } from "child_process";
@@ -9843,6 +9843,7 @@ var VALUE_FLAGS = /* @__PURE__ */ new Set([
   "write",
   "topic",
   "assignee",
+  "issue",
   "resume"
 ]);
 function positionalArgs(argv2) {
@@ -16532,24 +16533,55 @@ function planEventsSweep(stateDir, retentionDays, now = Date.now()) {
 }
 
 // src/cli.ts
-import { realpathSync as realpathSync3, readFileSync as readFileSync32, existsSync as existsSync36, mkdirSync as mkdirSync23, writeFileSync as writeFileSync24, rmSync as rmSync16, unlinkSync as unlinkSync5, copyFileSync as copyFileSync2, renameSync as renameSync3, statSync as statSync11, readdirSync as readdirSync17 } from "fs";
+import { realpathSync as realpathSync3, readFileSync as readFileSync33, existsSync as existsSync37, mkdirSync as mkdirSync24, writeFileSync as writeFileSync25, rmSync as rmSync17, unlinkSync as unlinkSync5, copyFileSync as copyFileSync2, renameSync as renameSync3, statSync as statSync11, readdirSync as readdirSync17 } from "fs";
 import { createInterface } from "readline/promises";
 
 // src/periscope-cmd.ts
+import { existsSync as existsSync32, mkdirSync as mkdirSync19, readFileSync as readFileSync28, rmSync as rmSync15, writeFileSync as writeFileSync21 } from "fs";
+import { join as join35 } from "path";
 var PeriscopeError = class extends Error {
 };
+var priorDir = (stateDir) => join35(stateDir, "periscope-priors");
+var priorPath = (stateDir, ticketRecordId) => join35(priorDir(stateDir), `${ticketRecordId}.json`);
+function removePeriscopePrior(stateDir, ticketRecordId) {
+  rmSync15(priorPath(stateDir, ticketRecordId), { force: true });
+}
+function writePeriscopePrior(stateDir, ticketRecordId, prior) {
+  try {
+    mkdirSync19(priorDir(stateDir), { recursive: true });
+    writeFileSync21(priorPath(stateDir, ticketRecordId), JSON.stringify(prior));
+  } catch {
+  }
+}
+function readPeriscopePrior(stateDir, ticketRecordId) {
+  try {
+    const p = priorPath(stateDir, ticketRecordId);
+    return existsSync32(p) ? JSON.parse(readFileSync28(p, "utf8")) : void 0;
+  } catch {
+    return void 0;
+  }
+}
 var DEFAULT_MAX_PERISCOPES2 = 3;
 var DEFAULT_PERISCOPE_IDLE_MINUTES2 = 120;
 function parsePeriscopeUpArgs(positional2, flags) {
+  const usage2 = "usage: crew periscope up [route] REPO [--topic TEXT | --issue NNN] [--isolate] [--host HOST] [--assignee CREW_ROW_ID] [--json]";
   const rest = positional2.slice(2);
-  if (rest.length === 0 || rest.length > 2) {
-    throw new PeriscopeError("usage: crew periscope up [route] REPO [--topic TEXT] [--isolate] [--host HOST] [--assignee CREW_ROW_ID] [--json]");
-  }
+  if (rest.length === 0 || rest.length > 2) throw new PeriscopeError(usage2);
   const topic = flags.topic?.trim();
+  let issue;
+  if (flags.issue !== void 0) {
+    if (topic) throw new PeriscopeError(`--issue and --topic cannot be combined: --issue periscopes a ticket that already exists
+${usage2}`);
+    const m = /^(?:[A-Za-z]+-)?(\d+)$/.exec(flags.issue.trim());
+    if (!m) throw new PeriscopeError(`"${flags.issue}" is not a ticket number
+${usage2}`);
+    issue = String(Number.parseInt(m[1], 10));
+  }
   return {
     ...rest.length === 2 ? { route: rest[0] } : {},
     repo: rest[rest.length - 1],
     ...topic ? { topic } : {},
+    ...issue ? { issue } : {},
     isolate: flags.isolate,
     ...flags.host ? { host: flags.host } : {},
     ...flags.assignee ? { assignee: flags.assignee } : {},
@@ -16574,6 +16606,17 @@ function periscopeCaps(l) {
     idleMinutes: l.periscopeIdleMinutes ?? DEFAULT_PERISCOPE_IDLE_MINUTES2
   };
 }
+async function existingRefusal(e, t) {
+  if (t.closed) return `${t.tag} is ${t.status}; a closed ticket cannot be periscoped`;
+  if (e.repoId && t.repoId !== e.repoId) return `${t.tag} belongs to a different repository than ${e.repoName}`;
+  if (t.assignee && t.assignee !== e.pairId) {
+    const agent = await e.agentHolder(t.assignee);
+    if (agent) return `${t.tag} is held by ${agent}`;
+  }
+  if (t.heldByShipId && e.shipId && t.heldByShipId !== e.shipId) return `${t.tag} is held by another ship (${t.heldByShipId})`;
+  if (e.hasLiveRun(t.id)) return `${t.tag} has a run in flight on this ship`;
+  return void 0;
+}
 var tail = (s, n = 20) => s.trimEnd().split("\n").slice(-n).join("\n");
 function progressComment(url, handoff) {
   return [
@@ -16595,17 +16638,36 @@ async function periscopePreflight(d, repo) {
 }
 async function runPeriscopeUp(d, args) {
   await periscopePreflight(d, args.repo);
-  const topic = args.topic ?? (await d.askTopic())?.trim();
-  if (!topic) throw new PeriscopeError("a topic is required: pass --topic TEXT");
-  const unsafe = d.baseProblem();
-  if (unsafe) throw new PeriscopeError(`DO NOT CUT A WORKTREE FROM THIS BASE \u2014 ${unsafe}`);
-  const draft = await d.fileDraft(`Periscope: ${topic}`);
-  d.say("filed", `filed draft ${draft.tag}`, { ticket: draft.tag, ticketRecordId: draft.id });
+  const ex = d.existing;
+  let draft;
+  let prior;
+  if (args.issue) {
+    if (!ex) throw new PeriscopeError("--issue is not supported here");
+    prior = await ex.load(args.issue);
+    if (!prior) throw new PeriscopeError(`no ticket numbered ${args.issue} on this route`);
+    const refused = await existingRefusal(ex, prior);
+    if (refused) throw new PeriscopeError(refused);
+    const unsafe = d.baseProblem();
+    if (unsafe) throw new PeriscopeError(`DO NOT CUT A WORKTREE FROM THIS BASE \u2014 ${unsafe}`);
+    await ex.hold(prior.id);
+    ex.remember(prior.id, { assignee: prior.assignee, status: prior.status });
+    draft = prior;
+    d.say("held", `holding ${prior.tag} (status ${prior.status} stays)`, { ticket: prior.tag, ticketRecordId: prior.id });
+  } else {
+    const topic = args.topic ?? (await d.askTopic())?.trim();
+    if (!topic) throw new PeriscopeError("a topic is required: pass --topic TEXT");
+    const unsafe = d.baseProblem();
+    if (unsafe) throw new PeriscopeError(`DO NOT CUT A WORKTREE FROM THIS BASE \u2014 ${unsafe}`);
+    draft = await d.fileDraft(`Periscope: ${topic}`);
+    d.say("filed", `filed draft ${draft.tag}`, { ticket: draft.tag, ticketRecordId: draft.id });
+  }
   let wt;
   const abandon = async (why) => {
     if (wt) await d.teardown(wt.path, wt.branch).catch(() => {
     });
-    await d.closeDraft(draft.id, `Periscope abandoned: ${why.split("\n")[0]}`).catch(() => {
+    if (prior) await d.existing.restore(prior.id, prior.assignee).catch(() => {
+    });
+    else await d.closeDraft(draft.id, `Periscope abandoned: ${why.split("\n")[0]}`).catch(() => {
     });
     throw new PeriscopeError(why);
   };
@@ -16682,7 +16744,15 @@ ${tail(preview.output)}`);
   await d.comment(draft.id, progressComment(url, handoff?.output)).catch((e) => {
     d.say("warning", `progress comment not posted: ${e.message}`);
   });
-  return { ticket: draft.tag, ticketRecordId: draft.id, worktree: wt.path, branch: wt.branch, url, periscopeRecordId: row.id };
+  return {
+    ticket: draft.tag,
+    ticketRecordId: draft.id,
+    worktree: wt.path,
+    branch: wt.branch,
+    url,
+    periscopeRecordId: row.id,
+    ...prior ? { existing: true, priorStatus: prior.status } : {}
+  };
 }
 function parsePeriscopeDownArgs(positional2, flags) {
   const usage2 = "usage: crew periscope down [route] NNN --keep|--discard [--allow-empty] [--json]";
@@ -16731,6 +16801,21 @@ async function runPeriscopeDown(d, args) {
     d.say("unchanged", `${done.ticket} is already ${done.state}; nothing to do`);
     return { ticket: done.ticket, mode: args.mode, outcome: "unchanged", state: done.state };
   }
+  const existing = (await d.readTicket(row.ticketRecordId)).isDraft === false;
+  const prior = existing ? d.priorHold?.(row.ticketRecordId) : void 0;
+  if (existing && args.mode === "discard") {
+    const killed2 = await d.stopServer(row.worktree, row.number);
+    d.say("server", killed2 ? `stopped ${killed2} process(es)` : "no server was listening");
+    const onRemote = d.remoteHasBranch?.(row.worktree, row.branch) ?? true;
+    d.removeWorktree(row.worktree, row.branch, !onRemote);
+    d.say("worktree", onRemote ? `removed ${row.worktree}; ${row.branch} stays, it is on the remote` : `removed ${row.worktree} and branch ${row.branch}`);
+    await d.updateTicket(row.ticketRecordId, { status: "released", fillProjectAndRepo: false });
+    d.say("ticket", `${row.ticket} hold cleared; status unchanged${prior ? ` (assignee before the periscope: ${prior.assignee ?? "none"})` : ""}`);
+    await d.setRowState(row.id, "discarded");
+    d.say("row", "row is discarded");
+    forgetLocal(d, row.ticketRecordId);
+    return { ticket: row.ticket, mode: "discard", outcome: "done", state: "discarded", existing: true, ...prior ? { status: prior.status } : {} };
+  }
   if (args.mode === "discard") {
     const killed2 = await d.stopServer(row.worktree, row.number);
     d.say("server", killed2 ? `stopped ${killed2} process(es)` : "no server was listening");
@@ -16762,12 +16847,17 @@ async function runPeriscopeDown(d, args) {
   const description = t.description.includes(PROTOTYPE_HEADING) ? t.description : `${t.description.trimEnd()}
 
 ${section}`;
-  await d.updateTicket(row.ticketRecordId, {
-    description,
-    fillProjectAndRepo: !t.hasProject || !t.hasRepo,
-    status: "new"
-  });
-  d.say("ticket", `${row.ticket} is new and unassigned with a Prototype section`);
+  if (existing) {
+    await d.updateTicket(row.ticketRecordId, { description, fillProjectAndRepo: false, status: "released" });
+    d.say("ticket", `${row.ticket} has a Prototype section and no assignee; status unchanged${prior ? ` (assignee before the periscope: ${prior.assignee ?? "none"})` : ""}`);
+  } else {
+    await d.updateTicket(row.ticketRecordId, {
+      description,
+      fillProjectAndRepo: !t.hasProject || !t.hasRepo,
+      status: "new"
+    });
+    d.say("ticket", `${row.ticket} is new and unassigned with a Prototype section`);
+  }
   await d.postPushed(row.ticketRecordId, pushed.sha, pushed.remote, row.branch);
   const killed = await d.stopServer(row.worktree, row.number);
   d.say("server", killed ? `stopped ${killed} process(es)` : "no server was listening");
@@ -16776,7 +16866,7 @@ ${section}`;
   await d.setRowState(row.id, "kept");
   d.say("row", "row is kept");
   forgetLocal(d, row.ticketRecordId);
-  return { ticket: row.ticket, mode: "keep", outcome: "done", state: "kept", sha: pushed.sha };
+  return { ticket: row.ticket, mode: "keep", outcome: "done", state: "kept", sha: pushed.sha, ...existing ? { existing: true, ...prior ? { status: prior.status } : {} } : {} };
 }
 function periscopeListEntries(rows, now, isListening) {
   return rows.filter((r) => r.state === "live").map((r) => {
@@ -16838,7 +16928,7 @@ ${tail2(preview.output)}`);
 // src/periscope-idle.ts
 import { execFileSync as execFileSync6 } from "child_process";
 import { statSync as statSync9 } from "fs";
-import { join as join35 } from "path";
+import { join as join36 } from "path";
 var MAX_SCANNED_FILES = 2e4;
 function newestWorktreeMtime(root) {
   let listing;
@@ -16858,7 +16948,7 @@ function newestWorktreeMtime(root) {
     if (!rel) continue;
     if (++scanned > MAX_SCANNED_FILES) break;
     try {
-      const m = statSync9(join35(root, rel)).mtimeMs;
+      const m = statSync9(join36(root, rel)).mtimeMs;
       if (newest === null || m > newest) newest = m;
     } catch {
     }
@@ -16934,18 +17024,18 @@ import { dirname as dirOf2, resolve as resolvePath } from "path";
 
 // src/ssh-keys.ts
 import { execFileSync as execFileSync7 } from "child_process";
-import { existsSync as existsSync32, mkdirSync as mkdirSync19, readFileSync as readFileSync28, chmodSync } from "fs";
-import { dirname as dirname19, join as join36 } from "path";
+import { existsSync as existsSync33, mkdirSync as mkdirSync20, readFileSync as readFileSync29, chmodSync } from "fs";
+import { dirname as dirname19, join as join37 } from "path";
 var SshKeyError = class extends Error {
 };
 function shipSshKeyPathFor(stateDir) {
-  return join36(stateDir, "ssh", "id_ed25519");
+  return join37(stateDir, "ssh", "id_ed25519");
 }
 function ensureShipSshKeypair(stateDir) {
   const privateKeyPath = shipSshKeyPathFor(stateDir);
   const publicKeyPath = `${privateKeyPath}.pub`;
-  if (!existsSync32(privateKeyPath)) {
-    mkdirSync19(dirname19(privateKeyPath), { recursive: true });
+  if (!existsSync33(privateKeyPath)) {
+    mkdirSync20(dirname19(privateKeyPath), { recursive: true });
     try {
       execFileSync7("ssh-keygen", [
         "-t",
@@ -16965,10 +17055,10 @@ function ensureShipSshKeypair(stateDir) {
     }
     chmodSync(privateKeyPath, 384);
   }
-  if (!existsSync32(publicKeyPath)) {
+  if (!existsSync33(publicKeyPath)) {
     throw new SshKeyError(`${privateKeyPath} exists but ${publicKeyPath} does not \u2014 regenerate or restore it`);
   }
-  const publicKey = readFileSync28(publicKeyPath, "utf8").trim();
+  const publicKey = readFileSync29(publicKeyPath, "utf8").trim();
   return { privateKeyPath, publicKeyPath, publicKey };
 }
 function sshKeygenAvailable() {
@@ -17185,9 +17275,9 @@ function syncAllPassengerCheckouts(cfg) {
 
 // src/tunnel.ts
 import { spawn as spawn5 } from "child_process";
-import { existsSync as existsSync33, mkdirSync as mkdirSync20, readFileSync as readFileSync29, writeFileSync as writeFileSync21, unlinkSync as unlinkSync3, readdirSync as readdirSync14 } from "fs";
+import { existsSync as existsSync34, mkdirSync as mkdirSync21, readFileSync as readFileSync30, writeFileSync as writeFileSync22, unlinkSync as unlinkSync3, readdirSync as readdirSync14 } from "fs";
 import { randomInt } from "crypto";
-import { join as join37 } from "path";
+import { join as join38 } from "path";
 var DEFAULT_SPAWN_OPTIONS = { stdio: "ignore", detached: true };
 var defaultSpawn = (cmd, args) => spawn5(cmd, args, DEFAULT_SPAWN_OPTIONS);
 var SLUG_ALPHABET = "abcdefghijklmnopqrstuvwxyz0123456789";
@@ -17254,21 +17344,21 @@ function startTunnel(opts) {
   };
 }
 function tunnelStatePath(stateDir, workspaceId) {
-  return join37(stateDir, "passengers", `${workspaceId}.json`);
+  return join38(stateDir, "passengers", `${workspaceId}.json`);
 }
 function readPersistedTunnel(stateDir, workspaceId) {
   const path = tunnelStatePath(stateDir, workspaceId);
-  if (!existsSync33(path)) return void 0;
+  if (!existsSync34(path)) return void 0;
   try {
-    return JSON.parse(readFileSync29(path, "utf8"));
+    return JSON.parse(readFileSync30(path, "utf8"));
   } catch {
     return void 0;
   }
 }
 function writePersistedTunnel(stateDir, state) {
   const path = tunnelStatePath(stateDir, state.workspaceId);
-  mkdirSync20(join37(stateDir, "passengers"), { recursive: true });
-  writeFileSync21(path, `${JSON.stringify(state, null, 2)}
+  mkdirSync21(join38(stateDir, "passengers"), { recursive: true });
+  writeFileSync22(path, `${JSON.stringify(state, null, 2)}
 `);
 }
 function updatePersistedTunnel(stateDir, workspaceId, patch2) {
@@ -17365,8 +17455,8 @@ function syncPassengerTunnels(plans, relayHost, relayPort, privateKeyPath, state
   }
 }
 function readAllPersistedWorkspaceIds(stateDir) {
-  const dir = join37(stateDir, "passengers");
-  if (!existsSync33(dir)) return [];
+  const dir = join38(stateDir, "passengers");
+  if (!existsSync34(dir)) return [];
   return readdirSync14(dir).filter((f) => f.endsWith(".json") && !f.endsWith("-sync.json")).map((f) => f.slice(0, -".json".length));
 }
 
@@ -17487,8 +17577,8 @@ async function unregisterEndpoint(workspaceId, info, d) {
 import { createServer as createHttpServer } from "http";
 import { spawn as spawn6 } from "child_process";
 import { randomBytes } from "crypto";
-import { existsSync as existsSync34, mkdirSync as mkdirSync21, readFileSync as readFileSync30, writeFileSync as writeFileSync22, unlinkSync as unlinkSync4, readdirSync as readdirSync15 } from "fs";
-import { join as join38 } from "path";
+import { existsSync as existsSync35, mkdirSync as mkdirSync22, readFileSync as readFileSync31, writeFileSync as writeFileSync23, unlinkSync as unlinkSync4, readdirSync as readdirSync15 } from "fs";
+import { join as join39 } from "path";
 
 // src/secret-compare.ts
 import { timingSafeEqual } from "crypto";
@@ -17577,21 +17667,21 @@ var defaultSpawn2 = (cmd, args, env) => {
   return child;
 };
 function syncDaemonStatePath(stateDir, workspaceId) {
-  return join38(stateDir, "passengers", `${workspaceId}-sync.json`);
+  return join39(stateDir, "passengers", `${workspaceId}-sync.json`);
 }
 function readPersistedSyncDaemon(stateDir, workspaceId) {
   const path = syncDaemonStatePath(stateDir, workspaceId);
-  if (!existsSync34(path)) return void 0;
+  if (!existsSync35(path)) return void 0;
   try {
-    return JSON.parse(readFileSync30(path, "utf8"));
+    return JSON.parse(readFileSync31(path, "utf8"));
   } catch {
     return void 0;
   }
 }
 function writePersistedSyncDaemon(stateDir, state) {
   const path = syncDaemonStatePath(stateDir, state.workspaceId);
-  mkdirSync21(join38(stateDir, "passengers"), { recursive: true });
-  writeFileSync22(path, `${JSON.stringify(state, null, 2)}
+  mkdirSync22(join39(stateDir, "passengers"), { recursive: true });
+  writeFileSync23(path, `${JSON.stringify(state, null, 2)}
 `);
 }
 function removePersistedSyncDaemon(stateDir, workspaceId) {
@@ -17611,8 +17701,8 @@ function waitForExit(pid, alive, timeoutMs = 5e3) {
   }
 }
 function readAllPersistedSyncWorkspaceIds(stateDir) {
-  const dir = join38(stateDir, "passengers");
-  if (!existsSync34(dir)) return [];
+  const dir = join39(stateDir, "passengers");
+  if (!existsSync35(dir)) return [];
   const suffix = "-sync.json";
   return readdirSync15(dir).filter((f) => f.endsWith(suffix)).map((f) => f.slice(0, -suffix.length));
 }
@@ -17700,8 +17790,8 @@ function describeCause(err) {
 }
 
 // src/daemon.ts
-import { existsSync as existsSync35, mkdirSync as mkdirSync22, readFileSync as readFileSync31, readdirSync as readdirSync16, rmSync as rmSync15, statSync as statSync10, writeFileSync as writeFileSync23 } from "fs";
-import { join as join39 } from "path";
+import { existsSync as existsSync36, mkdirSync as mkdirSync23, readFileSync as readFileSync32, readdirSync as readdirSync16, rmSync as rmSync16, statSync as statSync10, writeFileSync as writeFileSync24 } from "fs";
+import { join as join40 } from "path";
 import { randomBytes as randomBytes2 } from "crypto";
 var DEFAULT_FLOOR_MS = 5e3;
 var DEFAULT_CEILING_MS = INTERVAL_SECONDS * 1e3;
@@ -17772,7 +17862,7 @@ function latestMtime(path) {
   if (!stat.isDirectory()) return 0;
   let latest = stat.mtimeMs;
   for (const entry of readdirSync16(path, { withFileTypes: true })) {
-    latest = Math.max(latest, latestMtime(join39(path, entry.name)));
+    latest = Math.max(latest, latestMtime(join40(path, entry.name)));
   }
   return latest;
 }
@@ -17781,23 +17871,23 @@ function computeTreeSignature(paths) {
 }
 function makeStaleChecker(paths, opts = {}) {
   const initial = computeTreeSignature(paths);
-  return () => computeTreeSignature(paths) !== initial || opts.reloadSentinel !== void 0 && existsSync35(opts.reloadSentinel);
+  return () => computeTreeSignature(paths) !== initial || opts.reloadSentinel !== void 0 && existsSync36(opts.reloadSentinel);
 }
 function reloadSentinelFor(stateDir) {
-  return join39(stateDir, "reload-requested");
+  return join40(stateDir, "reload-requested");
 }
 function daemonStampFor(stateDir) {
-  return join39(stateDir, "daemon.started");
+  return join40(stateDir, "daemon.started");
 }
 function noteDaemonStarted(stateDir, now = Date.now()) {
-  mkdirSync22(stateDir, { recursive: true });
-  rmSync15(reloadSentinelFor(stateDir), { force: true });
-  writeFileSync23(daemonStampFor(stateDir), `${JSON.stringify({ pid: process.pid, startedAt: now })}
+  mkdirSync23(stateDir, { recursive: true });
+  rmSync16(reloadSentinelFor(stateDir), { force: true });
+  writeFileSync24(daemonStampFor(stateDir), `${JSON.stringify({ pid: process.pid, startedAt: now })}
 `);
 }
 function readDaemonStarted(stateDir) {
   try {
-    const v = JSON.parse(readFileSync31(daemonStampFor(stateDir), "utf8")).startedAt;
+    const v = JSON.parse(readFileSync32(daemonStampFor(stateDir), "utf8")).startedAt;
     return typeof v === "number" ? v : null;
   } catch {
     return null;
@@ -18419,7 +18509,7 @@ function usage(problem, requested = false) {
   crew reap [route]              kill orphaned servers, drop worktrees for closed tickets
   crew drop [route] NNN          remove a merged ticket's worktree and branch
   crew rotate-passenger-url [route]   force a Host Passengers tunnel to reconnect with a fresh public URL
-  crew periscope up [route] REPO --topic TEXT [--isolate] [--host H] [--assignee ID] [--dry-run] [--json]
+  crew periscope up [route] REPO --topic TEXT|--issue NNN [--isolate] [--host H] [--assignee ID] [--dry-run] [--json]
   crew periscope up --resume NNN restart the preview an idle periscope's server was stopped for
                                  file a draft ticket, cut and prepare its worktree, start the repo's preview hook and record a Periscopes row (alias: start)
   crew periscope down [route] NNN --keep|--discard [--allow-empty] [--json]
@@ -18699,7 +18789,7 @@ if (command === "passenger-sync-daemon") {
     } else {
       const toleratesNoRoutes = command === "repos" || command === "ship" || command === "disconnect" && flag("reset") || command === "connect" && flag("sign-out");
       const configless = command === "connect" && flag("sign-out") || command === "disconnect" && flag("reset");
-      if (configless && !existsSync36(findConfigFile(CREW_HOME))) {
+      if (configless && !existsSync37(findConfigFile(CREW_HOME))) {
         cfg = loadConfig(CREW_HOME, firstRunConfigPath(), { text: "ship: {}\n", allowNoRoutes: true });
       } else {
         cfg = loadConfig(CREW_HOME, void 0, toleratesNoRoutes ? { allowNoRoutes: true } : {});
@@ -18937,8 +19027,8 @@ if (command === "passenger-sync-daemon") {
     }
     if (host === "linux" && hasSystemd) {
       const label = labelFor(CREW_HOME, "run");
-      const staleTimer = join40(homedir10(), ".config", "systemd", "user", `${label}.timer`);
-      if (existsSync36(staleTimer)) {
+      const staleTimer = join41(homedir10(), ".config", "systemd", "user", `${label}.timer`);
+      if (existsSync37(staleTimer)) {
         process.stdout.write(
           `removing stale run timer from before the persistent-service cutover: ${staleTimer}${dryRun ? " (dry run)" : ""}
 `
@@ -18965,7 +19055,7 @@ if (command === "passenger-sync-daemon") {
     const tracker = new Tracker(c, cfg.ship);
     problems.push(...validateContract(tracker.contract).map((p) => `contract: ${p}`));
     for (const r of await resolvedRepos(c)) {
-      if (!existsSync36(r.dir)) problems.push(`repo ${r.name}: ${r.dir} is missing on disk`);
+      if (!existsSync37(r.dir)) problems.push(`repo ${r.name}: ${r.dir} is missing on disk`);
       if (!satisfies(host, r.config.platform)) problems.push(`repo ${r.name}: requires ${r.config.platform}, this host is ${host}`);
       readiness.push(...validateEffective(r.config).map((p) => `repo ${r.name}: ${p}`));
     }
@@ -18983,7 +19073,7 @@ if (command === "passenger-sync-daemon") {
   }
   async function doctorFix(o) {
     const routes = await Promise.all(routesInScope(cfg.routes, named).map((c) => gatherHealth({ route: c.route, enabled: c.enabled, hasRepos: reposOf(c).length > 0 }, () => routeProblems(c))));
-    const unitExists = (p) => existsSync36(p);
+    const unitExists = (p) => existsSync37(p);
     const crontab = o.host === "linux" ? spawnSync7("crontab", ["-l"], { encoding: "utf8" }).stdout ?? "" : "";
     const schedulerAbsent = o.host !== "windows" ? !schedulerInstalled(planInstall(cfg.ship, CREW_HOME, o.host, detectSystemd(), "run"), unitExists, crontab) : true;
     const plan = planFix({ routes, schedulerAbsent, host: o.host });
@@ -19000,7 +19090,7 @@ if (command === "passenger-sync-daemon") {
       for (const a of plan.actions) {
         if (a.kind === "enable") {
           if (prompter && !await prompter.confirm(`Route ${a.route} passes every check \u2014 set enabled: true in ${cfg.configFile}?`, false)) continue;
-          writeFileSync24(cfg.configFile, planEnable(readFileSync32(cfg.configFile, "utf8"), a.route));
+          writeFileSync25(cfg.configFile, planEnable(readFileSync33(cfg.configFile, "utf8"), a.route));
           enabledSound.add(a.route);
           changed2.push(`enabled route ${a.route} in ${cfg.configFile}`);
         } else {
@@ -20104,7 +20194,7 @@ ${cu.tail.trimEnd()}
         process.exit(1);
       }
       requireArmed("run the daemon loop");
-      const watchPaths = isCompiledBinary(import.meta.url) ? [process.execPath] : [join40(CREW_HOME, "src"), join40(CREW_HOME, "dist"), join40(CREW_HOME, "bin")];
+      const watchPaths = isCompiledBinary(import.meta.url) ? [process.execPath] : [join41(CREW_HOME, "src"), join41(CREW_HOME, "dist"), join41(CREW_HOME, "bin")];
       const configPaths = daemonConfigPaths(cfg);
       watchPaths.push(...configPaths);
       noteDaemonStarted(cfg.ship.stateDir);
@@ -20333,10 +20423,10 @@ ${cu.tail.trimEnd()}
 `);
       if (!dryRun) {
         const resolvedPath = resolvedPathFor(cfg.ship.stateDir, target.route);
-        const raw = existsSync36(resolvedPath) ? JSON.parse(readFileSync32(resolvedPath, "utf8")) : {};
+        const raw = existsSync37(resolvedPath) ? JSON.parse(readFileSync33(resolvedPath, "utf8")) : {};
         raw.agentSkills = result.agentSkills;
-        mkdirSync23(dirOf2(resolvedPath), { recursive: true });
-        writeFileSync24(resolvedPath, `${JSON.stringify(raw, null, 2)}
+        mkdirSync24(dirOf2(resolvedPath), { recursive: true });
+        writeFileSync25(resolvedPath, `${JSON.stringify(raw, null, 2)}
 `);
       }
       if (result.outcomes.some((o) => o.action === "diverged")) process.exitCode = 1;
@@ -20359,7 +20449,7 @@ ${cu.tail.trimEnd()}
         throw e;
       }
       const oldName = cfg.ship.name;
-      writeFileSync24(cfg.configFile, setShipNameInYaml(readFileSync32(cfg.configFile, "utf8"), newName));
+      writeFileSync25(cfg.configFile, setShipNameInYaml(readFileSync33(cfg.configFile, "utf8"), newName));
       cfg.ship.name = newName;
       let renameMachineId;
       try {
@@ -20406,7 +20496,7 @@ ${cu.tail.trimEnd()}
         process.exit(2);
       };
       if (sub !== "add" && sub !== "list" && sub !== "clone" && sub !== "hooks" && sub !== "check") usage2();
-      const configText = readFileSync32(cfg.configFile, "utf8");
+      const configText = readFileSync33(cfg.configFile, "utf8");
       if (sub === "check") {
         try {
           const routeArg = value("route") ?? positional[2];
@@ -20437,8 +20527,8 @@ ${cu.tail.trimEnd()}
         try {
           const a = parseHooksArgs(positional.slice(2), routeNamesOf(configText));
           const dir = repoDirOf(configText, dirname20(cfg.configFile), a.route, a.name);
-          if (!existsSync36(dir)) throw new ReposError(`${dir} does not exist on disk`);
-          const files = { exists: (r) => existsSync36(resolvePath(dir, r)), list: (r) => {
+          if (!existsSync37(dir)) throw new ReposError(`${dir} does not exist on disk`);
+          const files = { exists: (r) => existsSync37(resolvePath(dir, r)), list: (r) => {
             try {
               return readdirSync17(resolvePath(dir, r));
             } catch {
@@ -20446,7 +20536,7 @@ ${cu.tail.trimEnd()}
             }
           }, read: (r) => {
             try {
-              return readFileSync32(resolvePath(dir, r), "utf8");
+              return readFileSync33(resolvePath(dir, r), "utf8");
             } catch {
               return void 0;
             }
@@ -20488,19 +20578,19 @@ ${cu.tail.trimEnd()}
           let cleared;
           if (clear2) {
             const plan = clearRouteHooks(configText, a.route, a.name);
-            if (plan.removed.length > 0) writeFileSync24(cfg.configFile, plan.text);
+            if (plan.removed.length > 0) writeFileSync25(cfg.configFile, plan.text);
             cleared = { file: cfg.configFile, removed: plan.removed };
           }
           if (write && suggestion.source === null && recipeIds.length === 0 && hookSpecs.length === 0) throw new ReposError(`nothing to write: ${suggestion.notes[0]}`);
           if (write === "route") {
             const plan = planRouteHooks(configText, a.route, a.name, picked.hooks, { replace: flag("replace") });
-            writeFileSync24(cfg.configFile, plan.text);
+            writeFileSync25(cfg.configFile, plan.text);
             written = { target: "route", file: cfg.configFile, hooks: plan.written, kept: plan.kept, replaced: plan.replaced };
           } else if (write === "repo") {
             const have = existingRepoConfig(files);
             if (have) throw new ReposError(`${resolvePath(dir, have)} already exists; not overwriting it`);
             const file = resolvePath(dir, ".crew.yaml");
-            writeFileSync24(file, starterRepoConfig(picked.hooks, picked.release), { flag: "wx" });
+            writeFileSync25(file, starterRepoConfig(picked.hooks, picked.release), { flag: "wx" });
             written = { target: "repo", file, hooks: Object.keys(picked.hooks), kept: [], replaced: [] };
           }
           if (flag("json")) {
@@ -20556,7 +20646,7 @@ ${cu.tail.trimEnd()}
       if (sub === "list" && !routeName) usage2();
       if (sub === "add") {
         try {
-          const a = parseAddArgs(positional.slice(2), routeNamesOf(configText), (p) => existsSync36(resolvePath(p.replace(/^~(?=\/|$)/, homedir10()))));
+          const a = parseAddArgs(positional.slice(2), routeNamesOf(configText), (p) => existsSync37(resolvePath(p.replace(/^~(?=\/|$)/, homedir10()))));
           routeName = a.route;
           addPath = a.path;
           addName = a.name;
@@ -20585,16 +20675,16 @@ ${cu.tail.trimEnd()}
       }
       const resolvedFile = resolvedPathFor(cfg.ship.stateDir, routeName);
       let resolvedRemotes;
-      if (existsSync36(resolvedFile)) {
+      if (existsSync37(resolvedFile)) {
         try {
-          resolvedRemotes = JSON.parse(readFileSync32(resolvedFile, "utf8"));
+          resolvedRemotes = JSON.parse(readFileSync33(resolvedFile, "utf8"));
         } catch {
         }
       }
       const originOf = (dir) => gitOk(dir, ["remote", "get-url", "origin"]) ?? void 0;
       const text = configText;
       const base = dirname20(cfg.configFile);
-      const isCheckout = (d) => existsSync36(`${d}/.git`);
+      const isCheckout = (d) => existsSync37(`${d}/.git`);
       try {
         if (sub === "list") {
           if (flag("json")) {
@@ -20604,11 +20694,11 @@ ${cu.tail.trimEnd()}
               base,
               resolved: resolvedRemotes,
               originOf,
-              exists: (d) => existsSync36(d),
+              exists: (d) => existsSync37(d),
               isCheckout,
               repoHasHooks: (d) => REPO_CONFIG_FILENAMES.some((f) => {
                 try {
-                  return Object.keys(parseRepoConfig(readFileSync32(resolvePath(d, f), "utf8"), f).hooks).length > 0;
+                  return Object.keys(parseRepoConfig(readFileSync33(resolvePath(d, f), "utf8"), f).hooks).length > 0;
                 } catch {
                   return false;
                 }
@@ -20625,7 +20715,7 @@ ${cu.tail.trimEnd()}
           for (const r of repos) {
             const origin2 = originOf(r.dir);
             const row = matchRepoName(origin2, resolvedRemotes);
-            const note = !existsSync36(r.dir) ? "missing on disk" : row ? `Repos row: ${row}` : `no Repos row matches ${normalizeRemote(origin2) ?? "this checkout (no origin remote)"}`;
+            const note = !existsSync37(r.dir) ? "missing on disk" : row ? `Repos row: ${row}` : `no Repos row matches ${normalizeRemote(origin2) ?? "this checkout (no origin remote)"}`;
             process.stdout.write(`${r.name}	${r.dir}	${note}
 `);
           }
@@ -20637,9 +20727,9 @@ ${cu.tail.trimEnd()}
 ` : `${human}
 `);
           const plan2 = planRepoClone({ text, base, route: routeName, name: addName, resolved: resolvedRemotes, dir: value("dir"), isCheckout });
-          if (existsSync36(plan2.target) && (existsSync36(`${plan2.target}/.git`) || readdirSync17(plan2.target).length > 0)) {
+          if (existsSync37(plan2.target) && (existsSync37(`${plan2.target}/.git`) || readdirSync17(plan2.target).length > 0)) {
             throw new ReposError(
-              existsSync36(`${plan2.target}/.git`) ? `${plan2.target} is already a checkout \u2014 attach it with \`crew repos add ${routeName} ${plan2.name} ${plan2.target}\`` : `${plan2.target} exists and is not empty \u2014 pass --dir to clone somewhere else`
+              existsSync37(`${plan2.target}/.git`) ? `${plan2.target} is already a checkout \u2014 attach it with \`crew repos add ${routeName} ${plan2.name} ${plan2.target}\`` : `${plan2.target} exists and is not empty \u2014 pass --dir to clone somewhere else`
             );
           }
           if (dryRun) {
@@ -20657,14 +20747,14 @@ ${cu.tail.trimEnd()}
             throw new ReposError(`${e.message}${authHint}
   crew.yaml was not changed`);
           }
-          writeFileSync24(cfg.configFile, plan2.text);
+          writeFileSync25(cfg.configFile, plan2.text);
           if (plan2.droppedDir) process.stderr.write(`crew repos: dropped dir: ${plan2.droppedDir} from route ${routeName} \u2014 it is not a checkout (the clone base); checkouts now live under repos:
 `);
           say("attached", { route: routeName, name: plan2.name, dir: plan2.target, mode: plan2.mode }, `cloned and attached ${plan2.target} to ${routeName} as ${plan2.mode === "dir" ? "dir" : `repos.${plan2.name}`} in ${cfg.configFile}`);
           break;
         }
         const target = resolvePath(addPath.replace(/^~(?=\/|$)/, homedir10()));
-        const top = existsSync36(target) ? gitOk(target, ["rev-parse", "--show-toplevel"]) : null;
+        const top = existsSync37(target) ? gitOk(target, ["rev-parse", "--show-toplevel"]) : null;
         if (!top) throw new ReposError(`${target} is not a git checkout`);
         const origin = originOf(top);
         const plan = planRepoAdd({
@@ -20716,15 +20806,15 @@ ${cu.tail.trimEnd()}
           const created = await rowTracker.createRepoRow(rowPayload);
           process.stdout.write(`created Repos row ${String(rowPayload.name)} (${String(rowPayload.remote)}) ${created.id}
 `);
-          if (existsSync36(resolvedFile)) {
-            const raw = JSON.parse(readFileSync32(resolvedFile, "utf8"));
+          if (existsSync37(resolvedFile)) {
+            const raw = JSON.parse(readFileSync33(resolvedFile, "utf8"));
             raw.repoNames = { ...raw.repoNames, [created.id]: String(rowPayload.name) };
             raw.repoRemotes = { ...raw.repoRemotes, [created.id]: String(rowPayload.remote) };
-            writeFileSync24(resolvedFile, `${JSON.stringify(raw, null, 2)}
+            writeFileSync25(resolvedFile, `${JSON.stringify(raw, null, 2)}
 `);
           }
         }
-        writeFileSync24(cfg.configFile, plan.text);
+        writeFileSync25(cfg.configFile, plan.text);
         process.stdout.write(`added ${top} to ${routeName} as ${plan.mode === "dir" ? "dir" : `repos.${plan.name}`} in ${cfg.configFile}
 `);
       } catch (e) {
@@ -21091,7 +21181,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
           process.exit(2);
         }
         if (found.shipNameAdopted && !dryRun) {
-          writeFileSync24(cfg.configFile, setShipNameInYaml(readFileSync32(cfg.configFile, "utf8"), found.shipNameAdopted));
+          writeFileSync25(cfg.configFile, setShipNameInYaml(readFileSync33(cfg.configFile, "utf8"), found.shipNameAdopted));
           cfg.ship.name = found.shipNameAdopted;
         }
         if (found.shipRow) {
@@ -21134,10 +21224,10 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
           }
         }
         let previous;
-        const hadPreviousFile = existsSync36(resolvedPath);
+        const hadPreviousFile = existsSync37(resolvedPath);
         if (hadPreviousFile) {
           try {
-            previous = JSON.parse(readFileSync32(resolvedPath, "utf8"));
+            previous = JSON.parse(readFileSync33(resolvedPath, "utf8"));
           } catch {
           }
         }
@@ -21266,10 +21356,10 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
           process.stderr.write(`(dry run) would write resolved ids to ${resolvedPath}
 `);
         } else {
-          mkdirSync23(dirname20(resolvedPath), { recursive: true });
+          mkdirSync24(dirname20(resolvedPath), { recursive: true });
           if (hadPreviousFile) copyFileSync2(resolvedPath, `${resolvedPath}.bak`);
           const tmpPath = `${resolvedPath}.tmp${process.pid}`;
-          writeFileSync24(tmpPath, `${JSON.stringify(resolved, null, 2)}
+          writeFileSync25(tmpPath, `${JSON.stringify(resolved, null, 2)}
 `);
           renameSync3(tmpPath, resolvedPath);
           process.stderr.write(`Resolved ids written to ${resolvedPath}
@@ -21315,8 +21405,8 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
             process.stderr.write(`(dry run) would write the minted API key to ${apiKeyFile}
 `);
           } else {
-            mkdirSync23(dirname20(apiKeyFile), { recursive: true });
-            writeFileSync24(apiKeyFile, `${apiKeyVar}=${apiKey}
+            mkdirSync24(dirname20(apiKeyFile), { recursive: true });
+            writeFileSync25(apiKeyFile, `${apiKeyVar}=${apiKey}
 `, { mode: 384 });
             process.stderr.write(`API key written to ${apiKeyFile}
 `);
@@ -21866,7 +21956,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
     case "periscope": {
       const subP = positional[1];
       if (subP !== "up" && subP !== "start" && subP !== "down" && subP !== "end" && subP !== "list") {
-        process.stderr.write("crew periscope up [route] REPO --topic TEXT [--isolate] [--host H] [--assignee ID] [--dry-run] [--json]\n");
+        process.stderr.write("crew periscope up [route] REPO --topic TEXT|--issue NNN [--isolate] [--host H] [--assignee ID] [--dry-run] [--json]\n");
         process.stderr.write("crew periscope down [route] NNN --keep|--discard [--allow-empty] [--json]\n");
         process.stderr.write("crew periscope list [route] [--json]\n");
         process.exit(2);
@@ -21950,11 +22040,17 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
             },
             readTicket: async (id) => {
               const t = await trD.ticket(id);
-              return { description: String(t.description ?? ""), hasProject: !!t[cD.columns.slice], hasRepo: !!t[cD.columns.repo] };
+              return { description: String(t.description ?? ""), hasProject: !!t[cD.columns.slice], hasRepo: !!t[cD.columns.repo], isDraft: t.status === cD.statuses.draft };
             },
+            priorHold: (id) => readPeriscopePrior(cfg.ship.stateDir, id),
+            remoteHasBranch: (_wt, branch) => remoteBranchExists(repoD.dir, remote, branch),
             updateTicket: async (id, p) => {
               const patch2 = {};
-              if (p.status === "new") {
+              if (p.status === "released") {
+                patch2[cD.columns.assignee] = null;
+                if ((await trD.authorshipProbe()).issueHeld) patch2[cD.columns.heldBy] = null;
+                if (p.description !== void 0) patch2.description = p.description;
+              } else if (p.status === "new") {
                 patch2[cD.columns.status] = "new";
                 patch2[cD.columns.assignee] = null;
                 if (p.description !== void 0) patch2.description = p.description;
@@ -21979,7 +22075,10 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
               if (deleteBranch) gitOk(repoD.dir, ["branch", "-D", branch]);
             },
             setRowState: (id, state2) => trD.updatePeriscope(id, { state: state2 }),
-            forgetLocal: (id) => removePeriscopeSidecar(cfg.ship.stateDir, id),
+            forgetLocal: (id) => {
+              removePeriscopeSidecar(cfg.ship.stateDir, id);
+              removePeriscopePrior(cfg.ship.stateDir, id);
+            },
             say
           };
           if (dryRun) {
@@ -22024,7 +22123,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
           const shellR = hit && resolveShell(hit.repo.config.shell ?? cfg.ship.shell);
           const resumed = await runPeriscopeResume({
             find: async () => hit && { row: hit.row, tag: hit.tag },
-            worktreeExists: (p) => existsSync36(p),
+            worktreeExists: (p) => existsSync37(p),
             caps: periscopeCaps(cfg.ship),
             runHook: async (name, cwd, env) => {
               const script = hit?.repo.config.hooks[name];
@@ -22043,7 +22142,7 @@ ${resumed.url}
 `);
           break;
         }
-        const a = parsePeriscopeUpArgs(positional, { topic: value("topic"), host: value("host"), assignee: value("assignee"), isolate: flag("isolate"), json: jsonP });
+        const a = parsePeriscopeUpArgs(positional, { topic: value("topic"), issue: value("issue"), host: value("host"), assignee: value("assignee"), isolate: flag("isolate"), json: jsonP });
         const candidatesP = a.route ? [findRoute(cfg, a.route)] : cfg.routes.filter((r) => r.enabled);
         const servedP = [];
         for (const cand of candidatesP) {
@@ -22105,10 +22204,10 @@ ${resumed.url}
           },
           prepare: async (path) => {
             for (const f of repoP.config.worktrees.copy) {
-              const src = join40(repoP.dir, f);
-              if (!existsSync36(src)) continue;
-              mkdirSync23(dirOf2(join40(path, f)), { recursive: true });
-              copyFileSync2(src, join40(path, f));
+              const src = join41(repoP.dir, f);
+              if (!existsSync37(src)) continue;
+              mkdirSync24(dirOf2(join41(path, f)), { recursive: true });
+              copyFileSync2(src, join41(path, f));
             }
             const setup = repoP.config.hooks.setup;
             return setup ? runScript(setup, { cwd: path, shell: shellP, onLine: (l) => {
@@ -22132,12 +22231,58 @@ ${resumed.url}
             const closed = cP.statuses.resolved.includes("closed_obsolete") ? "closed_obsolete" : cP.statuses.wontFix;
             await trackerP.updateTicket(ticketId, { [cP.columns.status]: closed, [cP.columns.resolutionNote]: note });
           },
+          existing: {
+            load: async (number) => {
+              const t = (await trackerP.ticketsByNumbers([number])).find((x) => String(x[cP.columns.key]).replace(/^\D+/, "").replace(/^0+(?=\d)/, "") === number);
+              if (!t) return void 0;
+              return {
+                id: t.id,
+                tag: t.issue_tag ?? t.issue_id,
+                issueId: t.issue_id,
+                prefix: t.project_issue_prefix,
+                status: t.status,
+                closed: cP.statuses.resolved.includes(t.status) || t.status === cP.statuses.wontFix,
+                repoId: t[cP.columns.repo] ?? null,
+                assignee: t[cP.columns.assignee] ?? null,
+                heldByShipId: t[cP.columns.heldBy] ?? null
+              };
+            },
+            repoId: repoP.id ?? null,
+            repoName: a.repo,
+            pairId,
+            shipId: (await trackerP.authorshipProbe()).shipId,
+            agentHolder: async (assigneeId) => {
+              const row = crewP.find((r) => r.id === assigneeId);
+              return row?.agent_id ? row.name ?? assigneeId : void 0;
+            },
+            hasLiveRun: (ticketRecordId) => liveRuns(cfg.ship.stateDir).some((r) => r.ticketRecordId === ticketRecordId),
+            hold: async (id) => {
+              const auth = await trackerP.authorshipProbe();
+              await trackerP.updateTicket(id, {
+                [cP.columns.assignee]: pairId,
+                ...auth.issueHeld && auth.shipId ? { [cP.columns.heldBy]: auth.shipId } : {}
+              });
+            },
+            restore: async (id, assignee) => {
+              const auth = await trackerP.authorshipProbe();
+              await trackerP.updateTicket(id, { [cP.columns.assignee]: assignee, ...auth.issueHeld ? { [cP.columns.heldBy]: null } : {} });
+            },
+            remember: (id, prior) => writePeriscopePrior(cfg.ship.stateDir, id, prior)
+          },
           now: () => /* @__PURE__ */ new Date(),
           host: a.host ?? "localhost",
           say
         };
         if (dryRun) {
           await periscopePreflight(deps, a.repo);
+          if (a.issue) {
+            const t = await deps.existing.load(a.issue);
+            if (!t) throw new PeriscopeError(`no ticket numbered ${a.issue} on this route`);
+            const refused = await existingRefusal(deps.existing, t);
+            if (refused) throw new PeriscopeError(refused);
+            say("dry-run", `would hold ${t.tag} (status ${t.status} stays) for ${pairId}, cut or reuse its worktree for ${a.repo}, run setup${a.isolate ? ", isolate" : ""}, ports, handoff and preview on ${deps.host}, and record a Periscopes row`);
+            break;
+          }
           say("dry-run", `would file "Periscope: ${a.topic ?? "<topic>"}" as ${cP.statuses.draft} for ${pairId}, cut a worktree for ${a.repo}, run setup${a.isolate ? ", isolate" : ""}, ports, handoff and preview on ${deps.host}, and record a Periscopes row (expires after ${caps.idleMinutes} minutes idle)`);
           break;
         }
@@ -22332,7 +22477,7 @@ ${res.url}
       };
       const droppedRoutes = [];
       try {
-        const rawCfg = parseYaml2(readFileSync32(cfg.configFile, "utf8"));
+        const rawCfg = parseYaml2(readFileSync33(cfg.configFile, "utf8"));
         for (const r of rawCfg?.routes ?? []) {
           if (typeof r?.route !== "string" || cfg.routes.some((x) => x.route === r.route)) continue;
           try {
@@ -22374,8 +22519,8 @@ ${res.url}
         process.stdout.write("crew reload: no daemon unit is running \u2014 nothing to reload (the next run reads crew.yaml fresh)\n");
         break;
       }
-      mkdirSync23(cfg.ship.stateDir, { recursive: true });
-      writeFileSync24(sentinel, `${(/* @__PURE__ */ new Date()).toISOString()}
+      mkdirSync24(cfg.ship.stateDir, { recursive: true });
+      writeFileSync25(sentinel, `${(/* @__PURE__ */ new Date()).toISOString()}
 `);
       process.stdout.write("crew reload: requested \u2014 the daemon finishes its in-flight pass, then relaunches with the new config\n");
       if (flag("now") && control?.stopCommand && control.startCommand) {
@@ -22426,7 +22571,7 @@ ${res.url}
     }
     case "log": {
       try {
-        const text = readFileSync32(cfg.ship.logFile, "utf8").split("\n");
+        const text = readFileSync33(cfg.ship.logFile, "utf8").split("\n");
         process.stdout.write(`${text.slice(-(Number(value("tail")) || 40)).join("\n")}
 `);
       } catch {
@@ -22449,7 +22594,7 @@ ${res.url}
       };
       if (!route.resolved) fail(`route ${route.route} is not connected \u2014 run \`crew connect\` first`);
       const tracker = new Tracker(route, cfg.ship);
-      const configText = readFileSync32(cfg.configFile, "utf8");
+      const configText = readFileSync33(cfg.configFile, "utf8");
       const cfgBase = dirname20(cfg.configFile);
       const configured = configuredRepos(configText, route.route, cfgBase);
       const dir = configured.find((r) => r.name === SAMPLE_REPO)?.dir ?? sampleDir(configured.map((r) => r.dir), route.reposBasePath, route.route.split("/")[0]);
@@ -22478,7 +22623,7 @@ ${res.url}
         }
         if (configured.some((r) => r.dir === dir)) {
           try {
-            writeFileSync24(cfg.configFile, planRepoRemove(configText, cfgBase, route.route, dir).text);
+            writeFileSync25(cfg.configFile, planRepoRemove(configText, cfgBase, route.route, dir).text);
           } catch (e) {
             if (e instanceof ReposError) fail(e.message);
             throw e;
@@ -22486,29 +22631,29 @@ ${res.url}
         }
         if (row) {
           await tracker.deleteRepoRow(row.id);
-          if (existsSync36(resolvedFile)) {
-            const raw = JSON.parse(readFileSync32(resolvedFile, "utf8"));
+          if (existsSync37(resolvedFile)) {
+            const raw = JSON.parse(readFileSync33(resolvedFile, "utf8"));
             if (raw.repoNames) delete raw.repoNames[row.id];
             if (raw.repoRemotes) delete raw.repoRemotes[row.id];
-            writeFileSync24(resolvedFile, `${JSON.stringify(raw, null, 2)}
+            writeFileSync25(resolvedFile, `${JSON.stringify(raw, null, 2)}
 `);
           }
         }
-        if (existsSync36(join40(dir, ".git")) && basename12(dir) === SAMPLE_REPO) rmSync16(dir, { recursive: true, force: true });
+        if (existsSync37(join41(dir, ".git")) && basename12(dir) === SAMPLE_REPO) rmSync17(dir, { recursive: true, force: true });
         say("removed", { dir, closed }, `removed the sample repo${closed.length ? `, closed ${closed.join(", ")}` : ""}`);
         break;
       }
       const projectId = route.resolved.areaId ?? resolveRepoProject(await tracker.projectRows(), value("project"));
-      const fresh = !existsSync36(join40(dir, ".git"));
-      if (existsSync36(dir) && fresh && readdirSync17(dir).length > 0) fail(`${dir} exists and is not a git checkout \u2014 move it aside`);
+      const fresh = !existsSync37(join41(dir, ".git"));
+      if (existsSync37(dir) && fresh && readdirSync17(dir).length > 0) fail(`${dir} exists and is not a git checkout \u2014 move it aside`);
       if (dryRun) {
         say("dry-run", { dir, newCheckout: fresh, repoRow: row?.id ?? null }, `would ${fresh ? "create" : "reuse"} ${dir}${row ? "" : ", create the Repos row"}, and file one ${tracker.contract.statuses.approved} ticket`);
         break;
       }
       if (fresh) {
-        mkdirSync23(dir, { recursive: true });
-        writeFileSync24(join40(dir, "README.md"), SAMPLE_README);
-        writeFileSync24(join40(dir, ".crew.yaml"), SAMPLE_CREW_YAML);
+        mkdirSync24(dir, { recursive: true });
+        writeFileSync25(join41(dir, "README.md"), SAMPLE_README);
+        writeFileSync25(join41(dir, ".crew.yaml"), SAMPLE_CREW_YAML);
         const g = (...a) => {
           const r = spawnSync7("git", a, { cwd: dir, encoding: "utf8" });
           if (r.status !== 0) fail(`git ${a[0]} failed in ${dir}: ${(r.stderr || r.stdout).trim()}`);
@@ -22526,17 +22671,17 @@ ${res.url}
           spec: { platform: "unix", releaseMode: "integrate", ciProvider: "none" }
         });
         repoId = (await tracker.createRepoRow(payload)).id;
-        if (existsSync36(resolvedFile)) {
-          const raw = JSON.parse(readFileSync32(resolvedFile, "utf8"));
+        if (existsSync37(resolvedFile)) {
+          const raw = JSON.parse(readFileSync33(resolvedFile, "utf8"));
           raw.repoNames = { ...raw.repoNames, [repoId]: SAMPLE_REPO };
           raw.repoRemotes = { ...raw.repoRemotes, [repoId]: SAMPLE_REMOTE };
-          writeFileSync24(resolvedFile, `${JSON.stringify(raw, null, 2)}
+          writeFileSync25(resolvedFile, `${JSON.stringify(raw, null, 2)}
 `);
         }
       }
       if (!configured.some((r) => r.dir === dir)) {
         try {
-          writeFileSync24(cfg.configFile, planRepoAdd({ text: configText, base: cfgBase, route: route.route, path: dir, name: SAMPLE_REPO }).text);
+          writeFileSync25(cfg.configFile, planRepoAdd({ text: configText, base: cfgBase, route: route.route, path: dir, name: SAMPLE_REPO }).text);
         } catch (e) {
           if (e instanceof ReposError) fail(e.message);
           throw e;
@@ -22871,7 +23016,7 @@ watermark:  ${state.watermark()}
           }
           for (const r of repos) {
             const remote = r.config.branch.remote;
-            if (existsSync36(r.dir)) {
+            if (existsSync37(r.dir)) {
               pushAuth.push({
                 route: c.route,
                 repo: r.name,
@@ -22948,7 +23093,7 @@ routes:            ${cfg.routes.map((c) => c.route).join(", ")}
       }
       try {
         const evFile = eventFileFor(cfg.ship.stateDir);
-        const evSize = existsSync36(evFile) ? statSync11(evFile).size : 0;
+        const evSize = existsSync37(evFile) ? statSync11(evFile).size : 0;
         process.stdout.write(
           evSize > cfg.ship.eventsRotateBytes * 4 ? `events log:        WARN ${evFile} is ${Math.round(evSize / 1048576)} MB (> 4x eventsRotateBytes); run \`crew reap\` to rotate it
 ` : "events log:        ok\n"
@@ -22959,7 +23104,7 @@ routes:            ${cfg.routes.map((c) => c.route).join(", ")}
         const unitPlan = planInstall(cfg.ship, CREW_HOME, host, detectSystemd(), "run");
         const abandons = unitAbandonsAgents(unitPlan, (p) => {
           try {
-            return readFileSync32(p, "utf8");
+            return readFileSync33(p, "utf8");
           } catch {
             return null;
           }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tablation/crew",
-  "version": "0.88.0",
+  "version": "0.89.0",
   "description": "A standing team of headless agents that picks work off a Tablation board, does it on a machine you control, and reports back.",
   "type": "module",
   "license": "MIT",