catherd-cli 1.3.0 → 1.5.0

package/src/entry/host-arg.ts

@@ -0,0 +1,56 @@
+import { CatherdError } from "../domain/errors.ts";
+import type { HostContext } from "../domain/host.ts";
+import { resolveHost } from "../infra/host-context.ts";
+
+export const HOST_ARG = {
+  host: {
+    type: "enum" as const,
+    options: ["auto", "codex", "claude-code"],
+    description: "orchestration host (auto uses session evidence)",
+  },
+};
+
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+
+/**
+ * Plan 22, `doctor --test-push --thread <uuid>`: Codex does not export its thread id to the commands it runs, so a
+ * shell names the thread the smoke goes to. It makes the host that Codex thread; a Claude Code session refuses it.
+ */
+export function withThread(host: HostContext, thread: string | undefined): HostContext {
+  if (thread === undefined) return host;
+  if (!UUID.test(thread))
+    throw new CatherdError("E_INPUT_INVALID", `--thread ${thread} is not a Codex thread id`, {
+      fix: "pass the thread's UUID, as the first line of a catherd message names it (thread: <uuid>)",
+    });
+  if (host.host === "claude-code")
+    throw new CatherdError(
+      "E_INPUT_INVALID",
+      "--thread names a Codex thread, and this is a Claude Code session",
+      {
+        fix: "run catherd doctor --test-push without --thread from Claude Code",
+      },
+    );
+  const sessionId = thread.toLowerCase();
+  return {
+    host: "codex",
+    session: { host: "codex", sessionId, hostSessionId: null, name: null },
+    conflict: null,
+  };
+}
+
+export function terminalHost(value: string | undefined, env = process.env): HostContext {
+  if (value === undefined || value === "auto") return resolveHost({ env });
+  if (value !== "codex" && value !== "claude-code")
+    throw new CatherdError("E_INPUT_INVALID", `unknown host ${value}`, {
+      fix: "use --host auto, codex or claude-code",
+    });
+  const resolved = resolveHost({ env, terminalHost: value });
+  if (resolved.conflict) return resolved;
+  if (resolved.host !== value)
+    return {
+      host: "unknown",
+      session: null,
+      conflict: "Terminal host and launcher session evidence disagree; remove the other host’s environment",
+    };
+  return { ...resolved, session: null };
+}

package/src/entry/init-command.ts

@@ -1,3 +1,5 @@
+import { gitToplevel } from "../infra/git.ts";
+import { HOST_ARG, terminalHost } from "./host-arg.ts";
 import { defineCommand } from "citty";
 import { assertProfileName } from "../domain/profile.ts";
 import { errorMessage, isCatherdError } from "../domain/errors.ts";
@@ -11,8 +13,9 @@ import { type SyncReport, syncSources } from "../services/source-sync.ts";
 import { reinstallCommand } from "../services/doctor-checks.ts";
 import { ensureGlobal, type GlobalInstallDeps, realGlobalInstall } from "../services/global-install.ts";
 import { hasProfileFile, type InitResult, initSetup, moveLegacy } from "../services/setup.ts";
+import { activeName } from "../services/profile-store.ts";
 import { formatRefreshed, syncLines } from "./catalog-command.ts";
-import { mark as markOf } from "./cli-kit.ts";
+import { mark as markOf, refuseInRole } from "./cli-kit.ts";
 import { formatReport } from "./doctor-command.ts";
 import { mcpHandshake } from "./mcp/handshake.ts";
 import type { State } from "./glyphs.ts";
