svamp-cli 0.2.188 → 0.2.190

package/dist/commands-2vgPBzxG.mjs

@@ -1,255 +0,0 @@
-import * as path from 'path';
-
-function getFlag(args, flag) {
-  const idx = args.indexOf(flag);
-  return idx !== -1 && idx + 1 < args.length ? args[idx + 1] : void 0;
-}
-function getAllFlags(args, flag) {
-  const values = [];
-  for (let i = 0; i < args.length; i++) {
-    if (args[i] === flag && i + 1 < args.length) {
-      values.push(args[i + 1]);
-      i++;
-    }
-  }
-  return values;
-}
-function hasFlag(args, ...flags) {
-  return flags.some((f) => args.includes(f));
-}
-function positionalArgs(args) {
-  const result = [];
-  for (let i = 0; i < args.length; i++) {
-    if (args[i].startsWith("--")) {
-      if (i + 1 < args.length && !args[i + 1].startsWith("--")) i++;
-      continue;
-    }
-    result.push(args[i]);
-  }
-  return result;
-}
-function parsePorts(args) {
-  const portStrs = getAllFlags(args, "--port");
-  if (portStrs.length === 0) return [];
-  const ports = [];
-  for (const s of portStrs) {
-    const p = parseInt(s, 10);
-    if (isNaN(p) || p < 1 || p > 65535) {
-      console.error(`Error: invalid port '${s}' \u2014 must be 1-65535`);
-      process.exit(1);
-    }
-    ports.push(p);
-  }
-  return ports;
-}
-async function serviceExpose(args) {
-  const positional = positionalArgs(args);
-  const name = positional[0];
-  const ports = parsePorts(args);
-  const group = getFlag(args, "--group");
-  const groupKey = getFlag(args, "--group-key");
-  const healthCheck = getFlag(args, "--health-check");
-  const healthPath = getFlag(args, "--health-path");
-  const healthInterval = getFlag(args, "--health-interval");
-  const foreground = hasFlag(args, "--foreground");
-  if (!name || ports.length === 0) {
-    console.error("Usage: svamp service expose <name> --port <port> [--port <port2>] [options]");
-    console.error("       --foreground    run frpc in this shell (legacy, dies with shell)");
-    process.exit(1);
-  }
-  if (foreground) {
-    const { runFrpcTunnel } = await import('./frpc-CDj2C0fs.mjs');
-    await runFrpcTunnel(name, ports, void 0, {
-      group,
-      groupKey,
-      healthCheckType: healthCheck,
-      healthCheckPath: healthPath,
-      healthCheckInterval: healthInterval ? parseInt(healthInterval, 10) : void 0
-    });
-    return;
-  }
-  const { connectAndGetMachine } = await import('./commands-CkxVt5V0.mjs');
-  const { server, machine } = await connectAndGetMachine();
-  try {
-    const status = await machine.tunnelStart({
-      name,
-      ports,
-      group: group || void 0,
-      groupKey: groupKey || void 0,
-      healthCheckType: healthCheck,
-      healthCheckPath: healthPath || void 0,
-      healthCheckInterval: healthInterval ? parseInt(healthInterval, 10) : void 0
-    });
-    console.log(`Tunnel '${name}' registered with daemon \u2014 supervised + restart-persistent.`);
-    if (status && status.urls) {
-      for (const [port, url] of Object.entries(status.urls)) {
-        console.log(`  port ${port}: ${url}`);
-      }
-    }
-    console.log(`To stop: svamp service delete ${name}  (or: svamp tunnel stop ${name})`);
-  } catch (err) {
-    if (/already running/i.test(err?.message || "")) {
-      console.error(`Tunnel '${name}' is already running. Use \`svamp service delete ${name}\` first.`);
-    } else {
-      console.error(`Failed to register tunnel: ${err?.message || err}`);
-      console.error(`Falling back to foreground mode? Add --foreground to run in this shell.`);
-    }
-    process.exit(1);
-  } finally {
-    await server.disconnect();
-  }
-}
-async function serviceServe(args) {
-  const positional = positionalArgs(args);
-  const name = positional[0];
-  const directory = positional[1] || ".";
-  const noListing = hasFlag(args, "--no-listing");
-  if (!name) {
-    console.error("Usage: svamp service serve <name> [directory] [--no-listing]");
-    console.error("  directory defaults to current directory");
-    process.exit(1);
-  }
-  try {
-    const resolvedDir = path.resolve(directory);
-    console.log(`Serving ${resolvedDir}`);
-    const caddyPort = 18080;
-    const { CaddyManager } = await import('./caddy-CuTbE3NY.mjs');
-    const caddy = new CaddyManager({ listenPort: caddyPort });
-    await caddy.addMount(name, resolvedDir, !noListing);
-    await caddy.start();
-    const cleanup = () => {
-      caddy.stop();
-      process.exit(0);
-    };
-    process.on("SIGINT", cleanup);
-    process.on("SIGTERM", cleanup);
-    const { runFrpcTunnel } = await import('./frpc-CDj2C0fs.mjs');
-    await runFrpcTunnel(name, [caddyPort]);
-  } catch (err) {
-    console.error(`Error serving directory: ${err.message}`);
-    process.exit(1);
-  }
-}
-async function serviceList(_args) {
-  try {
-    const { connectAndGetMachine } = await import('./commands-CkxVt5V0.mjs');
-    const { server, machine } = await connectAndGetMachine();
-    try {
-      const tunnels = await machine.tunnelList({});
-      if (!tunnels || tunnels.length === 0) {
-        console.log("No daemon-managed tunnels configured.");
-        console.log("Standalone foreground tunnels (from `svamp service expose`) are not listed here \u2014 check `pgrep -af frpc`.");
-        return;
-      }
-      const label = (t) => typeof t.state === "string" ? t.state : t.connected ? "connected" : "disconnected";
-      const icon = { connected: "\u2713", reconnecting: "\u21BB", failed: "\u2717", disconnected: "\u2717" };
-      console.log("Daemon-managed tunnels:");
-      for (const t of tunnels) {
-        const st = label(t);
-        const ports = Array.isArray(t.ports) && t.ports.length ? ` :${t.ports.join(",")}` : "";
-        let extra = "";
-        if (st !== "connected") {
-          const bits = [];
-          if (t.restartAttempts) bits.push(`${t.restartAttempts} restarts`);
-          if (t.probe && !t.probe.ok && t.probe.stalenessMs) bits.push(`probe stale ${Math.round(t.probe.stalenessMs / 1e3)}s`);
-          if (bits.length) extra = ` (${bits.join(", ")})`;
-        }
-        console.log(`  ${icon[st] ?? "\u2022"} ${t.name}${ports} \u2014 ${st}${extra}`);
-      }
-    } finally {
-      await server.disconnect();
-    }
-  } catch (err) {
-    console.error(`Error listing tunnels: ${err.message}`);
-    process.exit(1);
-  }
-}
-async function serviceDelete(args) {
-  const positional = positionalArgs(args);
-  const name = positional[0];
-  if (!name) {
-    console.error("Usage: svamp service delete <name>");
-    process.exit(1);
-  }
-  try {
-    const { connectAndGetMachine } = await import('./commands-CkxVt5V0.mjs');
-    const { server, machine } = await connectAndGetMachine();
-    try {
-      await machine.tunnelStop({ name });
-      console.log(`Stopped tunnel '${name}'.`);
-    } catch (err) {
-      if (/not found/i.test(err.message)) {
-        console.error(`No daemon-managed tunnel named '${name}'.`);
-        console.error("If this was a standalone foreground tunnel (from `svamp service expose`), the daemon can't stop it.");
-        console.error(`Kill the frpc process directly: pkill -f 'frpc.*${name}'`);
-      } else {
-        console.error(`Error stopping tunnel: ${err.message}`);
-      }
-      process.exit(1);
-    } finally {
-      await server.disconnect();
-    }
-  } catch (err) {
-    console.error(`Error: ${err.message}`);
-    process.exit(1);
-  }
-}
-async function handleServiceCommand() {
-  const args = process.argv.slice(2);
-  const serviceArgs = args.slice(1);
-  const sub = serviceArgs[0];
-  if (!sub || sub === "--help" || sub === "-h") {
-    printServiceHelp();
-    return;
-  }
-  const commandArgs = serviceArgs.slice(1);
-  if (sub === "expose" || sub === "tunnel") {
-    await serviceExpose(commandArgs);
-  } else if (sub === "serve") {
-    await serviceServe(commandArgs);
-  } else if (sub === "list" || sub === "ls") {
-    await serviceList();
-  } else if (sub === "delete" || sub === "rm") {
-    await serviceDelete(commandArgs);
-  } else {
-    console.error(`Unknown service command: ${sub}`);
-    printServiceHelp();
-    process.exit(1);
-  }
-}
-function printServiceHelp() {
-  console.log(`
-svamp service \u2014 Expose local services via frpc tunnels
-
-Usage:
-  svamp service expose <name> --port <port> [options]    Expose local ports via tunnel
-  svamp service serve <name> [directory] [--no-listing]   Serve static files via tunnel
-  svamp service list                                      List active tunnels (daemon)
-  svamp service delete <name>                             Stop a tunnel (daemon)
-
-Options:
-  --port <port>              Port to expose (repeatable for multi-port)
-  --group <name>             Service group \u2014 multiple machines share the same URL
-  --group-key <secret>       Shared key for the service group
-  --health-check <tcp|http>  Enable health checks on local backend
-  --health-path <path>       HTTP health check path (e.g., /health)
-  --health-interval <sec>    Health check interval (default: 10s)
-
-Service Groups:
-  Run the same command on different machines with --group to create a
-  load-balanced service. frps round-robins traffic across all group members.
-
-  Machine A:  svamp service expose my-api --port 8000 --group my-api --group-key s3cret
-  Machine B:  svamp service expose my-api --port 8000 --group my-api --group-key s3cret
-  \u2192 Both serve at the same URL, frps load-balances between them
-
-Examples:
-  svamp service expose my-api --port 8000
-  svamp service expose my-api --port 8000 --health-check http --health-path /health
-  svamp service expose my-api --port 8000 --port 3000
-  svamp service expose my-api --port 8000 --group my-api --group-key s3cret
-  svamp service serve my-site ./dist
-`.trim());
-}
-
-export { handleServiceCommand, serviceDelete, serviceExpose, serviceList, serviceServe };

