@tablation/crew 0.87.1 → 0.89.0

package/dist/cli.js

@@ -4225,8 +4225,8 @@ var CHECKOUT_LOCK_STALE_MS = 5 * 60 * 1e3;
 function checkoutLockPath(dir) {
   return `${dir}.sync.lock`;
 }
-function sleepSync(ms2) {
-  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms2);
+function sleepSync(ms3) {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms3);
 }
 function acquireCheckoutLock(dir, timeoutMs = 3e4) {
   const lockPath = checkoutLockPath(dir);
@@ -6980,6 +6980,25 @@ var Tracker = class {
     });
     return rows.length;
   }
+  /** This ship's `live` Periscopes rows (EPIC-077); empty without the table or a Ships row. */
+  async liveShipPeriscopes() {
+    const modelId = this.route.resolved?.periscopesModelId;
+    const { shipId } = await this.authorshipProbe();
+    if (!modelId || !shipId) return [];
+    return this.client.records.list(modelId, {
+      filters: encodeFilters([
+        { columnName: "ship_id", operator: "EQ", value: shipId },
+        { columnName: "state", operator: "EQ", value: "live" }
+      ]),
+      limit: 200
+    });
+  }
+  /** Patches one Periscopes row (EPIC-077). */
+  async updatePeriscope(rowId, fields) {
+    const modelId = this.route.resolved?.periscopesModelId;
+    if (!modelId) throw new Error("this workspace has no Periscopes table");
+    await this.client.records.update(modelId, rowId, fields);
+  }
   /** Records a Periscopes row for this ship (EPIC-077); `ship_id` is stamped here, never by the caller. */
   async createPeriscope(fields) {
     const modelId = this.route.resolved?.periscopesModelId;
@@ -7008,12 +7027,6 @@ var Tracker = class {
     }
     return out.sort((a, b) => String(b.row.started_at ?? "").localeCompare(String(a.row.started_at ?? "")));
   }
-  /** Updates one Periscopes row (EPIC-077). */
-  async updatePeriscope(id, patch2) {
-    const modelId = this.route.resolved?.periscopesModelId;
-    if (!modelId) throw new Error("this workspace has no Periscopes table");
-    await this.client.records.update(modelId, id, patch2);
-  }
   /**
    * The authorship columns this workspace is missing, as `table.column` names
    * for `crew doctor` to report (CREW-1371). Empty on a fully updated install.
@@ -9096,10 +9109,10 @@ async function finishRun(id, obs, emit, startedAt, end, agentLogKey, hintMoved)
     });
   } catch {
   }
-  const ms2 = Date.now() - Date.parse(startedAt);
+  const ms3 = Date.now() - Date.parse(startedAt);
   emit.emit(end.interrupted ? "agent run interrupted" : `agent run finished (${pending ? "hand-off pending" : `exit ${end.code ?? "unknown"}`})`, {
     data: {
-      ms: ms2,
+      ms: ms3,
       code: end.code,
       ...pending ? { handoff: "pending" } : {},
       ...end.interrupted ? { interrupted: end.interrupted } : {},
@@ -9166,7 +9179,7 @@ async function finishRun(id, obs, emit, startedAt, end, agentLogKey, hintMoved)
             nextAttemptAt: (/* @__PURE__ */ new Date()).toISOString()
           });
           emit.warn(`could not report agent log (${e.message}); queued to retry`, { step: "agent" });
-          return { ms: ms2, ticket: attributedTicket, handoffPending: !!pending };
+          return { ms: ms3, ticket: attributedTicket, handoffPending: !!pending };
         } catch {
         }
       }
@@ -9182,7 +9195,7 @@ async function finishRun(id, obs, emit, startedAt, end, agentLogKey, hintMoved)
       emit.warn(`could not report agent log: ${e.message}`, { step: "agent" });
     }
   }
