svamp-cli 0.2.116 → 0.2.118

package/dist/{commands-DdW5M7Le.mjs → commands-B5rek8XG.mjs}

@@ -1,8 +1,8 @@
-import { existsSync, readFileSync } from 'node:fs';
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
 import { execSync } from 'node:child_process';
-import { basename, resolve, join } from 'node:path';
+import { basename, resolve, join, isAbsolute } from 'node:path';
 import os from 'node:os';
-import { G as normalizeAllowedUser, H as loadSecurityContextConfig, I as resolveSecurityContext, J as buildSecurityContextFromFlags, K as mergeSecurityContexts, c as connectToHypha, L as buildSessionShareUrl, M as computeOutboundHop, n as shortId, N as buildMachineShareUrl } from './run-DHPCWQUq.mjs';
+import { G as normalizeAllowedUser, H as loadSecurityContextConfig, I as resolveSecurityContext, J as buildSecurityContextFromFlags, K as mergeSecurityContexts, c as connectToHypha, L as buildSessionShareUrl, M as computeOutboundHop, n as shortId, N as buildMachineShareUrl } from './run-9C2ogsuu.mjs';
 import 'os';
 import 'fs/promises';
 import 'fs';
@@ -999,6 +999,22 @@ function generateWorktreeName() {
   const noun = WORKTREE_NOUNS[Math.floor(Math.random() * WORKTREE_NOUNS.length)];
   return `${adj}-${noun}`;
 }
