@tablation/crew 0.63.2 → 0.64.0

package/README.md

@@ -263,7 +263,7 @@ crew inbox [--member NAME]    your tickets across every workspace
 crew connect WS[/PROJECT]     resolve a workspace/project's ids into the state tree
 crew repos add [ROUTE] [NAME] [PATH]  attach a local checkout to a route in crew.yaml, creating its Repos row if missing (--dry-run previews)
 crew repos list ROUTE         the checkouts a route has, and the tracker Repos row each matches
-crew repos hooks [ROUTE] NAME  suggest test/build hooks for a checkout (--write route|repo writes them, --json)
+crew repos hooks [ROUTE] NAME  suggest test/build hooks for a checkout (--write route|repo writes them, --recipes, --agent, --json)
 crew install [--replace]     write and load this platform's scheduler unit (macOS: clears a crew installed from another path)
 crew uninstall [--all]        unload and remove it (--all: every crew launchd unit, whichever path it came from)
 ```

package/dist/cli.js

@@ -5209,6 +5209,7 @@ var VALUE_FLAGS = /* @__PURE__ */ new Set([
   "repo",
   "role",
   "route",
+  "recipes",
   "ship-name",
   "tail",
   "ticket",
@@ -13204,17 +13205,62 @@ var DETECTORS = [
   { source: "pyproject.toml", detect: fromPyproject },
   { source: "Makefile", detect: fromMakefile }
 ];
+var WORKFLOW_RE = /\.ya?ml$/;
+function detectRecipes(f) {
+  const workflows = (f.list?.(".github/workflows") ?? []).filter((n) => WORKFLOW_RE.test(n)).sort();
+  if (workflows.length === 0) return [];
+  const evidence = workflows.map((n) => `.github/workflows/${n}`);
+  return [
+    {
+      id: "github-actions-release",
+      title: "Releases run in GitHub Actions",
+      description: "CI publishes the release after the crew merges; the crew watches `gh release view` for the live tag.",
+      evidence,
+      // `ltrimstr` because `verify.match: version` compares the bare version, not `v1.2.3`.
+      hooks: { released: `gh release view --json tagName -q '.tagName | ltrimstr("v")'` },
+      release: { mode: "ci_auto", ci: "github", verifyMatch: "version" },
+      writable: true,
+      defaultOn: true
+    },
+    {
+      id: "github-actions-ci-status",
+      title: "Check CI status before hand-off",
+      description: "Ask GitHub whether the latest run on the branch passed before a ticket is handed to QA. The repo spec has no hook for this yet, so it is reported but cannot be written.",
+      evidence,
+      hooks: {},
+      check: `gh run list --branch "$CREW_BRANCH" --limit 1 --json conclusion -q '.[0].conclusion == "success"'`,
+      writable: false,
+      defaultOn: false
+    }
+  ];
+}
 function suggestHooks(f) {
+  const recipes = detectRecipes(f);
   const found = DETECTORS.flatMap((d) => {
     const hooks = d.detect(f);
     return hooks && Object.keys(hooks).length > 0 ? [{ source: d.source, hooks }] : [];
   });
   if (found.length === 0) {
-    return { source: null, hooks: {}, notes: ["no package.json scripts, Package.swift, pyproject.toml or Makefile test/build targets found \u2014 nothing to propose"] };
+    return { source: null, hooks: {}, notes: ["no package.json scripts, Package.swift, pyproject.toml or Makefile test/build targets found \u2014 nothing to propose"], recipes };
   }
   const [first, ...others] = found;
   const notes = others.length > 0 ? [`also found ${others.map((o) => o.source).join(", ")}; proposing from ${first.source} only`] : [];
-  return { source: first.source, hooks: first.hooks, notes };
+  return { source: first.source, hooks: first.hooks, notes, recipes };
+}
+function selectRecipes(s, ids) {
+  const chosen = ids.map((id) => {
+    const r = s.recipes.find((x) => x.id === id);
+    if (!r) throw new ReposError(`no recipe "${id}" here (have: ${s.recipes.map((x) => x.id).join(", ") || "none"})`);
+    if (!r.writable) throw new ReposError(`recipe "${id}" cannot be written: ${r.description}`);
+    return r;
+  });
+  let hooks = { ...s.hooks };
+  let release;
+  for (const r of chosen) {
+    hooks = { ...r.hooks, ...hooks };
+    release ??= r.release;
+  }
+  return { hooks, ...release ? { release } : {} };
 }
 function parseHooksArgs(args, routes) {
   const rest = [...args];
@@ -13224,7 +13270,7 @@ function parseHooksArgs(args, routes) {
     if (routes.length === 1) route = routes[0];
     else throw new ReposError(routes.length === 0 ? "the config has no routes \u2014 run `crew connect` first" : `several routes are configured; name one: ${routes.join(", ")}`);
   }
-  if (rest.length !== 1) throw new ReposError("expected: crew repos hooks [route] <name> [--suggest] [--write route|repo] [--json]");
+  if (rest.length !== 1) throw new ReposError("expected: crew repos hooks [route] <name> [--suggest] [--agent] [--write route|repo] [--recipes ID,ID] [--json]");
   return { route, name: rest[0] };
 }
 function repoDirOf(text, base, route, name) {
@@ -13270,7 +13316,7 @@ function planRouteHooks(text, route, name, hooks) {
   }
   return { text: String(doc), written, kept };
 }
-function starterRepoConfig(hooks) {
+function starterRepoConfig(hooks, release) {
   const lines = [
     "# Starter .crew.yaml proposed by `crew repos hooks --write repo`.",
     "# Review the hooks, then commit this file; it is the durable home for them",
@@ -13283,7 +13329,12 @@ function starterRepoConfig(hooks) {
   const entries = Object.entries(hooks).filter(([, v]) => v !== void 0);
   if (entries.length === 0) lines.push('  # test: "..."', '  # build: "..."');
   for (const [k, v] of entries) lines.push(`  ${k}: ${JSON.stringify(v)}`);
-  lines.push("", "release:", "  # integrate: merging to the base branch is the release; nothing is deployed.", "  mode: integrate", "");
+  if (release) {
+    lines.push("", "release:", `  mode: ${release.mode}`);
+    if (release.ci) lines.push(`  ci: { provider: ${release.ci} }`);
+    if (release.verifyMatch) lines.push("  verify:", `    match: ${release.verifyMatch}`);
+    lines.push("");
+  } else lines.push("", "release:", "  # integrate: merging to the base branch is the release; nothing is deployed.", "  mode: integrate", "");
   const text = lines.join("\n");
   parseRepoConfig(text, ".crew.yaml");
   return text;
@@ -13292,6 +13343,178 @@ function existingRepoConfig(f) {
   return REPO_CONFIG_FILENAMES.find((n) => f.exists(n));
 }
 
+// src/repos-hooks-agent.ts
+import { spawn as spawn4, execFileSync as execFileSync4 } from "child_process";
+import { realpathSync as realpathSync2 } from "fs";
+import { isAbsolute as isAbsolute2, relative } from "path";
+var AgentSuggestError = class extends Error {
+  reason;
+  constructor(reason, message) {
+    super(message);
+    this.reason = reason;
+  }
+};
+var HOOK_KEYS = ["test", "build", "version", "bump", "released"];
+var READ_ONLY_TOOLS = ["Read", "Grep", "Glob"];
+var WRITING_TOOLS = ["Bash", "Edit", "Write", "NotebookEdit", "WebFetch", "WebSearch", "Task", "Agent"];
+var DEFAULT_TIMEOUT_MS = 18e4;
+function buildAgentPrompt(sniff) {
+  return [
+    "You are reviewing a git checkout (the current directory) to work out how to test and build it.",
+    "Read README*, CLAUDE.md, AGENTS.md, GEMINI.md, package/build manifests and .github/workflows/* as needed.",
+    "You may only read files. Do not modify anything and do not run commands.",
+    "",
+    `A file sniff already proposed: ${JSON.stringify(sniff.hooks)}.`,
+    "Propose the commands a contributor should run, using the repo's own documented ones over guesses.",
+    "Omit any hook you cannot support from a file you read.",
+    "",
+    "Answer with ONLY one JSON object, no prose and no code fence:",
+    '{"hooks": {"test": "...", "build": "...", "version": "...", "bump": "...", "released": "..."}, "notes": ["..."]}',
+    "`version` prints the bare version, `bump` bumps by $CREW_BUMP (patch|minor|major) and prints the new version,",
+    "`released` prints what is live (a version or sha). Keys you cannot support are left out."
+  ].join("\n");
+}
+function agentInvocation(spec, model) {
+  if (spec.harness !== "claude") {
+    throw new AgentSuggestError("unsupported_harness", `--agent supports the claude harness only (toolchain "${spec.name}" is ${spec.harness})`);
+  }
+  return wrapInvocation(spec, {
+    model,
+    args: [
+      "-p",
+      "--allowedTools",
+      ...READ_ONLY_TOOLS,
+      "--disallowedTools",
+      ...WRITING_TOOLS,
+      "--model",
+      model,
+      "--output-format",
+      "stream-json",
+      "--verbose",
+      ...spec.args
+    ]
+  });
+}
+function parseAgentStream(out, dir) {
+  let text = "";
+  let isError = false;
+  const files = /* @__PURE__ */ new Set();
+  let base = dir;
+  try {
+    base = realpathSync2(dir);
+  } catch {
+  }
+  for (const line of out.split("\n")) {
+    if (!line.trim()) continue;
+    let ev;
+    try {
+      ev = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (ev?.type === "assistant" && Array.isArray(ev.message?.content)) {
+      for (const b of ev.message.content) {
+        const p = b?.type === "tool_use" && b.name === "Read" ? b.input?.file_path : void 0;
+        if (typeof p === "string") files.add(isAbsolute2(p) ? relative(base, p) : p);
+      }
+    } else if (ev?.type === "result") {
+      text = typeof ev.result === "string" ? ev.result : "";
+      isError = ev.is_error === true;
+    }
+  }
+  return { text, isError, filesRead: [...files].sort() };
+}
+function parseAgentHooks(text) {
+  const start = text.indexOf("{");
+  const end = text.lastIndexOf("}");
+  if (start < 0 || end <= start) throw new AgentSuggestError("bad_output", "the toolchain did not answer with a JSON object");
+  let obj;
+  try {
+    obj = JSON.parse(text.slice(start, end + 1));
+  } catch {
+    throw new AgentSuggestError("bad_output", "the toolchain's answer was not valid JSON");
+  }
+  const raw = obj && typeof obj === "object" && obj.hooks && typeof obj.hooks === "object" ? obj.hooks : {};
+  const hooks = {};
+  for (const k of HOOK_KEYS) if (typeof raw[k] === "string" && raw[k].trim()) hooks[k] = raw[k].trim();
+  const notes = Array.isArray(obj.notes) ? obj.notes.filter((n) => typeof n === "string") : [];
+  return { hooks, notes };
+}
+var SIGNED_OUT = /not logged in|\/login|invalid api key|authentication|unauthori[sz]ed|\b401\b|credit balance/i;
+function classifyFailure(o) {
+  if (o.spawnError?.code === "ENOENT") return "not_installed";
+  return SIGNED_OUT.test(o.output) ? "not_signed_in" : "failed";
+}
+function porcelain(dir) {
+  try {
+    return execFileSync4("git", ["status", "--porcelain", "--untracked-files=all"], { cwd: dir, encoding: "utf8" });
+  } catch {
+    return void 0;
+  }
+}
+async function runAgentSuggest(o) {
+  const model = o.model ?? o.spec.model;
+  const { bin, args } = agentInvocation(o.spec, model);
+  const adapter = adapterFor(o.spec.harness);
+  const env = { ...process.env, ...adapter.runEnv(o.spec) };
+  for (const v of adapter.unsetEnv) delete env[v];
+  delete env.CREW_API_KEY;
+  const before = porcelain(o.dir);
+  const timeout = AbortSignal.timeout(o.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+  const signal = o.signal ? AbortSignal.any([o.signal, timeout]) : timeout;
+  const run2 = await new Promise((resolve6) => {
+    let out = "";
+    let err = "";
+    const child = spawn4(bin, args, { cwd: o.dir, env, detached: true, stdio: ["pipe", "pipe", "pipe"] });
+    let settled = false;
+    const settle = (r) => {
+      if (settled) return;
+      settled = true;
+      signal.removeEventListener("abort", onAbort);
+      resolve6(r);
+    };
+    const onAbort = () => {
+      try {
+        if (child.pid) process.kill(-child.pid, "SIGTERM");
+      } catch {
+        child.kill("SIGTERM");
+      }
+      child.stdout.destroy();
+      child.stderr.destroy();
+      settle({ code: null, out, err, aborted: true });
+    };
+    if (signal.aborted) onAbort();
+    else signal.addEventListener("abort", onAbort, { once: true });
+    child.stdout.on("data", (d) => {
+      out += d.toString();
+    });
+    child.stderr.on("data", (d) => {
+      err += d.toString();
+    });
+    child.on("error", (e) => settle({ code: null, out, err, spawnError: e, aborted: false }));
+    child.on("close", (code) => settle({ code, out, err, aborted: false }));
+    child.stdin.on("error", () => {
+    });
+    child.stdin.end(buildAgentPrompt(o.sniff));
+  });
+  if (run2.aborted || signal.aborted) {
+    throw new AgentSuggestError(o.signal?.aborted ? "cancelled" : "timeout", o.signal?.aborted ? "cancelled" : "the toolchain did not answer in time");
+  }
+  const after = porcelain(o.dir);
+  if (before !== void 0 && after !== before) {
+    throw new AgentSuggestError("modified_checkout", "the checkout changed during --agent; inspect it with `git status` (the agent result was discarded)");
+  }
+  const parsed = parseAgentStream(run2.out, o.dir);
+  if (run2.spawnError || run2.code !== 0 || parsed.isError) {
+    const reason = classifyFailure({ code: run2.code, ...run2.spawnError ? { spawnError: run2.spawnError } : {}, output: `${parsed.text}
+${run2.err}` });
+    throw new AgentSuggestError(reason, reason === "not_installed" ? `${bin} is not installed` : reason === "not_signed_in" ? `${o.spec.name} is not signed in` : (parsed.text || run2.err).trim().slice(0, 300) || `exited ${run2.code}`);
+  }
+  const { hooks, notes } = parseAgentHooks(parsed.text);
+  const differsFromSniff = HOOK_KEYS.filter((k) => hooks[k] !== void 0 && hooks[k] !== o.sniff.hooks[k]);
+  return { source: "agent", hooks, filesRead: parsed.filesRead, differsFromSniff, notes, toolchain: o.spec.name, model };
+}
+
 // src/sample-ticket.ts
 import { basename as basename8, dirname as dirname15, join as join23 } from "path";
 var SAMPLE_REPO = "crew-sample";
@@ -13719,12 +13942,12 @@ function planEventsSweep(stateDir, retentionDays, now = Date.now()) {
 }
 
 // src/cli.ts
-import { realpathSync as realpathSync2, readFileSync as readFileSync25, existsSync as existsSync31, mkdirSync as mkdirSync18, writeFileSync as writeFileSync19, rmSync as rmSync12, unlinkSync as unlinkSync5, copyFileSync as copyFileSync2, renameSync as renameSync2, statSync as statSync10, readdirSync as readdirSync12 } from "fs";
+import { realpathSync as realpathSync3, readFileSync as readFileSync25, existsSync as existsSync31, mkdirSync as mkdirSync18, writeFileSync as writeFileSync19, rmSync as rmSync12, unlinkSync as unlinkSync5, copyFileSync as copyFileSync2, renameSync as renameSync2, statSync as statSync10, readdirSync as readdirSync12 } from "fs";
 import { createInterface } from "readline/promises";
 import { dirname as dirOf, resolve as resolvePath } from "path";
 
 // src/ssh-keys.ts
-import { execFileSync as execFileSync4 } from "child_process";
+import { execFileSync as execFileSync5 } from "child_process";
 import { existsSync as existsSync25, mkdirSync as mkdirSync13, readFileSync as readFileSync19, chmodSync } from "fs";
 import { dirname as dirname17, join as join26 } from "path";
 var SshKeyError = class extends Error {
@@ -13738,7 +13961,7 @@ function ensureShipSshKeypair(stateDir) {
   if (!existsSync25(privateKeyPath)) {
     mkdirSync13(dirname17(privateKeyPath), { recursive: true });
     try {
-      execFileSync4("ssh-keygen", [
+      execFileSync5("ssh-keygen", [
         "-t",
         "ed25519",
         "-N",
@@ -13764,7 +13987,7 @@ function ensureShipSshKeypair(stateDir) {
 }
 function sshKeygenAvailable() {
   try {
-    execFileSync4("ssh-keygen", ["-V"], { stdio: ["ignore", "ignore", "ignore"] });
+    execFileSync5("ssh-keygen", ["-V"], { stdio: ["ignore", "ignore", "ignore"] });
     return true;
   } catch (e) {
     return e.code !== "ENOENT";
@@ -13772,7 +13995,7 @@ function sshKeygenAvailable() {
 }
 
 // src/machine-id.ts
-import { execFileSync as execFileSync5 } from "child_process";
+import { execFileSync as execFileSync6 } from "child_process";
 import { createHash as createHash4 } from "crypto";
 import { existsSync as existsSync26, mkdirSync as mkdirSync14, readFileSync as readFileSync20, writeFileSync as writeFileSync15 } from "fs";
 import { dirname as dirname18, join as join27 } from "path";
@@ -13783,7 +14006,7 @@ var sha256 = (s) => createHash4("sha256").update(s).digest("hex");
 function readRawMachineId(platform2 = process.platform) {
   try {
     if (platform2 === "darwin") {
-      const out = execFileSync5("ioreg", ["-rd1", "-c", "IOPlatformExpertDevice"], {
+      const out = execFileSync6("ioreg", ["-rd1", "-c", "IOPlatformExpertDevice"], {
         encoding: "utf8",
         stdio: ["ignore", "pipe", "ignore"]
       });
@@ -13822,11 +14045,11 @@ function matchShipRows(ships, shipName2, machineId) {
 }
 
 // src/passenger-containers.ts
-import { execFileSync as execFileSync6 } from "child_process";
+import { execFileSync as execFileSync7 } from "child_process";
 import { createHash as createHash5 } from "crypto";
 var realExec = (cmd, args) => {
   try {
-    return execFileSync6(cmd, args, { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
+    return execFileSync7(cmd, args, { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
   } catch (e) {
     const err = e;
     const why = [err.stderr, err.stdout].map((x) => (x ?? "").trim()).filter(Boolean).join(" / ");
@@ -14024,12 +14247,12 @@ function syncAllPassengerCheckouts(cfg) {
 }
 
 // src/tunnel.ts
-import { spawn as spawn4 } from "child_process";
+import { spawn as spawn5 } from "child_process";
 import { existsSync as existsSync27, mkdirSync as mkdirSync15, readFileSync as readFileSync21, writeFileSync as writeFileSync16, unlinkSync as unlinkSync3, readdirSync as readdirSync8 } from "fs";
 import { randomInt } from "crypto";
 import { join as join28 } from "path";
 var DEFAULT_SPAWN_OPTIONS = { stdio: "ignore", detached: true };
-var defaultSpawn = (cmd, args) => spawn4(cmd, args, DEFAULT_SPAWN_OPTIONS);
+var defaultSpawn = (cmd, args) => spawn5(cmd, args, DEFAULT_SPAWN_OPTIONS);
 var SLUG_ALPHABET = "abcdefghijklmnopqrstuvwxyz0123456789";
 var SLUG_LENGTH = 12;
 function generateTunnelSlug() {
@@ -14325,7 +14548,7 @@ async function unregisterEndpoint(workspaceId, info, d) {
 
 // src/passenger-sync-daemon.ts
 import { createServer as createHttpServer } from "http";
-import { spawn as spawn5 } from "child_process";
+import { spawn as spawn6 } from "child_process";
 import { randomBytes } from "crypto";
 import { existsSync as existsSync28, mkdirSync as mkdirSync16, readFileSync as readFileSync22, writeFileSync as writeFileSync17, unlinkSync as unlinkSync4, readdirSync as readdirSync9 } from "fs";
 import { join as join29 } from "path";
@@ -14412,7 +14635,7 @@ function runSyncDaemonFromEnv(env = process.env) {
   return server;
 }
 var defaultSpawn2 = (cmd, args, env) => {
-  const child = spawn5(cmd, args, { detached: true, stdio: "ignore", env });
+  const child = spawn6(cmd, args, { detached: true, stdio: "ignore", env });
   child.unref();
   return child;
 };
@@ -14732,7 +14955,7 @@ async function runOnePassUnguarded(o) {
   await hydrateApiKeys([o.route], o.getSessionStore);
   const emit = o.newEmitter();
   const decide = o.decide ?? decideCycle;
-  const spawn6 = o.spawnRoleAgent ?? runRoleAgent;
+  const spawn7 = o.spawnRoleAgent ?? runRoleAgent;
   const breaker = o.spawnBreaker ?? new SpawnBreaker();
   const ctx = { route: o.route, ship: o.ship, state: o.state, emit, getSessionStore: o.getSessionStore };
   try {
@@ -14793,7 +15016,7 @@ async function runOnePassUnguarded(o) {
       continue;
     }
     started.push(role);
-    const run2 = spawn6(role, decision, ctx).then(() => {
+    const run2 = spawn7(role, decision, ctx).then(() => {
       breaker.recordSuccess(role);
       clearShipAttention(o.state, `role_parked:${role}`);
     }).catch(async (e) => {
@@ -15192,7 +15415,7 @@ function usage() {
   crew skills sync [route]      push only crew's skill files (e.g. grill-me) into the workspace Agent Skills table
   crew repos add [ROUTE] [NAME] [PATH]  attach a local checkout to a route in crew.yaml (--dry-run previews)
   crew repos clone [ROUTE] NAME  clone a Repos row's remote into the route directory and attach it (--dir PATH, --dry-run, --json)
-  crew repos hooks [ROUTE] NAME suggest test/build hooks for a checkout (--write route|repo, --json)
+  crew repos hooks [ROUTE] NAME suggest test/build hooks for a checkout (--agent, --write route|repo, --recipes, --json)
   crew repos list ROUTE         the checkouts a route has, with the tracker's Repos row each matches
   crew logbook list [route]     recent Agent Log entries, filterable by --role/--ticket
   crew logbook show [route] ID [--prompt]   one entry; --prompt reconstructs and verifies its prompt
@@ -16121,10 +16344,12 @@ ${changed2.map((c) => `  - ${c}
     lock?.release();
     lock = void 0;
   };