-  return { ms: ms2, ticket: attributedTicket, handoffPending: !!pending };
+  return { ms: ms3, ticket: attributedTicket, handoffPending: !!pending };
 }
 function spawnAgent(plan, emit, hintMoved) {
   const adapter = adapterFor(plan.harness ?? LEGACY_TOOLCHAIN_HARNESS);
@@ -9237,8 +9250,8 @@ function spawnAgent(plan, emit, hintMoved) {
     const meta = { pid: child.pid ?? null };
     obs.onClaim = () => writeRunMeta(id, startedAt, obs.liveTicket, meta);
     if (child.pid !== void 0) writeRunMeta(id, startedAt, obs.liveTicket, meta);
-    const tail2 = new FileTail(plan.streamPath);
-    const timer = setInterval(() => obs.feed(tail2.poll()), TAIL_POLL_MS);
+    const tail3 = new FileTail(plan.streamPath);
+    const timer = setInterval(() => obs.feed(tail3.poll()), TAIL_POLL_MS);
     let spawnFailed = false;
     child.on("error", (err) => {
       spawnFailed = true;
@@ -9247,12 +9260,12 @@ function spawnAgent(plan, emit, hintMoved) {
     });
     child.on("close", async (code) => {
       clearInterval(timer);
-      obs.feed(tail2.poll());
+      obs.feed(tail3.poll());
       obs.end();
       await endSink(eventsSink);
       if (spawnFailed) return;
-      const { ms: ms2, handoffPending } = await finishRun(id, obs, emit, startedAt, { code: code ?? 1 }, plan.agentLog?.apiKey, hintMoved);
-      resolve6({ code: code ?? 1, ms: ms2, ...handoffPending ? { handoffPending } : {} });
+      const { ms: ms3, handoffPending } = await finishRun(id, obs, emit, startedAt, { code: code ?? 1 }, plan.agentLog?.apiKey, hintMoved);
+      resolve6({ code: code ?? 1, ms: ms3, ...handoffPending ? { handoffPending } : {} });
     });
     child.stdin?.on("error", (err) => {
       emit.warn(`agent closed stdin before the prompt was delivered: ${err.message}`, { step: "agent" });
@@ -9266,24 +9279,24 @@ async function reattachRun(streamPath, sc, emit, o = {}) {
   const id = { ...sc, streamPath };
   const eventsSink = openSink(sc.eventsPath);
   const obs = new RunObserver(id, adapter, eventsSink, emit.cycle);
-  const tail2 = new FileTail(streamPath);
+  const tail3 = new FileTail(streamPath);
   obs.muted = true;
-  obs.feed(tail2.poll());
+  obs.feed(tail3.poll());
   obs.muted = false;
   const adopted = isAlive(sc);
   if (adopted) {
     o.onAdopted?.();
     const pollMs = o.pollMs ?? TAIL_POLL_MS;
     while (isAlive(sc)) {
-      obs.feed(tail2.poll());
+      obs.feed(tail3.poll());
       await new Promise((r) => setTimeout(r, pollMs));
     }
   }
-  obs.feed(tail2.poll());
+  obs.feed(tail3.poll());
   obs.end();
   await endSink(eventsSink);
   const interrupted = obs.sawResult ? void 0 : adopted ? "no-result" : "daemon-exit";
-  const { ms: ms2, ticket } = await finishRun(
+  const { ms: ms3, ticket } = await finishRun(
     id,
     obs,
     emit,
@@ -9291,7 +9304,7 @@ async function reattachRun(streamPath, sc, emit, o = {}) {
     { code: null, ...interrupted ? { interrupted } : {} },
     o.agentLogKey
   );
-  return { adopted, ...interrupted ? { interrupted } : {}, ms: ms2, ticket };
+  return { adopted, ...interrupted ? { interrupted } : {}, ms: ms3, ticket };
 }
 
 // src/seat-keys.ts
@@ -9790,7 +9803,7 @@ function doctorSelftestLines(stored, toolchains) {
 }
 
 // src/cli.ts
-import { resolve as resolve5, dirname as dirname20, join as join39, 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";
@@ -9829,7 +9842,9 @@ var VALUE_FLAGS = /* @__PURE__ */ new Set([
   "workspace-id",
   "write",
   "topic",
-  "assignee"
+  "assignee",
+  "issue",
+  "resume"
 ]);
 function positionalArgs(argv2) {
   const out = [];
@@ -13169,7 +13184,7 @@ async function isolateAndRetry(o, name, output, merged, preMerge, decision, fres
       }
       if (culprits.length === 0 && truncated) {
         let lo = 2, hi = applied.length;
-        let tail2 = lastLines(output, HOOK_FAILURE_TAIL_LINES);
+        let tail3 = lastLines(output, HOOK_FAILURE_TAIL_LINES);
         while (lo < hi) {
           const mid = Math.floor((lo + hi) / 2);
           gitOk(o.cwd, ["reset", "--hard", preMerge]);
@@ -13184,12 +13199,12 @@ async function isolateAndRetry(o, name, output, merged, preMerge, decision, fres
           const r = clean ? await hook(o, name) : null;
           if (r && r.code !== 0) {
             hi = mid;
-            tail2 = lastLines(r.output, HOOK_FAILURE_TAIL_LINES);
+            tail3 = lastLines(r.output, HOOK_FAILURE_TAIL_LINES);
           } else lo = mid + 1;
         }
         const owner = applied[hi - 1];
         o.emit.warn(`${owner.branch} is the first branch whose prefix fails the ${name} hook (bisected over ${applied.length})`, { ticket: owner.ticket.issue_id });
-        culprits.push({ c: owner, how: "pair", sibling: applied[hi - 2], tail: tail2 });
+        culprits.push({ c: owner, how: "pair", sibling: applied[hi - 2], tail: tail3 });
       }
     }
   }
@@ -14301,8 +14316,8 @@ async function decideFleet(o) {
 }
 var LOUD_STREAK = 5;
 function since(iso, now = Date.now()) {
-  const ms2 = Math.max(0, now - Date.parse(iso));
-  const mins = Math.round(ms2 / 6e4);
+  const ms3 = Math.max(0, now - Date.parse(iso));
+  const mins = Math.round(ms3 / 6e4);
   if (mins < 60) return `${mins}m`;
   const hours = Math.round(mins / 60);
   if (hours < 48) return `${hours}h`;
@@ -16197,6 +16212,7 @@ function planWorktreeSweep(target, tickets, contract) {
   for (const w of worktrees(target.dir).slice(1)) {
     const ticket = ticketForWorktree(w, byNumber, contract);
     if (!ticket) continue;
+    if (ticket.status === contract.statuses.draft) continue;
     const isVerified = ticket.status === verified;
     if (!isVerified && !terminal.has(ticket.status)) continue;
     actions.push({
@@ -16209,6 +16225,15 @@ function planWorktreeSweep(target, tickets, contract) {
   }
   return actions;
 }
+function draftWorktrees(target, tickets, contract) {
+  const byNumber = new Map(tickets.map((t) => [t.issue_id.replace(/^\D+/, ""), t]));
+  const out = [];
+  for (const w of worktrees(target.dir).slice(1)) {
+    const ticket = ticketForWorktree(w, byNumber, contract);
+    if (ticket && ticket.status === contract.statuses.draft) out.push({ ticket, path: w.path });
+  }
+  return out;
+}
 var DIR_NUMBER = /(?:^|-)(\d+)$/;
 var DIR_NUMBER_SUFFIXED = /(?:^|-)(\d+)(?:-[a-z0-9]{1,8})?$/;
 var BRANCH_STEM = /^(?:.*\/)?([^/]+?-\d+)(?:-.*)?$/;
@@ -16508,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 statSync10, 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 } : {},
@@ -16550,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 [
@@ -16571,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);
   };
@@ -16658,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]";
@@ -16707,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");
@@ -16738,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");
@@ -16752,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) => {
@@ -16773,25 +16887,157 @@ function formatPeriscopeList(entries) {
   ].join("  ")).join("\n");
 }
 
+// src/periscope-resume.ts
+var tail2 = (s, n = 20) => s.trimEnd().split("\n").slice(-n).join("\n");
+async function runPeriscopeResume(d, number) {
+  const found = await d.find(number);
+  if (!found) throw new PeriscopeError(`no live periscope for ISSUE-${number} on this ship \u2014 open one with \`crew periscope up\``);
+  const { row, tag } = found;
+  if (!d.worktreeExists(row.worktree)) {
+    throw new PeriscopeError(`the worktree of ${tag} is gone (${row.worktree}); there is nothing to resume`);
+  }
+  const env = { CREW_TICKET: tag };
+  if (row.branch) env.CREW_BRANCH = row.branch;
+  const ports = await d.runHook("ports", row.worktree, env);
+  if (ports) Object.assign(env, parseEnvLines(ports.output));
+  if (row.isolated) {
+    const iso = await d.runHook("isolate", row.worktree, env);
+    if (iso && iso.code !== 0) throw new PeriscopeError(`isolate failed (exit ${iso.code})
+${tail2(iso.output)}`);
+    if (iso) Object.assign(env, parseEnvLines(iso.output));
+  }
+  const preview = await d.runHook("preview", row.worktree, { ...env, CREW_PREVIEW_HOST: row.host || "localhost" });
+  if (!preview || preview.code !== 0) {
+    throw new PeriscopeError(`preview exited ${preview?.code ?? "without running"}
+${tail2(preview?.output ?? "")}`);
+  }
+  const url = previewUrlFrom(preview.output);
+  if (!url) throw new PeriscopeError(`preview printed no URL as its last line
+${tail2(preview.output)}`);
+  const now = d.now();
+  await d.update(row.id, {
+    url,
+    last_activity_at: now.toISOString(),
+    expires_at: new Date(now.getTime() + d.caps.idleMinutes * 6e4).toISOString()
+  });
+  d.clearItem(tag);
+  d.say("resumed", `preview at ${url}`, { url });
+  return { ticket: tag, worktree: row.worktree, url, periscopeRecordId: row.id };
+}
+
+// src/periscope-idle.ts
+import { execFileSync as execFileSync6 } from "child_process";
+import { statSync as statSync9 } from "fs";
+import { join as join36 } from "path";
+var MAX_SCANNED_FILES = 2e4;
+function newestWorktreeMtime(root) {
+  let listing;
+  try {
+    listing = execFileSync6("git", ["ls-files", "-z", "--cached", "--others", "--exclude-standard"], {
+      cwd: root,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+      maxBuffer: 64 * 1024 * 1024
+    });
+  } catch {
+    return null;
+  }
+  let newest = null;
+  let scanned = 0;
+  for (const rel of listing.split("\0")) {
+    if (!rel) continue;
+    if (++scanned > MAX_SCANNED_FILES) break;
+    try {
+      const m = statSync9(join36(root, rel)).mtimeMs;
+      if (newest === null || m > newest) newest = m;
+    } catch {
+    }
+  }
+  return newest;
+}
+var ms2 = (iso) => {
+  const t = iso ? Date.parse(iso) : NaN;
+  return Number.isFinite(t) ? t : 0;
+};
+function decideIdle(row, mtimeMs, nowMs, idleMinutes) {
+  const idleMs = idleMinutes * 6e4;
+  const recordedActivity = ms2(row.last_activity_at);
+  const activity = Math.max(recordedActivity, mtimeMs ?? 0);
+  const expiresAt = ms2(row.expires_at);
+  if (activity > 0 && activity + idleMs > expiresAt) {
+    return {
+      action: "refresh",
+      lastActivityAt: new Date(activity).toISOString(),
+      expiresAt: new Date(activity + idleMs).toISOString()
+    };
+  }
+  if (expiresAt > 0 && nowMs >= expiresAt) return { action: "expire", idleMs: Math.max(0, nowMs - activity) };
+  return { action: "none" };
+}
+var periscopeIdleKey = (ticket) => `periscope_idle:${ticket}`;
+var fmtIdle = (idleMs) => {
+  const minutes = Math.max(1, Math.round(idleMs / 6e4));
+  const h = Math.floor(minutes / 60);
+  return h > 0 ? `${h}h ${minutes % 60}m` : `${minutes}m`;
+};
+function periscopeIdleItem(ticket, repo, number, idleMs, nowIso) {
+  return {
+    kind: "periscope_idle",
+    key: periscopeIdleKey(ticket),
+    since: nowIso,
+    message: `Periscope ${ticket} (${repo}) has been idle for ${fmtIdle(idleMs)}; its server is stopped and the worktree is untouched. End it with \`crew periscope down ${number} --keep\` (push the work) or \`crew periscope down ${number} --discard\`, or bring the server back with \`crew periscope up --resume ${number}\`.`
+  };
+}
+async function runPeriscopeIdlePass(d) {
+  const result = { refreshed: 0, expired: 0 };
+  const now = d.now();
+  const liveKeys = /* @__PURE__ */ new Set();
+  let lookupFailed = false;
+  for (const row of await d.listLive()) {
+    try {
+      const t = await d.ticketOf(row);
+      liveKeys.add(periscopeIdleKey(t.tag));
+      const decision = decideIdle(row, d.mtimeOf(row.worktree), now.getTime(), d.idleMinutes);
+      if (decision.action === "none") continue;
+      if (decision.action === "refresh") {
+        await d.update(row.id, { last_activity_at: decision.lastActivityAt, expires_at: decision.expiresAt });
+        d.clear(periscopeIdleKey(t.tag));
+        result.refreshed++;
+        continue;
+      }
+      await d.stopServer(row.worktree, t.number);
+      await d.raise(periscopeIdleItem(t.tag, t.repo, t.number, decision.idleMs, now.toISOString()));
+      result.expired++;
+    } catch (e) {
+      lookupFailed = true;
+      d.warn(`periscope idle check failed for ${row.worktree}: ${e.message}`);
+    }
+  }
+  if (!lookupFailed) {
+    for (const key of d.openKeys()) if (!liveKeys.has(key)) d.clear(key);
+  }
+  return result;
+}
+
 // src/cli.ts
 import { dirname as dirOf2, resolve as resolvePath } from "path";
 
 // src/ssh-keys.ts
-import { execFileSync as execFileSync6 } from "child_process";
-import { existsSync as existsSync32, mkdirSync as mkdirSync19, readFileSync as readFileSync28, chmodSync } from "fs";
-import { dirname as dirname19, join as join35 } from "path";
+import { execFileSync as execFileSync7 } from "child_process";
+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 join35(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 {
-      execFileSync6("ssh-keygen", [
+      execFileSync7("ssh-keygen", [
         "-t",
         "ed25519",
         "-N",
@@ -16809,15 +17055,15 @@ 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() {
   try {
-    execFileSync6("ssh-keygen", ["-V"], { stdio: ["ignore", "ignore", "ignore"] });
+    execFileSync7("ssh-keygen", ["-V"], { stdio: ["ignore", "ignore", "ignore"] });
     return true;
   } catch (e) {
     return e.code !== "ENOENT";
@@ -16825,11 +17071,11 @@ function sshKeygenAvailable() {
 }
 
 // src/passenger-containers.ts
-import { execFileSync as execFileSync7 } from "child_process";
+import { execFileSync as execFileSync8 } from "child_process";
 import { createHash as createHash6 } from "crypto";
 var realExec = (cmd, args, opts) => {
   try {
-    return execFileSync7(cmd, args, { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], timeout: opts?.timeoutMs });
+    return execFileSync8(cmd, args, { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], timeout: opts?.timeoutMs });
   } catch (e) {
     const err = e;
     const why = [err.stderr, err.stdout].map((x) => (x ?? "").trim()).filter(Boolean).join(" / ");
@@ -17029,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 join36 } 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";
@@ -17098,21 +17344,21 @@ function startTunnel(opts) {
   };
 }
 function tunnelStatePath(stateDir, workspaceId) {
-  return join36(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(join36(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) {
@@ -17209,8 +17455,8 @@ function syncPassengerTunnels(plans, relayHost, relayPort, privateKeyPath, state
   }
 }
 function readAllPersistedWorkspaceIds(stateDir) {
-  const dir = join36(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));
 }
 
@@ -17331,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 join37 } 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";
@@ -17421,21 +17667,21 @@ var defaultSpawn2 = (cmd, args, env) => {
   return child;
 };
 function syncDaemonStatePath(stateDir, workspaceId) {
-  return join37(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(join37(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) {
@@ -17445,8 +17691,8 @@ function removePersistedSyncDaemon(stateDir, workspaceId) {
   } catch {
   }
 }
-function sleepSync2(ms2) {
-  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms2);
+function sleepSync2(ms3) {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms3);
 }
 function waitForExit(pid, alive, timeoutMs = 5e3) {
   const deadline = Date.now() + timeoutMs;
@@ -17455,8 +17701,8 @@ function waitForExit(pid, alive, timeoutMs = 5e3) {
   }
 }
 function readAllPersistedSyncWorkspaceIds(stateDir) {
-  const dir = join37(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));
 }
@@ -17544,12 +17790,12 @@ function describeCause(err) {
 }
 
 // src/daemon.ts
-import { existsSync as existsSync35, mkdirSync as mkdirSync22, readFileSync as readFileSync31, readdirSync as readdirSync16, rmSync as rmSync15, statSync as statSync9, writeFileSync as writeFileSync23 } from "fs";
-import { join as join38 } 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;
-var defaultSleep = (ms2) => new Promise((resolve6) => setTimeout(resolve6, ms2));
+var defaultSleep = (ms3) => new Promise((resolve6) => setTimeout(resolve6, ms3));
 async function runDaemonLoop(o) {
   const floor = o.floorMs ?? DEFAULT_FLOOR_MS;
   const ceiling = o.ceilingMs ?? DEFAULT_CEILING_MS;
@@ -17608,7 +17854,7 @@ async function runDaemonLoop(o) {
 function latestMtime(path) {
   let stat;
   try {
-    stat = statSync9(path);
+    stat = statSync10(path);
   } catch {
     return 0;
   }
@@ -17616,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(join38(path, entry.name)));
+    latest = Math.max(latest, latestMtime(join40(path, entry.name)));
   }
   return latest;
 }
@@ -17625,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 join38(stateDir, "reload-requested");
+  return join40(stateDir, "reload-requested");
 }
 function daemonStampFor(stateDir) {
-  return join38(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;
@@ -17650,7 +17896,7 @@ function readDaemonStarted(stateDir) {
 function configChangedAfter(files, startedAt) {
   for (const f of files) {
     try {
-      if (statSync9(f).mtimeMs > startedAt) return f;
+      if (statSync10(f).mtimeMs > startedAt) return f;
     } catch {
     }
   }
@@ -17749,6 +17995,35 @@ async function runOnePassUnguarded(o) {
       emit.warn(`could not sweep stalled tickets: ${e.message}`, { step: "sweep" });
     }
   }
+  if (o.route.resolved?.periscopesModelId) {
+    const tracker = new Tracker(o.route, o.ship);
+    try {
+      await runPeriscopeIdlePass({
+        idleMinutes: periscopeCaps(o.ship).idleMinutes,
+        now: () => /* @__PURE__ */ new Date(),
+        listLive: () => tracker.liveShipPeriscopes(),
+        mtimeOf: newestWorktreeMtime,
+        update: (id, fields) => tracker.updatePeriscope(id, fields),
+        ticketOf: async (row) => {
+          const t = await tracker.ticket(row.issue_id);
+          return {
+            tag: t.issue_tag ?? t.issue_id,
+            number: t.issue_id.replace(/^\D+/, ""),
+            repo: t.repo_id && o.route.resolved?.repoNames?.[t.repo_id] || "unknown repository"
+          };
+        },
+        stopServer: (worktree, number) => killGently(pidsInWorktree(worktree, Number(number))),
+        raise: async (item) => {
+          await raiseShipAttention({ state: o.state, emit, route: o.route, ship: o.ship }, item);
+        },
+        clear: (key) => clearShipAttention(o.state, key),
+        openKeys: () => openShipAttention(o.state).filter((i) => i.kind === "periscope_idle").map((i) => i.key),
+        warn: (message) => emit.warn(message, { step: "sweep" })
+      });
+    } catch (e) {
+      emit.warn(`could not check idle periscopes: ${e.message}`, { step: "sweep" });
+    }
+  }
   const order = [...decision.selection.pending].sort(
     (a, b) => (decision.selection.ranks[a] ?? Number.POSITIVE_INFINITY) - (decision.selection.ranks[b] ?? Number.POSITIVE_INFINITY)
   );
@@ -18234,7 +18509,8 @@ 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]
                                  end a periscope: commit and push its branch (ticket back to new), or throw it away (alias: end)
@@ -18513,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 } : {});
@@ -18751,8 +19027,8 @@ if (command === "passenger-sync-daemon") {
     }
     if (host === "linux" && hasSystemd) {
       const label = labelFor(CREW_HOME, "run");
-      const staleTimer = join39(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)" : ""}
 `
@@ -18779,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}`));
     }
@@ -18797,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 });
@@ -18814,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 {
@@ -19918,7 +20194,7 @@ ${cu.tail.trimEnd()}
         process.exit(1);
       }
       requireArmed("run the daemon loop");
-      const watchPaths = isCompiledBinary(import.meta.url) ? [process.execPath] : [join39(CREW_HOME, "src"), join39(CREW_HOME, "dist"), join39(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);
@@ -20147,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;
@@ -20173,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 {
@@ -20220,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];
@@ -20251,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 {
@@ -20260,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;
             }
@@ -20302,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")) {
@@ -20370,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;
@@ -20399,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")) {
@@ -20418,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;
                 }
@@ -20439,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}
 `);
           }
@@ -20451,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) {
@@ -20471,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({
@@ -20530,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) {
@@ -20905,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) {
@@ -20948,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 {
           }
         }
@@ -21080,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}
@@ -21129,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}
 `);
@@ -21449,6 +21725,10 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
           await tracker.ticketsByNumbers(remoteBranchTicketNumbers(r.dir, r.config.branch.remote, r.config.branch.base), truncated)
         ).byRepo.get(r.name) ?? [];
         const actions = planWorktreeSweep(r, wtTickets, tracker.contract);
+        for (const k of draftWorktrees(r, wtTickets, tracker.contract)) {
+          anything = true;
+          emit.emit(`keeping ${k.path}: ${k.ticket.issue_tag ?? k.ticket.issue_id} is a draft (a periscope) \u2014 end it with \`crew periscope down\``, { step: "worktree" });
+        }
         const orphanDirs = orphanedWorktreeDirs(r, wtTickets, tracker.contract);
         warnOrphanedWorktreeDirs(orphanDirs, emit, dryRun ? void 0 : { state, repo: r.name });
         const stale = planRemoteBranchCleanup(r.dir, r.config.branch.remote, r.config.branch.base, brTickets, tracker.contract);
@@ -21514,6 +21794,16 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
       }
       const { repo: target, found } = candidates[0];
       const wt = found.path;
+      try {
+        const trD = new Tracker(route, cfg.ship);
+        const tD = (await trD.ticketsByNumbers([n])).find((t) => t.issue_id.replace(/^\D+/, "") === String(num));
+        if (tD && tD[trD.contract.columns.status] === trD.contract.statuses.draft) {
+          process.stderr.write(`drop: ${tD.issue_tag ?? tD.issue_id} is a draft ticket \u2014 its worktree belongs to a periscope; end it with \`crew periscope down ${num} --keep\` or \`--discard\`
+`);
+          process.exit(2);
+        }
+      } catch {
+      }
       const branch = found.branch ?? branchForIssue(target.dir, `ISSUE-${n}`, {
         name: target.config.branch.name,
         push: target.config.branch.push
@@ -21666,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);
@@ -21750,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;
@@ -21779,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) {
@@ -21802,7 +22101,48 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
         break;
       }
       try {
-        const a = parsePeriscopeUpArgs(positional, { topic: value("topic"), host: value("host"), assignee: value("assignee"), isolate: flag("isolate"), json: jsonP });
+        const resumeRaw = value("resume");
+        if (resumeRaw !== void 0) {
+          const nR = parseTicketNumber(resumeRaw);
+          if (!nR) throw new PeriscopeError("--resume needs a ticket number (326, ISSUE-326, or CREW-326)");
+          let hit;
+          for (const cand of cfg.routes.filter((r) => r.enabled && r.resolved?.periscopesModelId)) {
+            const tr = new Tracker(cand, cfg.ship);
+            for (const row of await tr.liveShipPeriscopes()) {
+              const t = await tr.ticket(row.issue_id);
+              if (t.issue_id.replace(/^\D+/, "") !== String(Number(nR))) continue;
+              const repo = (await resolvedRepos(cand)).find((r) => r.id === t.repo_id);
+              if (!repo) throw new PeriscopeError(`route ${cand.route} has no checkout for the repository of ${t.issue_tag ?? t.issue_id}`);
+              hit = { route: cand, tracker: tr, row, tag: t.issue_tag ?? t.issue_id, repo };
+            }
+          }
+          if (dryRun) {
+            say("dry-run", hit ? `would rerun ports${hit.row.isolated ? ", isolate" : ""} and preview in ${hit.row.worktree} and refresh the row` : `no live periscope for ISSUE-${nR} on this ship`);
+            break;
+          }
+          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) => existsSync37(p),
+            caps: periscopeCaps(cfg.ship),
+            runHook: async (name, cwd, env) => {
+              const script = hit?.repo.config.hooks[name];
+              return script ? runScript(script, { cwd, env, shell: shellR, timeoutMs: name === "preview" ? 18e4 : void 0 }) : null;
+            },
+            update: (id, fields) => hit.tracker.updatePeriscope(id, fields),
+            clearItem: (tag) => clearShipAttention(state, periscopeIdleKey(tag)),
+            now: () => /* @__PURE__ */ new Date(),
+            say
+          }, String(Number(nR)));
+          if (jsonP) process.stdout.write(`${JSON.stringify({ event: "done", ...resumed })}
+`);
+          else process.stdout.write(`${resumed.ticket}
+${resumed.worktree}
+${resumed.url}
+`);
+          break;
+        }
+        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) {
@@ -21864,10 +22204,10 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
           },
           prepare: async (path) => {
             for (const f of repoP.config.worktrees.copy) {
-              const src = join39(repoP.dir, f);
-              if (!existsSync36(src)) continue;
-              mkdirSync23(dirOf2(join39(path, f)), { recursive: true });
-              copyFileSync2(src, join39(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) => {
@@ -21891,12 +22231,58 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
             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;
         }
@@ -22091,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 {
@@ -22133,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) {
@@ -22185,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 {
@@ -22208,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]);
@@ -22237,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;
@@ -22245,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(join39(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(join39(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(join39(dir, "README.md"), SAMPLE_README);
-        writeFileSync24(join39(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()}`);
@@ -22285,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;
@@ -22630,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,
@@ -22707,7 +23093,7 @@ routes:            ${cfg.routes.map((c) => c.route).join(", ")}
       }
       try {
         const evFile = eventFileFor(cfg.ship.stateDir);
-        const evSize = existsSync36(evFile) ? statSync10(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"
@@ -22718,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;
           }
@@ -22734,7 +23120,7 @@ routes:            ${cfg.routes.map((c) => c.route).join(", ")}
         const changed2 = configChangedAfter(daemonConfigPaths(cfg), daemonStartedAt);
         if (changed2) {
           process.stdout.write(
-            `daemon config:     WARN ${changed2} changed at ${new Date(statSync10(changed2).mtimeMs).toISOString()} but the daemon started at ${new Date(daemonStartedAt).toISOString()} \u2014 run \`crew reload\`
+            `daemon config:     WARN ${changed2} changed at ${new Date(statSync11(changed2).mtimeMs).toISOString()} but the daemon started at ${new Date(daemonStartedAt).toISOString()} \u2014 run \`crew reload\`
 `
           );
         }