+function ensureWorktreeExcludes(projectRoot) {
+  try {
+    const common = execSync("git rev-parse --git-common-dir", { cwd: projectRoot, stdio: "pipe" }).toString().trim();
+    const commonAbs = isAbsolute(common) ? common : join(projectRoot, common);
+    const excludeFile = join(commonAbs, "info", "exclude");
+    const existing = existsSync(excludeFile) ? readFileSync(excludeFile, "utf-8") : "";
+    const lines = existing.split("\n");
+    const want = [".svamp/", ".dev/"];
+    const missing = want.filter((w) => !lines.some((l) => l.trim() === w));
+    if (missing.length) {
+      const prefix = existing && !existing.endsWith("\n") ? "\n" : "";
+      writeFileSync(excludeFile, existing + prefix + missing.join("\n") + "\n");
+    }
+  } catch {
+  }
+}
 function createWorktree(baseDir) {
   const absBase = resolve(baseDir);
   const marker = "/.dev/worktree/";
@@ -1009,6 +1025,7 @@ function createWorktree(baseDir) {
   } catch {
     throw new Error(`Not a git repository: ${projectRoot}`);
   }
+  ensureWorktreeExcludes(projectRoot);
   const name = generateWorktreeName();
   const relPath = `.dev/worktree/${name}`;
   try {
@@ -2360,6 +2377,44 @@ async function sessionLoopStatus(sessionIdPartial, machineId) {
     await server.disconnect();
   }
 }
+async function sessionSupervise(sessionIdPartial, criteria, machineId, opts) {
+  const { server, machine, fullId } = await connectAndResolveSession(sessionIdPartial, machineId);
+  try {
+    const svc = getSessionProxy(machine, fullId);
+    const judges = [];
+    if (opts?.oracle) judges.push({ type: "oracle", cmd: opts.oracle, on_fail: opts?.parent ? "escalate" : "reject" });
+    if (opts?.parent) judges.push({ type: "parent", parent: opts.parent });
+    if (opts?.agent || judges.length === 0) judges.push({ type: "agent" });
+    const maxRounds = opts?.maxRounds ?? 20;
+    await svc.updateConfig({
+      supervisor: {
+        criteria,
+        judges,
+        action: opts?.action || "block",
+        max_rounds: maxRounds
+      }
+    });
+    const judgeLabel = judges.map((j) => j.type).join("\u2192");
+    console.log(`\u{1F441} Supervisor attached to session ${fullId.slice(0, 8)}`);
+    console.log(`  Criteria: ${criteria.slice(0, 100)}${criteria.length > 100 ? "..." : ""}`);
+    console.log(`  Judges: ${judgeLabel}`);
+    if (opts?.oracle) console.log(`  Oracle: ${opts.oracle}`);
+    if (opts?.parent) console.log(`  Parent review: ${opts.parent.slice(0, 8)} (async)`);
+    console.log(`  Max rounds: ${maxRounds}`);
+  } finally {
+    await server.disconnect();
+  }
+}
+async function sessionUnsupervise(sessionIdPartial, machineId) {
+  const { server, machine, fullId } = await connectAndResolveSession(sessionIdPartial, machineId);
+  try {
+    const svc = getSessionProxy(machine, fullId);
+    await svc.updateConfig({ supervisor: null });
+    console.log(`Supervisor detached from session ${fullId.slice(0, 8)}`);
+  } finally {
+    await server.disconnect();
+  }
+}
 async function sessionInboxSend(sessionIdPartial, body, machineId, opts) {
   const { server, machine, fullId } = await connectAndResolveSession(sessionIdPartial, machineId);
   try {
@@ -2500,4 +2555,4 @@ async function sessionInboxClear(sessionIdPartial, machineId, opts) {
   }
 }
 
-export { collectAssistantResponse, connectAndGetMachine, connectAndResolveSession, createWorktree, generateWorktreeName, machineExec, machineInfo, machineLs, machineShare, parseShareArg, queryCore, renderMessage, resolveSessionId, sendCore, sessionApprove, sessionArchive, sessionAttach, sessionDelete, sessionDeny, sessionInboxClear, sessionInboxList, sessionInboxRead, sessionInboxReply, sessionInboxSend, sessionInfo, sessionList, sessionLoopCancel, sessionLoopStart, sessionLoopStatus, sessionMachines, sessionMessages, sessionQuery, sessionResume, sessionSend, sessionShare, sessionSpawn, sessionWait, sessionWhoami, snapshotLatestSeq, validateSendOptions, wiseAskCli };
+export { collectAssistantResponse, connectAndGetMachine, connectAndResolveSession, createWorktree, generateWorktreeName, machineExec, machineInfo, machineLs, machineShare, parseShareArg, queryCore, renderMessage, resolveSessionId, sendCore, sessionApprove, sessionArchive, sessionAttach, sessionDelete, sessionDeny, sessionInboxClear, sessionInboxList, sessionInboxRead, sessionInboxReply, sessionInboxSend, sessionInfo, sessionList, sessionLoopCancel, sessionLoopStart, sessionLoopStatus, sessionMachines, sessionMessages, sessionQuery, sessionResume, sessionSend, sessionShare, sessionSpawn, sessionSupervise, sessionUnsupervise, sessionWait, sessionWhoami, snapshotLatestSeq, validateSendOptions, wiseAskCli };

package/dist/{commands-zMw02qH_.mjs → commands-BEjlVtvS.mjs}

@@ -1,7 +1,7 @@
 import os from 'os';
 import fs__default from 'fs';
 import { resolve, join, relative } from 'path';
-import { p as parseFrontmatter, o as getSkillsServer, q as getSkillsWorkspaceName, t as getSkillsCollectionName, u as fetchWithTimeout, v as searchSkills, w as SKILLS_DIR, x as getSkillInfo, y as downloadSkillFile, z as listSkillFiles } from './run-DHPCWQUq.mjs';
+import { p as parseFrontmatter, o as getSkillsServer, q as getSkillsWorkspaceName, t as getSkillsCollectionName, u as fetchWithTimeout, v as searchSkills, w as SKILLS_DIR, x as getSkillInfo, y as downloadSkillFile, z as listSkillFiles } from './run-9C2ogsuu.mjs';
 import 'fs/promises';
 import 'url';
 import 'child_process';

package/dist/commands-BJfRk4KT.mjs

@@ -0,0 +1,513 @@
+import { existsSync } from 'node:fs';
+import { connectAndGetMachine, resolveSessionId, createWorktree, connectAndResolveSession } from './commands-B5rek8XG.mjs';
+import { execSync } from 'node:child_process';
+import { n as shortId } from './run-9C2ogsuu.mjs';
+import 'node:path';
+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}` };
+  }
+  if (!existsSync(worktreePath)) {
+    return { ok: false, stage: "verify", detail: `worktree not found: ${worktreePath}` };
+  }
+  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) {
+    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 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 projectRoot = opts.directory || lead.directory;
+    if (!projectRoot) {
+      console.error("Could not determine the lead project directory.");
+      process.exit(1);
+    }
+    const base = opts.baseBranch || currentBranch(projectRoot) || "main";
+    let wt;
+    try {
+      wt = createWorktree(projectRoot);
+    } catch (e) {
+      console.error(`Failed to create worktree: ${e.message}`);
+      process.exit(1);
+    }
+    console.log(`Worktree: ${wt.branch} \u2192 ${wt.path}`);
+    const result = await machine.spawnSession({
+      directory: wt.path,
+      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;
+    if (!lead.metadata?.crew) {
+      try {
+        await rpc(machine, lead.sessionId, "updateConfig", { patch: { crew: { role: "lead" } } });
+      } catch {
+      }
+    }
+    const oracle = opts.oracle?.trim();
+    const patch = {
+      crew: { role: "feature", feature: brief.trim(), branch: wt.branch, worktreePath: wt.path, baseBranch: base }
+    };
+    let judges = [];
+    if (oracle) {
+      judges = [{ type: "oracle", cmd: oracle, on_fail: "escalate" }, { type: "parent", parent: lead.sessionId }];
+      patch.supervisor = {
+        criteria: brief.trim(),
+        judges,
+        action: opts.action || "nudge",
+        max_rounds: opts.maxRounds ?? 20
+      };
+    }
+    try {
+      await rpc(machine, childId, "updateConfig", { patch });
+    } catch (e) {
+      console.warn(`Note: could not write crew/supervisor config yet (${e.message}).`);
+    }
+    try {
+      await rpc(machine, childId, "sendMessage", {
+        content: JSON.stringify({
+          role: "user",
+          content: { type: "text", text: `You are a crew feature child on branch \`${wt.branch}\` (base \`${base}\`), reporting to lead \`${lead.sessionId.slice(0, 8)}\`.
+
+Feature brief:
+${brief.trim()}
+
+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.` },
+          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" : ""}`);
+    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 merges)` : `  gate:   none \u2014 child runs \`feature done\` when complete; lead 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 dir = c.directory || crew.worktreePath || "";
+      const base = crew.baseBranch || "main";
+      const branch = crew.branch || (dir && existsSync(dir) ? currentBranch(dir) : "") || "";
+      let ahead = 0, behind = 0, dirty = false, gone = false;
+      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" : ""),
+        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.gone ? "worktree-gone" : r.active ? "active" : "idle";
+      const ab = r.gone ? "" : `+${r.ahead}/-${r.behind}${r.dirty ? " \u2717dirty" : ""}`;
+      const title = (r.feature || r.title || "").slice(0, 48);
+      console.log(`  ${r.id.slice(0, 8)}  ${state.padEnd(13)} ${(r.branch || "\u2014").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 || {};
+    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 || {};
+    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>] [--lead <id>] [-m <machine>]
+      Spawn a managed worktree child of the lead + attach a supervisor (oracle\u2192parent).
+  list [--json] [--lead <id>] [-m <machine>]
+      The lead's feature children: branch, 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) send a merge-request \u2192 lead
+  merge <child-id> [--keep-child] [--no-delete-branch] [-m <machine>]
+      (run by the lead) verify \u2192 merge \u2192 remove worktree \u2192 archive child.`;
+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"];
+    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"),
+      oracle: flag(rest, "--oracle"),
+      baseBranch: flag(rest, "--base"),
+      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 };

package/dist/{commands-ClxBUkI3.mjs → commands-Bw2V_awn.mjs}

@@ -1,6 +1,6 @@
 import { execFileSync } from 'node:child_process';
 import { createServer } from 'node:http';
-import { R as RoutineStore, m as RoutineRunner } from './run-DHPCWQUq.mjs';
+import { R as RoutineStore, m as RoutineRunner } from './run-9C2ogsuu.mjs';
 import 'os';
 import 'fs/promises';
 import 'fs';
@@ -89,7 +89,7 @@ async function routineCommand(args) {
         process.exit(1);
       }
       const r = store.save(buildRoutineFromArgs(a));
-      console.log(`\u2705 added routine ${r.id} (${r.name}) trigger=${r.trigger.type} action=${r.action.kind} session=${r.session_id}`);
+      console.log(`\u2705 added trigger ${r.id} (${r.name}) source=${r.trigger.type} action=${r.action.kind} session=${r.session_id}`);
       if (r.trigger.key) console.log(`   webhook key: ${r.trigger.key}`);
       break;
     }
@@ -100,7 +100,7 @@ async function routineCommand(args) {
         break;
       }
       if (!rs.length) {
-        console.log("(no routines)");
+        console.log("(no triggers)");
         break;
       }
       for (const r of rs) console.log(`${r.enabled ? "\u25CF" : "\u25CB"} ${r.id}  ${r.name}  [${r.trigger.type}${r.trigger.cron ? " " + r.trigger.cron : ""}] -> ${r.action.kind}  ${r.bind === "stateless" ? `stateless(${r.dir || "?"})` : `session=${r.session_id}`}`);
@@ -124,7 +124,7 @@ async function routineCommand(args) {
       await serve(runner, Number(a.port) || 8722);
       break;
     default:
-      console.log(`usage: svamp routine <add|list|remove|enable|disable|run-now|serve>
+      console.log(`usage: svamp trigger <add|list|remove|enable|disable|run-now|serve>   (alias: svamp routine)
   add --session <id> --name <n> [--schedule "*/5 * * * *" [--missed catchup]] [--webhook|--api [--get] [--public]] [--stateless --dir <path>] (--message "..." | --loop --dir <path> --task "..." [--oracle "cmd"])
   list [--session <id>] [--json]
   serve [--port 8722]`);
@@ -165,9 +165,9 @@ async function serve(runner, port) {
     });
   });
   server.listen(port, () => {
-    console.log(`\u{1FA9D} routine server on http://localhost:${port}`);
+    console.log(`\u{1FA9D} trigger server on http://localhost:${port}`);
     console.log(`   webhook URL: http://localhost:${port}/routine/<id>?key=<key>`);
-    console.log(`   expose:      svamp service expose routines --port ${port}`);
+    console.log(`   expose:      svamp service expose triggers --port ${port}`);
   });
   process.on("SIGINT", () => {
     clearInterval(timer);