@tablation/crew 0.88.0 → 0.90.0

package/dist/cli.js

@@ -139,6 +139,89 @@ async function periscopesForStatus(stateDir, probe = portListening) {
   }));
 }
 
+// src/shell-init.ts
+var SHELLS = ["zsh", "bash", "fish"];
+function shellFor(requested, envShell) {
+  const pick = (requested ?? envShell ?? "").split("/").pop() ?? "";
+  return SHELLS.includes(pick) ? pick : "zsh";
+}
+var POSIX = String.raw`# crew shell-init: "periscope up" lands in the worktree, "periscope down" returns to the checkout.
+periscope() {
+  case "${"$"}{1-}" in
+    up|start)
+      shift
+      local _out _wt _url _noopen=
+      _out=$(mktemp) || return 1
+      case " $* " in *" --no-open "*) _noopen=1 ;; esac
+      command crew periscope up --json "$@" 2>&1 >"$_out" \
+        | command sed -e 's/^{.*"message":"\([^"]*\)".*}$/  \1/' >&2
+      if command grep -q '"event":"done"' "$_out"; then
+        _wt=$(command sed -n 's/.*"worktree":"\([^"]*\)".*/\1/p' "$_out" | command tail -n 1)
+        _url=$(command sed -n 's/.*"url":"\([^"]*\)".*/\1/p' "$_out" | command tail -n 1)
+      fi
+      command rm -f "$_out"
+      [ -n "$_wt" ] && [ -d "$_wt" ] || return 1
+      builtin cd "$_wt" || return 1
+      printf '%s\n%s\n' "$_url" "$_wt"
+      if [ -z "$_noopen" ] && [ -n "$_url" ]; then
+        if command -v open >/dev/null 2>&1; then command open "$_url"
+        elif command -v xdg-open >/dev/null 2>&1; then command xdg-open "$_url" >/dev/null 2>&1; fi
+      fi
+      ;;
+    down|end)
+      local _common _checkout=
+      _common=$(command git rev-parse --path-format=absolute --git-common-dir 2>/dev/null) && _checkout=${"$"}{_common%/.git}
+      command crew periscope "$@" || return $?
+      if [ -n "$_checkout" ] && [ -d "$_checkout" ]; then builtin cd "$_checkout" || return 1; fi
+      ;;
+    *)
+      command crew periscope "$@"
+      ;;
+  esac
+}
+`;
+var FISH = String.raw`# crew shell-init: "periscope up" lands in the worktree, "periscope down" returns to the checkout.
+function periscope
+    switch "$argv[1]"
+        case up start
+            set -e argv[1]
+            set -l out (mktemp); or return 1
+            command crew periscope up --json $argv 2>&1 >$out \
+                | command sed -e 's/^{.*"message":"\([^"]*\)".*}$/  \1/' >&2
+            set -l wt
+            set -l url
+            if command grep -q '"event":"done"' $out
+                set wt (command sed -n 's/.*"worktree":"\([^"]*\)".*/\1/p' $out | command tail -n 1)
+                set url (command sed -n 's/.*"url":"\([^"]*\)".*/\1/p' $out | command tail -n 1)
+            end
+            command rm -f $out
+            test -n "$wt" -a -d "$wt"; or return 1
+            builtin cd $wt; or return 1
+            printf '%s\n%s\n' $url $wt
+            if not contains -- --no-open $argv; and test -n "$url"
+                if command -sq open
+                    command open $url
+                else if command -sq xdg-open
+                    command xdg-open $url >/dev/null 2>&1
+                end
+            end
+        case down end
+            set -l checkout
+            set -l common (command git rev-parse --path-format=absolute --git-common-dir 2>/dev/null)
+            and set checkout (string replace -r '/\.git$' '' -- $common)
+            command crew periscope $argv; or return $status
+            if test -n "$checkout" -a -d "$checkout"
+                builtin cd $checkout
+            end
+        case '*'
+            command crew periscope $argv
+    end
+end
+`;
+function shellInitScript(shell) {
+  return shell === "fish" ? FISH : POSIX;
+}
+
 // src/config.ts
 import { readFileSync as readFileSync9, existsSync as existsSync8 } from "fs";
 import { resolve, dirname as dirname3, isAbsolute, join as join10, basename as basename3 } from "path";
