@tablation/crew 0.87.1 → 0.88.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 join40, 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,8 @@ var VALUE_FLAGS = /* @__PURE__ */ new Set([
   "workspace-id",
   "write",
   "topic",
-  "assignee"
+  "assignee",
+  "resume"
 ]);
 function positionalArgs(argv2) {
   const out = [];
@@ -13169,7 +13183,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 +13198,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 +14315,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 +16211,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 +16224,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,7 +16532,7 @@ 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 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 { createInterface } from "readline/promises";
 
 // src/periscope-cmd.ts
@@ -16773,17 +16797,149 @@ 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 join35 } 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(join35(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 { 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 join35 } from "path";
+import { dirname as dirname19, join as join36 } from "path";
 var SshKeyError = class extends Error {
 };
 function shipSshKeyPathFor(stateDir) {
-  return join35(stateDir, "ssh", "id_ed25519");
+  return join36(stateDir, "ssh", "id_ed25519");
 }
 function ensureShipSshKeypair(stateDir) {
   const privateKeyPath = shipSshKeyPathFor(stateDir);
@@ -16791,7 +16947,7 @@ function ensureShipSshKeypair(stateDir) {
   if (!existsSync32(privateKeyPath)) {
     mkdirSync19(dirname19(privateKeyPath), { recursive: true });
     try {
-      execFileSync6("ssh-keygen", [
+      execFileSync7("ssh-keygen", [
         "-t",
         "ed25519",
         "-N",
@@ -16817,7 +16973,7 @@ function ensureShipSshKeypair(stateDir) {
 }
 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 +16981,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(" / ");
@@ -17031,7 +17187,7 @@ function syncAllPassengerCheckouts(cfg) {
 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 { randomInt } from "crypto";
-import { join as join36 } from "path";
+import { join as join37 } 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,7 +17254,7 @@ function startTunnel(opts) {
   };
 }
 function tunnelStatePath(stateDir, workspaceId) {
-  return join36(stateDir, "passengers", `${workspaceId}.json`);
+  return join37(stateDir, "passengers", `${workspaceId}.json`);
 }
 function readPersistedTunnel(stateDir, workspaceId) {
   const path = tunnelStatePath(stateDir, workspaceId);
@@ -17111,7 +17267,7 @@ function readPersistedTunnel(stateDir, workspaceId) {
 }
 function writePersistedTunnel(stateDir, state) {
   const path = tunnelStatePath(stateDir, state.workspaceId);
-  mkdirSync20(join36(stateDir, "passengers"), { recursive: true });
+  mkdirSync20(join37(stateDir, "passengers"), { recursive: true });
   writeFileSync21(path, `${JSON.stringify(state, null, 2)}
 `);
 }
@@ -17209,7 +17365,7 @@ function syncPassengerTunnels(plans, relayHost, relayPort, privateKeyPath, state
   }
 }
 function readAllPersistedWorkspaceIds(stateDir) {
-  const dir = join36(stateDir, "passengers");
+  const dir = join37(stateDir, "passengers");
   if (!existsSync33(dir)) return [];
   return readdirSync14(dir).filter((f) => f.endsWith(".json") && !f.endsWith("-sync.json")).map((f) => f.slice(0, -".json".length));
 }
@@ -17332,7 +17488,7 @@ 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 { join as join38 } from "path";
 
 // src/secret-compare.ts
 import { timingSafeEqual } from "crypto";
@@ -17421,7 +17577,7 @@ var defaultSpawn2 = (cmd, args, env) => {
   return child;
 };
 function syncDaemonStatePath(stateDir, workspaceId) {
-  return join37(stateDir, "passengers", `${workspaceId}-sync.json`);
+  return join38(stateDir, "passengers", `${workspaceId}-sync.json`);
 }
 function readPersistedSyncDaemon(stateDir, workspaceId) {
   const path = syncDaemonStatePath(stateDir, workspaceId);
@@ -17434,7 +17590,7 @@ function readPersistedSyncDaemon(stateDir, workspaceId) {
 }
 function writePersistedSyncDaemon(stateDir, state) {
   const path = syncDaemonStatePath(stateDir, state.workspaceId);
-  mkdirSync21(join37(stateDir, "passengers"), { recursive: true });
+  mkdirSync21(join38(stateDir, "passengers"), { recursive: true });
   writeFileSync22(path, `${JSON.stringify(state, null, 2)}
 `);
 }
@@ -17445,8 +17601,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,7 +17611,7 @@ function waitForExit(pid, alive, timeoutMs = 5e3) {
   }
 }
 function readAllPersistedSyncWorkspaceIds(stateDir) {
-  const dir = join37(stateDir, "passengers");
+  const dir = join38(stateDir, "passengers");
   if (!existsSync34(dir)) return [];
   const suffix = "-sync.json";
   return readdirSync15(dir).filter((f) => f.endsWith(suffix)).map((f) => f.slice(0, -suffix.length));
@@ -17544,12 +17700,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 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 { 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 +17764,7 @@ async function runDaemonLoop(o) {
 function latestMtime(path) {
   let stat;
   try {
-    stat = statSync9(path);
+    stat = statSync10(path);
   } catch {
     return 0;
   }
@@ -17616,7 +17772,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(join39(path, entry.name)));
   }
   return latest;
 }
@@ -17628,10 +17784,10 @@ function makeStaleChecker(paths, opts = {}) {
   return () => computeTreeSignature(paths) !== initial || opts.reloadSentinel !== void 0 && existsSync35(opts.reloadSentinel);
 }
 function reloadSentinelFor(stateDir) {
-  return join38(stateDir, "reload-requested");
+  return join39(stateDir, "reload-requested");
 }
 function daemonStampFor(stateDir) {
-  return join38(stateDir, "daemon.started");
+  return join39(stateDir, "daemon.started");
 }
 function noteDaemonStarted(stateDir, now = Date.now()) {
   mkdirSync22(stateDir, { recursive: true });
@@ -17650,7 +17806,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 +17905,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)
   );
@@ -18235,6 +18420,7 @@ function usage(problem, requested = false) {
   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 --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)
@@ -18751,7 +18937,7 @@ if (command === "passenger-sync-daemon") {
     }
     if (host === "linux" && hasSystemd) {
       const label = labelFor(CREW_HOME, "run");
-      const staleTimer = join39(homedir10(), ".config", "systemd", "user", `${label}.timer`);
+      const staleTimer = join40(homedir10(), ".config", "systemd", "user", `${label}.timer`);
       if (existsSync36(staleTimer)) {
         process.stdout.write(
           `removing stale run timer from before the persistent-service cutover: ${staleTimer}${dryRun ? " (dry run)" : ""}
@@ -19918,7 +20104,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] : [join40(CREW_HOME, "src"), join40(CREW_HOME, "dist"), join40(CREW_HOME, "bin")];
       const configPaths = daemonConfigPaths(cfg);
       watchPaths.push(...configPaths);
       noteDaemonStarted(cfg.ship.stateDir);
@@ -21449,6 +21635,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 +21704,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
@@ -21802,6 +22002,47 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
         break;
       }
       try {
+        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) => existsSync36(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"), 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 = [];
@@ -21864,10 +22105,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);
+              const src = join40(repoP.dir, f);
               if (!existsSync36(src)) continue;
-              mkdirSync23(dirOf2(join39(path, f)), { recursive: true });
-              copyFileSync2(src, join39(path, f));
+              mkdirSync23(dirOf2(join40(path, f)), { recursive: true });
+              copyFileSync2(src, join40(path, f));
             }
             const setup = repoP.config.hooks.setup;
             return setup ? runScript(setup, { cwd: path, shell: shellP, onLine: (l) => {
@@ -22253,12 +22494,12 @@ ${res.url}
 `);
           }
         }
-        if (existsSync36(join39(dir, ".git")) && basename12(dir) === SAMPLE_REPO) rmSync16(dir, { recursive: true, force: true });
+        if (existsSync36(join40(dir, ".git")) && basename12(dir) === SAMPLE_REPO) rmSync16(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"));
+      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`);
       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`);
@@ -22266,8 +22507,8 @@ ${res.url}
       }
       if (fresh) {
         mkdirSync23(dir, { recursive: true });
-        writeFileSync24(join39(dir, "README.md"), SAMPLE_README);
-        writeFileSync24(join39(dir, ".crew.yaml"), SAMPLE_CREW_YAML);
+        writeFileSync24(join40(dir, "README.md"), SAMPLE_README);
+        writeFileSync24(join40(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()}`);
@@ -22707,7 +22948,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 = existsSync36(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"
@@ -22734,7 +22975,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\`
 `
           );
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tablation/crew",
-  "version": "0.87.1",
+  "version": "0.88.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",