+  let sigintOwnedByCommand = false;
   if (!dryRun) {
     process.on("exit", dropLock);
     for (const sig of ["SIGINT", "SIGTERM"]) {
       process.on(sig, () => {
+        if (sig === "SIGINT" && sigintOwnedByCommand) return;
         dropLock();
         process.exit(0);
       });
@@ -16879,7 +17104,7 @@ ${changed2.map((c) => `  - ${c}
     case "repos": {
       const sub = positional[1];
       const usage2 = () => {
-        process.stderr.write("crew repos add [workspace/project] [name] [path] [--name N] [--project P] [--dry-run] [--no-create]\ncrew repos clone [workspace/project] <name> [--dir PATH] [--dry-run] [--json]\ncrew repos list <workspace/project>\ncrew repos hooks [workspace/project] <name> [--suggest] [--write route|repo] [--json]\n");
+        process.stderr.write("crew repos add [workspace/project] [name] [path] [--name N] [--project P] [--dry-run] [--no-create]\ncrew repos clone [workspace/project] <name> [--dir PATH] [--dry-run] [--json]\ncrew repos list <workspace/project>\ncrew repos hooks [workspace/project] <name> [--suggest] [--agent] [--write route|repo] [--recipes ID,ID] [--json]\n");
         process.exit(2);
       };
       if (sub !== "add" && sub !== "list" && sub !== "clone" && sub !== "hooks") usage2();
@@ -16889,7 +17114,13 @@ ${changed2.map((c) => `  - ${c}
           const a = parseHooksArgs(positional.slice(2), routeNamesOf(configText));
           const dir = repoDirOf(configText, dirname19(cfg.configFile), a.route, a.name);
           if (!existsSync31(dir)) throw new ReposError(`${dir} does not exist on disk`);
-          const files = { exists: (r) => existsSync31(resolvePath(dir, r)), read: (r) => {
+          const files = { exists: (r) => existsSync31(resolvePath(dir, r)), list: (r) => {
+            try {
+              return readdirSync12(resolvePath(dir, r));
+            } catch {
+              return [];
+            }
+          }, read: (r) => {
             try {
               return readFileSync25(resolvePath(dir, r), "utf8");
             } catch {
@@ -16899,21 +17130,43 @@ ${changed2.map((c) => `  - ${c}
           const suggestion = suggestHooks(files);
           const write = value("write");
           if (write !== void 0 && write !== "route" && write !== "repo") throw new ReposError(`--write takes "route" or "repo" (got "${write}")`);
+          const recipeIds = (value("recipes") ?? "").split(",").map((x) => x.trim()).filter((x) => x && x !== "none");
+          if (recipeIds.length > 0 && !write) throw new ReposError("--recipes only applies with --write route|repo");
+          if (flag("agent") && write) throw new ReposError("--agent is read-only; drop --write (write the sniffed hooks, then re-run --agent to compare)");
+          let agent = null;
+          let agentError = null;
+          if (flag("agent")) {
+            const ac = new AbortController();
+            const onSigint = () => ac.abort();
+            process.once("SIGINT", onSigint);
+            sigintOwnedByCommand = true;
+            try {
+              const routeCfg = cfg.routes.find((r) => r.route === a.route);
+              agent = await runAgentSuggest({ spec: resolveToolchain(cfg.ship, routeCfg, a.name), dir, sniff: suggestion, signal: ac.signal });
+            } catch (e) {
+              if (!(e instanceof AgentSuggestError)) throw e;
+              agentError = { reason: e.reason, message: e.message };
+            } finally {
+              process.off("SIGINT", onSigint);
+              sigintOwnedByCommand = false;
+            }
+          }
+          const picked = selectRecipes(suggestion, recipeIds);
           let written;
-          if (write && suggestion.source === null) throw new ReposError(`nothing to write: ${suggestion.notes[0]}`);
+          if (write && suggestion.source === null && recipeIds.length === 0) throw new ReposError(`nothing to write: ${suggestion.notes[0]}`);
           if (write === "route") {
-            const plan = planRouteHooks(configText, a.route, a.name, suggestion.hooks);
+            const plan = planRouteHooks(configText, a.route, a.name, picked.hooks);
             writeFileSync19(cfg.configFile, plan.text);
             written = { target: "route", file: cfg.configFile, hooks: plan.written, kept: plan.kept };
           } 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");
-            writeFileSync19(file, starterRepoConfig(suggestion.hooks), { flag: "wx" });
-            written = { target: "repo", file, hooks: Object.keys(suggestion.hooks), kept: [] };
+            writeFileSync19(file, starterRepoConfig(picked.hooks, picked.release), { flag: "wx" });
+            written = { target: "repo", file, hooks: Object.keys(picked.hooks), kept: [] };
           }
           if (flag("json")) {
-            process.stdout.write(`${JSON.stringify({ route: a.route, repo: a.name, dir, ...suggestion, written: written ?? null })}
+            process.stdout.write(`${JSON.stringify({ route: a.route, repo: a.name, dir, ...suggestion, agent, agentError, written: written ?? null })}
 `);
           } else {
             if (suggestion.source) process.stdout.write(`${a.name}: proposed from ${suggestion.source}
@@ -16921,6 +17174,18 @@ ${changed2.map((c) => `  - ${c}
             for (const [k, v] of Object.entries(suggestion.hooks)) process.stdout.write(`  ${k}: ${v}
 `);
             for (const n of suggestion.notes) process.stdout.write(`note: ${n}
+`);
+            for (const r of suggestion.recipes) process.stdout.write(`recipe ${r.id}${r.defaultOn ? " (default on)" : ""}${r.writable ? "" : " (advisory)"}: ${r.title} [${r.evidence.join(", ")}]
+`);
+            if (agent) {
+              process.stdout.write(`agent (${agent.toolchain}, ${agent.model}) read ${agent.filesRead.join(", ") || "no files"}
+`);
+              for (const [k, v] of Object.entries(agent.hooks)) process.stdout.write(`  ${k}: ${v}${agent.differsFromSniff.includes(k) ? "   (differs from file sniff)" : ""}
+`);
+              for (const n of agent.notes) process.stdout.write(`note: ${n}
+`);
+            }
+            if (agentError) process.stderr.write(`crew repos: --agent failed (${agentError.reason}): ${agentError.message}
 `);
             if (written) {
               process.stdout.write(`wrote ${written.hooks.join(", ") || "nothing new"} to ${written.file}
@@ -16928,8 +17193,11 @@ ${changed2.map((c) => `  - ${c}
               if (written.kept.length) process.stdout.write(`kept existing route hooks: ${written.kept.join(", ")}
 `);
               if (written.target === "repo") process.stdout.write("review it and commit it to the repository\n");
+              if (written.target === "route" && picked.release) process.stdout.write(`note: release.mode ${picked.release.mode} is repo-level; use --write repo to set it
+`);
             }
           }
+          if (agentError) process.exitCode = 1;
         } catch (e) {
           if (e instanceof ReposError) {
             process.stderr.write(`crew repos: ${e.message}
@@ -18239,7 +18507,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
         },
         inspectCheckout(dir) {
           const dirty = status(dir).map((c) => c.path);
-          const linkedWorktrees = worktrees(dir).map((w) => w.path).filter((p) => realpathSync2(p) !== realpathSync2(dir));
+          const linkedWorktrees = worktrees(dir).map((w) => w.path).filter((p) => realpathSync3(p) !== realpathSync3(dir));
           return { dirty, linkedWorktrees };
         }
       };

package/package.json

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