@testmuai/rook 0.1.2 → 0.1.3

package/dist/cli.js

@@ -499,7 +499,7 @@ var VERSION, SHA, VERSION_LABEL, CLIENT_NAME, PUBLIC_DOCS_URL, PUBLIC_UPDATE_COM
 var init_constants = __esm({
   "src/constants.ts"() {
     "use strict";
-    VERSION = true ? "0.1.2" : "0.0.0-dev";
+    VERSION = true ? "0.1.3" : "0.0.0-dev";
     SHA = /^[0-9a-f]{40}$/;
     VERSION_LABEL = SHA.test(VERSION) ? VERSION.slice(0, 7) : VERSION.includes("-") ? VERSION : `${VERSION}-alpha`;
     CLIENT_NAME = "ROOK";
@@ -19494,8 +19494,26 @@ var init_drift = __esm({
 });
 
 // src/run/materialise.ts
-import { copyFileSync, cpSync, existsSync as existsSync31, mkdirSync as mkdirSync25, readFileSync as readFileSync34, readdirSync as readdirSync19, realpathSync as realpathSync8, writeFileSync as writeFileSync23 } from "fs";
-import { basename as basename8, dirname as dirname21, isAbsolute as isAbsolute8, join as join36, relative as relative14, resolve as resolve15, sep as sep15 } from "path";
+import {
+  cpSync,
+  existsSync as existsSync31,
+  mkdirSync as mkdirSync25,
+  readFileSync as readFileSync34,
+  readdirSync as readdirSync19,
+  realpathSync as realpathSync8,
+  rmSync as rmSync9,
+  statSync as statSync16,
+  writeFileSync as writeFileSync23
+} from "fs";
+import {
+  basename as basename8,
+  dirname as dirname21,
+  isAbsolute as isAbsolute8,
+  join as join36,
+  relative as relative14,
+  resolve as resolve15,
+  sep as sep15
+} from "path";
 import yaml10 from "js-yaml";
 function scenarioDir(root, agentId, runId, scenarioId) {
   return join36(runDir(root, agentId, runId), "scenarios", scenarioId);
@@ -19531,7 +19549,10 @@ function materialiseContext(root, agentId, runId, context) {
   );
   write2("agent.yaml", context.spec);
   write2("features.yaml", context.features);
-  write2("profile.yaml", readableProfile(root, resolve15(dir2, "..", ".."), context.profile));
+  write2(
+    "profile.yaml",
+    readableProfile(root, resolve15(dir2, "..", ".."), context.profile)
+  );
 }
 function priorWork(root, agentId, runId) {
   const dir2 = join36(runDir(root, agentId, runId), "scenarios");
@@ -19551,34 +19572,99 @@ function priorWork(root, agentId, runId) {
   }
   return { decided, ungraded };
 }
-function carryForward(root, agentId, from, to) {
+function carryForward(root, agentId, from, to, opts = {}) {
   const src = scenarioDir(root, agentId, from.runId, from.scenarioId);
   const dst = scenarioDir(root, agentId, to.runId, to.scenarioId);
   if (!existsSync31(src)) return "nothing";
-  mkdirSync25(dst, { recursive: true });
-  const copy = (name) => {
-    const at = join36(src, name);
-    if (!existsSync31(at)) return false;
-    copyFileSync(at, join36(dst, name));
-    return true;
-  };
-  const copyTree = (name) => {
-    const at = join36(src, name);
-    if (!existsSync31(at)) return false;
-    cpSync(at, join36(dst, name), { recursive: true });
-    return true;
+  const carried = () => {
+    const take = (name) => {
+      try {
+        return readFileSync34(join36(src, name), "utf-8");
+      } catch {
+        return null;
+      }
+    };
+    const put = (name, body) => {
+      mkdirSync25(dst, { recursive: true });
+      writeFileSync23(join36(dst, name), body, "utf-8");
+    };
+    const move2 = (name) => {
+      const body = take(name);
+      if (body === null) return false;
+      put(name, body);
+      return true;
+    };
+    const record = (body, parse2) => {
+      if (body === null) return null;
+      let parsed;
+      try {
+        parsed = parse2(body);
+      } catch {
+        return null;
+      }
+      if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+        return null;
+      return parsed;
+    };
+    const moveTree = (name, skip) => {
+      const at = join36(src, name);
+      if (!existsSync31(at)) return false;
+      mkdirSync25(dst, { recursive: true });
+      cpSync(at, join36(dst, name), {
+        recursive: true,
+        ...skip ? { filter: (f) => basename8(f) !== skip } : {}
+      });
+      return true;
+    };
+    const response = record(take("response.json"), JSON.parse);
+    if (!response || !judgeable(response, from.scenarioId)) return "nothing";
+    move2("request.json");
+    move2("output.txt");
+    move2("hooks.json");
+    moveTree("artifacts");
+    const within2 = (base, file) => {
+      const path = relative14(base, file);
+      return path !== "" && path !== ".." && !path.startsWith(`..${sep15}`) && !isAbsolute8(path);
+    };
+    const artifacts = response.artifacts.map((name) => {
+      const source = resolve15(root, name);
+      if (!within2(join36(src, "artifacts"), source) || !within2(realpathSync8(src), realpathSync8(source)))
+        throw new Error("artifact is outside the prior scenario's artifacts directory");
+      const destination2 = join36(dst, relative14(src, source));
+      if (!within2(realpathSync8(dst), realpathSync8(destination2)) || !statSync16(destination2).isFile()) throw new Error("copied artifact is missing");
+      return relative14(root, destination2);
+    });
+    moveTree("hook-state");
+    const verdict3 = opts.verdict === false ? null : record(take("verdict.yaml"), (t) => yaml10.load(t));
+    const carriesVerdict = verdict3 !== null && completeVerdict(verdict3, from.scenarioId);
+    moveTree("evidence", carriesVerdict ? void 0 : JUDGE_WORKING);
+    if (carriesVerdict) {
+      put(
+        "verdict.yaml",
+        yaml10.dump(verdict3, { lineWidth: 100, noRefs: true, sortKeys: false })
+      );
+    }
+    put("response.json", JSON.stringify({ ...response, artifacts }, null, 2));
+    return carriesVerdict ? "verdict" : "response";
   };
-  const hasResponse = copy("response.json");
-  if (hasResponse) {
-    copy("request.json");
-    copy("output.txt");
-    copy("hooks.json");
-    copyTree("evidence");
-    copyTree("hook-state");
-    if (copy("verdict.yaml")) return "verdict";
-    return "response";
-  }
-  return "nothing";
+  try {
+    return carried();
+  } catch {
+    for (const name of CARRIED_FILES) {
+      try {
+        rmSync9(join36(dst, name), { recursive: true, force: true });
+      } catch {
+      }
+    }
+    return "nothing";
+  }
+}
+function completeVerdict(value, scenarioId) {
+  const record = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
+  return value.scenario_id === scenarioId && typeof value.run_id === "string" && value.run_id.length > 0 && DECIDED.includes(value.status) && typeof value.summary === "string" && ["pass_count", "fail_count", "unable_to_verify_count", "compliance_percentage", "latency_ms", "turns"].every((key2) => typeof value[key2] === "number" && Number.isFinite(value[key2])) && Array.isArray(value.forbidden_hits) && value.forbidden_hits.every((hit) => typeof hit === "string") && record(value.metrics) && Object.values(value.metrics).every((metric) => typeof metric === "number" && Number.isFinite(metric)) && Array.isArray(value.criteria) && value.criteria.every((row) => record(row) && ["criterion_id", "criterion", "expected", "achieved", "evidence"].every((key2) => typeof row[key2] === "string") && DECIDED.includes(row.status) && ["High", "Medium", "Low"].includes(row.confidence));
+}
+function judgeable(response, scenarioId) {
+  return response.scenario_id === scenarioId && typeof response.status === "string" && typeof response.output === "string" && Array.isArray(response.transcript) && Array.isArray(response.artifacts) && response.artifacts.every((path) => typeof path === "string" && path.length > 0);
 }
 function phasesRunIn(root, agentId, runId) {
   const dir2 = join36(runDir(root, agentId, runId), "scenarios");
@@ -19603,7 +19689,10 @@ function phasesRunIn(root, agentId, runId) {
   return [...seen];
 }
 function loadSnapshot(root, agentId, runId, scenarioId) {
-  const at = join36(scenarioDir(root, agentId, runId, scenarioId), "snapshot.yaml");
+  const at = join36(
+    scenarioDir(root, agentId, runId, scenarioId),
+    "snapshot.yaml"
+  );
   let parsed;
   try {
     parsed = yaml10.load(readFileSync34(at, "utf-8"));
@@ -19648,12 +19737,25 @@ function real(p) {
     return parent === p ? p : join36(real(parent), basename8(p));
   }
 }
+var CARRIED_FILES, DECIDED, JUDGE_WORKING;
 var init_materialise = __esm({
   "src/run/materialise.ts"() {
     "use strict";
     init_spec2();
     init_plan_file();
     init_types3();
+    CARRIED_FILES = [
+      "response.json",
+      "request.json",
+      "output.txt",
+      "hooks.json",
+      "verdict.yaml",
+      "artifacts",
+      "evidence",
+      "hook-state"
+    ];
+    DECIDED = ["Pass", "Fail", "Unable to Verify"];
+    JUDGE_WORKING = "judge-working.json";
   }
 });
 
@@ -20092,6 +20194,522 @@ var init_hook_scripts = __esm({
   }
 });
 
+// src/run/plan.ts
+import yaml13 from "js-yaml";
+function staticPlan(input) {
+  const { partition: partition2 } = input;
+  const included = partition2.candidates.map((c) => ({
+    scenario_id: c.local_id,
+    why: "a candidate, and nothing narrowed this run further",
+    confidence: "high"
+  }));
+  const judge_only = [];
+  const carried = [];
+  const skipped = [
+    ...partition2.excluded.map((e) => ({
+      scenario_id: e.scenario_id,
+      why: `excluded by the flags: ${e.why}`,
+      confidence: "high"
+    })),
+    ...partition2.filtered.map((f) => ({
+      scenario_id: f.scenario_id,
+      why: `left out by the tree: ${f.why}`,
+      confidence: "high"
+    }))
+  ];
+  const counts = [
+    included.length ? `${included.length} to execute` : "",
+    // SAID, not implied. Somebody who typed `--resume` expects work to be
+    // reused, and a plan that silently re-ran everything would look like one
+    // that had reused nothing to reuse.
+    input.resumeHint ? `nothing reused from ${input.resumeHint}` : ""
+  ].filter(Boolean);
+  return {
+    included,
+    skipped,
+    judge_only,
+    carried,
+    /*
+     * `--rca` and nothing else. There is no sentence for anything to read an
+     * intent out of, and RCA costs a model call per failure cluster — turning
+     * it on because a run happens to be large would spend on an explanation
+     * nobody asked for.
+     */
+    rca: Boolean(input.rca),
+    summary: counts.length ? `no instruction given \u2014 ${counts.join(", ")}. Every candidate the flags and the tree left.` : "no instruction given, and nothing is left to run.",
+    ...input.resumeHint ? { resume_from: input.resumeHint } : {},
+    /*
+     * No `name` and no `concurrency`. Both are proposals a planner makes from
+     * a sentence, and `applyPlanned` already lets an explicit flag win — so
+     * omitting them leaves the flag, or the default, exactly as typed.
+     */
+    // Nothing was spent. A non-zero cost here would bill a run for a decision
+    // no model was asked to make.
+    credits: 0
+  };
+}
+async function planRun(input, deps) {
+  const { partition: partition2 } = input;
+  const flagsAsked = input.flags ?? [];
+  const task4 = [
+    input.instruction ? `## WHAT THE USER ASKED FOR
+
+  ${input.instruction}
+` : "",
+    input.resumeHint ? `## THEY NAMED A RUN
+
+  ${input.resumeHint} \u2014 look it up before planning.
+` : "",
+    /**
+     * The same rendering of the agent every other planner gets.
+     *
+     * From the same function, so a planner deciding what to SPEND cannot be
+     * reasoning about a different agent than the writers described.
+     */
+    agentContext({
+      spec: input.spec,
+      features: input.features,
+      ...input.findings?.length ? { findings: input.findings } : {},
+      ...input.callers?.length ? { callers: input.callers } : {},
+      ...input.callees?.length ? { callees: input.callees } : {}
+    }),
+    "",
+    /**
+     * How the agent is reached, and what rook can SEE while it runs.
+     *
+     * The second half is what decides whether a scenario is checkable at all,
+     * and the unrunnable list below is computed from it — so the planner is
+     * shown the reason as well as the verdict.
+     */
+    "## THE PROFILE THIS RUN WILL USE",
+    "",
+    "```yaml",
+    yaml13.dump(
+      {
+        id: input.profile.id,
+        /*
+         * WHICH PHASES, not which transport.
+         *
+         * `kind` and `mode` were here and told the planner the agent was
+         * reached over http, synchronously — neither of which changes what
+         * to run. The phases do: a profile with a `collect` can be run now
+         * and collected later, and one without cannot, so a planner asked
+         * about staging a run needs this and had no way to see it.
+         */
+        phases: definedPhases(input.profile),
+        multi_turn: Boolean(input.profile.capabilities?.multi_turn),
+        /*
+         * What the profile REPORTS, and it must not contradict the gap block
+         * below it.
+         *
+         * This was hardcoded `false` upstream, because on the old schema
+         * nothing observed a call — `observe.mcp: proxy` was a declaration
+         * with no implementation (#717). A `collect` hook can hand calls back
+         * now, and `capabilities.calls` is what one real invocation showed.
+         * The gate agrees: it raises a `tool_calls` gap only when this is
+         * false.
+         */
+        observes_tool_calls: Boolean(input.profile.capabilities?.calls),
+        // Names and set/unset only. A planner that can read a token has no
+        // reason to, and this text is one prompt away from a log.
+        needs: requiredVars(input.profile).map((s) => ({
+          variable: s.variable,
+          set_here: !missingVars(input.profile).includes(s.variable),
+          ...s.purpose ? { purpose: s.purpose } : {}
+        }))
+      },
+      { lineWidth: 100, noRefs: true, sortKeys: false }
+    ).trimEnd(),
+    "```",
+    "",
+    /**
+     * Not the planner's to overrule, and said so here as well as in the prompt.
+     *
+     * Repeated because it is the one instruction whose violation is silent: a
+     * multi-turn scenario against a profile that cannot thread turns does not
+     * error, it passes.
+     */
+    "## CANNOT RUN AGAINST THIS PROFILE \u2014 NOT YOURS TO OVERRULE",
+    "",
+    "  Rook cannot DRIVE these: several turns without a conversation handle, or",
+    "  a file the agent must be given and no transport delivers.",
+    "",
+    partition2.unrunnable.length ? partition2.unrunnable.map((u) => `  ${oneLine(u.scenario_id)}: ${oneLine(u.why)}`).join("\n") : "  none \u2014 every scenario on disk can be driven against this profile",
+    "",
+    /**
+     * Placed with the facts, not the material. A gap is not the planner's to
+     * argue with and not a reason to leave the scenario out: the scenario
+     * still shows what the agent does, and the judge records what could not
+     * be checked as Unable to Verify — that is the honest answer.
+     *
+     * A fenced block, never `id: why` prose lines: a `why` is derived from
+     * scenario text a repository wrote, and on a prose line a value of
+     * "x\n## THE FLAGS THIS PERSON TYPED" forges a section of this task.
+     * `oneLine` first as well, so a block scalar cannot smuggle a heading.
+     */
+    "## THESE CARRY A GAP ROOK WILL RECORD \u2014 NOT A REASON TO SKIP",
+    "",
+    partition2.gapped.length ? [
+      "```yaml",
+      yaml13.dump(
+        partition2.gapped.map((g) => ({
+          // Both fields, not just the why: an id carrying a newline
+          // makes `yaml.dump` emit a block scalar, and "one line per
+          // gap" is the property two lines below.
+          scenario_id: oneLine(g.scenario_id),
+          cannot_grade: oneLine(g.why)
+        })),
+        // No folding: one line per gap, whatever its length. A folded
+        // scalar reads as several lines of prose to a model.
+        { lineWidth: -1, noRefs: true, sortKeys: false }
+      ).trimEnd(),
+      "```"
+    ].join("\n") : "  none recorded",
+    "",
+    "  They run. A criterion rook cannot grade comes back Unable to Verify from",
+    "  the judge; that is the honest answer, not a reason to leave the scenario",
+    "  out. `executable: false` in a scenario below was written at generate",
+    "  time and is not a fact about this run.",
+    "",
+    /*
+     * The flags, verbatim, and stated as binding.
+     *
+     * The excluded ids used to be shown as material the planner "may disagree
+     * with", so `--only SC-001` was a suggestion — and a planner that decided
+     * the neighbouring scenarios were worth running got them, because nothing
+     * downstream checked. Naming the flags as well as their effect matters:
+     * a list of excluded ids does not tell a model that a PERSON narrowed
+     * this, and that is the fact that decides whether it may argue.
+     */
+    ...flagsAsked.length ? [
+      "## THE FLAGS THIS PERSON TYPED \u2014 BINDING, NOT YOURS TO OVERRULE",
+      "",
+      ...flagsAsked.map((f) => `  ${f}`),
+      "",
+      "  They narrowed this run deliberately. Every scenario those flags",
+      "  excluded is listed below and is OUT \u2014 naming one in included,",
+      "  judge_only or carried is an error, and rook drops it. If the flags",
+      "  look wrong for what they asked, say so in summary rather than",
+      "  planning around them.",
+      "",
+      "## WHAT THOSE FLAGS EXCLUDED \u2014 out of this run",
+      "",
+      partition2.excluded.length ? partition2.excluded.map((f) => `  ${f.scenario_id}: ${f.why}`).join("\n") : "  nothing \u2014 every scenario on disk matched them",
+      ""
+    ] : [],
+    "## WHAT THE TREE LEFT OUT \u2014 material, and you may disagree",
+    "",
+    partition2.filtered.length ? partition2.filtered.map((f) => `  ${f.scenario_id}: ${f.why}`).join("\n") : "  nothing \u2014 no scenario was dropped for the state it is in",
+    "",
+    "## YOUR CANDIDATES \u2014 everything you may choose from",
+    "",
+    partition2.candidates.length ? partition2.candidates.map((c) => `  ${c.local_id}  ${c.title}`).join("\n") : "  nothing \u2014 the flags excluded everything runnable",
+    "",
+    ...input.stale.length ? [
+      "## THESE PIN OLDER FEATURE TEXT",
+      "",
+      `  ${input.stale.join(", ")}`,
+      "",
+      "They still run \u2014 an outdated test that passes is information. What must",
+      "not happen is a plan describing them as though they were written",
+      "against the feature as it stands.",
+      ""
+    ] : [],
+    /**
+     * Every scenario, in full, and LAST — the state block.
+     *
+     * Titles and counts cannot tell six behaviours from six rewordings, and
+     * that difference is exactly what decides whether a run is worth its cost.
+     * Last because it is the part that changes every run, which is what prompt
+     * caching wants.
+     */
+    "## EVERY SCENARIO ON DISK",
+    "",
+    "```yaml",
+    yaml13.dump(input.scenarios, { lineWidth: 100, noRefs: true, sortKeys: false }).trimEnd(),
+    "```",
+    ""
+  ].filter(Boolean).join("\n");
+  const child = await spawnSubagent(
+    {
+      role: "run_planner",
+      label: `${partition2.candidates.length} candidate(s)`,
+      task: task4,
+      // The BUDGET phase, not the command. `plan_scenarios` bills to
+      // "generate" for the same reason: a planner is charged to the work it is
+      // planning, so one bucket covers deciding and doing.
+      phase: "execute",
+      responseSchema: PLAN_SCHEMA2,
+      tools: toolsForRole("run_planner", { root: input.root, mcpAgent: null })
+    },
+    deps
+  );
+  if (!child.ok || child.data == null)
+    throw new Error(roleFailure("run_planner", child));
+  const forbidden = /* @__PURE__ */ new Set([
+    ...partition2.unrunnable.map((u) => u.scenario_id),
+    ...partition2.excluded.map((e) => e.scenario_id)
+  ]);
+  const known = new Set(input.scenarios.map((s) => s.local_id));
+  const included = (child.data.included ?? []).filter(
+    (e) => e?.scenario_id && known.has(e.scenario_id) && !forbidden.has(e.scenario_id)
+  );
+  const skipped = (child.data.skipped ?? []).filter(
+    (e) => e?.scenario_id && known.has(e.scenario_id)
+  );
+  const canJudge = new Set(input.ungraded ?? []);
+  const canCarry = new Set(input.decided ?? []);
+  const eligible = (entries, allowed) => {
+    const kept = [];
+    const demoted = [];
+    for (const e of entries ?? []) {
+      if (!e?.scenario_id || !known.has(e.scenario_id)) continue;
+      if (forbidden.has(e.scenario_id)) continue;
+      (allowed.has(e.scenario_id) ? kept : demoted).push(e);
+    }
+    return { kept, demoted };
+  };
+  const judgeOnly = eligible(child.data.judge_only, canJudge);
+  const carried = eligible(child.data.carried, canCarry);
+  const claimed = /* @__PURE__ */ new Set();
+  const takeOnce = (entries) => entries.filter(
+    (e) => !claimed.has(e.scenario_id) && claimed.add(e.scenario_id)
+  );
+  const finalIncluded = takeOnce([
+    ...included,
+    ...judgeOnly.demoted,
+    ...carried.demoted
+  ]);
+  const finalJudgeOnly = takeOnce(judgeOnly.kept);
+  const finalCarried = takeOnce(carried.kept);
+  return {
+    included: finalIncluded,
+    skipped,
+    judge_only: finalJudgeOnly,
+    carried: finalCarried,
+    /**
+     * The flag forces it ON and never off.
+     *
+     * A planner that declined costs nothing to overrule, and somebody who typed
+     * `--rca` has asked plainly. The reverse — a flag that silences a planner
+     * which decided an explanation was needed — would hide the reasoning at the
+     * moment it is most wanted.
+     */
+    rca: Boolean(child.data.rca) || Boolean(input.rca),
+    summary: child.data.summary ?? "",
+    ...child.data.resume_from ? { resume_from: child.data.resume_from } : {},
+    ...child.data.name ? { name: child.data.name } : {},
+    ...child.data.concurrency ? { concurrency: child.data.concurrency } : {},
+    credits: child.credits
+  };
+}
+function applyPlanned(plan2, flags) {
+  const proposed = plan2.concurrency ?? 1;
+  return {
+    ...flags.name ?? plan2.name ? { name: flags.name ?? plan2.name } : {},
+    concurrency: flags.concurrency ?? Math.min(Math.max(1, Math.trunc(proposed)), MAX_PLANNED_CONCURRENCY)
+  };
+}
+function renderRunPlan(plan2, view) {
+  const gap = new Map(view.gapped.map((g) => [g.scenario_id, g.why]));
+  const excluded = new Set(view.excluded.map((e) => e.scenario_id));
+  const gapLine = (id) => {
+    const why2 = gap.get(id);
+    return why2 === void 0 ? [] : [`      cannot grade: ${oneLine(why2)}`];
+  };
+  const lines = [`plan: ${plan2.included.length} scenario(s) to run`];
+  for (const e of plan2.included) {
+    const sure = e.confidence && e.confidence !== "high" ? `  (${e.confidence} confidence)` : "";
+    lines.push(`  ${oneLine(e.scenario_id)}${sure}`);
+    lines.push(`      ${oneLine(e.why)}`);
+    lines.push(...gapLine(e.scenario_id));
+  }
+  for (const e of plan2.judge_only) {
+    lines.push(`  ${oneLine(e.scenario_id)}  judge only \u2014 ${oneLine(e.why)}`);
+    lines.push(...gapLine(e.scenario_id));
+  }
+  for (const e of plan2.carried) {
+    lines.push(`  ${oneLine(e.scenario_id)}  carried \u2014 ${oneLine(e.why)}`);
+    lines.push(...gapLine(e.scenario_id));
+  }
+  for (const e of plan2.skipped) {
+    lines.push(`  ${oneLine(e.scenario_id)}  skipped \u2014 ${oneLine(e.why)}`);
+    const why2 = gap.get(e.scenario_id);
+    if (why2 === void 0) continue;
+    lines.push(
+      excluded.has(e.scenario_id) ? `      carries a gap: ${oneLine(why2)}` : `      carries a gap, which is not a reason to skip: ${oneLine(why2)}`
+    );
+  }
+  if (view.unrunnable.length)
+    lines.push(`  ${view.unrunnable.length} cannot run against this profile`);
+  if (plan2.resume_from)
+    lines.push(`  carrying finished work from ${plan2.resume_from}`);
+  return lines;
+}
+function decidedElsewhere(plan2) {
+  return new Set(
+    [...plan2.judge_only ?? [], ...plan2.carried ?? []].map(
+      (e) => e.scenario_id
+    )
+  );
+}
+function scenariosOf(plan2) {
+  return [
+    ...plan2.included,
+    ...plan2.judge_only ?? [],
+    ...plan2.carried ?? []
+  ];
+}
+function judgedHere(plan2) {
+  return [...plan2.included, ...plan2.judge_only ?? []];
+}
+function gapLines(view, plan2) {
+  const does = /* @__PURE__ */ new Map();
+  for (const e of plan2.included) does.set(e.scenario_id, "runs");
+  for (const e of plan2.judge_only ?? []) does.set(e.scenario_id, "is judged");
+  return view.gapped.filter((g) => does.has(g.scenario_id)).map(
+    (g) => `${oneLine(g.scenario_id)}: ${does.get(g.scenario_id)} \u2014 cannot grade: ${oneLine(g.why)}`
+  );
+}
+var PLAN_SCHEMA2, MAX_PLANNED_CONCURRENCY;
+var init_plan2 = __esm({
+  "src/run/plan.ts"() {
+    "use strict";
+    init_subagent();
+    init_role_failure();
+    init_registry4();
+    init_context();
+    init_types3();
+    init_env();
+    init_render();
+    PLAN_SCHEMA2 = {
+      type: "object",
+      /*
+       * `rca` is NOT required, and requiring it failed real runs.
+       *
+       * "run_planner: the reply does not match the shape asked for — rca:
+       * required, and absent" is the whole of `/run` refusing because a boolean
+       * with an obvious default was left out. The schema's own description says
+       * "false is the ordinary answer", and `planRun` already reads it as
+       * `Boolean(child.data.rca) || Boolean(input.rca)` — so absence was always
+       * handled everywhere except the validator that rejected it first.
+       *
+       * The three that remain are the answer itself: what to run, what was left
+       * out, and the sentence somebody reads before spending. A reply missing any
+       * of those is not a plan.
+       */
+      required: ["included", "skipped", "summary"],
+      properties: {
+        /**
+         * The four lists are a PARTITION of the candidates.
+         *
+         * Every candidate lands in exactly one, and rook enforces it — a scenario
+         * in two is ambiguous about whether it costs an agent call, and one in none
+         * is silently dropped. `judge_only` and `carried` are the resume half: rook
+         * works out which scenarios are ELIGIBLE for each from the files, and the
+         * planner decides which of them the request actually wants that done to.
+         */
+        included: {
+          type: "array",
+          description: "Execute these: call the agent, then judge. One entry per scenario.",
+          items: {
+            type: "object",
+            required: ["scenario_id", "why", "confidence"],
+            properties: {
+              scenario_id: { type: "string" },
+              why: {
+                type: "string",
+                description: "What this one establishes that the others do not. Not 'important coverage', which is true of everything and decides nothing."
+              },
+              confidence: {
+                type: "string",
+                enum: ["high", "medium", "low"],
+                description: "`low` says you are unsure it earns its cost \u2014 exactly what somebody about to approve wants to know."
+              }
+            }
+          }
+        },
+        judge_only: {
+          type: "array",
+          description: "Already executed by the prior run and never judged. A judge call and NO agent call. Only ids listed as ungraded below are eligible.",
+          items: {
+            type: "object",
+            required: ["scenario_id", "why"],
+            properties: {
+              scenario_id: { type: "string" },
+              why: { type: "string" },
+              confidence: { type: "string", enum: ["high", "medium", "low"] }
+            }
+          }
+        },
+        carried: {
+          type: "array",
+          description: "Already decided by the prior run. Copy the verdict forward \u2014 no agent call, no judge call. Only ids listed as decided below are eligible.",
+          items: {
+            type: "object",
+            required: ["scenario_id", "why"],
+            properties: {
+              scenario_id: { type: "string" },
+              why: { type: "string" },
+              confidence: { type: "string", enum: ["high", "medium", "low"] }
+            }
+          }
+        },
+        rca: {
+          type: "boolean",
+          description: "Explain the failure clusters when this run ends. True when the request asks WHY something fails, or when a run this large failing would leave somebody with nowhere to start. It costs one model call per cluster, so false is the ordinary answer."
+        },
+        skipped: {
+          type: "array",
+          description: "One entry per scenario you deliberately left out.",
+          items: {
+            type: "object",
+            required: ["scenario_id", "why", "confidence"],
+            properties: {
+              scenario_id: { type: "string" },
+              why: {
+                type: "string",
+                description: "Why it is not worth running now. A scenario nobody considered and one deliberately excluded look identical afterwards."
+              },
+              confidence: { type: "string", enum: ["high", "medium", "low"] }
+            }
+          }
+        },
+        summary: {
+          type: "string",
+          description: "What this run will establish, and what it will not. The sentence a person reads before deciding to spend."
+        },
+        resume_from: {
+          type: "string",
+          description: "A prior run to carry finished work from. Omit unless proposing one."
+        },
+        /**
+         * Two fields of `run.yaml` the planner may set, and only these two.
+         *
+         * Both are things a person expresses in words — "call this the threshold
+         * sweep", "run them one at a time" — and neither changes what a run MEANS.
+         *
+         * `test_mode` is deliberately NOT here. It decides whether the run is
+         * pinned upstream at all, so a model able to set it could turn a real run
+         * into one that records nothing, or a smoke test into a version-pinned
+         * result. That is a flag, and flags are for people.
+         *
+         * An explicit flag always wins over both — see `applyPlanned`.
+         */
+        name: {
+          type: "string",
+          description: "A short name for this run, when the request suggests one. Omit rather than inventing a label nobody used."
+        },
+        concurrency: {
+          type: "integer",
+          description: "How many scenarios to run at once, when the request says. One is the default and the right answer for anything hitting a rate-limited API."
+        }
+      }
+    };
+    MAX_PLANNED_CONCURRENCY = 8;
+  }
+});
+
 // src/report/cluster.ts
 function shapeOf2(verdict3) {
   if (verdict3.compromised) return `compromised:${verdict3.impact ?? "unrated"}`;
@@ -20555,9 +21173,38 @@ function resolveRun(root, agentId, runId) {
   const plans = readdirSync21(dir2).map((id) => loadPlan(root, agentId, id)).filter((p) => Boolean(p?.id)).sort((a, b) => (b.created ?? "").localeCompare(a.created ?? ""));
   return plans[0] ?? null;
 }
+function snapshotsOf(root, agentId, plan2) {
+  return judgedHere(plan2).map((e) => {
+    const at = join44(
+      scenarioDir(root, agentId, plan2.id, e.scenario_id),
+      "snapshot.yaml"
+    );
+    try {
+      return yaml15.load(readFileSync40(at, "utf-8"));
+    } catch {
+      return null;
+    }
+  }).filter((s) => Boolean(s?.local_id));
+}
+function fallbackTotals(plan2, verdicts) {
+  const planned = judgedHere(plan2).length;
+  return {
+    planned,
+    executed: verdicts.length,
+    passed: verdicts.filter((v) => v.status === "Pass").length,
+    failed: verdicts.filter((v) => v.status === "Fail").length,
+    unverifiable: verdicts.filter((v) => v.status === "Unable to Verify").length,
+    unjudged: 0,
+    not_run: Math.max(0, planned - verdicts.length),
+    unrunnable: plan2.unrunnable.length,
+    decided: verdicts.filter((v) => v.status !== "Unable to Verify").length,
+    pass_rate: null,
+    carried_forward: (plan2.carried ?? []).length
+  };
+}
 function runVerdicts(root, agentId, plan2) {
   const out = [];
-  for (const entry of plan2.included) {
+  for (const entry of judgedHere(plan2)) {
     const at = join44(
       scenarioDir(root, agentId, plan2.id, entry.scenario_id),
       "verdict.yaml"
@@ -20622,19 +21269,7 @@ async function explainRun(input, deps) {
     );
     return null;
   }
-  const scenarios2 = plan2.included.map((e) => {
-    const at = join44(
-      scenarioDir(input.root, input.agentId, plan2.id, e.scenario_id),
-      "snapshot.yaml"
-    );
-    try {
-      return yaml15.load(readFileSync40(at, "utf-8"));
-    } catch {
-      return null;
-    }
-  }).filter(
-    (s) => Boolean(s?.local_id)
-  );
+  const scenarios2 = snapshotsOf(input.root, input.agentId, plan2);
   const prior = (() => {
     try {
       return yaml15.load(
@@ -20683,19 +21318,7 @@ async function explainRun(input, deps) {
       // Kept from the run that produced them. Recomputing totals here would
       // count only the scenarios that left a verdict file, silently dropping
       // everything the run never reached.
-      totals: prior?.totals ?? {
-        planned: plan2.included.length,
-        executed: verdicts.length,
-        passed: verdicts.filter((v) => v.status === "Pass").length,
-        failed: verdicts.filter((v) => v.status === "Fail").length,
-        unverifiable: verdicts.filter((v) => v.status === "Unable to Verify").length,
-        unjudged: 0,
-        not_run: Math.max(0, plan2.included.length - verdicts.length),
-        unrunnable: plan2.unrunnable.length,
-        decided: verdicts.filter((v) => v.status !== "Unable to Verify").length,
-        pass_rate: null,
-        carried_forward: 0
-      },
+      totals: prior?.totals ?? fallbackTotals(plan2, verdicts),
       ...prior?.metrics ? { metrics: prior.metrics } : {},
       say: input.say,
       rca: true
@@ -20714,6 +21337,7 @@ var init_command = __esm({
     init_store3();
     init_plan_file();
     init_materialise();
+    init_plan2();
     init_report();
     init_hook_scripts();
   }
@@ -20819,6 +21443,59 @@ var init_output = __esm({
   }
 });
 
+// src/command-arguments.ts
+function argumentPlaceholder(arg) {
+  return arg.required ? `<${arg.name()}>` : `[${arg.name()}]`;
+}
+function declaredChoices(arg) {
+  return arg.argChoices?.length ? `(choices: ${arg.argChoices.join(", ")})` : "";
+}
+function argumentDescription(arg) {
+  return [arg.description, declaredChoices(arg)].filter(Boolean).join(" ");
+}
+function argumentSummary(arg) {
+  return [argumentPlaceholder(arg), declaredChoices(arg)].filter(Boolean).join(" ");
+}
+function commandWords(line) {
+  const out = [];
+  let current2 = "";
+  let quote2 = null;
+  let started = false;
+  for (const ch of line) {
+    if (quote2) {
+      if (ch === quote2) quote2 = null;
+      else current2 += ch;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      quote2 = ch;
+      started = true;
+      continue;
+    }
+    if (/\s/.test(ch)) {
+      if (current2 || started) out.push(current2);
+      current2 = "";
+      started = false;
+      continue;
+    }
+    current2 += ch;
+  }
+  if (current2 || started) out.push(current2);
+  return {
+    words: out,
+    complete: !started && current2 === "",
+    openQuote: quote2 !== null
+  };
+}
+function split2(line) {
+  return commandWords(line).words;
+}
+var init_command_arguments = __esm({
+  "src/command-arguments.ts"() {
+    "use strict";
+  }
+});
+
 // src/classify/material.ts
 function nutshell(root, projectId2) {
   const active2 = activeAgentId(root);
@@ -20850,12 +21527,12 @@ function commandForm(surface, name) {
 function commandCatalogue(program2, surface = "cli") {
   const lines = [];
   for (const cmd of program2.commands) {
-    const args = cmd.registeredArguments.map((a) => a.required ? `<${a.name()}>` : `[${a.name()}]`).join(" ");
+    const args = cmd.registeredArguments.map(argumentSummary).join(" ");
     lines.push(
       `  ${commandForm(surface, cmd.name())}${args ? ` ${args}` : ""} \u2014 ${cmd.description()}`
     );
     for (const sub of cmd.commands) {
-      const subArgs = sub.registeredArguments.map((a) => a.required ? `<${a.name()}>` : `[${a.name()}]`).join(" ");
+      const subArgs = sub.registeredArguments.map(argumentSummary).join(" ");
       lines.push(
         `      ${sub.name()}${subArgs ? ` ${subArgs}` : ""} \u2014 ${sub.description()}`
       );
@@ -20872,6 +21549,7 @@ function roleCatalogue() {
 var init_material = __esm({
   "src/classify/material.ts"() {
     "use strict";
+    init_command_arguments();
     init_dist();
     init_registry2();
     init_state();
@@ -20884,7 +21562,7 @@ var init_material = __esm({
 
 // src/help.ts
 function usageOf(cmd, surface = "cli") {
-  const args = cmd.registeredArguments.map((a) => a.required ? `<${a.name()}>` : `[${a.name()}]`).join(" ");
+  const args = cmd.registeredArguments.map(argumentPlaceholder).join(" ");
   const subs = cmd.commands.length > 0 ? " <subcommand>" : "";
   const name = surface === "tui" ? `/${cmd.name()}` : cmd.name();
   return `${name}${subs}${args ? ` ${args}` : ""}`;
@@ -20955,12 +21633,33 @@ function renderCommandHelp(program2, name, surface = "cli") {
       lines.push(
         `  ${usageOf(sub).padEnd(w)}  ${sub.description()}${isDefault ? "  (default)" : ""}`
       );
+      for (const arg of sub.registeredArguments) {
+        if (!argumentDescription(arg)) continue;
+        lines.push(
+          `      ${argumentPlaceholder(arg)}  ${argumentDescription(arg)}`
+        );
+      }
       for (const opt of sub.options) {
         lines.push(`      ${opt.flags.padEnd(fw)}  ${opt.description}`);
       }
     }
     lines.push("");
   }
+  const describedArguments = cmd.registeredArguments.filter(
+    (a) => argumentDescription(a)
+  );
+  if (describedArguments.length > 0) {
+    lines.push("ARGUMENTS", "");
+    const width = Math.max(
+      ...describedArguments.map((a) => argumentPlaceholder(a).length)
+    );
+    for (const arg of describedArguments) {
+      lines.push(
+        `  ${argumentPlaceholder(arg).padEnd(width)}  ${argumentDescription(arg)}`
+      );
+    }
+    lines.push("");
+  }
   if (cmd.options.length > 0) {
     lines.push("OPTIONS", "");
     const w = Math.max(...cmd.options.map((o) => o.flags.length));
@@ -21045,6 +21744,7 @@ var ORDER2, GROUPS;
 var init_help = __esm({
   "src/help.ts"() {
     "use strict";
+    init_command_arguments();
     init_material();
     ORDER2 = [
       {
@@ -21904,6 +22604,7 @@ var init_Choice = __esm({
 });
 
 // src/app/commands.ts
+import { Command, Option } from "commander";
 function slashCommands(program2) {
   return program2.commands.map((c) => ({ name: `/${c.name()}`, description: c.description() })).sort((a, b) => a.name.localeCompare(b.name));
 }
@@ -21925,23 +22626,33 @@ function completionsFor(program2, input) {
     return finishedTyping ? [] : slashCommands(program2).filter((c) => c.name.startsWith(head));
   }
   if (!finishedTyping) return [];
-  const typed = parts.slice(1);
-  const partial = typed.at(-1) ?? "";
-  const given = new Set(typed.slice(0, -1));
-  const chosen = command.commands.find((sc) => given.has(sc.name()));
-  if (chosen) return flagsOf(chosen, partial, given);
-  const subs = command.commands.filter((sc) => sc.name().startsWith(partial)).map((sc) => ({
+  const parsed = commandWords(trimmed);
+  if (parsed.openQuote) return [];
+  const typed = parsed.words.slice(1);
+  const partial = parsed.complete ? "" : typed.pop() ?? "";
+  const state4 = completionState(command, typed, partial);
+  const cmd = state4.command;
+  if (state4.unknown || state4.pending && (state4.requiresValue || partial === "" || !partial.startsWith("-")))
+    return [];
+  const positional = cmd.registeredArguments[state4.position];
+  const values = positional && !positional.variadic ? (positional.argChoices ?? []).filter((value) => value.startsWith(partial)).map((value) => ({
+    name: value,
+    description: positional.description
+  })) : [];
+  if (state4.literal) return values;
+  const subs = state4.position === 0 ? cmd.commands.filter((sc) => sc.name().startsWith(partial)).map((sc) => ({
     name: [sc.name(), placeholders(sc)].filter(Boolean).join(" "),
     description: sc.description()
-  }));
+  })) : [];
   return [
     ...subs,
-    ...flagsOf(command, partial, given),
-    ...instruction(command, partial, given)
+    ...values,
+    ...flagsOf(cmd, partial, state4.given),
+    ...cmd === command ? instruction(cmd, partial) : []
   ];
 }
 function placeholders(cmd) {
-  return cmd.registeredArguments.filter((a) => !a.variadic).map((a) => a.required ? `<${a.name()}>` : `[${a.name()}]`).join(" ");
+  return cmd.registeredArguments.filter((a) => !a.variadic).map(argumentPlaceholder).join(" ");
 }
 function flagsOf(cmd, partial, given) {
   return cmd.options.filter((o) => !o.hidden).map((o) => ({ flag: longest(o.flags), option: o })).filter(({ flag }) => flag !== null && !given.has(flag)).filter(({ flag }) => flag.startsWith(partial)).map(({ flag, option }) => ({
@@ -21955,14 +22666,109 @@ function longest(flags) {
   const match = flags.match(/--[a-z][\w-]*/);
   return match ? match[0] : null;
 }
-function instruction(cmd, partial, given) {
+function instruction(cmd, partial) {
   const variadic = cmd.registeredArguments.find((a) => a.variadic);
-  if (!variadic || given.has("--") || !"--".startsWith(partial)) return [];
+  if (!variadic || !"--".startsWith(partial)) return [];
   return [{ name: "-- <text>", description: variadic.description }];
 }
+function completionState(command, words, partial) {
+  let position = 0;
+  let pending2;
+  let requiresValue = false;
+  let literal = false;
+  const initial = withoutAncestorOptions(command, words, partial);
+  let unknown = initial === void 0;
+  const given = /* @__PURE__ */ new Set();
+  const tokens = initial ?? [];
+  while (tokens.length) {
+    const word = tokens.shift();
+    if (pending2) {
+      if (requiresValue || !word.startsWith("-") || word === "-") {
+        requiresValue = false;
+        pending2 = pending2.variadic ? pending2 : void 0;
+        continue;
+      }
+      pending2 = void 0;
+    }
+    if (!literal && word === "--") {
+      literal = true;
+      given.add(word);
+      continue;
+    }
+    if (!literal && word.startsWith("-") && word !== "-") {
+      const equals = word.startsWith("--") ? word.indexOf("=") : -1;
+      const flag = equals >= 0 ? word.slice(0, equals) : word;
+      const options = command.options;
+      let option = options.find((o) => o.short === flag || o.long === flag);
+      let inline = equals >= 0;
+      if (!option && !word.startsWith("--") && word.length > 2) {
+        option = options.find((o) => o.short === word.slice(0, 2));
+        if (option) {
+          inline = option.required || option.optional;
+          if (!inline) tokens.unshift(`-${word.slice(2)}`);
+        }
+      }
+      if (!option || inline && word.startsWith("--") && !option.required && !option.optional) {
+        unknown = true;
+        break;
+      }
+      given.add(option.long ?? option.short);
+      if (!inline && (option.required || option.optional)) {
+        pending2 = option;
+        requiresValue = option.required;
+      }
+      continue;
+    }
+    const sub = !literal && position === 0 ? command.commands.find(
+      (c) => c.name() === word || c.aliases().includes(word)
+    ) : void 0;
+    if (sub) {
+      command = sub;
+      const remaining = withoutAncestorOptions(command, tokens, partial);
+      if (!remaining) {
+        unknown = true;
+        break;
+      }
+      tokens.splice(0, tokens.length, ...remaining);
+      given.clear();
+    } else {
+      position++;
+    }
+  }
+  return { command, position, given, pending: pending2, requiresValue, literal, unknown };
+}
+function withoutAncestorOptions(command, words, partial) {
+  const ancestors = [];
+  for (let scope = command.parent; scope; scope = scope.parent)
+    ancestors.unshift(scope);
+  let remaining = [...words];
+  for (const scope of ancestors) {
+    if (scope.options.length === 0) continue;
+    const parser = new Command().exitOverride().configureOutput({ writeOut: () => {
+    }, writeErr: () => {
+    } });
+    for (const option of scope.options)
+      parser.addOption(new Option(option.flags));
+    let boundary = "--__rook_completion_boundary";
+    while (remaining.includes(boundary) || scope.options.some((o) => o.long === boundary))
+      boundary += "_";
+    let cursor = partial.length > 1 && partial.startsWith("-") ? "--__rook_cursor" : "__rook_cursor";
+    while (remaining.includes(cursor) || scope.options.some((o) => o.long === cursor))
+      cursor += "_";
+    try {
+      const parsed = parser.parseOptions([boundary, ...remaining, cursor]);
+      if (!parsed.unknown.includes(cursor)) return void 0;
+      remaining = parsed.unknown.slice(1, -1);
+    } catch {
+      return void 0;
+    }
+  }
+  return remaining;
+}
 var init_commands = __esm({
   "src/app/commands.ts"() {
     "use strict";
+    init_command_arguments();
     init_help();
   }
 });
@@ -22021,10 +22827,8 @@ function InputPrompt({
   };
   const accept = (name) => {
     const word = name.split(" ")[0];
-    const trailing = /\s$/.test(value);
-    const parts = value.split(/\s+/).filter(Boolean);
-    if (!trailing && parts.length > 0) parts.pop();
-    const next = [...parts, word].join(" ") + " ";
+    const prefix = value.replace(/\S*$/, "");
+    const next = `${prefix}${word} `;
     edit(next, next.length);
   };
   const wordStart = (text, at) => {
@@ -23506,33 +24310,6 @@ var init_ThinkingLine = __esm({
 
 // src/app/dispatch.ts
 import { CommanderError } from "commander";
-function split3(line) {
-  const out = [];
-  let current2 = "";
-  let quote2 = null;
-  let started = false;
-  for (const ch of line) {
-    if (quote2) {
-      if (ch === quote2) quote2 = null;
-      else current2 += ch;
-      continue;
-    }
-    if (ch === '"' || ch === "'") {
-      quote2 = ch;
-      started = true;
-      continue;
-    }
-    if (/\s/.test(ch)) {
-      if (current2 || started) out.push(current2);
-      current2 = "";
-      started = false;
-      continue;
-    }
-    current2 += ch;
-  }
-  if (current2 || started) out.push(current2);
-  return out;
-}
 function joinLists(command, argv) {
   const out = [];
   let cmd = command;
@@ -23683,7 +24460,7 @@ function resetOptions(cmd) {
   for (const sub of cmd.commands) resetOptions(sub);
 }
 async function dispatch(deps) {
-  const argv = split3(deps.line.trim());
+  const argv = split2(deps.line.trim());
   const head = argv[0] ?? "";
   const name = head.startsWith("/") ? head.slice(1) : head;
   if (!name) return { kind: "unknown", name: "" };
@@ -23731,6 +24508,8 @@ function withExitOverride(program2) {
 var init_dispatch = __esm({
   "src/app/dispatch.ts"() {
     "use strict";
+    init_command_arguments();
+    init_command_arguments();
     init_commands();
     init_flags();
   }
@@ -25157,7 +25936,7 @@ function fatalExit(err, context = "command") {
 // src/index.ts
 init_flags();
 init_client();
-import { Command } from "commander";
+import { Argument, Command as Command2 } from "commander";
 
 // src/auth/account.ts
 function accountView(identity, credits) {
@@ -26847,7 +27626,7 @@ import { join as join42 } from "path";
 
 // src/judge/judge.ts
 init_envelope();
-import { copyFileSync as copyFileSync2, mkdirSync as mkdirSync27, statSync as statSync16, writeFileSync as writeFileSync25 } from "fs";
+import { copyFileSync, mkdirSync as mkdirSync27, statSync as statSync17, writeFileSync as writeFileSync25 } from "fs";
 import { basename as basename9, join as join39, relative as relative15 } from "path";
 import yaml12 from "js-yaml";
 
@@ -27808,7 +28587,7 @@ function evidencePack(scope, scenarioLocalId) {
     record(absolutePath) {
       if (seen.has(absolutePath)) return;
       try {
-        const size = statSync16(absolutePath).size;
+        const size = statSync17(absolutePath).size;
         mkdirSync27(dir2, { recursive: true });
         const name = `${seen.size + 1}-${basename9(absolutePath)}`;
         if (size > PACK_FILE_BYTES_MAX) {
@@ -27818,7 +28597,7 @@ function evidencePack(scope, scenarioLocalId) {
           );
           return;
         }
-        copyFileSync2(absolutePath, join39(dir2, name));
+        copyFileSync(absolutePath, join39(dir2, name));
         seen.set(absolutePath, name);
       } catch (err) {
         seen.set(absolutePath, `(not copied \u2014 ${err.message})`);
@@ -28497,14 +29276,14 @@ import {
   mkdirSync as mkdirSync29,
   readFileSync as readFileSync38,
   readdirSync as readdirSync20,
-  statSync as statSync18,
+  statSync as statSync19,
   writeFileSync as writeFileSync27
 } from "fs";
 import { join as join41, relative as relative16 } from "path";
 
 // src/run/capture.ts
 init_constants();
-import { copyFileSync as copyFileSync3, existsSync as existsSync35, mkdirSync as mkdirSync28, statSync as statSync17, writeFileSync as writeFileSync26 } from "fs";
+import { copyFileSync as copyFileSync2, existsSync as existsSync35, mkdirSync as mkdirSync28, statSync as statSync18, writeFileSync as writeFileSync26 } from "fs";
 import { basename as basename10, extname as extname8, join as join40 } from "path";
 var MAX_BYTES = 8 * 1024 * 1024;
 var MAX_ARTEFACTS = 12;
@@ -28620,7 +29399,7 @@ async function captureArtifacts(scenarioDir2, data) {
       continue;
     }
     try {
-      const stat = statSync17(source);
+      const stat = statSync18(source);
       if (!stat.isFile()) {
         result2.missed.push({ source, reason: "not a file" });
         continue;
@@ -28636,7 +29415,7 @@ async function captureArtifacts(scenarioDir2, data) {
         });
         continue;
       }
-      copyFileSync3(source, target);
+      copyFileSync2(source, target);
       bytes += stat.size;
       result2.files.push(target);
     } catch {
@@ -29030,7 +29809,7 @@ function capturedFiles(scenarioDirectory) {
   const dir2 = join41(scenarioDirectory, "artifacts");
   if (!existsSync36(dir2)) return [];
   try {
-    return readdirSync20(dir2).map((name) => join41(dir2, name)).filter((at) => statSync18(at).isFile());
+    return readdirSync20(dir2).map((name) => join41(dir2, name)).filter((at) => statSync19(at).isFile());
   } catch {
     return [];
   }
@@ -29251,6 +30030,7 @@ async function executeRun(opts, deps) {
     }
   }
   const total = opts.scenarios.length;
+  const planned = total + (opts.judgeOnly?.length ?? 0);
   const reachAtStart = resolveReach(opts.root);
   const verdicts = [];
   const outcomes = /* @__PURE__ */ new Map();
@@ -29259,6 +30039,7 @@ async function executeRun(opts, deps) {
   let haltReason;
   let next = 0;
   let consecutiveUnreached = 0;
+  let missingEvidence = false;
   const stop = (why2) => {
     if (!halted2) haltReason = why2;
     halted2 = true;
@@ -29268,25 +30049,29 @@ async function executeRun(opts, deps) {
     const index = next++;
     return { scenario: opts.scenarios[index], index };
   };
+  const stopDue = () => {
+    if (opts.signal.aborted) {
+      stop("interrupted");
+      return true;
+    }
+    if (!deps.budget.canStart()) {
+      opts.onProgress?.(
+        `${stoppedBecause("budget_halt")} \u2014 stopping before the next scenario`
+      );
+      stop("budget");
+      return true;
+    }
+    const halt = halted();
+    if (halt) {
+      opts.onProgress?.(halt.message);
+      stop(halt.kind);
+      return true;
+    }
+    return false;
+  };
   const worker = async () => {
     for (; ; ) {
-      if (opts.signal.aborted) {
-        stop("interrupted");
-        return;
-      }
-      if (!deps.budget.canStart()) {
-        opts.onProgress?.(
-          `${stoppedBecause("budget_halt")} \u2014 stopping before the next scenario`
-        );
-        stop("budget");
-        return;
-      }
-      const halt = halted();
-      if (halt) {
-        opts.onProgress?.(halt.message);
-        stop(halt.kind);
-        return;
-      }
+      if (stopDue()) return;
       const item = takeOne();
       if (!item) return;
       const { scenario: scenario2, index } = item;
@@ -29367,36 +30152,56 @@ async function executeRun(opts, deps) {
     }
   };
   for (const scenario2 of opts.judgeOnly ?? []) {
-    if (opts.signal.aborted) break;
-    const execution = readCarriedResponse(opts, scenario2);
-    if (!execution) continue;
+    const execution = opts.unavailableEvidence?.has(scenario2.local_id) ? null : readCarriedResponse(opts, scenario2);
+    if (!execution) {
+      opts.onProgress?.(
+        "carried evidence could not be read \u2014 restore it and start a newly approved run",
+        scenario2.local_id
+      );
+      missingEvidence = true;
+      continue;
+    }
+    if (!wants("judge")) {
+      opts.onProgress?.(
+        "not judged \u2014 rerun with --phases judge when you want a verdict",
+        scenario2.local_id
+      );
+      outcomes.set(scenario2.local_id, "unjudged");
+      continue;
+    }
+    if (stopDue()) break;
     opts.onProgress?.("judging what the last run executed", scenario2.local_id);
-    const judged = await judgeScenario(
-      { root: opts.root, agentId: opts.agentId, runId: opts.runId },
-      scenario2,
-      judgeContext(
-        opts,
+    const judgeDeps = {
+      ...deps,
+      ctx: {
+        ...deps.ctx,
+        runId: opts.upstream?.run_id,
+        runScenarioId: opts.upstream?.scenario_ids[planKey(scenario2.local_id, 1)]
+      }
+    };
+    try {
+      const judged = await judgeScenario(
+        { root: opts.root, agentId: opts.agentId, runId: opts.runId },
         scenario2,
-        /*
-         * THIS run executes nothing for a carried scenario, so it observes no
-         * filesystem — said as its own fact rather than as a concurrency
-         * number, which would print a "re-run at --concurrency 1" remedy to
-         * somebody already at 1 and would suppress the earlier walk's note.
-         *
-         * Reading the requirement's fate out of the carried `response.json`
-         * instead is reading a file the target can write: deleting `fs_note`
-         * from it removed the row and turned the verdict Pass.
-         */
-        unmetNow(opts, scenario2, 1, reachAtStart, false)
-      ),
-      execution,
-      deps,
-      (m) => opts.onProgress?.(m, scenario2.local_id)
-    );
-    credits += judged.credits;
-    verdicts.push(judged.verdict);
-    outcomes.set(scenario2.local_id, outcomeOf(judged.verdict));
-    await opts.onVerdict?.(judged.verdict, scenario2, 1);
+        judgeContext(
+          opts,
+          scenario2,
+          unmetNow(opts, scenario2, 1, reachAtStart, false)
+        ),
+        execution,
+        judgeDeps,
+        (m) => opts.onProgress?.(m, scenario2.local_id)
+      );
+      credits += judged.credits;
+      verdicts.push(judged.verdict);
+      outcomes.set(scenario2.local_id, outcomeOf(judged.verdict));
+      await opts.onVerdict?.(judged.verdict, scenario2, 1);
+    } catch (err) {
+      opts.onProgress?.(
+        `judge failed: ${err?.message ?? String(err)}`,
+        scenario2.local_id
+      );
+    }
   }
   const results = await Promise.allSettled(
     Array.from(
@@ -29412,6 +30217,7 @@ async function executeRun(opts, deps) {
       stop("runner_error");
     }
   }
+  if (missingEvidence) stop("runner_error");
   const order = new Map(opts.scenarios.map((s, i) => [s.local_id, i]));
   verdicts.sort((a, b) => {
     const byScenario = (order.get(a.scenario_id) ?? 1e9) - (order.get(b.scenario_id) ?? 1e9);
@@ -29419,7 +30225,7 @@ async function executeRun(opts, deps) {
   });
   return {
     verdicts,
-    totals: tally(outcomes, { planned: total, unrunnable: opts.unrunnable }),
+    totals: tally(outcomes, { planned, unrunnable: opts.unrunnable }),
     credits,
     halted: halted2,
     haltReason
@@ -29561,508 +30367,7 @@ init_manifest();
 init_sync2();
 init_materialise();
 init_plan_file();
-
-// src/run/plan.ts
-init_subagent();
-init_role_failure();
-init_registry4();
-init_context();
-init_types3();
-init_env();
-init_render();
-import yaml13 from "js-yaml";
-var PLAN_SCHEMA2 = {
-  type: "object",
-  /*
-   * `rca` is NOT required, and requiring it failed real runs.
-   *
-   * "run_planner: the reply does not match the shape asked for — rca:
-   * required, and absent" is the whole of `/run` refusing because a boolean
-   * with an obvious default was left out. The schema's own description says
-   * "false is the ordinary answer", and `planRun` already reads it as
-   * `Boolean(child.data.rca) || Boolean(input.rca)` — so absence was always
-   * handled everywhere except the validator that rejected it first.
-   *
-   * The three that remain are the answer itself: what to run, what was left
-   * out, and the sentence somebody reads before spending. A reply missing any
-   * of those is not a plan.
-   */
-  required: ["included", "skipped", "summary"],
-  properties: {
-    /**
-     * The four lists are a PARTITION of the candidates.
-     *
-     * Every candidate lands in exactly one, and rook enforces it — a scenario
-     * in two is ambiguous about whether it costs an agent call, and one in none
-     * is silently dropped. `judge_only` and `carried` are the resume half: rook
-     * works out which scenarios are ELIGIBLE for each from the files, and the
-     * planner decides which of them the request actually wants that done to.
-     */
-    included: {
-      type: "array",
-      description: "Execute these: call the agent, then judge. One entry per scenario.",
-      items: {
-        type: "object",
-        required: ["scenario_id", "why", "confidence"],
-        properties: {
-          scenario_id: { type: "string" },
-          why: {
-            type: "string",
-            description: "What this one establishes that the others do not. Not 'important coverage', which is true of everything and decides nothing."
-          },
-          confidence: {
-            type: "string",
-            enum: ["high", "medium", "low"],
-            description: "`low` says you are unsure it earns its cost \u2014 exactly what somebody about to approve wants to know."
-          }
-        }
-      }
-    },
-    judge_only: {
-      type: "array",
-      description: "Already executed by the prior run and never judged. A judge call and NO agent call. Only ids listed as ungraded below are eligible.",
-      items: {
-        type: "object",
-        required: ["scenario_id", "why"],
-        properties: {
-          scenario_id: { type: "string" },
-          why: { type: "string" },
-          confidence: { type: "string", enum: ["high", "medium", "low"] }
-        }
-      }
-    },
-    carried: {
-      type: "array",
-      description: "Already decided by the prior run. Copy the verdict forward \u2014 no agent call, no judge call. Only ids listed as decided below are eligible.",
-      items: {
-        type: "object",
-        required: ["scenario_id", "why"],
-        properties: {
-          scenario_id: { type: "string" },
-          why: { type: "string" },
-          confidence: { type: "string", enum: ["high", "medium", "low"] }
-        }
-      }
-    },
-    rca: {
-      type: "boolean",
-      description: "Explain the failure clusters when this run ends. True when the request asks WHY something fails, or when a run this large failing would leave somebody with nowhere to start. It costs one model call per cluster, so false is the ordinary answer."
-    },
-    skipped: {
-      type: "array",
-      description: "One entry per scenario you deliberately left out.",
-      items: {
-        type: "object",
-        required: ["scenario_id", "why", "confidence"],
-        properties: {
-          scenario_id: { type: "string" },
-          why: {
-            type: "string",
-            description: "Why it is not worth running now. A scenario nobody considered and one deliberately excluded look identical afterwards."
-          },
-          confidence: { type: "string", enum: ["high", "medium", "low"] }
-        }
-      }
-    },
-    summary: {
-      type: "string",
-      description: "What this run will establish, and what it will not. The sentence a person reads before deciding to spend."
-    },
-    resume_from: {
-      type: "string",
-      description: "A prior run to carry finished work from. Omit unless proposing one."
-    },
-    /**
-     * Two fields of `run.yaml` the planner may set, and only these two.
-     *
-     * Both are things a person expresses in words — "call this the threshold
-     * sweep", "run them one at a time" — and neither changes what a run MEANS.
-     *
-     * `test_mode` is deliberately NOT here. It decides whether the run is
-     * pinned upstream at all, so a model able to set it could turn a real run
-     * into one that records nothing, or a smoke test into a version-pinned
-     * result. That is a flag, and flags are for people.
-     *
-     * An explicit flag always wins over both — see `applyPlanned`.
-     */
-    name: {
-      type: "string",
-      description: "A short name for this run, when the request suggests one. Omit rather than inventing a label nobody used."
-    },
-    concurrency: {
-      type: "integer",
-      description: "How many scenarios to run at once, when the request says. One is the default and the right answer for anything hitting a rate-limited API."
-    }
-  }
-};
-function staticPlan(input) {
-  const { partition: partition2 } = input;
-  const included = partition2.candidates.map((c) => ({
-    scenario_id: c.local_id,
-    why: "a candidate, and nothing narrowed this run further",
-    confidence: "high"
-  }));
-  const judge_only = [];
-  const carried = [];
-  const skipped = [
-    ...partition2.excluded.map((e) => ({
-      scenario_id: e.scenario_id,
-      why: `excluded by the flags: ${e.why}`,
-      confidence: "high"
-    })),
-    ...partition2.filtered.map((f) => ({
-      scenario_id: f.scenario_id,
-      why: `left out by the tree: ${f.why}`,
-      confidence: "high"
-    }))
-  ];
-  const counts = [
-    included.length ? `${included.length} to execute` : "",
-    // SAID, not implied. Somebody who typed `--resume` expects work to be
-    // reused, and a plan that silently re-ran everything would look like one
-    // that had reused nothing to reuse.
-    input.resumeHint ? `nothing reused from ${input.resumeHint}` : ""
-  ].filter(Boolean);
-  return {
-    included,
-    skipped,
-    judge_only,
-    carried,
-    /*
-     * `--rca` and nothing else. There is no sentence for anything to read an
-     * intent out of, and RCA costs a model call per failure cluster — turning
-     * it on because a run happens to be large would spend on an explanation
-     * nobody asked for.
-     */
-    rca: Boolean(input.rca),
-    summary: counts.length ? `no instruction given \u2014 ${counts.join(", ")}. Every candidate the flags and the tree left.` : "no instruction given, and nothing is left to run.",
-    ...input.resumeHint ? { resume_from: input.resumeHint } : {},
-    /*
-     * No `name` and no `concurrency`. Both are proposals a planner makes from
-     * a sentence, and `applyPlanned` already lets an explicit flag win — so
-     * omitting them leaves the flag, or the default, exactly as typed.
-     */
-    // Nothing was spent. A non-zero cost here would bill a run for a decision
-    // no model was asked to make.
-    credits: 0
-  };
-}
-async function planRun(input, deps) {
-  const { partition: partition2 } = input;
-  const flagsAsked = input.flags ?? [];
-  const task4 = [
-    input.instruction ? `## WHAT THE USER ASKED FOR
-
-  ${input.instruction}
-` : "",
-    input.resumeHint ? `## THEY NAMED A RUN
-
-  ${input.resumeHint} \u2014 look it up before planning.
-` : "",
-    /**
-     * The same rendering of the agent every other planner gets.
-     *
-     * From the same function, so a planner deciding what to SPEND cannot be
-     * reasoning about a different agent than the writers described.
-     */
-    agentContext({
-      spec: input.spec,
-      features: input.features,
-      ...input.findings?.length ? { findings: input.findings } : {},
-      ...input.callers?.length ? { callers: input.callers } : {},
-      ...input.callees?.length ? { callees: input.callees } : {}
-    }),
-    "",
-    /**
-     * How the agent is reached, and what rook can SEE while it runs.
-     *
-     * The second half is what decides whether a scenario is checkable at all,
-     * and the unrunnable list below is computed from it — so the planner is
-     * shown the reason as well as the verdict.
-     */
-    "## THE PROFILE THIS RUN WILL USE",
-    "",
-    "```yaml",
-    yaml13.dump(
-      {
-        id: input.profile.id,
-        /*
-         * WHICH PHASES, not which transport.
-         *
-         * `kind` and `mode` were here and told the planner the agent was
-         * reached over http, synchronously — neither of which changes what
-         * to run. The phases do: a profile with a `collect` can be run now
-         * and collected later, and one without cannot, so a planner asked
-         * about staging a run needs this and had no way to see it.
-         */
-        phases: definedPhases(input.profile),
-        multi_turn: Boolean(input.profile.capabilities?.multi_turn),
-        /*
-         * What the profile REPORTS, and it must not contradict the gap block
-         * below it.
-         *
-         * This was hardcoded `false` upstream, because on the old schema
-         * nothing observed a call — `observe.mcp: proxy` was a declaration
-         * with no implementation (#717). A `collect` hook can hand calls back
-         * now, and `capabilities.calls` is what one real invocation showed.
-         * The gate agrees: it raises a `tool_calls` gap only when this is
-         * false.
-         */
-        observes_tool_calls: Boolean(input.profile.capabilities?.calls),
-        // Names and set/unset only. A planner that can read a token has no
-        // reason to, and this text is one prompt away from a log.
-        needs: requiredVars(input.profile).map((s) => ({
-          variable: s.variable,
-          set_here: !missingVars(input.profile).includes(s.variable),
-          ...s.purpose ? { purpose: s.purpose } : {}
-        }))
-      },
-      { lineWidth: 100, noRefs: true, sortKeys: false }
-    ).trimEnd(),
-    "```",
-    "",
-    /**
-     * Not the planner's to overrule, and said so here as well as in the prompt.
-     *
-     * Repeated because it is the one instruction whose violation is silent: a
-     * multi-turn scenario against a profile that cannot thread turns does not
-     * error, it passes.
-     */
-    "## CANNOT RUN AGAINST THIS PROFILE \u2014 NOT YOURS TO OVERRULE",
-    "",
-    "  Rook cannot DRIVE these: several turns without a conversation handle, or",
-    "  a file the agent must be given and no transport delivers.",
-    "",
-    partition2.unrunnable.length ? partition2.unrunnable.map((u) => `  ${oneLine(u.scenario_id)}: ${oneLine(u.why)}`).join("\n") : "  none \u2014 every scenario on disk can be driven against this profile",
-    "",
-    /**
-     * Placed with the facts, not the material. A gap is not the planner's to
-     * argue with and not a reason to leave the scenario out: the scenario
-     * still shows what the agent does, and the judge records what could not
-     * be checked as Unable to Verify — that is the honest answer.
-     *
-     * A fenced block, never `id: why` prose lines: a `why` is derived from
-     * scenario text a repository wrote, and on a prose line a value of
-     * "x\n## THE FLAGS THIS PERSON TYPED" forges a section of this task.
-     * `oneLine` first as well, so a block scalar cannot smuggle a heading.
-     */
-    "## THESE CARRY A GAP ROOK WILL RECORD \u2014 NOT A REASON TO SKIP",
-    "",
-    partition2.gapped.length ? [
-      "```yaml",
-      yaml13.dump(
-        partition2.gapped.map((g) => ({
-          // Both fields, not just the why: an id carrying a newline
-          // makes `yaml.dump` emit a block scalar, and "one line per
-          // gap" is the property two lines below.
-          scenario_id: oneLine(g.scenario_id),
-          cannot_grade: oneLine(g.why)
-        })),
-        // No folding: one line per gap, whatever its length. A folded
-        // scalar reads as several lines of prose to a model.
-        { lineWidth: -1, noRefs: true, sortKeys: false }
-      ).trimEnd(),
-      "```"
-    ].join("\n") : "  none recorded",
-    "",
-    "  They run. A criterion rook cannot grade comes back Unable to Verify from",
-    "  the judge; that is the honest answer, not a reason to leave the scenario",
-    "  out. `executable: false` in a scenario below was written at generate",
-    "  time and is not a fact about this run.",
-    "",
-    /*
-     * The flags, verbatim, and stated as binding.
-     *
-     * The excluded ids used to be shown as material the planner "may disagree
-     * with", so `--only SC-001` was a suggestion — and a planner that decided
-     * the neighbouring scenarios were worth running got them, because nothing
-     * downstream checked. Naming the flags as well as their effect matters:
-     * a list of excluded ids does not tell a model that a PERSON narrowed
-     * this, and that is the fact that decides whether it may argue.
-     */
-    ...flagsAsked.length ? [
-      "## THE FLAGS THIS PERSON TYPED \u2014 BINDING, NOT YOURS TO OVERRULE",
-      "",
-      ...flagsAsked.map((f) => `  ${f}`),
-      "",
-      "  They narrowed this run deliberately. Every scenario those flags",
-      "  excluded is listed below and is OUT \u2014 naming one in included,",
-      "  judge_only or carried is an error, and rook drops it. If the flags",
-      "  look wrong for what they asked, say so in summary rather than",
-      "  planning around them.",
-      "",
-      "## WHAT THOSE FLAGS EXCLUDED \u2014 out of this run",
-      "",
-      partition2.excluded.length ? partition2.excluded.map((f) => `  ${f.scenario_id}: ${f.why}`).join("\n") : "  nothing \u2014 every scenario on disk matched them",
-      ""
-    ] : [],
-    "## WHAT THE TREE LEFT OUT \u2014 material, and you may disagree",
-    "",
-    partition2.filtered.length ? partition2.filtered.map((f) => `  ${f.scenario_id}: ${f.why}`).join("\n") : "  nothing \u2014 no scenario was dropped for the state it is in",
-    "",
-    "## YOUR CANDIDATES \u2014 everything you may choose from",
-    "",
-    partition2.candidates.length ? partition2.candidates.map((c) => `  ${c.local_id}  ${c.title}`).join("\n") : "  nothing \u2014 the flags excluded everything runnable",
-    "",
-    ...input.stale.length ? [
-      "## THESE PIN OLDER FEATURE TEXT",
-      "",
-      `  ${input.stale.join(", ")}`,
-      "",
-      "They still run \u2014 an outdated test that passes is information. What must",
-      "not happen is a plan describing them as though they were written",
-      "against the feature as it stands.",
-      ""
-    ] : [],
-    /**
-     * Every scenario, in full, and LAST — the state block.
-     *
-     * Titles and counts cannot tell six behaviours from six rewordings, and
-     * that difference is exactly what decides whether a run is worth its cost.
-     * Last because it is the part that changes every run, which is what prompt
-     * caching wants.
-     */
-    "## EVERY SCENARIO ON DISK",
-    "",
-    "```yaml",
-    yaml13.dump(input.scenarios, { lineWidth: 100, noRefs: true, sortKeys: false }).trimEnd(),
-    "```",
-    ""
-  ].filter(Boolean).join("\n");
-  const child = await spawnSubagent(
-    {
-      role: "run_planner",
-      label: `${partition2.candidates.length} candidate(s)`,
-      task: task4,
-      // The BUDGET phase, not the command. `plan_scenarios` bills to
-      // "generate" for the same reason: a planner is charged to the work it is
-      // planning, so one bucket covers deciding and doing.
-      phase: "execute",
-      responseSchema: PLAN_SCHEMA2,
-      tools: toolsForRole("run_planner", { root: input.root, mcpAgent: null })
-    },
-    deps
-  );
-  if (!child.ok || child.data == null)
-    throw new Error(roleFailure("run_planner", child));
-  const forbidden = /* @__PURE__ */ new Set([
-    ...partition2.unrunnable.map((u) => u.scenario_id),
-    ...partition2.excluded.map((e) => e.scenario_id)
-  ]);
-  const known = new Set(input.scenarios.map((s) => s.local_id));
-  const included = (child.data.included ?? []).filter(
-    (e) => e?.scenario_id && known.has(e.scenario_id) && !forbidden.has(e.scenario_id)
-  );
-  const skipped = (child.data.skipped ?? []).filter(
-    (e) => e?.scenario_id && known.has(e.scenario_id)
-  );
-  const canJudge = new Set(input.ungraded ?? []);
-  const canCarry = new Set(input.decided ?? []);
-  const eligible = (entries, allowed) => {
-    const kept = [];
-    const demoted = [];
-    for (const e of entries ?? []) {
-      if (!e?.scenario_id || !known.has(e.scenario_id)) continue;
-      if (forbidden.has(e.scenario_id)) continue;
-      (allowed.has(e.scenario_id) ? kept : demoted).push(e);
-    }
-    return { kept, demoted };
-  };
-  const judgeOnly = eligible(child.data.judge_only, canJudge);
-  const carried = eligible(child.data.carried, canCarry);
-  const claimed = /* @__PURE__ */ new Set();
-  const takeOnce = (entries) => entries.filter(
-    (e) => !claimed.has(e.scenario_id) && claimed.add(e.scenario_id)
-  );
-  const finalIncluded = takeOnce([
-    ...included,
-    ...judgeOnly.demoted,
-    ...carried.demoted
-  ]);
-  const finalJudgeOnly = takeOnce(judgeOnly.kept);
-  const finalCarried = takeOnce(carried.kept);
-  return {
-    included: finalIncluded,
-    skipped,
-    judge_only: finalJudgeOnly,
-    carried: finalCarried,
-    /**
-     * The flag forces it ON and never off.
-     *
-     * A planner that declined costs nothing to overrule, and somebody who typed
-     * `--rca` has asked plainly. The reverse — a flag that silences a planner
-     * which decided an explanation was needed — would hide the reasoning at the
-     * moment it is most wanted.
-     */
-    rca: Boolean(child.data.rca) || Boolean(input.rca),
-    summary: child.data.summary ?? "",
-    ...child.data.resume_from ? { resume_from: child.data.resume_from } : {},
-    ...child.data.name ? { name: child.data.name } : {},
-    ...child.data.concurrency ? { concurrency: child.data.concurrency } : {},
-    credits: child.credits
-  };
-}
-var MAX_PLANNED_CONCURRENCY = 8;
-function applyPlanned(plan2, flags) {
-  const proposed = plan2.concurrency ?? 1;
-  return {
-    ...flags.name ?? plan2.name ? { name: flags.name ?? plan2.name } : {},
-    concurrency: flags.concurrency ?? Math.min(Math.max(1, Math.trunc(proposed)), MAX_PLANNED_CONCURRENCY)
-  };
-}
-function renderRunPlan(plan2, view) {
-  const gap = new Map(view.gapped.map((g) => [g.scenario_id, g.why]));
-  const excluded = new Set(view.excluded.map((e) => e.scenario_id));
-  const gapLine = (id) => {
-    const why2 = gap.get(id);
-    return why2 === void 0 ? [] : [`      cannot grade: ${oneLine(why2)}`];
-  };
-  const lines = [`plan: ${plan2.included.length} scenario(s) to run`];
-  for (const e of plan2.included) {
-    const sure = e.confidence && e.confidence !== "high" ? `  (${e.confidence} confidence)` : "";
-    lines.push(`  ${oneLine(e.scenario_id)}${sure}`);
-    lines.push(`      ${oneLine(e.why)}`);
-    lines.push(...gapLine(e.scenario_id));
-  }
-  for (const e of plan2.judge_only) {
-    lines.push(`  ${oneLine(e.scenario_id)}  judge only \u2014 ${oneLine(e.why)}`);
-    lines.push(...gapLine(e.scenario_id));
-  }
-  for (const e of plan2.carried) {
-    lines.push(`  ${oneLine(e.scenario_id)}  carried \u2014 ${oneLine(e.why)}`);
-    lines.push(...gapLine(e.scenario_id));
-  }
-  for (const e of plan2.skipped) {
-    lines.push(`  ${oneLine(e.scenario_id)}  skipped \u2014 ${oneLine(e.why)}`);
-    const why2 = gap.get(e.scenario_id);
-    if (why2 === void 0) continue;
-    lines.push(
-      excluded.has(e.scenario_id) ? `      carries a gap: ${oneLine(why2)}` : `      carries a gap, which is not a reason to skip: ${oneLine(why2)}`
-    );
-  }
-  if (view.unrunnable.length)
-    lines.push(`  ${view.unrunnable.length} cannot run against this profile`);
-  if (plan2.resume_from)
-    lines.push(`  carrying finished work from ${plan2.resume_from}`);
-  return lines;
-}
-function decidedElsewhere(plan2) {
-  return new Set(
-    [...plan2.judge_only ?? [], ...plan2.carried ?? []].map(
-      (e) => e.scenario_id
-    )
-  );
-}
-function gapLines(view, plan2) {
-  const does = /* @__PURE__ */ new Map();
-  for (const e of plan2.included) does.set(e.scenario_id, "runs");
-  for (const e of plan2.judge_only ?? []) does.set(e.scenario_id, "is judged");
-  return view.gapped.filter((g) => does.has(g.scenario_id)).map(
-    (g) => `${oneLine(g.scenario_id)}: ${does.get(g.scenario_id)} \u2014 cannot grade: ${oneLine(g.why)}`
-  );
-}
-
-// src/run/run.ts
+init_plan2();
 init_render();
 init_flags();
 init_tally();
@@ -30079,7 +30384,7 @@ import {
   mkdirSync as mkdirSync31,
   readFileSync as readFileSync41,
   readdirSync as readdirSync22,
-  statSync as statSync19,
+  statSync as statSync20,
   writeFileSync as writeFileSync29
 } from "fs";
 import { dirname as dirname23, join as join45 } from "path";
@@ -30182,7 +30487,7 @@ async function uploadDir(scope, dir2, kind, scenarioId, prefix) {
   for (const name of names) {
     const at = join45(dir2, name);
     try {
-      if (!statSync19(at).isFile()) continue;
+      if (!statSync20(at).isFile()) continue;
     } catch {
       continue;
     }
@@ -30287,6 +30592,7 @@ async function uploadReport(ctx, upstreamRunId, root, agentId, runId, report2) {
 // src/run/upstream.ts
 init_client();
 init_materialise();
+init_plan2();
 init_plan_file();
 import { readFileSync as readFileSync42 } from "fs";
 import { join as join46 } from "path";
@@ -30449,7 +30755,7 @@ async function reconcileRuns(ctx, root, agentId, say2) {
     if (!runId) continue;
     const reported = new Set(plan2.upstream?.reported ?? []);
     const owed = [];
-    for (const entry of plan2.included) {
+    for (const entry of judgedHere(plan2)) {
       const attempts = 8;
       for (let attempt = 1; attempt <= attempts; attempt++) {
         const key2 = planKey(entry.scenario_id, attempt);
@@ -30802,7 +31108,7 @@ async function run3(opts, deps) {
       why: r.why ?? `continuing ${opts.continueRun}`
     }));
     plan2 = {
-      included: asEntries(prior.included ?? []),
+      included: asEntries(judgedHere(prior)),
       skipped: asEntries(prior.skipped ?? []),
       /*
        * Both empty, and neither is a resume.
@@ -30852,12 +31158,6 @@ async function run3(opts, deps) {
       partition: split4,
       ...opts.resumeHint ? { resumeHint: opts.resumeHint } : {},
       ...opts.rca ? { rca: true } : {}
-      /*
-       * `eligible` is NOT passed, and `staticPlan`'s header says why: the
-       * lists it would fill are dropped a hundred lines below, where
-       * `included` is built from `plan.included` alone. Handing them over
-       * would settle scenarios that then get no folder and no verdict.
-       */
     });
     credits += planned.credits;
     plan2 = planned;
@@ -30952,48 +31252,102 @@ async function run3(opts, deps) {
       reason: "no plan"
     };
   const byId = new Map(scenarios2.map((s) => [s.local_id, s]));
-  const included = plan2.included.map(
+  const acted = scenariosOf(plan2).map(
     (e) => (opts.continueRun ? loadSnapshot(root, agentId, runId, e.scenario_id) : null) ?? byId.get(e.scenario_id)
   ).filter((s) => Boolean(s));
+  const actedById = new Map(acted.map((s) => [s.local_id, s]));
   if (!opts.continueRun) {
-    materialise(root, agentId, runId, included);
+    materialise(root, agentId, runId, acted);
     materialiseContext(root, agentId, runId, { spec, features, profile });
   }
-  const carriedIds = new Set(plan2.carried.map((e) => e.scenario_id));
-  const judgeOnlyIds = new Set(plan2.judge_only.map((e) => e.scenario_id));
+  const carriedIds = /* @__PURE__ */ new Set();
   let carried = 0;
   const toJudgeOnly = [];
-  if (resumeFrom && (carriedIds.size > 0 || judgeOnlyIds.size > 0)) {
-    for (const sc of included) {
-      if (!carriedIds.has(sc.local_id) && !judgeOnlyIds.has(sc.local_id))
-        continue;
+  const unavailableEvidence = /* @__PURE__ */ new Set();
+  const planFailure = (err) => {
+    const reason = `cannot read or update ${planPath(root, agentId, runId)}: ${err?.message ?? String(err)}`;
+    say2("error", `${reason} \u2014 restore access and create a new run; no target-agent work started`);
+    return { runId, credits, halted: true, reason };
+  };
+  const moved = [];
+  if (resumeFrom) {
+    const wanted = [
+      ...plan2.carried.map((entry) => ({ entry, as: "carried" })),
+      ...plan2.judge_only.map((entry) => ({ entry, as: "judge_only" }))
+    ];
+    for (const { entry, as } of wanted) {
+      const sc = actedById.get(entry.scenario_id);
+      if (!sc) continue;
       const what = carryForward(
         root,
         agentId,
         { runId: resumeFrom, scenarioId: sc.local_id },
-        { runId, scenarioId: sc.local_id }
+        { runId, scenarioId: sc.local_id },
+        { verdict: as === "carried" }
       );
-      if (carriedIds.has(sc.local_id) && what === "verdict") {
+      if (as === "carried" && what === "verdict") {
         carried++;
+        carriedIds.add(sc.local_id);
         continue;
       }
-      if (what === "response" || what === "verdict") toJudgeOnly.push(sc);
+      if (what === "response" || what === "verdict") {
+        toJudgeOnly.push(sc);
+        if (as === "carried")
+          moved.push({
+            entry,
+            why: `${resumeFrom} no longer holds a readable verdict.yaml \u2014 judged here instead`
+          });
+        continue;
+      }
+      unavailableEvidence.add(sc.local_id);
+      toJudgeOnly.push(sc);
+      moved.push({
+        entry,
+        why: `${resumeFrom} no longer holds a readable response.json \u2014 nothing to judge, and this run was not approved to execute it`
+      });
     }
     if (carried > 0) {
       say2("system", `carried ${carried} verdict(s) forward from ${resumeFrom}`);
     }
-    if (toJudgeOnly.length > 0) {
+    if (toJudgeOnly.length > unavailableEvidence.size && selection.phases.includes("judge")) {
       say2(
         "system",
-        `${toJudgeOnly.length} already executed \u2014 judging without calling the agent`
+        `${toJudgeOnly.length - unavailableEvidence.size} already executed \u2014 judging without calling the agent`
       );
     }
+    if (moved.length > 0) {
+      for (const m of moved) say2("warn", `${m.entry.scenario_id}: ${m.why}`);
+      try {
+        const before = loadPlanOrThrow(root, agentId, runId);
+        const movedIds = new Set(moved.map((m) => m.entry.scenario_id));
+        const row = (m) => ({
+          scenario_id: m.entry.scenario_id,
+          why: m.why,
+          confidence: "high"
+        });
+        savePlan(root, agentId, {
+          ...before,
+          judge_only: [
+            ...(before.judge_only ?? []).filter(
+              (e) => !movedIds.has(e.scenario_id)
+            ),
+            ...moved.map(row)
+          ],
+          carried: (before.carried ?? []).filter(
+            (e) => !movedIds.has(e.scenario_id)
+          )
+        });
+      } catch (err) {
+        return planFailure(err);
+      }
+    }
   }
   const settled = /* @__PURE__ */ new Set([
-    ...plan2.carried.map((e) => e.scenario_id),
+    ...carriedIds,
     ...toJudgeOnly.map((s) => s.local_id)
   ]);
-  const toExecute = included.filter((s) => !settled.has(s.local_id));
+  const toExecute = acted.filter((s) => !settled.has(s.local_id));
+  const own = acted.filter((s) => !carriedIds.has(s.local_id));
   const upstreamCtx = {
     api: opts.api,
     projectId: opts.projectId,
@@ -31001,7 +31355,12 @@ async function run3(opts, deps) {
     testMode: Boolean(opts.testMode)
   };
   const revisionOf = state4?.revisions?.scenarios ?? {};
-  const saved = loadPlanOrThrow(root, agentId, runId);
+  let saved;
+  try {
+    saved = loadPlanOrThrow(root, agentId, runId);
+  } catch (err) {
+    return planFailure(err);
+  }
   let upstream = null;
   try {
     upstream = await startRunUpstream(
@@ -31025,7 +31384,7 @@ async function run3(opts, deps) {
         // One or the other, never one field meaning both.
         ...state4?.profile_ids?.[profile.id] ? { profileId: state4.profile_ids[profile.id] } : { profileLocalId: profile.id }
       },
-      toExecute,
+      own,
       revisionOf
     );
   } catch (err) {
@@ -31066,6 +31425,7 @@ async function run3(opts, deps) {
       profile,
       scenarios: toExecute,
       ...toJudgeOnly.length > 0 ? { judgeOnly: toJudgeOnly } : {},
+      unavailableEvidence,
       unrunnable: split4.unrunnable.length,
       // The agent, once, for every judge this run spawns.
       spec,
@@ -31166,10 +31526,6 @@ async function run3(opts, deps) {
   }
   const totals = {
     ...result2.totals,
-    // Judged-without-executing counts as PLANNED work this run did; carried
-    // verdicts did not. A resume that judged two and inherited nine did not
-    // run eleven, and did not run two either.
-    planned: toExecute.length + toJudgeOnly.length,
     carried_forward: carried
   };
   await verdicts.flush();
@@ -31182,7 +31538,9 @@ async function run3(opts, deps) {
   const reported = opts.continueRun ? tallyFromVerdicts(allVerdicts, {
     planned: totals.planned,
     unrunnable: split4.unrunnable.length,
-    carriedForward: carried
+    // Nothing is carried on a continuation; what the resume carried is on
+    // its plan, and a later pass still inherited exactly that much.
+    carriedForward: (saved.carried ?? []).length
   }) : totals;
   const invokedHooks = selection.phases.some(
     (p) => HOOK_PHASES.includes(p)
@@ -31201,7 +31559,7 @@ async function run3(opts, deps) {
       spec,
       features,
       verdicts: allVerdicts,
-      scenarios: included,
+      scenarios: own,
       totals: reported,
       metrics,
       say: say2,
@@ -31404,8 +31762,8 @@ import {
   mkdirSync as mkdirSync32,
   mkdtempSync,
   readdirSync as readdirSync23,
-  rmSync as rmSync9,
-  statSync as statSync20,
+  rmSync as rmSync10,
+  statSync as statSync21,
   writeFileSync as writeFileSync31
 } from "fs";
 import { tmpdir } from "os";
@@ -31479,10 +31837,10 @@ function exportLogs(opts) {
     const out = destination(opts.out, name, tool.ext);
     mkdirSync32(dirname24(out), { recursive: true });
     build(tool.cmd, staging, name, out);
-    const bytes = existsSync40(out) ? statSync20(out).size : 0;
+    const bytes = existsSync40(out) ? statSync21(out).size : 0;
     return { path: out, included, bytes };
   } finally {
-    rmSync9(staging, { recursive: true, force: true });
+    rmSync10(staging, { recursive: true, force: true });
   }
 }
 function notALink(src) {
@@ -31497,11 +31855,11 @@ function scrub(box) {
     for (const entry of readdirSync23(dir2, { withFileTypes: true })) {
       const at = join47(dir2, entry.name);
       if (entry.isSymbolicLink()) {
-        rmSync9(at, { force: true, recursive: true });
+        rmSync10(at, { force: true, recursive: true });
       } else if (entry.isDirectory()) {
         walk4(at);
       } else if (NEVER.includes(entry.name)) {
-        rmSync9(at, { force: true });
+        rmSync10(at, { force: true });
       }
     }
   };
@@ -31597,7 +31955,7 @@ function terminal() {
   };
 }
 function runCommand(line) {
-  const parts = split2(line);
+  const parts = split3(line);
   const args = parts[0] === "rook" ? parts.slice(1) : parts;
   if (args.length === 0) return Promise.resolve(1);
   return new Promise((done) => {
@@ -31610,7 +31968,7 @@ function runCommand(line) {
     child.on("close", (code) => done(code ?? 1));
   });
 }
-function split2(line) {
+function split3(line) {
   const out = [];
   let current2 = "";
   let quote2 = null;
@@ -32091,7 +32449,7 @@ import {
   mkdtempSync as mkdtempSync2,
   readFileSync as readFileSync44,
   realpathSync as realpathSync10,
-  rmSync as rmSync10,
+  rmSync as rmSync11,
   writeFileSync as writeFileSync32
 } from "fs";
 import { tmpdir as tmpdir2 } from "os";
@@ -32257,9 +32615,9 @@ function readPackageName(pkgRoot) {
 // src/updater.ts
 init_version_check();
 var CURL_INSTALL_COMMAND = "curl -fsSL https://raw.githubusercontent.com/LambdaTest/rook/main/install.sh | bash";
-var SCOPE_REGISTRY_FLAG = `--${PUBLISHED_SCOPE}:registry`;
+var SCOPE_REGISTRY_ARG = `--${PUBLISHED_SCOPE}:registry=${NPM_REGISTRY_BASE}`;
 function npmInstallCommand(latest) {
-  return `npm install -g --registry ${NPM_REGISTRY_BASE} ${SCOPE_REGISTRY_FLAG} ${NPM_REGISTRY_BASE} ${PUBLISHED_PACKAGE_NAME}@${latest}`;
+  return `npm install -g --registry ${NPM_REGISTRY_BASE} ${SCOPE_REGISTRY_ARG} ${PUBLISHED_PACKAGE_NAME}@${latest}`;
 }
 function candidateCommands(latest) {
   return [npmInstallCommand(latest), CURL_INSTALL_COMMAND, "brew upgrade rook"];
@@ -32322,7 +32680,7 @@ async function runUpdate(deps) {
     case "npm-print": {
       const cause = provenance.reason === "layout" ? "not a global install \u2014 the layout above it is an npx cache, or a project-local node_modules, not an npm prefix" : "a global npm install, but the running copy could not be confirmed to be the one <prefix>/bin/rook points at";
       deps.out(
-        `this is the npm package, but ${cause}. If a global install exists, run: npm install -g --registry ${NPM_REGISTRY_BASE} ${SCOPE_REGISTRY_FLAG} ${NPM_REGISTRY_BASE} ${shellQuote(`${PUBLISHED_PACKAGE_NAME}@${latest}`)}`
+        `this is the npm package, but ${cause}. If a global install exists, run: npm install -g --registry ${NPM_REGISTRY_BASE} ${SCOPE_REGISTRY_ARG} ${shellQuote(`${PUBLISHED_PACKAGE_NAME}@${latest}`)}`
       );
       return 1;
     }
@@ -32361,8 +32719,7 @@ async function runUpdate(deps) {
         provenance.prefix,
         "--registry",
         NPM_REGISTRY_BASE,
-        SCOPE_REGISTRY_FLAG,
-        NPM_REGISTRY_BASE,
+        SCOPE_REGISTRY_ARG,
         `${PUBLISHED_PACKAGE_NAME}@${latest}`
       ];
       return dispatchAndConfirm(
@@ -32413,7 +32770,7 @@ async function runUpdate(deps) {
         );
         return 1;
       } finally {
-        rmSync10(tmpDir, { recursive: true, force: true });
+        rmSync11(tmpDir, { recursive: true, force: true });
       }
     }
   }
@@ -32606,7 +32963,13 @@ function announceUpdateIfAny() {
   writeErr(`Update available: ${VERSION} \u2192 ${updateInfo.latest}
 `);
 }
-var program = new Command();
+var program = new Command2().configureOutput({
+  writeOut,
+  writeErr,
+  outputError: (text, write2) => {
+    if (currentClient() === "cli") write2(text);
+  }
+});
 program.name("rook").description("Agent Assurance by Testmu AI").on("option:version", () => announceUpdateIfAny()).version(VERSION, "-v, --version");
 async function admit(command) {
   const auth3 = await resolveBootAuth();
@@ -34476,7 +34839,12 @@ program.command("docs").description("the public repo, printed and opened").optio
 `);
   await announceOpen(PUBLIC_DOCS_URL, flags.open);
 });
-program.command("update").description("check for a newer rook, and how to get it").argument("[auto]", "`auto` re-enables the notice after 'never ask again'").option("--json", "machine-readable output").action(async (sub, flags) => {
+program.command("update").description("check for a newer rook, and how to get it").addArgument(
+  new Argument(
+    "[auto]",
+    "`auto` re-enables the notice after 'never ask again'"
+  ).choices(["auto"])
+).option("--json", "machine-readable output").action(async (sub, flags) => {
   const mode = { json: Boolean(flags.json), verbose: false };
   const say2 = sayFor(mode);
   if (sub === "auto") {
@@ -34489,11 +34857,6 @@ program.command("update").description("check for a newer rook, and how to get it
     if (!cleared) process.exitCode = 1;
     return;
   }
-  if (sub) {
-    say2("error", "usage: rook update [auto]");
-    process.exitCode = 1;
-    return;
-  }
   if (needsProxyReexec(process.env)) {
     const { spawn: spawn8 } = await import("child_process");
     const child = spawn8(
@@ -34626,16 +34989,10 @@ mcp.command("approve <name>").description(
 ).option("--json", "machine-readable output").action((name, flags) => {
   runMcp(approve(process.cwd(), name, flags), Boolean(flags.json));
 });
-program.command("help").description("list commands \u2014 rook help <command> for its flags").argument("[command]", "one command, in full").action((name) => {
+var helpArgument = new Argument("[command]", "one command, in full");
+program.command("help").description("list commands \u2014 rook help <command> for its flags").addArgument(helpArgument).action((name) => {
   const surface = currentClient();
   const lines = name ? renderCommandHelp(program, name, surface) : renderHelp(program, surface);
-  if (!lines) {
-    writeErr(`no such command: ${name}
-`);
-    writeErr("rook help    lists them\n");
-    process.exitCode = 1;
-    return;
-  }
   writeOut(`${lines.join("\n")}
 `);
 });
@@ -34729,16 +35086,8 @@ ${out.ran.length} command(s) run this conversation`
     }
   }
 );
-program.command("export").description("bundle rook's logs for a bug report").argument("<what>", "`logs` \u2014 the only kind today").requiredOption("--out <path>", "a directory, or a filename ending .zip/.tgz").option("--session <id>", "also include this session's transcript").option("--all-sessions", "include every session recorded for this project").action(
+program.command("export").description("bundle rook's logs for a bug report").addArgument(new Argument("<what>", "what to export").choices(["logs"])).requiredOption("--out <path>", "a directory, or a filename ending .zip/.tgz").option("--session <id>", "also include this session's transcript").option("--all-sessions", "include every session recorded for this project").action(
   async (what, flags) => {
-    if (what !== "logs") {
-      writeErr(
-        `rook export ${what}: not something rook exports. Try 'logs'
-`
-      );
-      process.exitCode = 1;
-      return;
-    }
     try {
       const out = exportLogs({
         root: process.cwd(),
@@ -34831,6 +35180,9 @@ program.command("doctor").description("check the environment without starting an
 `);
   }
 });
+helpArgument.choices(
+  program.commands.flatMap((cmd) => [cmd.name(), ...cmd.aliases()])
+);
 
 // src/cli.ts
 init_dispatch();