@@ -2778,12 +2861,25 @@ function parseOneRoute(c, where, file, base, stateDir, raw, missing, crewHome, t
   return result;
 }
 function routeForDir(cfg, dir) {
-  const target = resolve(dir);
-  const isInside = (base) => {
+  return locateDir(cfg, dir)?.route;
+}
+function locateDir(cfg, dir, commonDirOf) {
+  const within = (base, target2) => {
     const b = resolve(base);
-    return target === b || target.startsWith(`${b}/`);
+    return target2 === b || target2.startsWith(`${b}/`);
   };
-  return cfg.routes.find((r) => reposOf(r).some((repo) => isInside(repo.dir)));
+  const find = (target2) => {
+    for (const route of cfg.routes) {
+      const repo = reposOf(route).find((x) => within(x.dir, target2));
+      if (repo) return { route, repo, checkout: resolve(repo.dir) };
+    }
+    return void 0;
+  };
+  const target = resolve(dir);
+  const direct = find(target);
+  if (direct) return direct;
+  const common = commonDirOf?.(target);
+  return common ? find(dirname3(resolve(target, common))) : void 0;
 }
 function findRoute(cfg, route) {
   if (!route) {
@@ -9803,7 +9899,7 @@ function doctorSelftestLines(stored, toolchains) {
 }
 
 // src/cli.ts
-import { resolve as resolve5, dirname as dirname20, join as join40, basename as basename12 } from "path";
+import { resolve as resolve5, dirname as dirname20, join as join41, basename as basename12 } from "path";
 import { fileURLToPath } from "url";
 import { hostname as hostname2, homedir as homedir10 } from "os";
 import { spawnSync as spawnSync7 } from "child_process";
@@ -9843,6 +9939,8 @@ var VALUE_FLAGS = /* @__PURE__ */ new Set([
   "write",
   "topic",
   "assignee",
+  "issue",
+  "shell",
   "resume"
 ]);
 function positionalArgs(argv2) {
@@ -16532,24 +16630,55 @@ function planEventsSweep(stateDir, retentionDays, now = Date.now()) {
 }
 
 // src/cli.ts
-import { realpathSync as realpathSync3, readFileSync as readFileSync32, existsSync as existsSync36, mkdirSync as mkdirSync23, writeFileSync as writeFileSync24, rmSync as rmSync16, unlinkSync as unlinkSync5, copyFileSync as copyFileSync2, renameSync as renameSync3, statSync as statSync11, readdirSync as readdirSync17 } from "fs";
+import { realpathSync as realpathSync3, readFileSync as readFileSync33, existsSync as existsSync37, mkdirSync as mkdirSync24, writeFileSync as writeFileSync25, rmSync as rmSync17, unlinkSync as unlinkSync5, copyFileSync as copyFileSync2, renameSync as renameSync3, statSync as statSync11, readdirSync as readdirSync17 } from "fs";
 import { createInterface } from "readline/promises";
 
 // src/periscope-cmd.ts
+import { existsSync as existsSync32, mkdirSync as mkdirSync19, readFileSync as readFileSync28, rmSync as rmSync15, writeFileSync as writeFileSync21 } from "fs";
+import { join as join35 } from "path";
 var PeriscopeError = class extends Error {
 };
+var priorDir = (stateDir) => join35(stateDir, "periscope-priors");
+var priorPath = (stateDir, ticketRecordId) => join35(priorDir(stateDir), `${ticketRecordId}.json`);
+function removePeriscopePrior(stateDir, ticketRecordId) {
+  rmSync15(priorPath(stateDir, ticketRecordId), { force: true });
+}
+function writePeriscopePrior(stateDir, ticketRecordId, prior) {
+  try {
+    mkdirSync19(priorDir(stateDir), { recursive: true });
+    writeFileSync21(priorPath(stateDir, ticketRecordId), JSON.stringify(prior));
+  } catch {
+  }
+}
+function readPeriscopePrior(stateDir, ticketRecordId) {
+  try {
+    const p = priorPath(stateDir, ticketRecordId);
+    return existsSync32(p) ? JSON.parse(readFileSync28(p, "utf8")) : void 0;
+  } catch {
+    return void 0;
+  }
+}
 var DEFAULT_MAX_PERISCOPES2 = 3;
 var DEFAULT_PERISCOPE_IDLE_MINUTES2 = 120;
 function parsePeriscopeUpArgs(positional2, flags) {
+  const usage2 = "usage: crew periscope up [[route] REPO] [--topic TEXT | --issue NNN] [--isolate] [--host HOST] [--assignee CREW_ROW_ID] [--no-open] [--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 > 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],
+    ...rest.length > 0 ? { repo: rest[rest.length - 1] } : {},
     ...topic ? { topic } : {},
+    ...issue ? { issue } : {},
     isolate: flags.isolate,
     ...flags.host ? { host: flags.host } : {},
     ...flags.assignee ? { assignee: flags.assignee } : {},
@@ -16574,7 +16703,37 @@ 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 defaultTopic(repo, now) {
+  return `${repo}, ${now.toISOString().slice(0, 10)}`;
+}
+function openerFor(platform2) {
+  return platform2 === "darwin" ? "open" : platform2 === "linux" ? "xdg-open" : void 0;
+}
+function upOutput(res, terminal) {
+  return terminal ? `${res.ticket}
+${res.url}
+${res.worktree}
+` : `${res.ticket}
+${res.worktree}
+${res.url}
+`;
+}
+function shouldOpen(f) {
+  if (f.noOpen || f.json) return false;
+  return f.open || f.terminal;
+}
 function progressComment(url, handoff) {
   return [
     `Periscope is up: ${url}`,
@@ -16595,17 +16754,35 @@ 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() ?? defaultTopic(args.repo, d.now());
+    const unsafe = d.baseProblem();
+    if (unsafe) throw new PeriscopeError(`DO NOT CUT A WORKTREE FROM THIS BASE \u2014 ${unsafe}`);
+    draft = await d.fileDraft(`Periscope: ${topic}`);
+    d.say("filed", `filed draft ${draft.tag}`, { ticket: draft.tag, ticketRecordId: draft.id });
+  }
   let wt;
   const abandon = async (why) => {
     if (wt) await d.teardown(wt.path, wt.branch).catch(() => {
     });
-    await d.closeDraft(draft.id, `Periscope abandoned: ${why.split("\n")[0]}`).catch(() => {
+    if (prior) await d.existing.restore(prior.id, prior.assignee).catch(() => {
+    });
+    else await d.closeDraft(draft.id, `Periscope abandoned: ${why.split("\n")[0]}`).catch(() => {
     });
     throw new PeriscopeError(why);
   };
@@ -16682,25 +16859,36 @@ ${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]";
+  const usage2 = "usage: crew periscope down [[route] NNN] --keep|--discard [--allow-empty] [--json]";
   const rest = positional2.slice(2);
-  if (rest.length === 0 || rest.length > 2) throw new PeriscopeError(usage2);
+  if (rest.length > 2) throw new PeriscopeError(usage2);
   if (flags.keep === flags.discard) throw new PeriscopeError(`pass exactly one of --keep or --discard
 ${usage2}`);
-  const m = /^(?:[A-Za-z]+-)?(\d+)$/.exec(rest[rest.length - 1]);
-  if (!m) throw new PeriscopeError(`"${rest[rest.length - 1]}" is not a ticket number
+  const m = rest.length === 0 ? null : /^(?:[A-Za-z]+-)?(\d+)$/.exec(rest[rest.length - 1]);
+  if (rest.length > 0 && !m) throw new PeriscopeError(`"${rest[rest.length - 1]}" is not a ticket number
 ${usage2}`);
   return {
     ...rest.length === 2 ? { route: rest[0] } : {},
-    number: m[1],
+    ...m ? { number: m[1] } : {},
     mode: flags.keep ? "keep" : "discard",
     allowEmpty: flags.allowEmpty,
     json: flags.json
   };
 }
+function rowForCwd(rows, cwd) {
+  return rows.find((r) => r.state === "live" && r.worktree !== "" && (cwd === r.worktree || cwd.startsWith(`${r.worktree}/`)));
+}
 var PROTOTYPE_HEADING = "## Prototype";
 function prototypeSection(files) {
   const added = files.reduce((n, f) => n + f.added, 0);
@@ -16731,6 +16919,21 @@ async function runPeriscopeDown(d, args) {
     d.say("unchanged", `${done.ticket} is already ${done.state}; nothing to do`);
     return { ticket: done.ticket, mode: args.mode, outcome: "unchanged", state: done.state };
   }
+  const existing = (await d.readTicket(row.ticketRecordId)).isDraft === false;
+  const prior = existing ? d.priorHold?.(row.ticketRecordId) : void 0;
+  if (existing && args.mode === "discard") {
+    const killed2 = await d.stopServer(row.worktree, row.number);
+    d.say("server", killed2 ? `stopped ${killed2} process(es)` : "no server was listening");
+    const onRemote = d.remoteHasBranch?.(row.worktree, row.branch) ?? true;
+    d.removeWorktree(row.worktree, row.branch, !onRemote);
+    d.say("worktree", onRemote ? `removed ${row.worktree}; ${row.branch} stays, it is on the remote` : `removed ${row.worktree} and branch ${row.branch}`);
+    await d.updateTicket(row.ticketRecordId, { status: "released", fillProjectAndRepo: false });
+    d.say("ticket", `${row.ticket} hold cleared; status unchanged${prior ? ` (assignee before the periscope: ${prior.assignee ?? "none"})` : ""}`);
+    await d.setRowState(row.id, "discarded");
+    d.say("row", "row is discarded");
+    forgetLocal(d, row.ticketRecordId);
+    return { ticket: row.ticket, mode: "discard", outcome: "done", state: "discarded", existing: true, ...prior ? { status: prior.status } : {} };
+  }
   if (args.mode === "discard") {
     const killed2 = await d.stopServer(row.worktree, row.number);
     d.say("server", killed2 ? `stopped ${killed2} process(es)` : "no server was listening");
@@ -16762,12 +16965,17 @@ async function runPeriscopeDown(d, args) {
   const description = t.description.includes(PROTOTYPE_HEADING) ? t.description : `${t.description.trimEnd()}
 
 ${section}`;
-  await d.updateTicket(row.ticketRecordId, {
-    description,
-    fillProjectAndRepo: !t.hasProject || !t.hasRepo,
-    status: "new"
-  });
-  d.say("ticket", `${row.ticket} is new and unassigned with a Prototype section`);
+  if (existing) {
+    await d.updateTicket(row.ticketRecordId, { description, fillProjectAndRepo: false, status: "released" });
+    d.say("ticket", `${row.ticket} has a Prototype section and no assignee; status unchanged${prior ? ` (assignee before the periscope: ${prior.assignee ?? "none"})` : ""}`);
+  } else {
+    await d.updateTicket(row.ticketRecordId, {
+      description,
+      fillProjectAndRepo: !t.hasProject || !t.hasRepo,
+      status: "new"
+    });
+    d.say("ticket", `${row.ticket} is new and unassigned with a Prototype section`);
+  }
   await d.postPushed(row.ticketRecordId, pushed.sha, pushed.remote, row.branch);
   const killed = await d.stopServer(row.worktree, row.number);
   d.say("server", killed ? `stopped ${killed} process(es)` : "no server was listening");
@@ -16776,7 +16984,7 @@ ${section}`;
   await d.setRowState(row.id, "kept");
   d.say("row", "row is kept");
   forgetLocal(d, row.ticketRecordId);
-  return { ticket: row.ticket, mode: "keep", outcome: "done", state: "kept", sha: pushed.sha };
+  return { ticket: row.ticket, mode: "keep", outcome: "done", state: "kept", sha: pushed.sha, ...existing ? { existing: true, ...prior ? { status: prior.status } : {} } : {} };
 }
 function periscopeListEntries(rows, now, isListening) {
   return rows.filter((r) => r.state === "live").map((r) => {
@@ -16838,7 +17046,7 @@ ${tail2(preview.output)}`);
 // src/periscope-idle.ts
 import { execFileSync as execFileSync6 } from "child_process";
 import { statSync as statSync9 } from "fs";
-import { join as join35 } from "path";
+import { join as join36 } from "path";
 var MAX_SCANNED_FILES = 2e4;
 function newestWorktreeMtime(root) {
   let listing;
@@ -16858,7 +17066,7 @@ function newestWorktreeMtime(root) {
     if (!rel) continue;
     if (++scanned > MAX_SCANNED_FILES) break;
     try {
-      const m = statSync9(join35(root, rel)).mtimeMs;
+      const m = statSync9(join36(root, rel)).mtimeMs;
       if (newest === null || m > newest) newest = m;
     } catch {
     }
@@ -16934,18 +17142,18 @@ import { dirname as dirOf2, resolve as resolvePath } from "path";
 
 // src/ssh-keys.ts
 import { execFileSync as execFileSync7 } from "child_process";
-import { existsSync as existsSync32, mkdirSync as mkdirSync19, readFileSync as readFileSync28, chmodSync } from "fs";
-import { dirname as dirname19, join as join36 } from "path";
+import { existsSync as existsSync33, mkdirSync as mkdirSync20, readFileSync as readFileSync29, chmodSync } from "fs";
+import { dirname as dirname19, join as join37 } from "path";
 var SshKeyError = class extends Error {
 };
 function shipSshKeyPathFor(stateDir) {
-  return join36(stateDir, "ssh", "id_ed25519");
+  return join37(stateDir, "ssh", "id_ed25519");
 }
 function ensureShipSshKeypair(stateDir) {
   const privateKeyPath = shipSshKeyPathFor(stateDir);
   const publicKeyPath = `${privateKeyPath}.pub`;
-  if (!existsSync32(privateKeyPath)) {
-    mkdirSync19(dirname19(privateKeyPath), { recursive: true });
+  if (!existsSync33(privateKeyPath)) {
+    mkdirSync20(dirname19(privateKeyPath), { recursive: true });
     try {
       execFileSync7("ssh-keygen", [
         "-t",
@@ -16965,10 +17173,10 @@ function ensureShipSshKeypair(stateDir) {
     }
     chmodSync(privateKeyPath, 384);
   }
-  if (!existsSync32(publicKeyPath)) {
+  if (!existsSync33(publicKeyPath)) {
     throw new SshKeyError(`${privateKeyPath} exists but ${publicKeyPath} does not \u2014 regenerate or restore it`);
   }
-  const publicKey = readFileSync28(publicKeyPath, "utf8").trim();
+  const publicKey = readFileSync29(publicKeyPath, "utf8").trim();
   return { privateKeyPath, publicKeyPath, publicKey };
 }
 function sshKeygenAvailable() {
@@ -17185,9 +17393,9 @@ function syncAllPassengerCheckouts(cfg) {
 
 // src/tunnel.ts
 import { spawn as spawn5 } from "child_process";
-import { existsSync as existsSync33, mkdirSync as mkdirSync20, readFileSync as readFileSync29, writeFileSync as writeFileSync21, unlinkSync as unlinkSync3, readdirSync as readdirSync14 } from "fs";
+import { existsSync as existsSync34, mkdirSync as mkdirSync21, readFileSync as readFileSync30, writeFileSync as writeFileSync22, unlinkSync as unlinkSync3, readdirSync as readdirSync14 } from "fs";
 import { randomInt } from "crypto";
-import { join as join37 } from "path";
+import { join as join38 } from "path";
 var DEFAULT_SPAWN_OPTIONS = { stdio: "ignore", detached: true };
 var defaultSpawn = (cmd, args) => spawn5(cmd, args, DEFAULT_SPAWN_OPTIONS);
 var SLUG_ALPHABET = "abcdefghijklmnopqrstuvwxyz0123456789";
@@ -17254,21 +17462,21 @@ function startTunnel(opts) {
   };
 }
 function tunnelStatePath(stateDir, workspaceId) {
-  return join37(stateDir, "passengers", `${workspaceId}.json`);
+  return join38(stateDir, "passengers", `${workspaceId}.json`);
 }
 function readPersistedTunnel(stateDir, workspaceId) {
   const path = tunnelStatePath(stateDir, workspaceId);
-  if (!existsSync33(path)) return void 0;
+  if (!existsSync34(path)) return void 0;
   try {
-    return JSON.parse(readFileSync29(path, "utf8"));
+    return JSON.parse(readFileSync30(path, "utf8"));
   } catch {
     return void 0;
   }
 }
 function writePersistedTunnel(stateDir, state) {
   const path = tunnelStatePath(stateDir, state.workspaceId);
-  mkdirSync20(join37(stateDir, "passengers"), { recursive: true });
-  writeFileSync21(path, `${JSON.stringify(state, null, 2)}
+  mkdirSync21(join38(stateDir, "passengers"), { recursive: true });
+  writeFileSync22(path, `${JSON.stringify(state, null, 2)}
 `);
 }
 function updatePersistedTunnel(stateDir, workspaceId, patch2) {
@@ -17365,8 +17573,8 @@ function syncPassengerTunnels(plans, relayHost, relayPort, privateKeyPath, state
   }
 }
 function readAllPersistedWorkspaceIds(stateDir) {
-  const dir = join37(stateDir, "passengers");
-  if (!existsSync33(dir)) return [];
+  const dir = join38(stateDir, "passengers");
+  if (!existsSync34(dir)) return [];
   return readdirSync14(dir).filter((f) => f.endsWith(".json") && !f.endsWith("-sync.json")).map((f) => f.slice(0, -".json".length));
 }
 
@@ -17487,8 +17695,8 @@ async function unregisterEndpoint(workspaceId, info, d) {
 import { createServer as createHttpServer } from "http";
 import { spawn as spawn6 } from "child_process";
 import { randomBytes } from "crypto";
-import { existsSync as existsSync34, mkdirSync as mkdirSync21, readFileSync as readFileSync30, writeFileSync as writeFileSync22, unlinkSync as unlinkSync4, readdirSync as readdirSync15 } from "fs";
-import { join as join38 } from "path";
+import { existsSync as existsSync35, mkdirSync as mkdirSync22, readFileSync as readFileSync31, writeFileSync as writeFileSync23, unlinkSync as unlinkSync4, readdirSync as readdirSync15 } from "fs";
+import { join as join39 } from "path";
 
 // src/secret-compare.ts
 import { timingSafeEqual } from "crypto";
@@ -17577,21 +17785,21 @@ var defaultSpawn2 = (cmd, args, env) => {
   return child;
 };
 function syncDaemonStatePath(stateDir, workspaceId) {
-  return join38(stateDir, "passengers", `${workspaceId}-sync.json`);
+  return join39(stateDir, "passengers", `${workspaceId}-sync.json`);
 }
 function readPersistedSyncDaemon(stateDir, workspaceId) {
   const path = syncDaemonStatePath(stateDir, workspaceId);
-  if (!existsSync34(path)) return void 0;
+  if (!existsSync35(path)) return void 0;
   try {
-    return JSON.parse(readFileSync30(path, "utf8"));
+    return JSON.parse(readFileSync31(path, "utf8"));
   } catch {
     return void 0;
   }
 }
 function writePersistedSyncDaemon(stateDir, state) {
   const path = syncDaemonStatePath(stateDir, state.workspaceId);
-  mkdirSync21(join38(stateDir, "passengers"), { recursive: true });
-  writeFileSync22(path, `${JSON.stringify(state, null, 2)}
+  mkdirSync22(join39(stateDir, "passengers"), { recursive: true });
+  writeFileSync23(path, `${JSON.stringify(state, null, 2)}
 `);
 }
 function removePersistedSyncDaemon(stateDir, workspaceId) {
@@ -17611,8 +17819,8 @@ function waitForExit(pid, alive, timeoutMs = 5e3) {
   }
 }
 function readAllPersistedSyncWorkspaceIds(stateDir) {
-  const dir = join38(stateDir, "passengers");
-  if (!existsSync34(dir)) return [];
+  const dir = join39(stateDir, "passengers");
+  if (!existsSync35(dir)) return [];
   const suffix = "-sync.json";
   return readdirSync15(dir).filter((f) => f.endsWith(suffix)).map((f) => f.slice(0, -suffix.length));
 }
@@ -17700,8 +17908,8 @@ function describeCause(err) {
 }
 
 // src/daemon.ts
-import { existsSync as existsSync35, mkdirSync as mkdirSync22, readFileSync as readFileSync31, readdirSync as readdirSync16, rmSync as rmSync15, statSync as statSync10, writeFileSync as writeFileSync23 } from "fs";
-import { join as join39 } from "path";
+import { existsSync as existsSync36, mkdirSync as mkdirSync23, readFileSync as readFileSync32, readdirSync as readdirSync16, rmSync as rmSync16, statSync as statSync10, writeFileSync as writeFileSync24 } from "fs";
+import { join as join40 } from "path";
 import { randomBytes as randomBytes2 } from "crypto";
 var DEFAULT_FLOOR_MS = 5e3;
 var DEFAULT_CEILING_MS = INTERVAL_SECONDS * 1e3;
@@ -17772,7 +17980,7 @@ function latestMtime(path) {
   if (!stat.isDirectory()) return 0;
   let latest = stat.mtimeMs;
   for (const entry of readdirSync16(path, { withFileTypes: true })) {
-    latest = Math.max(latest, latestMtime(join39(path, entry.name)));
+    latest = Math.max(latest, latestMtime(join40(path, entry.name)));
   }
   return latest;
 }
@@ -17781,23 +17989,23 @@ function computeTreeSignature(paths) {
 }
 function makeStaleChecker(paths, opts = {}) {
   const initial = computeTreeSignature(paths);
-  return () => computeTreeSignature(paths) !== initial || opts.reloadSentinel !== void 0 && existsSync35(opts.reloadSentinel);
+  return () => computeTreeSignature(paths) !== initial || opts.reloadSentinel !== void 0 && existsSync36(opts.reloadSentinel);
 }
 function reloadSentinelFor(stateDir) {
-  return join39(stateDir, "reload-requested");
+  return join40(stateDir, "reload-requested");
 }
 function daemonStampFor(stateDir) {
-  return join39(stateDir, "daemon.started");
+  return join40(stateDir, "daemon.started");
 }
 function noteDaemonStarted(stateDir, now = Date.now()) {
-  mkdirSync22(stateDir, { recursive: true });
-  rmSync15(reloadSentinelFor(stateDir), { force: true });
-  writeFileSync23(daemonStampFor(stateDir), `${JSON.stringify({ pid: process.pid, startedAt: now })}
+  mkdirSync23(stateDir, { recursive: true });
+  rmSync16(reloadSentinelFor(stateDir), { force: true });
+  writeFileSync24(daemonStampFor(stateDir), `${JSON.stringify({ pid: process.pid, startedAt: now })}
 `);
 }
 function readDaemonStarted(stateDir) {
   try {
-    const v = JSON.parse(readFileSync31(daemonStampFor(stateDir), "utf8")).startedAt;
+    const v = JSON.parse(readFileSync32(daemonStampFor(stateDir), "utf8")).startedAt;
     return typeof v === "number" ? v : null;
   } catch {
     return null;
@@ -18419,12 +18627,13 @@ 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] [--no-open] [--open] [--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]
+  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)
   crew periscope list [route] [--json]   the live periscopes on this ship, their idle minutes and whether each server is listening
+  crew shell-init [--shell zsh|bash|fish]   print the periscope shell function (install: eval "$(crew shell-init)")
   crew worktree [route] NNN      cut (or refresh) this run's worktree for a ticket from the remote; prints its path
   crew unassign [route] NNN      hand back a session's ticket \u2014 clears assignee, next cycle picks it up
   crew sync [route]              fast-forward the checkout and its worktrees from the remote
@@ -18530,6 +18739,7 @@ var KNOWN_COMMANDS = /* @__PURE__ */ new Set([
   "run",
   "sample-ticket",
   "selftest",
+  "shell-init",
   "ship",
   "skills",
   "status",
@@ -18541,6 +18751,16 @@ var KNOWN_COMMANDS = /* @__PURE__ */ new Set([
   "worktree"
 ]);
 if (!KNOWN_COMMANDS.has(command)) usage(`unknown command "${command}"`);
+if (command === "shell-init") {
+  const asked = value("shell");
+  if (asked !== void 0 && !SHELLS.includes(asked)) {
+    process.stderr.write(`crew shell-init: unknown shell "${asked}" (have: ${SHELLS.join(", ")})
+`);
+    process.exit(2);
+  }
+  process.stdout.write(shellInitScript(shellFor(asked, process.env.SHELL)));
+  process.exit(0);
+}
 function runReposCheck(dir, ship) {
   const report = checkRepoSpec(dir, { ship, strict: flag("strict") });
   if (flag("json")) {
@@ -18699,7 +18919,7 @@ if (command === "passenger-sync-daemon") {
     } else {
       const toleratesNoRoutes = command === "repos" || command === "ship" || command === "disconnect" && flag("reset") || command === "connect" && flag("sign-out");
       const configless = command === "connect" && flag("sign-out") || command === "disconnect" && flag("reset");
-      if (configless && !existsSync36(findConfigFile(CREW_HOME))) {
+      if (configless && !existsSync37(findConfigFile(CREW_HOME))) {
         cfg = loadConfig(CREW_HOME, firstRunConfigPath(), { text: "ship: {}\n", allowNoRoutes: true });
       } else {
         cfg = loadConfig(CREW_HOME, void 0, toleratesNoRoutes ? { allowNoRoutes: true } : {});
@@ -18937,8 +19157,8 @@ if (command === "passenger-sync-daemon") {
     }
     if (host === "linux" && hasSystemd) {
       const label = labelFor(CREW_HOME, "run");
-      const staleTimer = join40(homedir10(), ".config", "systemd", "user", `${label}.timer`);
-      if (existsSync36(staleTimer)) {
+      const staleTimer = join41(homedir10(), ".config", "systemd", "user", `${label}.timer`);
+      if (existsSync37(staleTimer)) {
         process.stdout.write(
           `removing stale run timer from before the persistent-service cutover: ${staleTimer}${dryRun ? " (dry run)" : ""}
 `
@@ -18965,7 +19185,7 @@ if (command === "passenger-sync-daemon") {
     const tracker = new Tracker(c, cfg.ship);
     problems.push(...validateContract(tracker.contract).map((p) => `contract: ${p}`));
     for (const r of await resolvedRepos(c)) {
-      if (!existsSync36(r.dir)) problems.push(`repo ${r.name}: ${r.dir} is missing on disk`);
+      if (!existsSync37(r.dir)) problems.push(`repo ${r.name}: ${r.dir} is missing on disk`);
       if (!satisfies(host, r.config.platform)) problems.push(`repo ${r.name}: requires ${r.config.platform}, this host is ${host}`);
       readiness.push(...validateEffective(r.config).map((p) => `repo ${r.name}: ${p}`));
     }
@@ -18983,7 +19203,7 @@ if (command === "passenger-sync-daemon") {
   }
   async function doctorFix(o) {
     const routes = await Promise.all(routesInScope(cfg.routes, named).map((c) => gatherHealth({ route: c.route, enabled: c.enabled, hasRepos: reposOf(c).length > 0 }, () => routeProblems(c))));
-    const unitExists = (p) => existsSync36(p);
+    const unitExists = (p) => existsSync37(p);
     const crontab = o.host === "linux" ? spawnSync7("crontab", ["-l"], { encoding: "utf8" }).stdout ?? "" : "";
     const schedulerAbsent = o.host !== "windows" ? !schedulerInstalled(planInstall(cfg.ship, CREW_HOME, o.host, detectSystemd(), "run"), unitExists, crontab) : true;
     const plan = planFix({ routes, schedulerAbsent, host: o.host });
@@ -19000,7 +19220,7 @@ if (command === "passenger-sync-daemon") {
       for (const a of plan.actions) {
         if (a.kind === "enable") {
           if (prompter && !await prompter.confirm(`Route ${a.route} passes every check \u2014 set enabled: true in ${cfg.configFile}?`, false)) continue;
-          writeFileSync24(cfg.configFile, planEnable(readFileSync32(cfg.configFile, "utf8"), a.route));
+          writeFileSync25(cfg.configFile, planEnable(readFileSync33(cfg.configFile, "utf8"), a.route));
           enabledSound.add(a.route);
           changed2.push(`enabled route ${a.route} in ${cfg.configFile}`);
         } else {
@@ -20104,7 +20324,7 @@ ${cu.tail.trimEnd()}
         process.exit(1);
       }
       requireArmed("run the daemon loop");
-      const watchPaths = isCompiledBinary(import.meta.url) ? [process.execPath] : [join40(CREW_HOME, "src"), join40(CREW_HOME, "dist"), join40(CREW_HOME, "bin")];
+      const watchPaths = isCompiledBinary(import.meta.url) ? [process.execPath] : [join41(CREW_HOME, "src"), join41(CREW_HOME, "dist"), join41(CREW_HOME, "bin")];
       const configPaths = daemonConfigPaths(cfg);
       watchPaths.push(...configPaths);
       noteDaemonStarted(cfg.ship.stateDir);
@@ -20333,10 +20553,10 @@ ${cu.tail.trimEnd()}
 `);
       if (!dryRun) {
         const resolvedPath = resolvedPathFor(cfg.ship.stateDir, target.route);
-        const raw = existsSync36(resolvedPath) ? JSON.parse(readFileSync32(resolvedPath, "utf8")) : {};
+        const raw = existsSync37(resolvedPath) ? JSON.parse(readFileSync33(resolvedPath, "utf8")) : {};
         raw.agentSkills = result.agentSkills;
-        mkdirSync23(dirOf2(resolvedPath), { recursive: true });
-        writeFileSync24(resolvedPath, `${JSON.stringify(raw, null, 2)}
+        mkdirSync24(dirOf2(resolvedPath), { recursive: true });
+        writeFileSync25(resolvedPath, `${JSON.stringify(raw, null, 2)}
 `);
       }
       if (result.outcomes.some((o) => o.action === "diverged")) process.exitCode = 1;
@@ -20359,7 +20579,7 @@ ${cu.tail.trimEnd()}
         throw e;
       }
       const oldName = cfg.ship.name;
-      writeFileSync24(cfg.configFile, setShipNameInYaml(readFileSync32(cfg.configFile, "utf8"), newName));
+      writeFileSync25(cfg.configFile, setShipNameInYaml(readFileSync33(cfg.configFile, "utf8"), newName));
       cfg.ship.name = newName;
       let renameMachineId;
       try {
@@ -20406,7 +20626,7 @@ ${cu.tail.trimEnd()}
         process.exit(2);
       };
       if (sub !== "add" && sub !== "list" && sub !== "clone" && sub !== "hooks" && sub !== "check") usage2();
-      const configText = readFileSync32(cfg.configFile, "utf8");
+      const configText = readFileSync33(cfg.configFile, "utf8");
       if (sub === "check") {
         try {
           const routeArg = value("route") ?? positional[2];
@@ -20437,8 +20657,8 @@ ${cu.tail.trimEnd()}
         try {
           const a = parseHooksArgs(positional.slice(2), routeNamesOf(configText));
           const dir = repoDirOf(configText, dirname20(cfg.configFile), a.route, a.name);
-          if (!existsSync36(dir)) throw new ReposError(`${dir} does not exist on disk`);
-          const files = { exists: (r) => existsSync36(resolvePath(dir, r)), list: (r) => {
+          if (!existsSync37(dir)) throw new ReposError(`${dir} does not exist on disk`);
+          const files = { exists: (r) => existsSync37(resolvePath(dir, r)), list: (r) => {
             try {
               return readdirSync17(resolvePath(dir, r));
             } catch {
@@ -20446,7 +20666,7 @@ ${cu.tail.trimEnd()}
             }
           }, read: (r) => {
             try {
-              return readFileSync32(resolvePath(dir, r), "utf8");
+              return readFileSync33(resolvePath(dir, r), "utf8");
             } catch {
               return void 0;
             }
@@ -20488,19 +20708,19 @@ ${cu.tail.trimEnd()}
           let cleared;
           if (clear2) {
             const plan = clearRouteHooks(configText, a.route, a.name);
-            if (plan.removed.length > 0) writeFileSync24(cfg.configFile, plan.text);
+            if (plan.removed.length > 0) writeFileSync25(cfg.configFile, plan.text);
             cleared = { file: cfg.configFile, removed: plan.removed };
           }
           if (write && suggestion.source === null && recipeIds.length === 0 && hookSpecs.length === 0) throw new ReposError(`nothing to write: ${suggestion.notes[0]}`);
           if (write === "route") {
             const plan = planRouteHooks(configText, a.route, a.name, picked.hooks, { replace: flag("replace") });
-            writeFileSync24(cfg.configFile, plan.text);
+            writeFileSync25(cfg.configFile, plan.text);
             written = { target: "route", file: cfg.configFile, hooks: plan.written, kept: plan.kept, replaced: plan.replaced };
           } else if (write === "repo") {
             const have = existingRepoConfig(files);
             if (have) throw new ReposError(`${resolvePath(dir, have)} already exists; not overwriting it`);
             const file = resolvePath(dir, ".crew.yaml");
-            writeFileSync24(file, starterRepoConfig(picked.hooks, picked.release), { flag: "wx" });
+            writeFileSync25(file, starterRepoConfig(picked.hooks, picked.release), { flag: "wx" });
             written = { target: "repo", file, hooks: Object.keys(picked.hooks), kept: [], replaced: [] };
           }
           if (flag("json")) {
@@ -20556,7 +20776,7 @@ ${cu.tail.trimEnd()}
       if (sub === "list" && !routeName) usage2();
       if (sub === "add") {
         try {
-          const a = parseAddArgs(positional.slice(2), routeNamesOf(configText), (p) => existsSync36(resolvePath(p.replace(/^~(?=\/|$)/, homedir10()))));
+          const a = parseAddArgs(positional.slice(2), routeNamesOf(configText), (p) => existsSync37(resolvePath(p.replace(/^~(?=\/|$)/, homedir10()))));
           routeName = a.route;
           addPath = a.path;
           addName = a.name;
@@ -20585,16 +20805,16 @@ ${cu.tail.trimEnd()}
       }
       const resolvedFile = resolvedPathFor(cfg.ship.stateDir, routeName);
       let resolvedRemotes;
-      if (existsSync36(resolvedFile)) {
+      if (existsSync37(resolvedFile)) {
         try {
-          resolvedRemotes = JSON.parse(readFileSync32(resolvedFile, "utf8"));
+          resolvedRemotes = JSON.parse(readFileSync33(resolvedFile, "utf8"));
         } catch {
         }
       }
       const originOf = (dir) => gitOk(dir, ["remote", "get-url", "origin"]) ?? void 0;
       const text = configText;
       const base = dirname20(cfg.configFile);
-      const isCheckout = (d) => existsSync36(`${d}/.git`);
+      const isCheckout = (d) => existsSync37(`${d}/.git`);
       try {
         if (sub === "list") {
           if (flag("json")) {
@@ -20604,11 +20824,11 @@ ${cu.tail.trimEnd()}
               base,
               resolved: resolvedRemotes,
               originOf,
-              exists: (d) => existsSync36(d),
+              exists: (d) => existsSync37(d),
               isCheckout,
               repoHasHooks: (d) => REPO_CONFIG_FILENAMES.some((f) => {
                 try {
-                  return Object.keys(parseRepoConfig(readFileSync32(resolvePath(d, f), "utf8"), f).hooks).length > 0;
+                  return Object.keys(parseRepoConfig(readFileSync33(resolvePath(d, f), "utf8"), f).hooks).length > 0;
                 } catch {
                   return false;
                 }
@@ -20625,7 +20845,7 @@ ${cu.tail.trimEnd()}
           for (const r of repos) {
             const origin2 = originOf(r.dir);
             const row = matchRepoName(origin2, resolvedRemotes);
-            const note = !existsSync36(r.dir) ? "missing on disk" : row ? `Repos row: ${row}` : `no Repos row matches ${normalizeRemote(origin2) ?? "this checkout (no origin remote)"}`;
+            const note = !existsSync37(r.dir) ? "missing on disk" : row ? `Repos row: ${row}` : `no Repos row matches ${normalizeRemote(origin2) ?? "this checkout (no origin remote)"}`;
             process.stdout.write(`${r.name}	${r.dir}	${note}
 `);
           }
@@ -20637,9 +20857,9 @@ ${cu.tail.trimEnd()}
 ` : `${human}
 `);
           const plan2 = planRepoClone({ text, base, route: routeName, name: addName, resolved: resolvedRemotes, dir: value("dir"), isCheckout });
-          if (existsSync36(plan2.target) && (existsSync36(`${plan2.target}/.git`) || readdirSync17(plan2.target).length > 0)) {
+          if (existsSync37(plan2.target) && (existsSync37(`${plan2.target}/.git`) || readdirSync17(plan2.target).length > 0)) {
             throw new ReposError(
-              existsSync36(`${plan2.target}/.git`) ? `${plan2.target} is already a checkout \u2014 attach it with \`crew repos add ${routeName} ${plan2.name} ${plan2.target}\`` : `${plan2.target} exists and is not empty \u2014 pass --dir to clone somewhere else`
+              existsSync37(`${plan2.target}/.git`) ? `${plan2.target} is already a checkout \u2014 attach it with \`crew repos add ${routeName} ${plan2.name} ${plan2.target}\`` : `${plan2.target} exists and is not empty \u2014 pass --dir to clone somewhere else`
             );
           }
           if (dryRun) {
@@ -20657,14 +20877,14 @@ ${cu.tail.trimEnd()}
             throw new ReposError(`${e.message}${authHint}
   crew.yaml was not changed`);
           }
-          writeFileSync24(cfg.configFile, plan2.text);
+          writeFileSync25(cfg.configFile, plan2.text);
           if (plan2.droppedDir) process.stderr.write(`crew repos: dropped dir: ${plan2.droppedDir} from route ${routeName} \u2014 it is not a checkout (the clone base); checkouts now live under repos:
 `);
           say("attached", { route: routeName, name: plan2.name, dir: plan2.target, mode: plan2.mode }, `cloned and attached ${plan2.target} to ${routeName} as ${plan2.mode === "dir" ? "dir" : `repos.${plan2.name}`} in ${cfg.configFile}`);
           break;
         }
         const target = resolvePath(addPath.replace(/^~(?=\/|$)/, homedir10()));
-        const top = existsSync36(target) ? gitOk(target, ["rev-parse", "--show-toplevel"]) : null;
+        const top = existsSync37(target) ? gitOk(target, ["rev-parse", "--show-toplevel"]) : null;
         if (!top) throw new ReposError(`${target} is not a git checkout`);
         const origin = originOf(top);
         const plan = planRepoAdd({
@@ -20716,15 +20936,15 @@ ${cu.tail.trimEnd()}
           const created = await rowTracker.createRepoRow(rowPayload);
           process.stdout.write(`created Repos row ${String(rowPayload.name)} (${String(rowPayload.remote)}) ${created.id}
 `);
-          if (existsSync36(resolvedFile)) {
-            const raw = JSON.parse(readFileSync32(resolvedFile, "utf8"));
+          if (existsSync37(resolvedFile)) {
+            const raw = JSON.parse(readFileSync33(resolvedFile, "utf8"));
             raw.repoNames = { ...raw.repoNames, [created.id]: String(rowPayload.name) };
             raw.repoRemotes = { ...raw.repoRemotes, [created.id]: String(rowPayload.remote) };
-            writeFileSync24(resolvedFile, `${JSON.stringify(raw, null, 2)}
+            writeFileSync25(resolvedFile, `${JSON.stringify(raw, null, 2)}
 `);
           }
         }
-        writeFileSync24(cfg.configFile, plan.text);
+        writeFileSync25(cfg.configFile, plan.text);
         process.stdout.write(`added ${top} to ${routeName} as ${plan.mode === "dir" ? "dir" : `repos.${plan.name}`} in ${cfg.configFile}
 `);
       } catch (e) {
@@ -21091,7 +21311,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
           process.exit(2);
         }
         if (found.shipNameAdopted && !dryRun) {
-          writeFileSync24(cfg.configFile, setShipNameInYaml(readFileSync32(cfg.configFile, "utf8"), found.shipNameAdopted));
+          writeFileSync25(cfg.configFile, setShipNameInYaml(readFileSync33(cfg.configFile, "utf8"), found.shipNameAdopted));
           cfg.ship.name = found.shipNameAdopted;
         }
         if (found.shipRow) {
@@ -21134,10 +21354,10 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
           }
         }
         let previous;
-        const hadPreviousFile = existsSync36(resolvedPath);
+        const hadPreviousFile = existsSync37(resolvedPath);
         if (hadPreviousFile) {
           try {
-            previous = JSON.parse(readFileSync32(resolvedPath, "utf8"));
+            previous = JSON.parse(readFileSync33(resolvedPath, "utf8"));
           } catch {
           }
         }
@@ -21266,10 +21486,10 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
           process.stderr.write(`(dry run) would write resolved ids to ${resolvedPath}
 `);
         } else {
-          mkdirSync23(dirname20(resolvedPath), { recursive: true });
+          mkdirSync24(dirname20(resolvedPath), { recursive: true });
           if (hadPreviousFile) copyFileSync2(resolvedPath, `${resolvedPath}.bak`);
           const tmpPath = `${resolvedPath}.tmp${process.pid}`;
-          writeFileSync24(tmpPath, `${JSON.stringify(resolved, null, 2)}
+          writeFileSync25(tmpPath, `${JSON.stringify(resolved, null, 2)}
 `);
           renameSync3(tmpPath, resolvedPath);
           process.stderr.write(`Resolved ids written to ${resolvedPath}
@@ -21315,8 +21535,8 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
             process.stderr.write(`(dry run) would write the minted API key to ${apiKeyFile}
 `);
           } else {
-            mkdirSync23(dirname20(apiKeyFile), { recursive: true });
-            writeFileSync24(apiKeyFile, `${apiKeyVar}=${apiKey}
+            mkdirSync24(dirname20(apiKeyFile), { recursive: true });
+            writeFileSync25(apiKeyFile, `${apiKeyVar}=${apiKey}
 `, { mode: 384 });
             process.stderr.write(`API key written to ${apiKeyFile}
 `);
@@ -21866,8 +22086,8 @@ 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 down [route] NNN --keep|--discard [--allow-empty] [--json]\n");
+        process.stderr.write("crew periscope up [[route] REPO] [--topic TEXT|--issue NNN] [--isolate] [--host H] [--assignee ID] [--no-open] [--open] [--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);
       }
@@ -21912,11 +22132,27 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
 `);
             break;
           }
-          const a = downArgs;
+          const real = (p) => {
+            try {
+              return realpathSync3(p);
+            } catch {
+              return p;
+            }
+          };
+          const gathered = await Promise.all(routesP.map(async (rt) => ({ rt, rows: await gather(rt) })));
+          const number = downArgs.number ?? (() => {
+            const here = real(process.cwd());
+            for (const g of gathered) {
+              const hit = rowForCwd(g.rows.map((r) => ({ ...r, worktree: real(r.worktree) })), here);
+              if (hit) return hit.number;
+            }
+            throw new PeriscopeError("not inside a periscope worktree \u2014 name the ticket: crew periscope down NNN --keep|--discard");
+          })();
+          const a = { ...downArgs, number };
           const hits = [];
-          for (const rt of routesP) {
-            const rows = (await gather(rt)).filter((r) => r.number === a.number);
-            if (rows.length) hits.push({ rt, rows });
+          for (const g of gathered) {
+            const rows = g.rows.filter((r) => r.number === a.number);
+            if (rows.length) hits.push({ rt: g.rt, rows });
           }
           if (hits.length !== 1) {
             throw new PeriscopeError(hits.length === 0 ? `no periscope for ticket ${a.number} on this ship` : `ticket ${a.number} has periscopes on more than one route (${hits.map((h) => h.rt.route).join(", ")}) \u2014 name the route`);
@@ -21950,11 +22186,17 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
             },
             readTicket: async (id) => {
               const t = await trD.ticket(id);
-              return { description: String(t.description ?? ""), hasProject: !!t[cD.columns.slice], hasRepo: !!t[cD.columns.repo] };
+              return { description: String(t.description ?? ""), hasProject: !!t[cD.columns.slice], hasRepo: !!t[cD.columns.repo], isDraft: t.status === cD.statuses.draft };
             },
+            priorHold: (id) => readPeriscopePrior(cfg.ship.stateDir, id),
+            remoteHasBranch: (_wt, branch) => remoteBranchExists(repoD.dir, remote, branch),
             updateTicket: async (id, p) => {
               const patch2 = {};
-              if (p.status === "new") {
+              if (p.status === "released") {
+                patch2[cD.columns.assignee] = null;
+                if ((await trD.authorshipProbe()).issueHeld) patch2[cD.columns.heldBy] = null;
+                if (p.description !== void 0) patch2.description = p.description;
+              } else if (p.status === "new") {
                 patch2[cD.columns.status] = "new";
                 patch2[cD.columns.assignee] = null;
                 if (p.description !== void 0) patch2.description = p.description;
@@ -21979,13 +22221,17 @@ 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) {
             say("dry-run", `would end the periscope for ${rowsD[0].ticket} (${a.mode})`);
             break;
           }
+          process.chdir(repoD.dir);
           const res = await runPeriscopeDown(depsD, a);
           if (jsonP) process.stdout.write(`${JSON.stringify({ event: "done", ...res })}
 `);
@@ -22024,7 +22270,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
           const shellR = hit && resolveShell(hit.repo.config.shell ?? cfg.ship.shell);
           const resumed = await runPeriscopeResume({
             find: async () => hit && { row: hit.row, tag: hit.tag },
-            worktreeExists: (p) => existsSync36(p),
+            worktreeExists: (p) => existsSync37(p),
             caps: periscopeCaps(cfg.ship),
             runHook: async (name, cwd, env) => {
               const script = hit?.repo.config.hooks[name];
@@ -22043,7 +22289,19 @@ ${resumed.url}
 `);
           break;
         }
-        const a = parsePeriscopeUpArgs(positional, { topic: value("topic"), host: value("host"), assignee: value("assignee"), isolate: flag("isolate"), json: jsonP });
+        const parsedUp = parsePeriscopeUpArgs(positional, { topic: value("topic"), issue: value("issue"), host: value("host"), assignee: value("assignee"), isolate: flag("isolate"), json: jsonP });
+        let a;
+        if (parsedUp.repo !== void 0) a = { ...parsedUp, repo: parsedUp.repo };
+        else {
+          const here = locateDir(cfg, process.cwd(), (d) => gitOk(d, ["rev-parse", "--path-format=absolute", "--git-common-dir"]) ?? void 0);
+          if (!here) {
+            const where = cfg.routes.flatMap((r) => reposOf(r).map((x) => `  ${x.name}: ${x.dir}`));
+            throw new PeriscopeError(`run it from inside a configured checkout, or name the repository (crew periscope up REPO). Configured checkouts:
+${where.join("\n")}`);
+          }
+          a = { ...parsedUp, repo: here.repo.name, route: parsedUp.route ?? here.route.route };
+        }
+        const terminal = !!process.stdin.isTTY && !!process.stdout.isTTY && !jsonP;
         const candidatesP = a.route ? [findRoute(cfg, a.route)] : cfg.routes.filter((r) => r.enabled);
         const servedP = [];
         for (const cand of candidatesP) {
@@ -22075,10 +22333,11 @@ ${resumed.url}
             return h.unsafe ? h.detail : void 0;
           },
           askTopic: async () => {
-            if (!process.stdin.isTTY || jsonP) return void 0;
+            if (!terminal) return void 0;
             const rl = createInterface({ input: process.stdin, output: process.stderr });
             try {
-              return await rl.question("Periscope topic: ");
+              const answer = (await rl.question(`Periscope topic for ${a.repo} (blank for "${defaultTopic(a.repo, /* @__PURE__ */ new Date())}"): `)).trim();
+              return answer || void 0;
             } finally {
               rl.close();
             }
@@ -22105,10 +22364,10 @@ ${resumed.url}
           },
           prepare: async (path) => {
             for (const f of repoP.config.worktrees.copy) {
-              const src = join40(repoP.dir, f);
-              if (!existsSync36(src)) continue;
-              mkdirSync23(dirOf2(join40(path, f)), { recursive: true });
-              copyFileSync2(src, join40(path, f));
+              const src = join41(repoP.dir, f);
+              if (!existsSync37(src)) continue;
+              mkdirSync24(dirOf2(join41(path, f)), { recursive: true });
+              copyFileSync2(src, join41(path, f));
             }
             const setup = repoP.config.hooks.setup;
             return setup ? runScript(setup, { cwd: path, shell: shellP, onLine: (l) => {
@@ -22132,22 +22391,73 @@ ${resumed.url}
             const closed = cP.statuses.resolved.includes("closed_obsolete") ? "closed_obsolete" : cP.statuses.wontFix;
             await trackerP.updateTicket(ticketId, { [cP.columns.status]: closed, [cP.columns.resolutionNote]: note });
           },
+          existing: {
+            load: async (number) => {
+              const t = (await trackerP.ticketsByNumbers([number])).find((x) => String(x[cP.columns.key]).replace(/^\D+/, "").replace(/^0+(?=\d)/, "") === number);
+              if (!t) return void 0;
+              return {
+                id: t.id,
+                tag: t.issue_tag ?? t.issue_id,
+                issueId: t.issue_id,
+                prefix: t.project_issue_prefix,
+                status: t.status,
+                closed: cP.statuses.resolved.includes(t.status) || t.status === cP.statuses.wontFix,
+                repoId: t[cP.columns.repo] ?? null,
+                assignee: t[cP.columns.assignee] ?? null,
+                heldByShipId: t[cP.columns.heldBy] ?? null
+              };
+            },
+            repoId: repoP.id ?? null,
+            repoName: a.repo,
+            pairId,
+            shipId: (await trackerP.authorshipProbe()).shipId,
+            agentHolder: async (assigneeId) => {
+              const row = crewP.find((r) => r.id === assigneeId);
+              return row?.agent_id ? row.name ?? assigneeId : void 0;
+            },
+            hasLiveRun: (ticketRecordId) => liveRuns(cfg.ship.stateDir).some((r) => r.ticketRecordId === ticketRecordId),
+            hold: async (id) => {
+              const auth = await trackerP.authorshipProbe();
+              await trackerP.updateTicket(id, {
+                [cP.columns.assignee]: pairId,
+                ...auth.issueHeld && auth.shipId ? { [cP.columns.heldBy]: auth.shipId } : {}
+              });
+            },
+            restore: async (id, assignee) => {
+              const auth = await trackerP.authorshipProbe();
+              await trackerP.updateTicket(id, { [cP.columns.assignee]: assignee, ...auth.issueHeld ? { [cP.columns.heldBy]: null } : {} });
+            },
+            remember: (id, prior) => writePeriscopePrior(cfg.ship.stateDir, id, prior)
+          },
           now: () => /* @__PURE__ */ new Date(),
           host: a.host ?? "localhost",
           say
         };
         if (dryRun) {
           await periscopePreflight(deps, a.repo);
-          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)`);
+          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 ?? defaultTopic(a.repo, /* @__PURE__ */ new Date())}" 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;
         }
         const res = await runPeriscopeUp(deps, a);
         if (jsonP) process.stdout.write(`${JSON.stringify({ event: "done", ...res })}
 `);
-        else process.stdout.write(`${res.ticket}
-${res.worktree}
-${res.url}
+        else {
+          process.stdout.write(upOutput(res, terminal));
+          const opener = openerFor(process.platform);
+          if (opener && shouldOpen({ open: flag("open"), noOpen: flag("no-open"), json: jsonP, terminal })) {
+            const r = spawnSync7(opener, [res.url], { stdio: "ignore" });
+            if (r.error || r.status !== 0) process.stderr.write(`crew periscope: could not open ${res.url} with ${opener}
 `);
+          }
+        }
       } catch (e) {
         if (e instanceof PeriscopeError || e instanceof ConfigError) {
           process.stderr.write(`crew periscope: ${e.message}
@@ -22332,7 +22642,7 @@ ${res.url}
       };
       const droppedRoutes = [];
       try {
-        const rawCfg = parseYaml2(readFileSync32(cfg.configFile, "utf8"));
+        const rawCfg = parseYaml2(readFileSync33(cfg.configFile, "utf8"));
         for (const r of rawCfg?.routes ?? []) {
           if (typeof r?.route !== "string" || cfg.routes.some((x) => x.route === r.route)) continue;
           try {
@@ -22374,8 +22684,8 @@ ${res.url}
         process.stdout.write("crew reload: no daemon unit is running \u2014 nothing to reload (the next run reads crew.yaml fresh)\n");
         break;
       }
-      mkdirSync23(cfg.ship.stateDir, { recursive: true });
-      writeFileSync24(sentinel, `${(/* @__PURE__ */ new Date()).toISOString()}
+      mkdirSync24(cfg.ship.stateDir, { recursive: true });
+      writeFileSync25(sentinel, `${(/* @__PURE__ */ new Date()).toISOString()}
 `);
       process.stdout.write("crew reload: requested \u2014 the daemon finishes its in-flight pass, then relaunches with the new config\n");
       if (flag("now") && control?.stopCommand && control.startCommand) {
@@ -22426,7 +22736,7 @@ ${res.url}
     }
     case "log": {
       try {
-        const text = readFileSync32(cfg.ship.logFile, "utf8").split("\n");
+        const text = readFileSync33(cfg.ship.logFile, "utf8").split("\n");
         process.stdout.write(`${text.slice(-(Number(value("tail")) || 40)).join("\n")}
 `);
       } catch {
@@ -22449,7 +22759,7 @@ ${res.url}
       };
       if (!route.resolved) fail(`route ${route.route} is not connected \u2014 run \`crew connect\` first`);
       const tracker = new Tracker(route, cfg.ship);
-      const configText = readFileSync32(cfg.configFile, "utf8");
+      const configText = readFileSync33(cfg.configFile, "utf8");
       const cfgBase = dirname20(cfg.configFile);
       const configured = configuredRepos(configText, route.route, cfgBase);
       const dir = configured.find((r) => r.name === SAMPLE_REPO)?.dir ?? sampleDir(configured.map((r) => r.dir), route.reposBasePath, route.route.split("/")[0]);
@@ -22478,7 +22788,7 @@ ${res.url}
         }
         if (configured.some((r) => r.dir === dir)) {
           try {
-            writeFileSync24(cfg.configFile, planRepoRemove(configText, cfgBase, route.route, dir).text);
+            writeFileSync25(cfg.configFile, planRepoRemove(configText, cfgBase, route.route, dir).text);
           } catch (e) {
             if (e instanceof ReposError) fail(e.message);
             throw e;
@@ -22486,29 +22796,29 @@ ${res.url}
         }
         if (row) {
           await tracker.deleteRepoRow(row.id);
-          if (existsSync36(resolvedFile)) {
-            const raw = JSON.parse(readFileSync32(resolvedFile, "utf8"));
+          if (existsSync37(resolvedFile)) {
+            const raw = JSON.parse(readFileSync33(resolvedFile, "utf8"));
             if (raw.repoNames) delete raw.repoNames[row.id];
             if (raw.repoRemotes) delete raw.repoRemotes[row.id];
-            writeFileSync24(resolvedFile, `${JSON.stringify(raw, null, 2)}
+            writeFileSync25(resolvedFile, `${JSON.stringify(raw, null, 2)}
 `);
           }
         }
-        if (existsSync36(join40(dir, ".git")) && basename12(dir) === SAMPLE_REPO) rmSync16(dir, { recursive: true, force: true });
+        if (existsSync37(join41(dir, ".git")) && basename12(dir) === SAMPLE_REPO) rmSync17(dir, { recursive: true, force: true });
         say("removed", { dir, closed }, `removed the sample repo${closed.length ? `, closed ${closed.join(", ")}` : ""}`);
         break;
       }
       const projectId = route.resolved.areaId ?? resolveRepoProject(await tracker.projectRows(), value("project"));
-      const fresh = !existsSync36(join40(dir, ".git"));
-      if (existsSync36(dir) && fresh && readdirSync17(dir).length > 0) fail(`${dir} exists and is not a git checkout \u2014 move it aside`);
+      const fresh = !existsSync37(join41(dir, ".git"));
+      if (existsSync37(dir) && fresh && readdirSync17(dir).length > 0) fail(`${dir} exists and is not a git checkout \u2014 move it aside`);
       if (dryRun) {
         say("dry-run", { dir, newCheckout: fresh, repoRow: row?.id ?? null }, `would ${fresh ? "create" : "reuse"} ${dir}${row ? "" : ", create the Repos row"}, and file one ${tracker.contract.statuses.approved} ticket`);
         break;
       }
       if (fresh) {
-        mkdirSync23(dir, { recursive: true });
-        writeFileSync24(join40(dir, "README.md"), SAMPLE_README);
-        writeFileSync24(join40(dir, ".crew.yaml"), SAMPLE_CREW_YAML);
+        mkdirSync24(dir, { recursive: true });
+        writeFileSync25(join41(dir, "README.md"), SAMPLE_README);
+        writeFileSync25(join41(dir, ".crew.yaml"), SAMPLE_CREW_YAML);
         const g = (...a) => {
           const r = spawnSync7("git", a, { cwd: dir, encoding: "utf8" });
           if (r.status !== 0) fail(`git ${a[0]} failed in ${dir}: ${(r.stderr || r.stdout).trim()}`);
@@ -22526,17 +22836,17 @@ ${res.url}
           spec: { platform: "unix", releaseMode: "integrate", ciProvider: "none" }
         });
         repoId = (await tracker.createRepoRow(payload)).id;
-        if (existsSync36(resolvedFile)) {
-          const raw = JSON.parse(readFileSync32(resolvedFile, "utf8"));
+        if (existsSync37(resolvedFile)) {
+          const raw = JSON.parse(readFileSync33(resolvedFile, "utf8"));
           raw.repoNames = { ...raw.repoNames, [repoId]: SAMPLE_REPO };
           raw.repoRemotes = { ...raw.repoRemotes, [repoId]: SAMPLE_REMOTE };
-          writeFileSync24(resolvedFile, `${JSON.stringify(raw, null, 2)}
+          writeFileSync25(resolvedFile, `${JSON.stringify(raw, null, 2)}
 `);
         }
       }
       if (!configured.some((r) => r.dir === dir)) {
         try {
-          writeFileSync24(cfg.configFile, planRepoAdd({ text: configText, base: cfgBase, route: route.route, path: dir, name: SAMPLE_REPO }).text);
+          writeFileSync25(cfg.configFile, planRepoAdd({ text: configText, base: cfgBase, route: route.route, path: dir, name: SAMPLE_REPO }).text);
         } catch (e) {
           if (e instanceof ReposError) fail(e.message);
           throw e;
@@ -22871,7 +23181,7 @@ watermark:  ${state.watermark()}
           }
           for (const r of repos) {
             const remote = r.config.branch.remote;
-            if (existsSync36(r.dir)) {
+            if (existsSync37(r.dir)) {
               pushAuth.push({
                 route: c.route,
                 repo: r.name,
@@ -22948,7 +23258,7 @@ routes:            ${cfg.routes.map((c) => c.route).join(", ")}
       }
       try {
         const evFile = eventFileFor(cfg.ship.stateDir);
-        const evSize = existsSync36(evFile) ? statSync11(evFile).size : 0;
+        const evSize = existsSync37(evFile) ? statSync11(evFile).size : 0;
         process.stdout.write(
           evSize > cfg.ship.eventsRotateBytes * 4 ? `events log:        WARN ${evFile} is ${Math.round(evSize / 1048576)} MB (> 4x eventsRotateBytes); run \`crew reap\` to rotate it
 ` : "events log:        ok\n"
@@ -22959,7 +23269,7 @@ routes:            ${cfg.routes.map((c) => c.route).join(", ")}
         const unitPlan = planInstall(cfg.ship, CREW_HOME, host, detectSystemd(), "run");
         const abandons = unitAbandonsAgents(unitPlan, (p) => {
           try {
-            return readFileSync32(p, "utf8");
+            return readFileSync33(p, "utf8");
           } catch {
             return null;
           }

package/package.json

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