@rulvar/cli 1.0.0 → 1.2.0

package/dist/cli.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { r as runCli, t as processIo } from "./io-DUfUn6KG.js";
+import { r as runCli, t as processIo } from "./io-poGpn70r.js";
 //#region src/cli.ts
 /**
 * The `rulvar` bin entry: thin wrapper over runCli with process io.

package/dist/{dist-DtuSmcav.js → dist-Cdj5YBRG.js}

@@ -14,9 +14,9 @@ var __esmMin = (fn, res, err) => () => {
 var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
 var __require = /* #__PURE__ */ (() => createRequire(import.meta.url))();
 //#endregion
-//#region ../planner/dist/compile-CfWgGVyz.js
+//#region ../planner/dist/compile-BtCY9wfO.js
 /**
-* The exact curated sandbox global set, in docs order (docs/06, 8.2).
+* The exact curated sandbox global set, in canonical order.
 * The worker binds the ctx methods as bare globals under these names and
 * the API card teaches exactly this list.
 */
@@ -180,11 +180,11 @@ function scanImports(source, blanked, allowImports) {
 	return diagnostics;
 }
 /**
-* Validates and compiles planner-generated source into a CompiledWorkflow
-* (docs/06, 8.3). The source is an async function body over the sandbox
+* Validates and compiles planner-generated source into a CompiledWorkflow.
+* The source is an async function body over the sandbox
 * globals; its `return` value is the workflow result. The compiled form is
 * pure data (the source is evaluated only inside the worker sandbox);
-* machine scripts run under errorPolicy 'lenient' (docs/06, Appendix A).
+* machine scripts run under errorPolicy 'lenient'.
 */
 function compileScript(source, o) {
 	const allowImports = o?.allowImports ?? [];
@@ -86992,7 +86992,7 @@ var require_eslint_helpers = /* @__PURE__ */ __commonJSMin(((exports, module) =>
 	*/
 	async function globMatch({ basePath, pattern }) {
 		let found = false;
-		const { hfs } = await import("./src-DVFj9U50.js");
+		const { hfs } = await import("./src-BA7JP7vn.js");
 		const patternToUse = normalizeToPosix(path$9.relative(basePath, pattern));
 		const matcher = new Minimatch(patternToUse, MINIMATCH_OPTIONS);
 		const walkSettings = {
@@ -87040,7 +87040,7 @@ var require_eslint_helpers = /* @__PURE__ */ __commonJSMin(((exports, module) =>
 			return new Minimatch(patternToUse, MINIMATCH_OPTIONS);
 		});
 		const unmatchedPatterns = /* @__PURE__ */ new Set([...relativeToPatterns.keys()]);
-		const { hfs } = await import("./src-DVFj9U50.js");
+		const { hfs } = await import("./src-BA7JP7vn.js");
 		const walk = hfs.walk(basePath, {
 			async directoryFilter(entry) {
 				if (!matchers.some((matcher) => matcher.match(entry.path, true))) return false;
@@ -94765,7 +94765,7 @@ const CTX_CALL_METHODS = /* @__PURE__ */ new Set([
 	"parallel",
 	"pipeline"
 ]);
-/** Bare sandbox globals that are ctx calls in compiled scripts (docs/06, 8.2). */
+/** Bare sandbox globals that are ctx calls in compiled scripts. */
 const SANDBOX_CALL_GLOBALS = /* @__PURE__ */ new Set([
 	"agent",
 	"workflow",
@@ -94980,8 +94980,7 @@ const plugin = {
 };
 /**
 * The flat-config preset for workflow modules: the determinism bans as
-* errors, the duplicate-identical-call advisory as a warning (docs/06,
-* 8.4).
+* errors, the duplicate-identical-call advisory as a warning.
 */
 const workflowsConfig = {
 	name: "rulvar/workflows",
@@ -95000,7 +94999,7 @@ plugin.configs = { workflows: workflowsConfig };
 //#region ../planner/dist/index.js
 /**
 * The API card (M6-T04): teaches the planner model EXACTLY the sandbox
-* dialect and global set (docs/06, sections 8.2 and 8.3). The card is a
+* dialect and global set. The card is a
 * pure constant, byte-stable across runs; plan() (M6-T05) composes it
 * with profileCard(registry) and the goal. The usage examples are
 * distilled from the runnable examples/ corpus (M5-T09).
@@ -95052,7 +95051,7 @@ function apiCard() {
 }
 /**
 * The plan agent and the self-repair loop (M6-T05): mode (b), the
-* flagship hybrid (docs/06, section 9.2). plan() asks a planner model
+* flagship hybrid. plan() asks a planner model
 * (role 'plan') to write a script against the API card and the profile
 * card, lints it with eslint-plugin-rulvar, self-repairs up to
 * repairRounds rounds from the JSON diagnostics, and compiles the
@@ -95063,7 +95062,7 @@ function apiCard() {
 * against the same store REPLAYS the unchanged prefix for free
 * (invariant I1; the M6-T05 acceptance).
 */
-/** The deterministic planner runId: one goal, one journal (docs/06, 9.2). */
+/** The deterministic planner runId: one goal, one journal. */
 function planRunIdOf(goal) {
 	return `plan-${createHash("sha256").update(goal, "utf8").digest("hex").slice(0, 24)}`;
 }
@@ -95196,7 +95195,7 @@ async function plan(engine, goal, o) {
 	};
 }
 /**
-* plan-then-run in one call (docs/06, section 9; amended during M6-T05:
+* plan-then-run in one call (amended during M6-T05:
 * the composition is async because planning itself is a run).
 */
 async function runPlanned(engine, goal, args) {
@@ -95207,19 +95206,19 @@ async function runPlanned(engine, goal, args) {
 * WorkerSandboxRunner (M6-T02): the mandatory runner for machine-generated
 * scripts, mode (b). Owns the worker lifecycle and the dedicated
 * MessageChannel; every primitive call is served by the core sandbox
-* bridge against the canonical run ctx (docs/06, 8.2).
+* bridge against the canonical run ctx.
 *
 * Port lifecycle: one channel per run; the worker end rides the init
 * transfer list; the host end is referenced while the worker computes and
 * unreferenced while every worker frame is blocked on a host call, so a
-* suspended run lets the process exit (docs/06, 2.7) and a computing
+* suspended run lets the process exit and a computing
 * worker keeps it alive. Breaching timeoutMs or memoryMb terminates the
 * worker and the run completes with outcome 'error' carrying the typed
-* SandboxError (docs/02, error taxonomy).
+* SandboxError.
 */
 const DEFAULT_SANDBOX_TIMEOUT_MS = 3e5;
 const DEFAULT_SANDBOX_MEMORY_MB = 512;
-/** Accepts CompiledWorkflow ONLY: feeding a closure is a type error (docs/06, 8). */
+/** Accepts CompiledWorkflow ONLY: feeding a closure is a type error. */
 var WorkerSandboxRunner = class {
 	timeoutMs;
 	memoryMb;

package/dist/{dist-4eKFSpyW.js → dist-M-vPRtBM.js}

@@ -1,4 +1,4 @@
-import { KnowledgeCasError, claimExpiry, defineWorkflow } from "@rulvar/core";
+import { KnowledgeCasError, claimExpiry, compileVerifiedLayer, defineWorkflow } from "@rulvar/core";
 import { createHash } from "node:crypto";
 //#region ../evals/dist/index.js
 /**
@@ -6,9 +6,9 @@ import { createHash } from "node:crypto";
 * suite runners. A separate quality-measurement package built strictly on
 * the public APIs (L6).
 *
-* Owning spec: docs/09-observability-testing-spec.md, section
-* "@rulvar/evals"; determinism rules in docs/11-testing-strategy.md,
-* section "Eval CI": judge graders run THROUGH the engine, so judge calls
+* Determinism rules (https://docs.rulvar.com/guide/evals and
+* https://docs.rulvar.com/guide/testing): judge graders run THROUGH the
+* engine, so judge calls
 * are journaled, budgeted, and VCR-recordable, and an eval suite replays
 * deterministically from cassettes with zero live calls.
 */
@@ -244,14 +244,14 @@ function judgeGrader(options) {
 	};
 }
 /**
-* The eval-committer identity (M11-T01; docs/05, sections "Data model"
-* and "Commit discipline"). The pipeline-side commit path: builds
+* The eval-committer identity (M11-T01; https://docs.rulvar.com/guide/model-knowledge).
+* The pipeline-side commit path: builds
 * eval-committer-gated ops (the coherence square: class eval-measured,
 * author eval-pipeline, metrics present) and commits them with the
 * documented CAS-rebase recipe. Humans never call this; their path is
 * the human gate and it structurally cannot carry metrics.
 */
-/** One measured claim, TTL applied per the docs/05 decay table. */
+/** One measured claim; claimExpiry applies the TTL from the decay table. */
 function evalMeasuredClaim(input, committerId) {
 	return {
 		id: input.id,
@@ -306,8 +306,7 @@ async function commitEvalMeasured(store, claims, options) {
 	throw lastCas ?? /* @__PURE__ */ new Error("commitEvalMeasured: unreachable");
 }
 /**
-* The canary fingerprint (M11-T04; docs/05, section "Grounding and
-* decay"; OQ-06). The optional compensation for silent alias
+* The canary fingerprint (M11-T04; OQ-06). The optional compensation for silent alias
 * re-pointing that modelEpoch honestly cannot catch: a FIXED probe set
 * at temperature 0, run through the ordinary engine (journaled,
 * budgeted, VCR-recordable), hashed over normalized outputs. A
@@ -341,9 +340,8 @@ async function canaryFingerprint(engine, probes) {
 }
 /**
 * Flips the model's ACTIVE eval-measured claims to stale when their
-* recorded canary fingerprint differs from the fresh one (docs/05:
-* "a fingerprint change immediately flips the model's eval claims to
-* stale"). Claims without a recorded fingerprint have no baseline and
+* recorded canary fingerprint differs from the fresh one. Claims
+* without a recorded fingerprint have no baseline and
 * stay untouched (the documented no-probe posture); a second run is
 * an idempotent noop. CAS-rebased like every maintenance commit.
 */
@@ -381,6 +379,159 @@ async function flipStaleOnCanaryDrift(store, model, freshFingerprint, options) {
 	}
 	throw lastCas ?? /* @__PURE__ */ new Error("flipStaleOnCanaryDrift: unreachable");
 }
+/**
+* The phases 1-2 measured-value checkpoint (M12-T01; the quantitative
+* criteria of OQ-09, closed at M11-T06). The M12 gate: kb_propose
+* and the proposal loop ship ONLY if the knowledge card demonstrably
+* improves tier and agentType selection on eval cases.
+*
+* Two experiments, both A/B under identical fixed pools:
+*
+* 1. RUNG SELECTION, per (ladder, taskClass) cell: the baseline arm
+*    runs every eval case at the ladder's DEFAULT start tier; the
+*    treatment arm runs at the tier recommended by
+*    compileVerifiedLayer over the store's claims (default when no
+*    recommendation). A cell passes when the treatment reaches a pass
+*    rate at least equal to the baseline at no more than 90 percent
+*    of its cost, OR at least 5 points above it at no more than its
+*    cost. Criterion 1 holds when a MAJORITY of cells pass AND the
+*    pooled aggregate passes the same rule.
+*
+* 2. AGENTTYPE SELECTION, pooled: the same orchestrate-role cases run
+*    with and without the knowledge store configured (the card docks
+*    into the spawn tool description when configured). Criterion 2
+*    holds when the card-informed arm matches or beats the baseline
+*    pass rate at no more than 105 percent of its cost, OR beats it
+*    by at least 15 points at no more than 115 percent of its cost
+*    (the quality branch; OQ-09 as amended 2026-07-12: the baseline
+*    fails CHEAPLY, so the flat cost bar tightened exactly when the
+*    card was winning on quality).
+*
+* The checkpoint PASSES only when both criteria hold. Methodology
+* guard: the claims the treatment consumes MUST come from a seeding
+* sweep over a DISJOINT case set (the seed/eval split is the caller's
+* pool contract), or the measurement is leakage.
+*/
+/** IEEE754 guard for the rule boundaries (0.8 + 0.05 exceeds 0.85). */
+const EPSILON = 1e-9;
+/**
+* The OQ-09 criterion 2 rule (as amended 2026-07-12): match-or-beat at
+* 105 percent of baseline cost, OR at least 15 points better at 115
+* percent (the quality branch: the baseline fails cheaply, so the flat
+* bar tightened exactly when the card won on quality). The vacuous-pass
+* guard stays with the caller.
+*/
+function agentTypeRuleHolds(baseline, informed) {
+	const matchesCheaply = informed.passRate >= baseline.passRate - EPSILON && informed.totalCostUsd <= 1.05 * baseline.totalCostUsd + EPSILON;
+	const clearlyBetterNearCost = informed.passRate >= baseline.passRate + .15 - EPSILON && informed.totalCostUsd <= 1.15 * baseline.totalCostUsd + EPSILON;
+	return matchesCheaply || clearlyBetterNearCost;
+}
+/** The OQ-09 cell rule (shared by the per-cell and pooled verdicts). */
+function rungRuleHolds(baseline, treatment) {
+	const equalOrBetterCheaper = treatment.passRate >= baseline.passRate - EPSILON && treatment.totalCostUsd <= .9 * baseline.totalCostUsd + EPSILON;
+	const clearlyBetterAtCost = treatment.passRate >= baseline.passRate + .05 - EPSILON && treatment.totalCostUsd <= baseline.totalCostUsd + EPSILON;
+	return equalOrBetterCheaper || clearlyBetterAtCost;
+}
+function armOf(suite) {
+	return {
+		passRate: suite.passRate,
+		totalCostUsd: suite.totalCostUsd,
+		n: suite.results.length
+	};
+}
+function pool(arms) {
+	const n = arms.reduce((sum, arm) => sum + arm.n, 0);
+	const passed = arms.reduce((sum, arm) => sum + arm.passRate * arm.n, 0);
+	const cost = arms.reduce((sum, arm) => sum + arm.totalCostUsd, 0);
+	return {
+		passRate: n === 0 ? 0 : passed / n,
+		totalCostUsd: cost,
+		n
+	};
+}
+/**
+* Runs the checkpoint over the fixed pool. Sequential in declaration
+* order (deterministic cassette consumption when recorded); every cell
+* runs baseline then treatment.
+*/
+async function runValueCheckpoint(checkpointPool, options) {
+	const recommendations = compileVerifiedLayer(options.snapshot.claims.filter((claim) => claim.status === "active"), checkpointPool.ladders);
+	const byTaskClass = /* @__PURE__ */ new Map();
+	for (const entry of checkpointPool.evalCases) {
+		const bucket = byTaskClass.get(entry.taskClass) ?? [];
+		bucket.push(entry.case);
+		byTaskClass.set(entry.taskClass, bucket);
+	}
+	const cells = [];
+	for (const ladder of checkpointPool.ladders) for (const [taskClass, cases] of byTaskClass) {
+		const recommendation = recommendations.find((row) => row.ladder === ladder.name && row.taskClass === taskClass);
+		const treatmentTier = recommendation?.recommendedTier ?? ladder.startTier;
+		const baseMember = ladder.rungs[ladder.startTier];
+		const treatMember = ladder.rungs[treatmentTier];
+		if (baseMember === void 0 || treatMember === void 0) throw new Error(`checkpoint: ladder '${ladder.name}' lacks rung ${String(treatmentTier)}`);
+		const baseline = armOf(await runEvalSuite(await options.engineFor(baseMember), cases, options.suite ?? {}));
+		const treatment = treatmentTier === ladder.startTier ? baseline : armOf(await runEvalSuite(await options.engineFor(treatMember), cases, options.suite ?? {}));
+		cells.push({
+			ladder: ladder.name,
+			taskClass,
+			defaultTier: ladder.startTier,
+			treatmentTier,
+			recommended: recommendation !== void 0,
+			baseline,
+			treatment,
+			passed: rungRuleHolds(baseline, treatment)
+		});
+	}
+	const recommendedCells = cells.filter((cell) => cell.recommended);
+	const cellsPassed = recommendedCells.filter((cell) => cell.passed).length;
+	const majorityHolds = recommendedCells.length > 0 && cellsPassed * 2 > recommendedCells.length;
+	const pooledBaseline = pool(cells.map((cell) => cell.baseline));
+	const pooledTreatment = pool(cells.map((cell) => cell.treatment));
+	const pooledHolds = rungRuleHolds(pooledBaseline, pooledTreatment);
+	const criterion1 = {
+		cells,
+		cellsPassed,
+		majorityHolds,
+		pooledBaseline,
+		pooledTreatment,
+		pooledHolds,
+		passed: majorityHolds && pooledHolds
+	};
+	let criterion2;
+	if (options.orchestrateEngineFor !== void 0 && options.orchestratedCases !== void 0) {
+		const cases = options.orchestratedCases.map((entry) => entry.case);
+		const orchestratedSuite = options.orchestratedSuite ?? options.suite ?? {};
+		const baseline = armOf(await runEvalSuite(await options.orchestrateEngineFor(false), cases, orchestratedSuite));
+		const informed = armOf(await runEvalSuite(await options.orchestrateEngineFor(true), cases, orchestratedSuite));
+		criterion2 = {
+			baseline,
+			informed,
+			passed: informed.n > 0 && informed.passRate > 0 && agentTypeRuleHolds(baseline, informed)
+		};
+	}
+	return {
+		observedAt: options.observedAt,
+		criterion1,
+		...criterion2 === void 0 ? {} : { criterion2 },
+		passed: criterion1.passed && criterion2 !== void 0 && criterion2.passed
+	};
+}
+const percent = (rate) => `${(rate * 100).toFixed(1)}%`;
+const usd = (value) => `$${value.toFixed(4)}`;
+/** The deterministic render for the M12 gate docs amendment. */
+function renderCheckpointReport(report) {
+	const lines = [
+		`Measured-value checkpoint (OQ-09) at ${report.observedAt}: ` + (report.passed ? "PASSED" : "FAILED"),
+		"",
+		`Criterion 1 (rung selection): ${report.criterion1.passed ? "holds" : "fails"} (${String(report.criterion1.cellsPassed)}/${String(report.criterion1.cells.length)} cells, pooled ${report.criterion1.pooledHolds ? "holds" : "fails"})`
+	];
+	for (const cell of report.criterion1.cells) lines.push(`* ${cell.ladder} :: ${cell.taskClass}: baseline tier ${String(cell.defaultTier)} ${percent(cell.baseline.passRate)} at ${usd(cell.baseline.totalCostUsd)}; treatment tier ${String(cell.treatmentTier)}${cell.recommended ? "" : " (no recommendation)"} ${percent(cell.treatment.passRate)} at ${usd(cell.treatment.totalCostUsd)}; ${cell.passed ? "pass" : "fail"} (n=${String(cell.baseline.n)})`);
+	if (report.criterion2 !== void 0) {
+		const c2 = report.criterion2;
+		lines.push("", `Criterion 2 (agentType selection): ${c2.passed ? "holds" : "fails"} (baseline ${percent(c2.baseline.passRate)} at ${usd(c2.baseline.totalCostUsd)}; card-informed ${percent(c2.informed.passRate)} at ${usd(c2.informed.totalCostUsd)}; n=${String(c2.baseline.n)})`);
+	} else lines.push("", "Criterion 2 (agentType selection): NOT MEASURED (counts as failed)");
+	return lines.join("\n");
+}
 const SWEEP_THRESHOLD_DEFAULTS = {
 	strength: .9,
 	weakness: .5
@@ -471,4 +622,4 @@ async function runSweepMatrix(pool, options) {
 	return report;
 }
 //#endregion
-export { EvalJudgeError, JUDGE_VERDICT_SCHEMA, SWEEP_THRESHOLD_DEFAULTS, canaryFingerprint, commitEvalMeasured, evalMeasuredClaim, flipStaleOnCanaryDrift, goldenGrader, judgeGrader, normalizeCanaryOutput, rubricGrader, runEvalCase, runEvalMatrix, runEvalSuite, runSweepMatrix };
+export { EvalJudgeError, JUDGE_VERDICT_SCHEMA, SWEEP_THRESHOLD_DEFAULTS, canaryFingerprint, commitEvalMeasured, evalMeasuredClaim, flipStaleOnCanaryDrift, goldenGrader, judgeGrader, normalizeCanaryOutput, renderCheckpointReport, rubricGrader, runEvalCase, runEvalMatrix, runEvalSuite, runSweepMatrix, runValueCheckpoint, rungRuleHolds };

package/dist/index.d.ts

@@ -37,7 +37,7 @@ declare function inspectCommand(argv: string[], context: CommandContext): Promis
 interface CliConfig {
   engineOptions?: Partial<CreateEngineOptions>;
   workflows?: WorkflowRegistry;
-  /** rulvar kb sweep configuration (M11-T05; docs/05, "Grounding and decay"). */
+  /** rulvar kb sweep configuration (M11-T05). */
   kbSweep?: KbSweepCliConfig;
 }
 /**
@@ -95,7 +95,7 @@ interface AssembledCli {
   engine: Engine;
   store: JournalStore;
   workflows: WorkflowRegistry;
-  /** The journal-fold price function (table wins over caps; docs/04, section 10). */
+  /** The journal-fold price function (table wins over caps). */
   priceUsd: (servedBy: ModelRef, usage: Usage) => number | undefined;
 }
 declare function assembleEngine(options: {
@@ -115,7 +115,7 @@ declare function driveRun(options: {
   engine: Engine;
   workflow: Workflow<never, unknown>;
   first: RunHandle<unknown>;
-  io: CliIo; /** Original run arguments: not journaled in v1, the host re-supplies them (docs/14). */
+  io: CliIo; /** Original run arguments: not journaled in v1, the host re-supplies them. */
   args?: unknown;
 }): Promise<RunOutcome<unknown>>;
 /** Renders the settled outcome; returns the process exit code. */
@@ -124,17 +124,17 @@ declare function reportOutcome(outcome: RunOutcome<unknown>, io: CliIo): number;
 //#region src/server.d.ts
 interface CreateServerOptions {
   engine: Engine;
-  /** The explicit, first-class registry (docs/06, section 10.4). */
+  /** The explicit, first-class registry. */
   workflows: WorkflowRegistry;
   /**
   * Prices the journal fold behind GET /runs/:id/cost for runs without a
   * settled in-process outcome (the host assembles pricing exactly as it
   * does for the CLI); absent means those usages surface as `unpriced`,
-  * never a silent zero (docs/04, section 10).
+  * never a silent zero.
   */
   priceUsd?: (servedBy: ModelRef, usage: Usage) => number | undefined;
   /**
-  * Opt-in retention (docs/02, 8.2; OQ-20 executed at M8-T04): evaluated
+  * Opt-in retention (OQ-20 executed at M8-T04): evaluated
   * when a tracked run settles terminally; a true verdict applies
   * engine.deleteRun (transcript cascade, then the journal) and
   * untracks the run. Absent means everything persists indefinitely.
@@ -147,7 +147,7 @@ interface RulvarServer {
 declare function createServer(options: CreateServerOptions): RulvarServer;
 //#endregion
 //#region src/worker.d.ts
-/** Appendix A: the committed reference lease ttl (docs/06). */
+/** Appendix A: the committed reference lease ttl. */
 declare const DEFAULT_WORKER_TTL_MS = 6e4;
 interface CreateWorkerOptions {
   /**
@@ -162,7 +162,7 @@ interface CreateWorkerOptions {
   owner?: string;
   /**
   * The store's lease ttl; the worker renews at ttl/3 (the normative
-  * bound, docs/03 12.3). Default: the Appendix A reference 60000 ms.
+  * bound). Default: the Appendix A reference 60000 ms.
   * MUST match the store's configured ttl.
   */
   ttlMs?: number;
@@ -179,7 +179,7 @@ interface CreateWorkerOptions {
   /** Observability hook for per-run failures; never throws into the loop. */
   onError?: (runId: string, error: unknown) => void;
   /**
-  * Opt-in retention (docs/02, 8.3; OQ-20 executed at M8-T04): evaluated
+  * Opt-in retention (OQ-20 executed at M8-T04): evaluated
   * during sweeps over SETTLED runs (terminal meta); a true verdict
   * applies engine.deleteRun under a briefly held lease. Absent means
   * everything persists indefinitely.

package/dist/index.js

@@ -1,12 +1,12 @@
-import { a as resumeCommand, c as driveRun, d as renderEventLine, f as DEFAULT_STORE_DIR, g as looksLikeFile, h as loadWorkflowModule, i as inspectCommand, l as reportOutcome, m as loadCliConfig, n as HELP, o as runCommand, p as assembleEngine, r as runCli, s as runsLsCommand, t as processIo, u as attachProgress } from "./io-DUfUn6KG.js";
+import { a as resumeCommand, c as driveRun, d as renderEventLine, f as DEFAULT_STORE_DIR, g as looksLikeFile, h as loadWorkflowModule, i as inspectCommand, l as reportOutcome, m as loadCliConfig, n as HELP, o as runCommand, p as assembleEngine, r as runCli, s as runsLsCommand, t as processIo, u as attachProgress } from "./io-poGpn70r.js";
 import { ConfigError, InvalidResolutionError, JournalCompatibilityError, LeaseHeldError, Replayer, RulvarError, buildDeriverRegistry, costReportFromJournal, maskSecrets, normalizeEntry, scanJournalCompatibility, validateSchemaSpec } from "@rulvar/core";
 //#region src/server.ts
 /**
 * createServer (M8-T01): the HTTP shell over the public engine API
-* (docs/02, section 8.2; FR-702). Canonical signature
+* (FR-702). Canonical signature
 * `createServer({ engine, workflows })` returning
 * `{ fetch(req: Request): Promise<Response> }`; the journal store comes
-* from the engine (Engine.stores, docs/06 10.2, M8 entry amendment).
+* from the engine (Engine.stores, M8 entry amendment).
 *
 * Routes:
 *   POST /runs                     start a run of a registered workflow
@@ -16,20 +16,19 @@ import { ConfigError, InvalidResolutionError, JournalCompatibilityError, LeaseHe
 *   GET  /runs/:id/cost            CostReport
 *
 * Authentication is explicitly out of scope: the server is host-embedded
-* and auth belongs to host middleware (docs/14, OQ-16). SSE reconnection
-* maps Last-Event-ID to the event seq (the per-run telemetry counter,
-* docs/09, section 1.1); replay is at-least-once by design, matching the
-* journal-backed re-emission contract (docs/09, section 1.5: consumers
+* and auth belongs to host middleware (OQ-16). SSE reconnection
+* maps Last-Event-ID to the event seq (the per-run telemetry counter);
+* replay is at-least-once by design, matching the
+* journal-backed re-emission contract (consumers
 * deduplicate on `replayed`).
 *
 * The server is a single-process shell: it tracks the runs it started
 * (or resumed) in memory and serves everything else from the engine's
 * stores. A resolution posted for a run that is NOT live in this process
-* is the documented offline append (docs/03, section 8: load, compute
+* is the documented offline append (load, compute
 * next seq, append, under a lease where the store is leasable); such a
 * run resumes on a queue worker (createWorker, M8-T02), not here,
-* because original run arguments are not journaled in v1 (docs/14,
-* OQ-21).
+* because original run arguments are not journaled in v1 (OQ-21).
 */
 const JSON_HEADERS = { "content-type": "application/json; charset=utf-8" };
 const wallClock = Date.now.bind(globalThis);
@@ -64,7 +63,7 @@ function isLeasable(store) {
 	const candidate = store;
 	return typeof candidate.acquire === "function" && typeof candidate.renew === "function" && typeof candidate.release === "function";
 }
-/** The approval-suspension resolution key (docs/08, section 3.6). */
+/** The approval-suspension resolution key. */
 const APPROVAL_KEY_PREFIX = "approval:";
 function suspensionKeyOf(entry) {
 	if (entry.status !== "suspended") return;
@@ -299,7 +298,7 @@ function createServer(options) {
 		return section;
 	}
 	/**
-	* The offline path (docs/03, section 8): the run is not live in this
+	* The offline path: the run is not live in this
 	* process; append the resolution under a lease where the store is
 	* leasable and leave the resume to a queue worker.
 	*/
@@ -433,7 +432,7 @@ function createServer(options) {
 //#region src/worker.ts
 /**
 * createWorker (M8-T02): the queue shell over the public engine API
-* (docs/02, section 8.3; FR-703). Canonical signature
+* (FR-703). Canonical signature
 * `createWorker(engine, { store: LeasableStore, concurrency? })`.
 *
 * The worker leases resumable ('running' meta: a crashed or currently
@@ -441,7 +440,7 @@ function createServer(options) {
 * fencing epoch; acquire on a held lease rejects with LeaseHeldError and
 * the worker simply moves on. Stateless workers call engine.resume,
 * passing the lease via ResumeOptions.lease so EVERY engine append of
-* the resumed run is fenced (docs/03, section 12.3, M8 entry amendment):
+* the resumed run is fenced (M8 entry amendment):
 * lease theft is impossible because a stale writer's appends are
 * rejected by the store and never become visible, whether or not the
 * stale worker noticed it lost the lease.
@@ -452,23 +451,23 @@ function createServer(options) {
 * this worker (an older library never writes into a newer journal).
 *
 * Queue semantics are honestly at-least-once with deduplication by the
-* journal (docs/03, section 13.1): re-leasing a settled or unchanged
+* journal: re-leasing a settled or unchanged
 * run replays to the same outcome with zero live calls. Workflows
 * resolve through the engine's defaults.workflows registry plus the
-* persisted CompiledWorkflow sources, never through a worker parameter
-* (docs/06, section 10.4); original in-process run arguments are not
+* persisted CompiledWorkflow sources, never through a worker parameter;
+* original in-process run arguments are not
 * journaled in v1, so the host MAY re-supply them per run via `argsFor`
-* (docs/14, OQ-21).
+* (OQ-21).
 *
 * Appendix A (committed at M8 entry): concurrency defaults to 1 (one
 * leased run per worker process; hosts scale out by adding workers,
 * which the fencing epoch makes safe by construction); the renew
 * cadence is ttl/3 with the reference ttl of 60000 ms. There is no
-* distributed cross-process rate limiter in v1 (EXC-14; docs/14,
-* OQ-17): divide provider quota per worker or front an external
+* distributed cross-process rate limiter in v1 (EXC-14; OQ-17):
+* divide provider quota per worker or front an external
 * gateway.
 */
-/** Appendix A: the committed reference lease ttl (docs/06). */
+/** Appendix A: the committed reference lease ttl. */
 const DEFAULT_WORKER_TTL_MS = 6e4;
 const CANDIDATE_STATUSES = /* @__PURE__ */ new Set(["running", "suspended"]);
 let workerOrdinal = 0;
@@ -544,7 +543,7 @@ function createWorker(engine, options) {
 		});
 		await settled;
 	}
-	/** Opt-in retention over settled runs (docs/02, 8.3; M8-T04). */
+	/** Opt-in retention over settled runs (M8-T04). */
 	async function applyRetention(meta) {
 		if (options.retention?.(meta) !== true) return;
 		let lease;
@@ -630,9 +629,9 @@ function createWorker(engine, options) {
 //#endregion
 //#region src/otel.ts
 /**
-* OpenTelemetry exporter (M5-T08; docs/09, section 3). `toOtel(run,
+* OpenTelemetry exporter (M5-T08; https://docs.rulvar.com/guide/observability). `toOtel(run,
 * tracer)` maps the spanId tree of a run 1:1 onto OTel spans: one span
-* per rulvar span, parented per the docs/09 1.2 hierarchy (run > phase >
+* per rulvar span, parented per the span hierarchy (run > phase >
 * agent > tool > child), with start/end timestamps from the lifecycle
 * events. Events without an own span (log, budget:update) attach as span
 * events on their enclosing span.

package/dist/{io-DUfUn6KG.js → io-poGpn70r.js}

@@ -6,9 +6,9 @@ import { pathToFileURL } from "node:url";
 import { createInterface } from "node:readline";
 //#region src/config.ts
 /**
-* CLI configuration convention (shell-owned; the canonical grammar in
-* docs/06 section 10.5 says nothing about engine assembly, and the CLI
-* builds exclusively from the public API per docs/02 section 4):
+* CLI configuration convention (shell-owned; the canonical CLI grammar
+* says nothing about engine assembly, and the CLI builds exclusively
+* from the public API):
 *
 * - `rulvar.config.mjs` (or .js) in the working directory default-exports
 *   `{ engineOptions?, workflows? }`: adapters, stores, defaults come
@@ -68,8 +68,8 @@ function looksLikeFile(target) {
 //#region src/engine-assembly.ts
 /**
 * Engine assembly for CLI commands: the host's config supplies adapters
-* and defaults (the CLI depends only on @rulvar/core, docs/02 section
-* 4); --store selects the JsonlFileStore directory (default `.rulvar`),
+* and defaults (the CLI depends only on @rulvar/core);
+* --store selects the JsonlFileStore directory (default `.rulvar`),
 * and an explicit stores entry in engineOptions wins over it.
 */
 const DEFAULT_STORE_DIR = ".rulvar";
@@ -279,8 +279,7 @@ function reportOutcome(outcome, io) {
 //#endregion
 //#region src/commands.ts
 /**
-* The four M5 commands of the canonical CLI grammar (docs/06, section
-* 10.5; no aliases in v1):
+* The four M5 commands of the canonical CLI grammar (no aliases in v1):
 *
 *   rulvar run <file|name> [--args JSON] [--store PATH] [--budget-usd N]
 *   rulvar resume <runId>  [--store PATH]
@@ -288,7 +287,7 @@ function reportOutcome(outcome, io) {
 *   rulvar inspect <runId> [--store PATH]
 *
 * `plan` and `kb` land with M6+/M10. Every command builds strictly from
-* the public @rulvar/core API (docs/02, section 4).
+* the public @rulvar/core API.
 */
 function parseRunFlags(argv) {
 	const { values, positionals } = parseArgs({
@@ -441,9 +440,9 @@ async function inspectCommand(argv, context) {
 	return 0;
 }
 /**
-* rulvar plan "<goal>" [--dry-run] (docs/06, 10.5; M6-T11): plans a
+* rulvar plan "<goal>" [--dry-run] (M6-T11): plans a
 * workflow script through @rulvar/planner (loaded dynamically: the CLI's
-* static dependency stays @rulvar/core only, docs/02 dependency rules),
+* static dependency stays @rulvar/core only),
 * prints the accepted script and its advisories, and runs it in the
 * worker sandbox unless --dry-run.
 */
@@ -457,7 +456,7 @@ async function planCommand(argv, context) {
 	if (goal === void 0 || parsed.positionals.length > 1) throw new ConfigError("usage: rulvar plan \"<goal>\" [--dry-run]");
 	let plannerModule;
 	try {
-		plannerModule = await import("./dist-DtuSmcav.js");
+		plannerModule = await import("./dist-Cdj5YBRG.js");
 	} catch {
 		throw new ConfigError("rulvar plan requires @rulvar/planner (the plan agent, compileScript, and the worker sandbox live there); install it next to the CLI");
 	}
@@ -484,7 +483,7 @@ async function planCommand(argv, context) {
 	}), context.io);
 }
 /**
-* rulvar kb list (docs/06, 10.5; docs/05, 4.4; M10-T04): the second
+* rulvar kb list (M10-T04): the second
 * consumption path. Claims with full provenance for the humans who
 * author ladders, floors, and profiles; no run and no pin, so model
 * names render VERBATIM here (only in-run cards are nameless). Reads
@@ -518,7 +517,7 @@ function renderKbList(snapshot, context) {
 	}
 }
 /**
-* rulvar kb sweep (M11-T05; docs/05, section "Grounding and decay"):
+* rulvar kb sweep (M11-T05):
 * falsification sweeps, run manually, from CI, or from a user cron,
 * NEVER engine-scheduled. The matrix is the config's FIXED pool
 * UNIONED with the store's falsification set: every model carrying an
@@ -534,7 +533,7 @@ async function kbSweepCommand(argv, context) {
 	if (sweep === void 0) throw new ConfigError("rulvar kb sweep requires a kbSweep section in rulvar.config.mjs ({ committerId, models, cases }; docs/05, section 'Grounding and decay')");
 	let evals;
 	try {
-		evals = await import("./dist-4eKFSpyW.js");
+		evals = await import("./dist-M-vPRtBM.js");
 	} catch {
 		throw new ConfigError("rulvar kb sweep requires @rulvar/evals (matrix sweeps, the eval-committer identity, and the canary live there); install it next to the CLI");
 	}
@@ -607,7 +606,7 @@ async function kbSweepCommand(argv, context) {
 //#endregion
 //#region src/cli-main.ts
 /**
-* Command dispatch for the canonical grammar (docs/06, section 10.5):
+* Command dispatch for the canonical grammar (https://docs.rulvar.com/guide/cli):
 * no aliases in v1; unknown commands and flags fail loudly with usage.
 */
 const HELP = `rulvar: durable multi-agent workflows (docs/06, section 10.5)
@@ -672,8 +671,8 @@ async function runCli(argv, options) {
 /**
 * CLI io seam: every command writes and prompts through this interface
 * so the e2e suite drives the real command paths in-process with
-* scripted stdin and captured output (docs/02, section 8.1: the CLI is
-* a shell strictly on top of the public APIs).
+* scripted stdin and captured output (the CLI is a shell strictly on
+* top of the public APIs).
 */
 /** The process-backed io the bin entry uses. */
 function processIo() {

package/dist/{src-DVFj9U50.js → src-BA7JP7vn.js}

@@ -1,4 +1,4 @@
-import { t as __esmMin } from "./dist-DtuSmcav.js";
+import { t as __esmMin } from "./dist-Cdj5YBRG.js";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import nativeFsp from "node:fs/promises";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rulvar/cli",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "description": "rulvar shell: run/resume/runs/inspect/plan/kb commands, TUI progress, createServer, createWorker, OTel exporter.",
   "type": "module",
   "license": "Apache-2.0",
@@ -22,17 +22,17 @@
     "access": "public"
   },
   "dependencies": {
-    "@rulvar/core": "1.0.0"
+    "@rulvar/core": "1.2.0"
   },
   "devDependencies": {
     "@types/node": "^22.20.0",
     "tsdown": "^0.22.3",
     "typescript": "~6.0.3",
-    "@rulvar/testing": "1.0.0",
-    "@rulvar/store-sqlite": "1.0.0",
-    "@rulvar/planner": "1.0.0",
-    "@rulvar/plan": "1.0.0",
-    "@rulvar/evals": "1.0.0"
+    "@rulvar/testing": "1.2.0",
+    "@rulvar/store-sqlite": "1.2.0",
+    "@rulvar/planner": "1.2.0",
+    "@rulvar/evals": "1.2.0",
+    "@rulvar/plan": "1.2.0"
   },
   "bin": {
     "rulvar": "./dist/cli.js"