@@ -195,6 +198,7 @@ export const initCommand = defineCommand({
       "First run: the global catherd command, the Jev key, the Artificial Analysis key, a sync of the public model sources, the default profile, its agents, and a readiness report. Piped, it reads the answers from stdin one per line, a line per question even when this machine skips it (the Jev key, the Artificial Analysis key, the profile, whether to replace it), and waits for stdin to close; --no-input asks nothing",
   },
   args: {
+    ...HOST_ARG,
     // citty reads --no-input as input: false, whatever the flag is named; naming it no-input shows it as is
     "no-input": { type: "boolean", description: "ask nothing: keep what exists, else write the defaults" },
     // read as global: false, like no-input above
@@ -202,10 +206,14 @@ export const initCommand = defineCommand({
       type: "boolean",
       description: "do not install the global catherd command (bun add -g catherd-cli@<this version>)",
     },
-    profile: { type: "string", description: "the profile to set up and make active (default: default)" },
+    profile: {
+      type: "string",
+      description: "the profile to set up and make active (default: current repo profile)",
+    },
     plain: { type: "boolean", description: "ASCII glyphs (NO_COLOR drops only colour)" },
   },
   async run({ args }) {
+    refuseInRole(process.env, "catherd init");
     // a bad --profile is refused before any question is asked
     if (args.profile !== undefined) assertProfileName(args.profile);
     const ask = (args as { input?: boolean }).input === false ? null : await prompter();
@@ -218,19 +226,21 @@ export const initCommand = defineCommand({
       await jevStep(ask, {}, plain);
       await aaStep(ask, {}, plain);
       await syncStep({ plain });
-      if (args.profile !== undefined) ask?.skip?.();
-      const name = assertProfileName(
-        args.profile ?? (ask ? (await ask.ask("Profile to set up [default]: ")) || "default" : "default"),
-      );
+      const repo = await gitToplevel(process.cwd());
       // 0.x files go first, so a legacy profile about to be moved aside is never asked about
       const moved = moveLegacy();
+      const current = activeName(repo);
+      if (args.profile !== undefined) ask?.skip?.();
+      const selected =
+        args.profile ?? (ask ? (await ask.ask(`Profile to set up [${current}]: `)) || undefined : undefined);
+      const name = assertProfileName(selected ?? current);
       const exists = hasProfileFile(name);
       if (!exists) ask?.skip?.();
       const overwrite =
         ask !== null &&
         exists &&
         /^y(es)?$/i.test(await ask.ask(`Replace profile ${name} with the default profile? [y/N] `));
-      const r = await initSetup({ profile: name, overwrite });
+      const r = await initSetup({ profile: selected, repo, overwrite, host: terminalHost(args.host) });
       for (const f of [...moved, ...r.moved]) console.log(`${mark("ok")} moved a 0.x file aside: ${f}`);
       for (const l of profileLines(r, plain)) console.log(l);
       if (r.synced?.linked.length)
@@ -238,13 +248,15 @@ export const initCommand = defineCommand({
       for (const x of r.refreshed) console.log(formatRefreshed(x, plain));
       console.log("");
       const report = await doctor({
+        host: terminalHost(args.host),
+        repo,
         bunVersion: Bun.version,
         version: VERSION,
         handshake: () => mcpHandshake(),
       });
       for (const l of formatReport(report, plain)) console.log(l);
       console.log("");
-      for (const l of PLUGIN_STEPS) console.log(l);
+      for (const l of terminalHost(args.host).host === "claude-code" ? PLUGIN_STEPS : []) console.log(l);
     } finally {
       ask?.close();
     }

package/src/entry/knowledge-command.ts

@@ -1,7 +1,9 @@
 import { resolve } from "node:path";
 import { defineCommand } from "citty";
+import { CatherdError } from "../domain/errors.ts";
+import { gateEnvLines, readGateEnv, removeGateEnv, setGateEnv } from "../services/gate-env.ts";
 import { addKnowledge, knowledgeLines, knowledgePath, readKnowledge } from "../services/run-service.ts";
-import { JSON_ARG, printJson } from "./cli-kit.ts";
+import { JSON_ARG, printJson, refuseInRole } from "./cli-kit.ts";
 
 /** `--repo`, else the repository the command runs in, as run_start and read_knowledge resolve it. */
 const REPO_ARG = {
@@ -29,6 +31,7 @@ const add = defineCommand({
     ...REPO_ARG,
   },
   async run({ args }) {
+    refuseInRole(process.env, "catherd knowledge add");
     console.log(await addKnowledge(repoOf(args.repo), args.line));
   },
 });
@@ -43,8 +46,80 @@ const path = defineCommand({
   },
 });
 
+/** `NAME=value` as name and value; null when it has no `=`. */
+function assignment(raw: string): { name: string; value: string } | null {
+  const eq = raw.indexOf("=");
+  return eq > 0 ? { name: raw.slice(0, eq), value: raw.slice(eq + 1) } : null;
+}
+
+const envSet = defineCommand({
+  meta: {
+    name: "set",
+    description:
+      "Set one variable of the repo's gate environment, which the verifier and preflight run with: NAME=value, or NAME --from ENV_VAR for a secret (stored by reference, read when a role starts)",
+  },
+  args: {
+    variable: { type: "positional", required: true, description: "NAME=value, or NAME with --from" },
+    from: { type: "string", description: "the env var that holds the secret value" },
+    ...REPO_ARG,
+    ...JSON_ARG,
+  },
+  async run({ args }) {
+    refuseInRole(process.env, "catherd knowledge env set");
+    const set = assignment(args.variable);
+    if (args.from !== undefined && set)
+      throw new CatherdError("E_INPUT_INVALID", "pass NAME=value or NAME --from ENV_VAR, not both", {
+        fix: "catherd knowledge env set DOCKER_HOST=unix:///var/run/docker.sock",
+      });
+    if (args.from === undefined && !set)
+      throw new CatherdError("E_INPUT_INVALID", `"${args.variable}" has no value`, {
+        fix: "catherd knowledge env set NAME=value, or catherd knowledge env set NAME --from ENV_VAR",
+      });
+    const r = set
+      ? await setGateEnv(repoOf(args.repo), set.name, { value: set.value })
+      : await setGateEnv(repoOf(args.repo), args.variable, { from: args.from as string });
+    if (args.json) return printJson(r);
+    for (const line of gateEnvLines(r.vars)) console.log(line);
+  },
+});
+
+const envRm = defineCommand({
+  meta: { name: "rm", description: "Remove one variable from the repo's gate environment" },
+  args: { name: { type: "positional", required: true }, ...REPO_ARG, ...JSON_ARG },
+  async run({ args }) {
+    refuseInRole(process.env, "catherd knowledge env rm");
+    const r = await removeGateEnv(repoOf(args.repo), args.name);
+    if (args.json) return printJson(r);
+    for (const line of gateEnvLines(r.vars)) console.log(line);
+  },
+});
+
+const envList = defineCommand({
+  meta: { name: "list", description: "Print the repo's gate environment (a secret shows as $ENV_VAR)" },
+  args: { ...REPO_ARG, ...JSON_ARG },
+  async run({ args }) {
+    const at = await knowledgePath(repoOf(args.repo));
+    const vars = await readGateEnv(at.repo);
+    if (args.json) return printJson({ repo: at.repo, vars });
+    const lines = gateEnvLines(vars);
+    console.log(lines.length ? lines.join("\n") : "catherd: no gate environment set for this repo");
+  },
+});
+
+/** Plan 23: the repo's gate environment, beside its knowledge.md. */
+const env = defineCommand({
+  meta: {
+    name: "env",
+    description: "The repo's gate environment, which the verifier and preflight run with: set, rm or list",
+  },
+  subCommands: { set: envSet, rm: envRm, list: envList },
+});
+
 /** What past runs of a repo learned, which the read_knowledge tool gives every new run (spec §4.7). */
 export const knowledgeCommand = defineCommand({
-  meta: { name: "knowledge", description: "What catherd knows about a repo: show, add or path" },
-  subCommands: { show, add, path },
+  meta: {
+    name: "knowledge",
+    description: "What catherd knows about a repo: show, add or path, and its gate environment (env)",
+  },
+  subCommands: { show, add, path, env },
 });

package/src/entry/lock-command.ts

@@ -1,10 +1,12 @@
+import { HOST_ARG } from "./host-arg.ts";
 import { defineCommand } from "citty";
 import { CatherdError } from "../domain/errors.ts";
 import { scrubSecrets } from "../infra/env.ts";
 import { gitToplevel } from "../infra/git.ts";
-import { heavySlots, withHeavySlot } from "../infra/heavy-lock.ts";
+import { heavySlots, withHeavySlot, withRoleLock } from "../infra/heavy-lock.ts";
+import { activityReporter, DISPATCH_ID_ENV } from "../infra/lock-activity.ts";
 import { killGroup } from "../infra/proc.ts";
-import { profileFor } from "../services/profile-store.ts";
+import { activeName, readProfileDoc } from "../services/profile-store.ts";
 import { printError } from "./cli-kit.ts";
 
 /**
@@ -43,14 +45,26 @@ export const DOUBLE_INTERRUPT_MS = 2_000;
  * a terminal's Ctrl-C reaches catherd only, so the command sees it exactly once, and so does every
  * process it started. A second Ctrl-C within 2 s kills the group. Resolves to the command's exit code.
  */
-export async function runForwarding(argv: string[]): Promise<number> {
+export async function runForwarding(
+  argv: string[],
+  o: { onOutput?: () => void; extraEnv?: Record<string, string> } = {},
+): Promise<number> {
+  // plan 23: inside a dispatch the output passes through catherd, which notes when the command last wrote
+  const piped = o.onOutput !== undefined;
   const child = Bun.spawn(argv, {
     stdin: "inherit",
-    stdout: "inherit",
-    stderr: "inherit",
-    env: scrubSecrets(process.env),
+    stdout: piped ? "pipe" : "inherit",
+    stderr: piped ? "pipe" : "inherit",
+    env: { ...scrubSecrets(process.env), ...o.extraEnv },
     detached: true,
   });
+  const pumps =
+    piped && o.onOutput
+      ? [
+          pump(child.stdout as ReadableStream<Uint8Array>, process.stdout, o.onOutput),
+          pump(child.stderr as ReadableStream<Uint8Array>, process.stderr, o.onOutput),
+        ]
+      : [];
   let lastInt = 0;
   const handlers: [NodeJS.Signals, () => void][] = [
     [
@@ -71,6 +85,7 @@ export async function runForwarding(argv: string[]): Promise<number> {
   const watchdog = Bun.spawn(
     ["sh", "-c", 'read _ || kill -s KILL -- "-$1" 2>/dev/null', "sh", String(child.pid)],
     {
+      env: scrubSecrets(process.env),
       stdin: "pipe",
       stdout: "ignore",
       stderr: "ignore",
@@ -78,15 +93,53 @@ export async function runForwarding(argv: string[]): Promise<number> {
     },
   );
   try {
-    return await child.exited;
+    const code = await child.exited;
+    // a process the command left behind may hold the pipes open: what it wrote by then is passed on
+    await Promise.race([Promise.all(pumps), Bun.sleep(PIPE_DRAIN_MS)]);
+    return code;
   } finally {
     watchdog.kill("SIGKILL");
     for (const [sig, h] of handlers) process.off(sig, h);
   }
 }
 
+/** How long the pipes may stay open after the command exits. */
+const PIPE_DRAIN_MS = 500;
+
+/** Copies a piped stream to `out`, calling `tick` for each chunk; a broken pipe ends the copy. */
+async function pump(
+  stream: ReadableStream<Uint8Array>,
+  out: NodeJS.WriteStream,
+  tick: () => void,
+): Promise<void> {
+  try {
+    for await (const chunk of stream) {
+      out.write(chunk);
+      tick();
+    }
+  } catch {
+    // the command's end closes the pipe
+  }
+}
+
 /** Spec §8: what `--help` and the usage error show; the command runs after `--`. */
-export const LOCK_USAGE = "catherd lock [--slots N] -- <command> [args...]";
+export const LOCK_USAGE = "catherd lock [--slots N] [--role verifier [--run <run>]] -- <command> [args...]";
+
+/** The roles that take a machine-wide role lock besides their slot (spec 1.5 "Cross-run verifier contention"). */
+export const ROLE_LOCKS = ["verifier"] as const;
+
+/**
+ * Whose a role lock is: `--run`, else the run in `CATHERD_ROLE` (`<run>/<role-name>`, which the supervisor
+ * sets in every role's env), else this process alone. Commands of one run share the lock.
+ */
+export function roleLockOwnerOf(run: string | undefined, env: NodeJS.ProcessEnv): string {
+  if (run) return `run:${run}`;
+  const fromRole = env.CATHERD_ROLE?.split("/")[0];
+  return fromRole ? `run:${fromRole}` : `process:${process.pid}`;
+}
+
+/** Set in a locked command's env: a `catherd lock` inside it runs at once, holding nothing more. */
+export const LOCK_HELD_ENV = "CATHERD_LOCK_HELD";
 
 export const lockCommand = defineCommand({
   meta: {
@@ -95,10 +148,20 @@ export const lockCommand = defineCommand({
       "Run a heavy command behind the machine-wide semaphore, in its own process group and session: it gets no /dev/tty and no job control",
   },
   args: {
+    ...HOST_ARG,
     slots: {
       type: "string",
       description: "Slots (default: CATHERD_LOCK_SLOTS, else the profile's lock.heavy, else half the cores)",
     },
+    role: {
+      type: "string",
+      description:
+        "verifier: also hold the machine-wide verifier lock, shared by one run's commands, so two runs' verifiers never overlap",
+    },
+    run: {
+      type: "string",
+      description: "with --role: the run whose commands share it (default: CATHERD_ROLE's)",
+    },
   },
   async run({ args, rawArgs }) {
     const sep = rawArgs.indexOf("--");
@@ -112,12 +175,50 @@ export const lockCommand = defineCommand({
       process.exitCode = 2;
       return;
     }
+    if (args.role !== undefined && !(ROLE_LOCKS as readonly string[]).includes(args.role)) {
+      printError(
+        new CatherdError("E_INPUT_INVALID", `no role lock "${args.role}"`, {
+          fix: "catherd lock --role verifier -- <command>",
+        }),
+      );
+      process.exitCode = 2;
+      return;
+    }
+    // already inside a locked command: run at once, so a nested lock never waits on its own parent's slot
+    if (process.env[LOCK_HELD_ENV] === "1") {
+      process.exitCode = await runForwarding(argv);
+      return;
+    }
+    // plan 23: a role's lock reports its output, so the role's wall timeout counts from its last line; it
+    // reports while it waits for the role lock or a slot too, so a gate queued behind another run's is not
+    // killed before its first command
+    const activity = activityReporter(process.env[DISPATCH_ID_ENV]);
+    const waiting = activity ? { onWait: activity.tick } : {};
+    const run = () =>
+      runForwarding(argv, {
+        extraEnv: { [LOCK_HELD_ENV]: "1" },
+        ...(activity ? { onOutput: activity.tick } : {}),
+      });
+    const role = args.role;
     const repo = await gitToplevel(process.cwd());
     const slots = resolveSlots(
       args.slots,
-      () => profileFor(repo).lock.heavy,
+      // lock.heavy is host-independent: read it stored, so a worker (whose host identity is scrubbed) and an
+      // unknown terminal host still get the profile's value instead of the cpus/2 fallback
+      () => readProfileDoc(activeName(repo)).lock?.heavy ?? "cpus/2",
       (m) => console.error(m),
     );
-    process.exitCode = await withHeavySlot(slots, () => runForwarding(argv));
+    try {
+      process.exitCode = role
+        ? await withRoleLock(
+            role,
+            roleLockOwnerOf(args.run, process.env),
+            () => withHeavySlot(slots, run, waiting),
+            waiting,
+          )
+        : await withHeavySlot(slots, run, waiting);
+    } finally {
+      activity?.done();
+    }
   },
 });

package/src/entry/mcp/dispatch-tools.ts

@@ -12,13 +12,13 @@ export function registerDispatchTools(server: McpServer, deps: Deps): void {
     "dispatch",
     {
       description:
-        "Start one role on a process backend (codex, claude-code, opencode) and return at launch, in about a second, with { dispatched: { name, role, rung, dispatchId, admittedAt }, hints }; the role runs on. When it finishes, catherd sends this session a <cross-session-message from-name=\"catherd\"> naming the run, the role and its status, and result(run, name) reads the record. Dispatch every independent role one after another, then end your turn. The brief is the text itself; dispatch appends the role's reply contract (reply length and the STATUS line), so do not write it. With lane, the lane file's Owns: paths guard against overlapping lanes, and a lane not yet routed is routed first (a rung off its routed ladder starts at the routed rung, with a hint). thread resumes that role's thread for its own fix round. Refused with a structured error (E_ADMIT_*, E_RUN_BUDGET, E_BACKEND_*) before anything starts. Call it from the main thread.",
+        "Start one role on a process backend (codex, claude-code, opencode) and return at launch, in about a second, with { dispatched: { name, role, rung, dispatchId, admittedAt }, hints }; the role runs on. When it finishes, catherd sends this session a <cross-session-message from-name=\"catherd\"> naming the run, the role and its status, and result(run, name) reads the record. Dispatch every independent role one after another, then end your turn. The brief is the text itself; dispatch appends the role's reply contract (reply length and the STATUS line), so do not write it. With lane, the lane file's Owns: paths guard against overlapping lanes, a lane not yet routed is routed first (a rung off its routed ladder starts at the routed rung, with a hint), and rung may be left out: the lane runs at its current rung (its route, or the rung its last climb gave). Without lane, rung is required (route(run, role) gives it), and the choice is recorded in routes.jsonl. thread resumes that role's thread for its own fix round: the thread its catherd message names, or \"latest\" for the name's last thread; a thread the name never ran on in this run is refused (E_ADMIT_THREAD). Refused with a structured error (E_ADMIT_*, E_RUN_BUDGET, E_BACKEND_*) before anything starts. Call it from the main thread.",
       inputSchema: {
         run: z.string(),
         role: z.enum(ROLES),
         name: z.string().regex(ID_PATTERN),
         brief: z.string().min(1),
-        rung: z.string().min(3),
+        rung: z.string().min(3).optional(),
         thread: z.string().optional(),
         lane: z.string().regex(ID_PATTERN).optional(),
         next: z.string().optional(),
@@ -31,7 +31,7 @@ export function registerDispatchTools(server: McpServer, deps: Deps): void {
     "peek",
     {
       description:
-        "A look at the runs, without waiting: with run, that run (and this session becomes its owner); without, every run this session owns, else the newest. Per run, first the open owner questions, which are the owner's questions: push them to the owner, relay the owner's answer with answer(run, milestone, answer), and go on with the work that does not depend on them. Then each live role with its rung, seconds since it started and its last event (the last command, file edit or message line); every finished record not yet read, as the first line of catherd's message; the latest native Claude run; the run's next step; protocol, the milestone loop's next step and its six-line checklist; and verifier, the verifier's latest gate step. name narrows it to one role. It never marks a record read: result(run, name) does. Call it when the user asks how it is going, when a decision needs the other roles' state, or once after run_start on a resumed run; never in a loop.",
+        "A look at the runs, without waiting: with run, that run (and this session becomes its owner); without, every run this session owns, else the newest. Per run, first the open owner questions, which are the owner's questions: push them to the owner, relay the owner's answer with answer(run, milestone, answer), and go on with the work that does not depend on them. Then each live role with its rung, seconds since it started and its last event (the last command, file edit or message line); every finished record not yet read, as the first line of catherd's message; the latest native Claude run; the run's next step; protocol, the milestone loop's next step and its six-line checklist; and verifier, the verifier's latest gate step. name narrows it to one role. It never marks a record read: result(run, name) does. Call it when the user asks how it is going, when a decision needs the other roles' state, or once after run_start on a resumed run; never in a loop. actionable is false, with its reason, when nothing is yours to do (only roles are live on the step, or the owner's answer comes first): end the turn with no tool call, and the next catherd message wakes you.",
       inputSchema: {
         run: z.string().optional(),
         name: z.string().regex(ID_PATTERN).optional(),

package/src/entry/mcp/handshake.ts

@@ -12,10 +12,16 @@ export const LAUNCHER = fileURLToPath(new URL("../../../plugin/bin/catherd-mcp",
 const TIMEOUT_MS = 60_000;
 const STDERR_TAIL = 4_000;
 
-/** The env the doctor's MCP server starts with: catherd's own secrets scrubbed, as for every process it starts. */
+/**
+ * The env the doctor's MCP server starts with: catherd's own secrets scrubbed, as for every process it starts,
+ * and no boot sync (1.2 minor): the server lives for one tools/list, so a sync there spends fetches (AA's
+ * included) and records nothing.
+ */
 export const handshakeEnv = (
   base: Record<string, string | undefined> = process.env,
-): Record<string, string> => scrubSecrets(base);
+): Record<string, string> => {
+  return { ...scrubSecrets(base), CATHERD_NO_SYNC: "1" };
+};
 
 /**
  * Spec §10.3 and 1.1 §12: starts the MCP server the way the plugin does, `sh <launcher>` over stdio, and

package/src/entry/mcp/lane-tools.ts

@@ -2,8 +2,10 @@ import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { z } from "zod";
 import { ID_PATTERN } from "../../domain/ids.ts";
 import { ROLES } from "../../domain/roles.ts";
+import { CatherdError } from "../../domain/errors.ts";
 import { CLIMB_REASONS } from "../../domain/route.ts";
-import { ask, climb, LAND_SKIPS, land, route } from "../../services/lane-service.ts";
+import { LANE_FIELDS, type LaneField, laneSet, ownsAdd } from "../../services/lane-edit.ts";
+import { ask, climb, LAND_SKIPS, land, route, routeLanes } from "../../services/lane-service.ts";
 import type { Deps } from "../../services/ports.ts";
 import { preflight } from "../../services/preflight.ts";
 import { handle } from "./result.ts";
@@ -13,31 +15,76 @@ export function registerLaneTools(server: McpServer, deps: Deps): void {
     "route",
     {
       description:
-        "The rung for a lane (from Jev, else the lane file's Kind/Difficulty lines, else the profile default) or, without a lane file, a role's default rung, with the ladder above it. Rungs are backend:model#effort; a claude: rung comes with the agent to run it as. `provenance` says why: each threshold of the lane's bar with the value used against it, that value's confidence, source and date (`inferred: true` when a treat-like or a stand-in lent it), the rung's speed and cost facts, and catherd's own run evidence for it (shown, never used to route). A lane whose Kind: or Difficulty: the catalog does not know is refused with E_LANE_INVALID.",
+        "The rung for a lane (from the lane file's Kind/Difficulty lines when it declares both, else Jev, else the profile default), or with lanes (several lane files) for each of them in one call, Jev asked about all at once ({ routes: [...] }, in order), or, without a lane file, a role's default rung, with the ladder above it: only rungs at least as strong as the start. Rungs are backend:model#effort; a claude: rung comes with the agent to run it as. Returns rung, ladder, backend, agent and why: one line naming the decision, where Jev disagreed with the lane's header, when no rung clears the bar (and the closest), and when a tie between quotas decided. Every decision, with its provenance (each threshold, the value used, its source and date, the rung's cost and run evidence), is written to the run's routes.jsonl. A lane whose Kind: or Difficulty: the catalog does not know is refused with E_LANE_INVALID.",
       inputSchema: {
         run: z.string(),
         lane_file: z.string().optional(),
+        lanes: z.array(z.string()).min(1).optional(),
         role: z.enum(ROLES).default("worker"),
       },
     },
-    (a) => handle(() => route(deps, { run: a.run, laneFile: a.lane_file, role: a.role })),
+    (a) =>
+      handle(async () => {
+        if (a.lanes && a.lane_file !== undefined)
+          throw new CatherdError("E_INPUT_INVALID", "route takes lane_file or lanes, not both", {
+            fix: "pass every lane file in lanes",
+          });
+        return a.lanes
+          ? { routes: await routeLanes(deps, { run: a.run, laneFiles: a.lanes, role: a.role }) }
+          : route(deps, { run: a.run, laneFile: a.lane_file, role: a.role });
+      }),
+  );
+
+  const lane = z.string().regex(ID_PATTERN);
+  server.registerTool(
+    "lane_set",
+    {
+      description:
+        "Set one header line of a lane file (owns, fast_check, kind, difficulty, after, allow), validated as write_run_file validates a lane: an unknown Kind or Difficulty, an Owns path outside the repo, or a malformed After:/Allow: is refused with E_LANE_INVALID, and an Owns that a running lane holds with E_ADMIT_OVERLAP. after names lanes that must finish first; allow lists path or path:line hits the lane's absence check may report. Returns the line and the header as it now reads. Orchestrator only.",
+      inputSchema: {
+        run: z.string(),
+        lane,
+        field: z.enum(Object.keys(LANE_FIELDS) as [LaneField, ...LaneField[]]),
+        value: z.string(),
+      },
+    },
+    (a) => handle(() => laneSet(deps, a)),
+  );
+
+  server.registerTool(
+    "owns_add",
+    {
+      description:
+        "Grow a lane's Owns mid-lane, with why (kept in the lane file): a running lane that owns one of the paths refuses it with E_ADMIT_OVERLAP; another lane file that lists one comes back as a hint. A dispatch of the lane still running is held to the new list when it finishes, so its edits there are not violations. Orchestrator only.",
+      inputSchema: {
+        run: z.string(),
+        lane,
+        paths: z.array(z.string().min(1)).min(1).max(100),
+        why: z.string().min(1),
+      },
+    },
+    (a) => handle(() => ownsAdd(deps, a)),
   );
 
   server.registerTool(
     "preflight",
     {
       description:
-        "Run each lane's fast check once, on the base tree, behind the heavy-command lock, with a 120 s timeout. Each lane is pass, fails-as-expected, skipped (it checks a file the lane creates) or cannot-start; only cannot-start blocks. When the profile asks for confirmation, the first call returns the commands to show the user; call again with confirmed: true. Refused with E_LANE_INVALID, running nothing, while any lane's Kind: or Difficulty: is not one the catalog knows.",
-      inputSchema: { run: z.string(), confirmed: z.boolean().optional() },
+        "Run each lane's fast check once, on the base tree, behind the heavy-command lock, with a 120 s timeout, in the user's login environment plus the repo's gate environment (catherd knowledge env). By default only the lanes of milestones not landed yet; milestone names one. Each lane is pass, fails-as-expected, skipped (it checks a file the lane creates, or a pnpm filter that matches no package yet), cannot-start (a missing command, a timeout, or an environment error: no Docker, DNS, a denied permission; its note says which) or lock-busy (no heavy slot came free within 60 s: run it again); only cannot-start blocks. warnings names each lane whose fast check runs no linter while the repo has one. When the profile asks for confirmation, the first call returns the commands to show the user; call again with confirmed: true. Refused with E_LANE_INVALID, running nothing, while any lane's Kind: or Difficulty: is not one the catalog knows.",
+      inputSchema: {
+        run: z.string(),
+        confirmed: z.boolean().optional(),
+        milestone: z.string().regex(ID_PATTERN).optional(),
+      },
     },
-    (a) => handle(() => preflight(deps, { run: a.run, confirmed: a.confirmed })),
+    (a) => handle(() => preflight(deps, { run: a.run, confirmed: a.confirmed, milestone: a.milestone })),
   );
 
   server.registerTool(
     "climb",
     {
       description:
-        "Move a routed lane one rung up its ladder and record why. Returns the next rung, or top: true, and any hints. Dispatch the lane again at that rung on a fresh thread. Pass env: true when the environment caused it (a missing service, a broken tool, a usage limit), not the rung. Refused with E_CLIMB_DESIGN when the evidence is a design question (Jev's finding answer is design, or a blocked climb's evidence is about lane ownership): send it to the architect instead.",
+        "Move a routed lane one rung up its ladder and record why. Returns the next rung, or top: true, and any hints. Dispatch the lane again at that rung on a fresh thread. Pass env: true when the environment caused it (a missing service, a broken tool, a usage limit), not the rung. Refused with E_CLIMB_DESIGN when the evidence is a design question (Jev's finding answer is design, or a blocked climb's evidence is about lane ownership): send it to the architect instead. Refused with E_CLIMB_ENV when the lane's last reply named the environment on an ENV: line: fix the environment or park the milestone.",
       inputSchema: {
         run: z.string(),
         lane: z.string().regex(ID_PATTERN),
@@ -67,7 +114,7 @@ export function registerLaneTools(server: McpServer, deps: Deps): void {
     "land",
     {
       description:
-        "Record a landed milestone after you commit it: its five-column ledger row (with the minutes it took) and state.md's last check and next step, with any hints. learned, when given, goes to this repo's knowledge.md. Returns digest: the milestone's digest (R/digests/<milestone>.md: A-lines, commit, lanes with rungs and climbs, reviewer findings, the verifier's verdict with carried items, minutes and tokens), for the milestone push to link. Refused with E_LAND_GATE unless, since the milestone's lanes started, a reviewer named reviewer-<milestone> ended ok (a dispatch, or a Claude subagent recorded with record_agent_run, role reviewer) and a verifier verdict naming the milestone was recorded ok (record_agent_run, role verifier; a headless verifier's reply opening VERDICT: PASS). A skip over an empty commit range is refused: commit first. skip: docs-only lands a milestone whose commit range changed only docs; skip: no-code one that changed no source file (put the evidence, e.g. a green pipeline, in evidence).",
+        "Record a landed milestone after you commit it: its five-column ledger row (with the minutes it took) and state.md's last check and next step, with any hints. learned, when given, goes to this repo's knowledge.md. Returns digest: the milestone's digest (R/digests/<milestone>.md: A-lines, the commits, lanes with rungs and climbs, the reviewer's BLOCKER and BUG lines, the owner questions still open, the verifier's verdict with carried items, minutes and tokens), and digestPath, its full path, for the milestone push to link. Refused with E_LAND_GATE unless, since the milestone's lanes started, a reviewer named reviewer-<milestone> ended ok (a dispatch, or a Claude subagent recorded with record_agent_run, role reviewer) and a verifier verdict was recorded ok under exactly verifier-<milestone> (record_agent_run, role verifier; a headless verifier's reply opening VERDICT: PASS; verifier-M1-pre does not count). minutes leave out the time the milestone was parked and any machine or workspace pause. A skip over an empty commit range is refused: commit first. skip: docs-only lands a milestone whose commit range changed only docs; skip: no-code one that changed no source file (put the evidence, e.g. a green pipeline, in evidence).",
       inputSchema: {
         run: z.string(),
         milestone: z.string().regex(ID_PATTERN),

package/src/entry/mcp/protocol-tools.ts

@@ -1,7 +1,7 @@
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { z } from "zod";
 import { ID_PATTERN } from "../../domain/ids.ts";
-import { gateCheck, gatePass } from "../../services/gate-service.ts";
+import { gateCheckOrList, gatePass } from "../../services/gate-service.ts";
 import { answer, park } from "../../services/questions.ts";
 import type { Deps } from "../../services/ports.ts";
 import { handle } from "./result.ts";
@@ -19,10 +19,16 @@ export function registerProtocolTools(server: McpServer, deps: Deps): void {
     "gate_check",
     {
       description:
-        "The verifier, before running a gate item: { carried: true, passedAt, commit } when this repo already has a pass of the same command on the same content of paths (repo-relative; . for the whole repo: HEAD plus uncommitted not-ignored changes; a git-ignored input such as .env or a build output is hashed only when named as a path), so it reports the item as carried over from that commit instead of running it; else { carried: false }, and it runs the item. Either way the call is recorded as the verifier's current step, which status and peek show. Pass milestone (the M the verifier checks) so the milestone's digest lists only its own carried items.",
-      inputSchema: { ...gate, milestone: z.string().regex(ID_PATTERN).optional() },
+        "The verifier, before running a gate item: { carried: true, passedAt, commit } when this repo already has a pass of the same command on the same content of paths (repo-relative; . for the whole repo: the tracked files plus uncommitted not-ignored changes; the repo's lockfiles always count, so never name node_modules; a git-ignored input such as .env or a build output is hashed only when named as a path, and as absent while it is not built), so it reports the item as carried over from that commit instead of running it; else { carried: false }, and it runs the item. Either way the call is recorded as the verifier's current step, which status and peek show. Pass milestone (the M the verifier checks): the milestone's digest then lists only its own carried items, and the answer adds recorded, the items already checked for that milestone in this run, each with its command and whether it passed. Call it first with only run and milestone to get that list without checking anything: reuse those item names, and re-check the failed ones first.",
+      inputSchema: {
+        run: z.string(),
+        item: gate.item.optional(),
+        command: gate.command.optional(),
+        paths: gate.paths.optional(),
+        milestone: z.string().regex(ID_PATTERN).optional(),
+      },
     },
-    (a) => handle(() => gateCheck(deps, a)),
+    (a) => handle(() => gateCheckOrList(deps, a)),
   );
 
   server.registerTool(

package/src/entry/mcp/push-tools.ts

@@ -0,0 +1,16 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { probePush } from "../../services/doctor-push.ts";
+import type { Deps } from "../../services/ports.ts";
+import { handle } from "./result.ts";
+
+export function registerPushTools(server: McpServer, deps: Deps): void {
+  server.registerTool(
+    "test_push",
+    {
+      description:
+        "Send this session one labeled smoke message through catherd's push (Claude Code's peer inbox, or the native Codex queue for this thread) and return the receipt: { outcome, enqueue, processing, msgId, detail }. A receipt proves the host accepted it, never that the model read it. For a check from inside a session, where a shell cannot name the Codex thread; catherd doctor --test-push --thread <uuid> is the shell's form.",
+      inputSchema: {},
+    },
+    () => handle(() => probePush(deps.host, process.env)),
+  );
+}