svamp-cli 0.2.225 → 0.2.227

package/dist/commands-YML8Rs_R.mjs

@@ -0,0 +1,643 @@
+import { existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { connectAndGetMachine, resolveSessionId, createWorktree, connectAndResolveSession } from './commands-CnlQyDxb.mjs';
+import { execSync } from 'node:child_process';
+import { u as updateIssue, q as addComment, t as addIssue, A as shortId } from './run-LEPH8aka.mjs';
+import 'node:os';
+import 'os';
+import 'fs/promises';
+import 'fs';
+import 'path';
+import 'url';
+import 'child_process';
+import 'crypto';
+import 'node:crypto';
+import 'util';
+import 'node:events';
+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';
+
+function git(cwd, args) {
+  return execSync(`git ${args}`, { cwd, stdio: "pipe", encoding: "utf-8" }).toString();
+}
+function worktreeStatus(worktreePath) {
+  const raw = git(worktreePath, "status --porcelain").trim();
+  if (!raw) return "";
+  return raw.split("\n").filter((line) => {
+    const p = line.slice(3);
+    return !p.startsWith(".svamp/") && !p.startsWith(".dev/");
+  }).join("\n").trim();
+}
+function aheadBehind(worktreePath, baseBranch) {
+  try {
+    const out = git(worktreePath, `rev-list --left-right --count ${baseBranch}...HEAD`).trim();
+    const [behind, ahead] = out.split(/\s+/).map((n) => parseInt(n, 10) || 0);
+    return { ahead, behind };
+  } catch {
+    return { ahead: 0, behind: 0 };
+  }
+}
+function currentBranch(worktreePath) {
+  try {
+    return git(worktreePath, "branch --show-current").trim();
+  } catch {
+    return "";
+  }
+}
+function mergeBack(input) {
+  const baseBranch = input.baseBranch || "main";
+  const { projectRoot, branch, worktreePath } = input;
+  if (!existsSync(projectRoot)) {
+    return { ok: false, stage: "verify", detail: `project root not found: ${projectRoot}` };
+  }
+  const worktreeGone = !existsSync(worktreePath);
+  if (!worktreeGone) {
+    let childStatus;
+    try {
+      childStatus = worktreeStatus(worktreePath);
+    } catch (e) {
+      return { ok: false, stage: "verify", detail: `not a git worktree: ${worktreePath} (${e.message})` };
+    }
+    if (childStatus) {
+      return {
+        ok: false,
+        stage: "verify",
+        rework: true,
+        detail: `feature worktree has uncommitted changes \u2014 commit (or run \`feature done\`) first:
+${childStatus}`
+      };
+    }
+  }
+  const leadBranch = currentBranch(projectRoot);
+  if (leadBranch !== baseBranch) {
+    return {
+      ok: false,
+      stage: "verify",
+      detail: `lead tree ${projectRoot} is on '${leadBranch || "detached"}', not base '${baseBranch}'. Check out ${baseBranch} there first.`
+    };
+  }
+  let leadStatus;
+  try {
+    leadStatus = git(projectRoot, "status --porcelain -uno").trim();
+  } catch (e) {
+    return { ok: false, stage: "verify", detail: `lead tree status failed: ${e.message}` };
+  }
+  if (leadStatus) {
+    return {
+      ok: false,
+      stage: "verify",
+      detail: `lead tree ${projectRoot} has uncommitted tracked changes; commit/stash before merging.`
+    };
+  }
+  try {
+    git(projectRoot, `merge --no-ff ${branch} -m "crew: merge ${branch} into ${baseBranch}"`);
+  } catch (e) {
+    const detail = (e.stdout?.toString() || "") + (e.stderr?.toString() || "") || e.message;
+    try {
+      git(projectRoot, "merge --abort");
+    } catch {
+    }
+    return { ok: false, stage: "merge", rework: true, detail: `merge conflict \u2014 aborted:
+${detail.trim()}` };
+  }
+  try {
+    git(projectRoot, `worktree remove --force ${worktreePath}`);
+  } catch (e) {
+    try {
+      git(projectRoot, "worktree prune");
+    } catch {
+    }
+    let stillRegistered = false;
+    try {
+      stillRegistered = git(projectRoot, "worktree list --porcelain").includes(worktreePath);
+    } catch {
+    }
+    if (stillRegistered) {
+      const detail = e.stderr?.toString() || "" || e.message;
+      return { ok: false, stage: "remove-worktree", detail: `merged OK but worktree removal failed: ${detail.trim()}` };
+    }
+  }
+  if (input.deleteBranch !== false) {
+    try {
+      git(projectRoot, `branch -d ${branch}`);
+    } catch {
+    }
+  }
+  return { ok: true, stage: "done", detail: `merged ${branch} into ${baseBranch}` };
+}
+function projectRootFromWorktree(worktreePath) {
+  const marker = "/.dev/worktree/";
+  const idx = worktreePath.indexOf(marker);
+  if (idx === -1) return null;
+  return worktreePath.slice(0, idx);
+}
+
+function isStandaloneChild(crew) {
+  return !!crew && crew.standalone === true;
+}
+function worktreeCrewMeta(feature, branch, worktreePath, baseBranch) {
+  return { role: "feature", feature, branch, worktreePath, baseBranch };
+}
+function standaloneCrewMeta(feature, directory) {
+  return { role: "feature", feature, standalone: true, directory };
+}
+function childDirectory(crew, sessionDir) {
+  return crew?.worktreePath || crew?.directory || sessionDir || "";
+}
+function standaloneBrief(directory, leadShort, brief) {
+  return `You are a crew STANDALONE child working directly in folder \`${directory}\` (no git worktree, no feature branch), reporting to lead \`${leadShort}\`.
+
+Feature brief:
+${brief}
+
+Work in this folder. Commit there yourself if it is a git repo. Report milestones with \`svamp feature report\`, and when done run \`svamp feature done\` \u2014 there is no branch to merge, so your lead just detaches & closes you.`;
+}
+function worktreeBrief(branch, base, leadShort, brief) {
+  return `You are a crew feature child on branch \`${branch}\` (base \`${base}\`), reporting to lead \`${leadShort}\`.
+
+Feature brief:
+${brief}
+
+Work in this worktree. Keep tests green, report milestones with \`svamp feature report\`, and when done run \`svamp feature done\` so your lead can review & merge. After merge you'll be closed.`;
+}
+
+function requireLead(explicit) {
+  const id = explicit || process.env.SVAMP_SESSION_ID;
+  if (!id) {
+    console.error("No lead session. Run inside a Svamp session, or pass --lead <id>.");
+    process.exit(1);
+  }
+  return id;
+}
+async function rpc(machine, id, method, kwargs = {}) {
+  return machine.sessionRPC(id, method, kwargs);
+}
+async function getMeta(machine, id) {
+  const r = await rpc(machine, id, "getMetadata");
+  return r?.metadata ?? r ?? {};
+}
+async function inbox(machine, fromId, toId, body, subject) {
+  await rpc(machine, toId, "sendInboxMessage", {
+    message: {
+      messageId: shortId(),
+      body,
+      timestamp: Date.now(),
+      read: false,
+      from: `agent:${fromId}`,
+      fromSession: fromId,
+      to: toId,
+      subject,
+      urgency: "normal"
+    }
+  });
+}
+async function featureStart(brief, opts = {}) {
+  if (!brief?.trim()) {
+    console.error('A feature brief is required: svamp feature start "<brief>"');
+    process.exit(1);
+  }
+  const leadId = requireLead(opts.leadId);
+  const { server, machine } = await connectAndGetMachine(opts.machineId);
+  try {
+    const sessions = await machine.listSessions();
+    const lead = resolveSessionId(sessions, leadId);
+    const standalone = !!opts.noWorktree;
+    let childDir;
+    let base = "";
+    let wt = null;
+    if (standalone) {
+      const dir = opts.directory;
+      if (!dir) {
+        console.error("--no-worktree requires --dir <folder> (the existing folder to run the child in).");
+        process.exit(1);
+      }
+      childDir = resolve(dir);
+      if (!existsSync(childDir)) {
+        console.error(`Folder not found: ${childDir}`);
+        process.exit(1);
+      }
+      console.log(`Standalone child folder: ${childDir} (no worktree)`);
+    } else {
+      const projectRoot2 = opts.directory || lead.directory;
+      if (!projectRoot2) {
+        console.error("Could not determine the lead project directory.");
+        process.exit(1);
+      }
+      base = opts.baseBranch || currentBranch(projectRoot2) || "main";
+      try {
+        wt = createWorktree(projectRoot2);
+      } catch (e) {
+        console.error(`Failed to create worktree: ${e.message}`);
+        process.exit(1);
+      }
+      childDir = wt.path;
+      console.log(`Worktree: ${wt.branch} \u2192 ${wt.path}`);
+    }
+    const projectRoot = lead.directory || opts.directory || childDir;
+    const result = await machine.spawnSession({
+      directory: childDir,
+      agent: "claude",
+      parentSessionId: lead.sessionId,
+      permissionMode: "bypassPermissions"
+    });
+    if (result.type !== "success" || !result.sessionId) {
+      console.error(`Failed to spawn feature child: ${result.errorMessage || result.type}`);
+      process.exit(1);
+    }
+    const childId = result.sessionId;
+    try {
+      const delegatedWhere = standalone ? `standalone folder \`${childDir}\`` : `\`${wt.branch}\` (base \`${base}\`)`;
+      let linkedId = opts.issueId;
+      if (linkedId) {
+        const u = updateIssue(projectRoot, linkedId, { disposition: "crew", session: childId, owner: leadId, ...standalone ? {} : { branch: wt.branch }, status: "in_progress" });
+        if (!u) {
+          console.warn(`Note: issue ${linkedId} not found \u2014 creating a new crew issue instead.`);
+          linkedId = void 0;
+        } else {
+          addComment(projectRoot, u.id, `Delegated to crew child ${childId.slice(0, 8)} on ${delegatedWhere}.`);
+          linkedId = u.id;
+        }
+      }
+      if (!linkedId) {
+        const created = addIssue(projectRoot, {
+          title: brief.trim().split("\n")[0].slice(0, 80),
+          status: "in_progress",
+          disposition: "crew",
+          triaged: true,
+          session: childId,
+          owner: leadId,
+          scope: "project",
+          // owner=lead (#0099): visible to the lead, not unrelated sessions
+          ...opts.oracle?.trim() ? { verify: { type: "command", text: opts.oracle.trim() } } : {},
+          body: brief.trim()
+        });
+        if (!standalone) updateIssue(projectRoot, created.id, { branch: wt.branch });
+        linkedId = created.id;
+      }
+      console.log(`  issue:  #${linkedId} (crew, child ${childId.slice(0, 8)})`);
+    } catch (e) {
+      console.warn(`Note: could not link a crew issue (${e.message}).`);
+    }
+    if (!lead.metadata?.crew) {
+      try {
+        await rpc(machine, lead.sessionId, "updateConfig", { patch: { crew: { role: "lead" } } });
+      } catch {
+      }
+    }
+    const oracle = opts.oracle?.trim();
+    const patch = {
+      crew: standalone ? standaloneCrewMeta(brief.trim(), childDir) : worktreeCrewMeta(brief.trim(), wt.branch, wt.path, base)
+    };
+    let judges = [];
+    if (oracle) {
+      judges = [{ type: "oracle", cmd: oracle, on_fail: "escalate" }, { type: "parent", parent: lead.sessionId }];
+      patch.loop = {
+        until: brief.trim(),
+        oracle,
+        parent: lead.sessionId,
+        max_iterations: opts.maxRounds ?? 20
+      };
+    }
+    try {
+      await rpc(machine, childId, "updateConfig", { patch });
+    } catch (e) {
+      console.warn(`Note: could not write crew/loop config yet (${e.message}).`);
+    }
+    try {
+      await rpc(machine, childId, "sendMessage", {
+        content: JSON.stringify({
+          role: "user",
+          content: { type: "text", text: standalone ? standaloneBrief(childDir, lead.sessionId.slice(0, 8), brief.trim()) : worktreeBrief(wt.branch, base, lead.sessionId.slice(0, 8), brief.trim()) },
+          meta: { sentFrom: "svamp-cli", crew: "feature-brief" }
+        })
+      });
+    } catch (e) {
+      console.warn(`Note: could not send the brief (${e.message}).`);
+    }
+    console.log(`Feature child started: ${childId}`);
+    console.log(`  brief:  ${brief.trim().slice(0, 80)}${brief.trim().length > 80 ? "\u2026" : ""}`);
+    if (standalone) {
+      console.log(`  folder: ${childDir}  (standalone \u2014 no branch; done detaches & closes)`);
+    } else {
+      console.log(`  branch: ${wt.branch}  (merges back to ${base})`);
+    }
+    console.log(judges.length ? `  gate:   ${judges.map((j) => j.type).join(" \u2192 ")} (oracle auto-approves \u2192 lead ${standalone ? "closes" : "merges"})` : `  gate:   none \u2014 child runs \`feature done\` when complete; lead ${standalone ? "detaches & closes" : "reviews & merges"}`);
+  } finally {
+    await server.disconnect();
+  }
+}
+async function featureList(opts = {}) {
+  const leadId = requireLead(opts.leadId);
+  const { server, machine } = await connectAndGetMachine(opts.machineId);
+  try {
+    const sessions = await machine.listSessions();
+    const lead = resolveSessionId(sessions, leadId);
+    const children = sessions.filter((s) => s.metadata?.parentSessionId === lead.sessionId);
+    const rows = children.map((c) => {
+      const crew = c.metadata?.crew || {};
+      const standalone = isStandaloneChild(crew);
+      const dir = childDirectory(crew, c.directory);
+      const base = crew.baseBranch || "main";
+      let branch = "", ahead = 0, behind = 0, dirty = false, gone = false;
+      if (standalone) {
+        gone = !(dir && existsSync(dir));
+      } else {
+        branch = crew.branch || (dir && existsSync(dir) ? currentBranch(dir) : "") || "";
+        if (dir && existsSync(dir)) {
+          const ab = aheadBehind(dir, base);
+          ahead = ab.ahead;
+          behind = ab.behind;
+          try {
+            dirty = worktreeStatus(dir) !== "";
+          } catch {
+          }
+        } else if (crew.worktreePath) {
+          gone = true;
+        }
+      }
+      return {
+        id: c.sessionId,
+        title: c.metadata?.summary?.text || c.metadata?.name || "",
+        role: crew.role || (crew.worktreePath ? "feature" : ""),
+        standalone,
+        dir,
+        branch,
+        base,
+        ahead,
+        behind,
+        dirty,
+        gone,
+        active: c.active,
+        feature: crew.feature || ""
+      };
+    });
+    if (opts.json) {
+      console.log(JSON.stringify(rows, null, 2));
+      return;
+    }
+    if (rows.length === 0) {
+      console.log(`No feature children for lead ${lead.sessionId.slice(0, 8)}.`);
+      return;
+    }
+    console.log(`Features under lead ${lead.sessionId.slice(0, 8)}:
+`);
+    for (const r of rows) {
+      const state = r.standalone ? r.gone ? "folder-gone" : r.active ? "standalone" : "standalone\xB7idle" : r.gone ? "worktree-gone" : r.active ? "active" : "idle";
+      const ab = r.standalone || r.gone ? "" : `+${r.ahead}/-${r.behind}${r.dirty ? " \u2717dirty" : ""}`;
+      const ref = r.standalone ? r.dir || "\u2014" : r.branch || "\u2014";
+      const title = (r.feature || r.title || "").slice(0, 48);
+      console.log(`  ${r.id.slice(0, 8)}  ${state.padEnd(15)} ${ref.padEnd(28)} ${ab.padEnd(14)} ${title}`);
+    }
+    console.log(`
+  Review a finished feature with: svamp feature merge <id>`);
+  } finally {
+    await server.disconnect();
+  }
+}
+async function featureReport(text, opts = {}) {
+  if (!text?.trim()) {
+    console.error("A report message is required.");
+    process.exit(1);
+  }
+  const selfId = requireLead(opts.selfId);
+  const { server, machine } = await connectAndGetMachine(opts.machineId);
+  try {
+    const meta = await getMeta(machine, selfId);
+    const parent = meta?.parentSessionId;
+    if (!parent) {
+      console.error("This session has no parent (lead) to report to.");
+      process.exit(1);
+    }
+    const kind = opts.blocker ? "blocker" : "progress";
+    await inbox(machine, selfId, parent, `<feature-${kind} from="${selfId}">
+${text.trim()}
+</feature-${kind}>`, `feature ${kind}`);
+    console.log(`Reported ${kind} to lead ${parent.slice(0, 8)}.`);
+  } finally {
+    await server.disconnect();
+  }
+}
+async function featureDone(opts = {}) {
+  const selfId = requireLead(opts.selfId);
+  const { server, machine } = await connectAndGetMachine(opts.machineId);
+  try {
+    const meta = await getMeta(machine, selfId);
+    const parent = meta?.parentSessionId;
+    if (!parent) {
+      console.error("This session has no parent (lead) to report to.");
+      process.exit(1);
+    }
+    const crew = meta?.crew || {};
+    if (isStandaloneChild(crew)) {
+      const dir2 = childDirectory(crew, meta?.path);
+      const body2 = [
+        `<done-request child="${selfId}" standalone="true" folder="${dir2}">`,
+        crew.feature ? `Feature: ${crew.feature}` : "",
+        opts.summary ? `Summary: ${opts.summary.trim()}` : "",
+        `No branch to merge (standalone folder). Detach & close with: svamp feature merge ${selfId.slice(0, 8)}`,
+        `</done-request>`
+      ].filter(Boolean).join("\n");
+      await inbox(machine, selfId, parent, body2, `done-request (standalone)`);
+      console.log(`Sent done-request to lead ${parent.slice(0, 8)} (standalone folder ${dir2 || "?"}; no branch to merge).`);
+      return;
+    }
+    const dir = meta?.path || crew.worktreePath || "";
+    const base = crew.baseBranch || "main";
+    const branch = crew.branch || (dir && existsSync(dir) ? currentBranch(dir) : "") || "";
+    const ab = dir && existsSync(dir) ? aheadBehind(dir, base) : { ahead: 0, behind: 0 };
+    let dirty = false;
+    try {
+      dirty = dir && existsSync(dir) ? worktreeStatus(dir) !== "" : false;
+    } catch {
+    }
+    const body = [
+      `<merge-request child="${selfId}" branch="${branch}" base="${base}" commits="${ab.ahead}"${dirty ? ' dirty="true"' : ""}>`,
+      crew.feature ? `Feature: ${crew.feature}` : "",
+      opts.summary ? `Summary: ${opts.summary.trim()}` : "",
+      dirty ? "WARNING: worktree has uncommitted changes \u2014 commit before this can merge." : "",
+      `Review & merge with: svamp feature merge ${selfId.slice(0, 8)}`,
+      `</merge-request>`
+    ].filter(Boolean).join("\n");
+    await inbox(machine, selfId, parent, body, `merge-request (${branch || "feature"})`);
+    console.log(`Sent merge-request to lead ${parent.slice(0, 8)} (branch ${branch || "?"}, +${ab.ahead} commits).`);
+    if (dirty) console.log("  \u26A0 Worktree is dirty \u2014 commit your work or the merge will be rejected.");
+  } finally {
+    await server.disconnect();
+  }
+}
+async function featureMerge(childPartial, opts = {}) {
+  const leadId = opts.leadId || process.env.SVAMP_SESSION_ID || "";
+  const { server, machine, fullId: childId } = await connectAndResolveSession(childPartial, opts.machineId);
+  try {
+    const meta = await getMeta(machine, childId);
+    const crew = meta?.crew || {};
+    if (isStandaloneChild(crew)) {
+      const dir = childDirectory(crew, meta?.path);
+      if (!opts.keepChild) {
+        try {
+          await machine.archiveSession(childId);
+        } catch (e) {
+          console.warn(`Could not archive standalone child: ${e.message}`);
+        }
+      }
+      console.log(`\u2705 Detached standalone child ${childId.slice(0, 8)} (folder ${dir || "?"}; no branch to merge) \u2014 ${opts.keepChild ? "kept" : "archived"}.`);
+      return;
+    }
+    const worktreePath = crew.worktreePath || meta?.path || "";
+    if (!worktreePath) {
+      console.error("Could not determine the child worktree path.");
+      process.exit(1);
+    }
+    const base = crew.baseBranch || "main";
+    const branch = crew.branch || currentBranch(worktreePath) || "";
+    if (!branch) {
+      console.error("Could not determine the feature branch.");
+      process.exit(1);
+    }
+    const projectRoot = projectRootFromWorktree(worktreePath) || (leadId ? (await getMeta(machine, leadId).catch(() => ({})))?.path : null) || "";
+    if (!projectRoot) {
+      console.error("Could not determine the lead project root (base worktree).");
+      process.exit(1);
+    }
+    if (leadId) {
+      try {
+        await inbox(
+          machine,
+          leadId,
+          childId,
+          `<crew-freeze>Your lead is merging branch ${branch} into ${base}. Stop editing files now; do not commit until told.</crew-freeze>`,
+          "crew: freeze for merge"
+        );
+      } catch {
+      }
+    }
+    const r = mergeBack({ projectRoot, branch, worktreePath, baseBranch: base, deleteBranch: opts.deleteBranch });
+    if (!r.ok) {
+      if (r.rework && leadId) {
+        try {
+          await inbox(
+            machine,
+            leadId,
+            childId,
+            `<crew-rework branch="${branch}">
+Merge was not applied: ${r.detail}
+Resolve and run \`svamp feature done\` again.
+</crew-rework>`,
+            "crew: rework needed"
+          );
+        } catch {
+        }
+        console.error(`Merge deferred (rework) at ${r.stage}: ${r.detail}`);
+        console.error(`Child ${childId.slice(0, 8)} re-woken with guidance; left running.`);
+      } else {
+        console.error(`Merge failed at ${r.stage}: ${r.detail}`);
+      }
+      process.exit(1);
+    }
+    if (!opts.keepChild) {
+      try {
+        await machine.archiveSession(childId);
+      } catch (e) {
+        console.warn(`Merged, but could not archive child: ${e.message}`);
+      }
+    }
+    console.log(`\u2705 Merged ${branch} \u2192 ${base}; worktree removed; child ${childId.slice(0, 8)} ${opts.keepChild ? "kept" : "archived"}.`);
+  } finally {
+    await server.disconnect();
+  }
+}
+function flag(args, ...names) {
+  for (const n of names) {
+    const i = args.indexOf(n);
+    if (i !== -1 && i + 1 < args.length) return args[i + 1];
+  }
+  return void 0;
+}
+function has(args, ...names) {
+  return names.some((n) => args.includes(n));
+}
+function positionals(args, valueFlags) {
+  const out = [];
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a.startsWith("-")) {
+      if (valueFlags.includes(a)) i++;
+      continue;
+    }
+    out.push(a);
+  }
+  return out;
+}
+const FEATURE_HELP = `Usage: svamp feature <command>
+
+  start "<brief>" [--oracle "<cmd>"] [--base <branch>] [--action nudge|block]
+                  [--max N] [--dir <path>] [--no-worktree] [--lead <id>] [-m <machine>]
+      Spawn a managed child of the lead + attach a loop gate (oracle\u2192parent).
+      Default: a git worktree + branch off the lead's project root (merges back).
+      --no-worktree --dir <folder>: run the child directly IN <folder> (a subdir or
+      sibling project) with NO worktree/branch \u2014 done/merge just detach & close it.
+  list [--json] [--lead <id>] [-m <machine>]
+      The lead's feature children: branch/folder, ahead/behind, status.
+  report "<text>" [--blocker] [-m <machine>]      (run by a child) progress/blocker \u2192 lead
+  done [--summary "<text>"] [-m <machine>]         (run by a child) merge-request (worktree) or done-request (standalone) \u2192 lead
+  merge <child-id> [--keep-child] [--no-delete-branch] [-m <machine>]
+      (run by the lead) worktree: verify \u2192 merge \u2192 remove worktree \u2192 archive child.
+      standalone: just detach & archive the child (no branch to merge).`;
+async function crewCommand(args) {
+  const sub = args[0];
+  const rest = args.slice(1);
+  const machineId = flag(rest, "-m", "--machine");
+  const lead = flag(rest, "--lead");
+  if (!sub || sub === "--help" || sub === "-h") {
+    console.log(FEATURE_HELP);
+    return;
+  }
+  if (sub === "start") {
+    const valueFlags = ["--oracle", "--base", "--action", "--max", "--dir", "-d", "--lead", "-m", "--machine", "--issue"];
+    const brief = positionals(rest, valueFlags).join(" ");
+    const maxStr = flag(rest, "--max");
+    const action = flag(rest, "--action");
+    await featureStart(brief, {
+      leadId: lead,
+      machineId,
+      directory: flag(rest, "--dir", "-d"),
+      noWorktree: has(rest, "--no-worktree", "--standalone"),
+      oracle: flag(rest, "--oracle"),
+      baseBranch: flag(rest, "--base"),
+      issueId: flag(rest, "--issue"),
+      action: action === "block" ? "block" : action === "nudge" ? "nudge" : void 0,
+      maxRounds: maxStr ? parseInt(maxStr, 10) : void 0
+    });
+  } else if (sub === "list" || sub === "ls") {
+    await featureList({ leadId: lead, machineId, json: has(rest, "--json") });
+  } else if (sub === "report") {
+    const text = positionals(rest, ["-m", "--machine", "--lead"]).join(" ");
+    await featureReport(text, { machineId, blocker: has(rest, "--blocker") });
+  } else if (sub === "done") {
+    await featureDone({ machineId, summary: flag(rest, "--summary") });
+  } else if (sub === "merge") {
+    const child = positionals(rest, ["-m", "--machine", "--lead"])[0];
+    if (!child) {
+      console.error("Usage: svamp feature merge <child-id>");
+      process.exit(1);
+    }
+    await featureMerge(child, {
+      leadId: lead,
+      machineId,
+      keepChild: has(rest, "--keep-child"),
+      deleteBranch: has(rest, "--no-delete-branch") ? false : void 0
+    });
+  } else {
+    console.error(`Unknown feature command: ${sub}
+`);
+    console.log(FEATURE_HELP);
+    process.exit(1);
+  }
+}
+
+export { crewCommand, featureDone, featureList, featureMerge, featureReport, featureStart };