package/dist/commands-B7oQTg-f.mjs

@@ -1,375 +0,0 @@
-import { execSync } from 'node:child_process';
-import { m as resolveProjectRoot, t as searchIssues, q as listIssues, o as addComment, u as updateIssue, n as getIssue, w as summarize, p as addIssue } from './run-DZLwKdGH.mjs';
-import 'os';
-import 'fs/promises';
-import 'fs';
-import 'path';
-import 'url';
-import 'child_process';
-import 'crypto';
-import 'node:crypto';
-import 'node:fs';
-import 'util';
-import 'node:path';
-import 'node:events';
-import 'node:os';
-import '@agentclientprotocol/sdk';
-import '@modelcontextprotocol/sdk/client/index.js';
-import '@modelcontextprotocol/sdk/client/stdio.js';
-import '@modelcontextprotocol/sdk/types.js';
-import 'zod';
-import 'node:fs/promises';
-import 'node:util';
-
-const STATUS_GLYPH = {
-  ready: "\u25C9",
-  in_progress: "\u25D0",
-  archived: "\u25A3"
-};
-function flag(args, name) {
-  const i = args.indexOf(name);
-  return i !== -1 && i + 1 < args.length ? args[i + 1] : void 0;
-}
-function has(args, name) {
-  return args.includes(name);
-}
-function positional(args) {
-  const out = [];
-  for (let i = 0; i < args.length; i++) {
-    const a = args[i];
-    if (a.startsWith("--")) {
-      if (a !== "--json" && a !== "--ready") i++;
-      continue;
-    }
-    out.push(a);
-  }
-  return out;
-}
-function fmtIssue(i) {
-  const tri = i.triaged === false ? " \u25B3triage" : "";
-  const disp = i.disposition === "crew" ? " {crew}" : "";
-  const label = i.labels.length ? ` [${i.labels.join(", ")}]` : "";
-  const v = i.verify ? ` (verify:${i.verify.type})` : "";
-  const br = i.branch ? ` {branch:${i.branch}}` : "";
-  return `#${i.id} ${STATUS_GLYPH[i.status]} ${i.title}${tri}${disp}${label}${v}${br}`;
-}
-function buildVerify(args) {
-  const cmd = flag(args, "--verify-cmd");
-  if (cmd) return { type: "command", text: cmd };
-  const agent = flag(args, "--verify");
-  if (agent) return { type: "agent", text: agent };
-  if (has(args, "--manual")) return { type: "manual" };
-  return null;
-}
-async function issueCommand(args) {
-  const sub = args[0];
-  const rest = args.slice(1);
-  const root = resolveProjectRoot();
-  const json = has(args, "--json");
-  const sessionId = process.env.SVAMP_SESSION_ID || null;
-  const out = (text) => console.log(text);
-  const ok = (obj, text) => {
-    if (json) console.log(JSON.stringify(obj));
-    else out(text);
-  };
-  switch (sub) {
-    case "add": {
-      let title = positional(rest)[0];
-      let body = flag(rest, "--body");
-      let original;
-      if (!title) {
-        const src = (body || "").trim();
-        if (!src) {
-          console.error('usage: svamp issue add "<title or text>" [--ready] [--label x] [--verify-cmd "npm test"] [--scope project|session] [--body "\u2026"]');
-          process.exit(1);
-        }
-        const nl = src.indexOf("\n");
-        title = (nl === -1 ? src : src.slice(0, nl)).trim().slice(0, 200);
-        original = src;
-        body = void 0;
-      }
-      const labels = rest.filter((a, idx) => rest[idx - 1] === "--label");
-      const owner = flag(rest, "--session") || sessionId;
-      const scope = flag(rest, "--scope") || (owner ? "session" : "project");
-      const issue = addIssue(root, {
-        title,
-        // New issues are actionable immediately (#0049) — there is no backlog to promote from.
-        // `--ready` is accepted for back-compat but is now the only behavior.
-        status: "ready",
-        scope,
-        labels,
-        verify: buildVerify(rest),
-        session: scope === "session" ? owner : null,
-        original,
-        body
-      });
-      ok(issue, `Created #${issue.id} (${issue.status}): ${issue.title}`);
-      break;
-    }
-    case "list":
-    case "ls": {
-      const status = flag(rest, "--status");
-      const opts = { includeArchived: status === "all" || status === "archived" || has(rest, "--all") };
-      if (status && status !== "all") opts.status = status;
-      if (flag(rest, "--label")) opts.label = flag(rest, "--label");
-      if (flag(rest, "--scope")) opts.scope = flag(rest, "--scope");
-      const mineList = flag(rest, "--session") || (has(rest, "--mine") ? sessionId : null);
-      let items = listIssues(root, opts);
-      if (mineList) items = items.filter((i) => i.scope === "project" || i.session === mineList);
-      if (json) {
-        console.log(JSON.stringify(items.map(({ body, original, ...r }) => r)));
-        break;
-      }
-      if (!items.length) {
-        out("No issues.");
-        break;
-      }
-      for (const i of items) out(fmtIssue(i));
-      const s = summarize(listIssues(root, { includeArchived: true }));
-      out(`
-${s.ready} ready \xB7 ${s.in_progress} in-progress \xB7 ${s.archived} archived`);
-      break;
-    }
-    case "show": {
-      const id = positional(rest)[0];
-      const issue = id ? getIssue(root, id) : null;
-      if (!issue) {
-        console.error(`Issue not found: ${id}`);
-        process.exit(1);
-      }
-      if (json) {
-        console.log(JSON.stringify(issue));
-        break;
-      }
-      out(fmtIssue(issue));
-      out(`status: ${issue.status} \xB7 scope: ${issue.scope} \xB7 created: ${issue.created}${issue.closed ? ` \xB7 closed: ${issue.closed}` : ""}`);
-      if (issue.original) out(`
-Original request:
-${issue.original}`);
-      if (issue.body) out(`
-Description:
-${issue.body}`);
-      break;
-    }
-    case "work": {
-      const id = positional(rest)[0];
-      if (!id) {
-        console.error("usage: svamp issue work <id> [--branch <name>] [--session <id>]");
-        process.exit(1);
-      }
-      const branch = flag(rest, "--branch");
-      const worker = flag(rest, "--session") || sessionId;
-      const cur = getIssue(root, id);
-      const claim = worker && cur && cur.scope === "project" && !cur.session ? { session: worker } : {};
-      const updated = updateIssue(root, id, { status: "in_progress", ...branch ? { branch } : {}, ...claim });
-      if (!updated) {
-        console.error(`Issue not found: ${id}`);
-        process.exit(1);
-      }
-      ok(updated, `#${updated.id} \u2192 in_progress${updated.branch ? ` on ${updated.branch}` : ""}${claim.session ? ` (claimed by ${claim.session})` : ""}`);
-      break;
-    }
-    case "ready":
-    case "start":
-    case "close":
-    case "done":
-    case "reopen":
-    case "archive":
-    case "backlog": {
-      const id = positional(rest)[0];
-      if (!id) {
-        console.error(`usage: svamp issue ${sub} <id>`);
-        process.exit(1);
-      }
-      const map = {
-        ready: "ready",
-        start: "in_progress",
-        close: "archived",
-        done: "archived",
-        reopen: "ready",
-        archive: "archived",
-        backlog: "ready"
-      };
-      if (sub === "close" || sub === "done") {
-        const current = getIssue(root, id);
-        const vc = current?.verify?.type === "command" ? current.verify.text?.trim() : "";
-        if (vc) {
-          if (has(rest, "--force")) {
-            console.error(`\u26A0 #${id}: closing WITHOUT running verify-cmd (--force): \`${vc}\``);
-          } else {
-            try {
-              execSync(vc, { cwd: root, stdio: "pipe", timeout: 6e5, maxBuffer: 64 * 1024 * 1024 });
-            } catch (e) {
-              const tail = (String(e?.stdout || "") + String(e?.stderr || "")).split("\n").slice(-15).join("\n").trim();
-              console.error(`Refusing to close #${id}: its verify-cmd failed \u2014 the fix is not verified.
-  $ ${vc}
-${tail}
-(Fix the issue, or pass --force to override.)`);
-              process.exit(1);
-            }
-          }
-        }
-      }
-      const updated = updateIssue(root, id, { status: map[sub] });
-      if (!updated) {
-        console.error(`Issue not found: ${id}`);
-        process.exit(1);
-      }
-      ok(updated, `#${updated.id} \u2192 ${updated.status}: ${updated.title}`);
-      break;
-    }
-    case "edit": {
-      const id = positional(rest)[0];
-      if (!id) {
-        console.error("usage: svamp issue edit <id> [--title \u2026] [--label x] [--verify-cmd \u2026] [--scope \u2026] [--body \u2026]");
-        process.exit(1);
-      }
-      const patch = {};
-      if (flag(rest, "--title")) patch.title = flag(rest, "--title");
-      const labels = rest.filter((a, idx) => rest[idx - 1] === "--label");
-      if (labels.length) patch.labels = labels;
-      const v = buildVerify(rest);
-      if (v || has(rest, "--no-verify")) patch.verify = has(rest, "--no-verify") ? null : v;
-      if (flag(rest, "--scope")) patch.scope = flag(rest, "--scope");
-      if (has(rest, "--unclaim")) patch.session = null;
-      else if (flag(rest, "--session")) patch.session = flag(rest, "--session");
-      if (flag(rest, "--body")) patch.body = flag(rest, "--body");
-      if (flag(rest, "--status")) patch.status = flag(rest, "--status");
-      if (has(rest, "--crew")) patch.disposition = "crew";
-      else if (has(rest, "--inline")) patch.disposition = "inline";
-      if (has(rest, "--triaged")) patch.triaged = true;
-      const updated = updateIssue(root, id, patch);
-      if (!updated) {
-        console.error(`Issue not found: ${id}`);
-        process.exit(1);
-      }
-      ok(updated, `Updated #${updated.id}: ${updated.title}`);
-      break;
-    }
-    case "triage": {
-      const id = positional(rest)[0];
-      if (!id) {
-        console.error('usage: svamp issue triage <id> [--title "\u2026"] [--label x \u2026] [--crew|--inline] [--verify-cmd "cmd" | --verify "criterion" | --manual] [--body "rewritten"] [--backlog]');
-        process.exit(1);
-      }
-      const patch = { triaged: true };
-      if (flag(rest, "--title")) patch.title = flag(rest, "--title");
-      const tlabels = rest.filter((a, idx) => rest[idx - 1] === "--label");
-      if (tlabels.length) patch.labels = tlabels;
-      if (has(rest, "--crew")) patch.disposition = "crew";
-      else if (has(rest, "--inline")) patch.disposition = "inline";
-      const tv = buildVerify(rest);
-      if (tv) patch.verify = tv;
-      if (flag(rest, "--body")) patch.body = flag(rest, "--body");
-      patch.status = "ready";
-      const updated = updateIssue(root, id, patch);
-      if (!updated) {
-        console.error(`Issue not found: ${id}`);
-        process.exit(1);
-      }
-      ok(updated, `Triaged #${updated.id}: ${updated.title} [${updated.disposition}${updated.verify ? ", verify:" + updated.verify.type : ""}] \u2192 ${updated.status}`);
-      break;
-    }
-    case "comment": {
-      const id = positional(rest)[0];
-      const text = positional(rest)[1];
-      if (!id || !text) {
-        console.error('usage: svamp issue comment <id> "<text>"');
-        process.exit(1);
-      }
-      const updated = addComment(root, id, text);
-      if (!updated) {
-        console.error(`Issue not found: ${id}`);
-        process.exit(1);
-      }
-      ok(updated, `Commented on #${updated.id}`);
-      break;
-    }
-    case "pending": {
-      const mine = flag(rest, "--session") || (has(rest, "--mine") ? sessionId : null);
-      const inScope = (i) => !mine || i.scope === "project" || i.session === mine;
-      const pending = listIssues(root).filter(inScope).filter((i) => i.status === "ready" || i.status === "in_progress");
-      if (json) console.log(JSON.stringify(pending));
-      else out(pending.length ? `${pending.length} pending: ${pending.map((i) => "#" + i.id).join(" ")}` : "No pending issues.");
-      process.exit(pending.length ? 1 : 0);
-      break;
-    }
-    case "search": {
-      const q = positional(rest)[0] || "";
-      const items = searchIssues(root, q);
-      if (json) {
-        console.log(JSON.stringify(items.map(({ body, original, ...r }) => r)));
-        break;
-      }
-      if (!items.length) {
-        out(`No issues match "${q}".`);
-        break;
-      }
-      for (const i of items) out(fmtIssue(i));
-      break;
-    }
-    case "guide": {
-      const topic = positional(rest)[0];
-      if (topic === "triage") {
-        out([
-          "TRIAGE an issue \u2014 turn a raw user post into a fully-specified, actionable issue:",
-          "  1. Read it:  svamp issue show <id>   (the user's original text is preserved separately)",
-          "  2. Triage it:",
-          '       svamp issue triage <id> --title "<concise title>" [--label <tag>]... \\',
-          `         [--inline | --crew] [--verify-cmd "<pass/fail cmd>" | --verify "<how we know it's done>"] \\`,
-          '         [--body "<expanded description>"]',
-          "     - inline = work it in this session; crew = isolated worktree child.",
-          "     - verify-cmd = a real pass/fail command (oracle); --verify = an agent/human criterion.",
-          "  3. SPLIT if the post bundles several independent asks: `svamp issue add` a new issue for",
-          "     each extra piece (carry over the relevant context) and triage each; keep the original as the primary.",
-          "  4. If it implies running on a schedule/event, also `svamp workflow add` it.",
-          "  Then reply with a one-line summary."
-        ].join("\n"));
-      } else if (topic === "work") {
-        out([
-          "WORK the ready issues in THIS session's backlog (your own + shared project items; leave other",
-          "sessions' private items alone). List: svamp issue list --status ready --session <id>.",
-          "  TRIAGE FIRST any \u25B3triage (untriaged) issue \u2014 see `svamp issue guide triage`.",
-          "  For each issue:",
-          "   1. On pickup: svamp issue work <id>   (status \u2192 in_progress; live status reflects the work).",
-          '   2. As you go: leave substantive `svamp issue comment <id> "\u2026"` notes \u2014 decisions, takeaways, blockers.',
-          "   3. Before closing: VERIFY with evidence \u2014 run its verify-cmd; for verify:agent cite the files/commit",
-          "      that resolve it in a summary comment. Post the summary, THEN `svamp issue close <id>`.",
-          "      NEVER close an issue that isn't genuinely resolved.",
-          "  CONVERGE TO MAIN: if an issue used an isolated branch/worktree, merge it back to `main` (and remove",
-          "  the worktree) BEFORE closing \u2014 never leave unmerged branches.",
-          "  Keep going until `svamp issue pending --session <id>` is empty."
-        ].join("\n"));
-      } else {
-        out("usage: svamp issue guide <triage|work>");
-      }
-      break;
-    }
-    case "help":
-    case void 0:
-    case "--help":
-    case "-h":
-      out([
-        "svamp issue \u2014 the session backlog (folder of .svamp/issues/<id>.md)",
-        "",
-        '  add ["<title>"] [--ready] [--label x] [--verify-cmd "cmd"] [--scope project|session] [--body "\u2026"]',
-        "          # title optional \u2014 if omitted, the first line of --body becomes the title",
-        "  list [--status ready|in_progress|archived|all] [--label x] [--scope \u2026] [--session <id>] [--json]",
-        "  show <id> [--json]",
-        "  ready <id> | close <id> (\u2192 archived) | reopen <id> | archive <id>   # lifecycle: ready \u2192 in_progress \u2192 archived",
-        "  work <id> [--branch <name>]   # mark in-progress (optionally on a branch; merge to main before close)",
-        "  triage <id> [--title \u2026] [--label x] [--inline|--crew] [--verify-cmd \u2026|--verify \u2026] [--body \u2026]",
-        "  edit <id> [--title \u2026] [--label x] [--verify-cmd \u2026] [--no-verify] [--status \u2026] [--body \u2026]",
-        '  comment <id> "<text>"   # append a follow-up to the issue',
-        "  pending [--session <id>]   # exit 0 if no actionable (ready/in_progress) issues \u2014 the loop oracle",
-        '  search "<query>" [--json]',
-        "  guide <triage|work>   # the triage / work-loop procedure (so triggers can stay short)"
-      ].join("\n"));
-      break;
-    default:
-      console.error(`Unknown: svamp issue ${sub}. Try: svamp issue help`);
-      process.exit(1);
-  }
-}
-
-export { issueCommand };