@alisio/alisio-code 0.6.0 → 0.8.0

package/dist/main.js

@@ -21,6 +21,8 @@ async function cliDefaults() {
         reservedPromptNames: reservedCommandNames(),
     };
 }
+/** Commander collector of a repeatable option. */
+const collect = (value, previous) => [...previous, value];
 const program = new Command();
 program
     .name("alisio")
@@ -118,6 +120,11 @@ async function run(cmd, prompt, sessionId) {
         const trusted = await withProjectTrust(opts);
         return runTui({ ...trusted, ...(sessionId ? { session: sessionId } : {}) });
     }
+    const proofFlags = opts;
+    // Invalid criteria fail before a session or a provider exists.
+    const proofCriteria = proofFlags.criterion?.length || proofFlags.verify?.length || proofFlags.proofFile
+        ? await (await import("./proof.js")).collectProofCriteria(proofFlags)
+        : [];
     const { createApplication, formatBytes, KIND_LABELS } = await import("@alisio/core");
     const app = await createApplication({
         ...(await cliDefaults()),
@@ -201,12 +208,34 @@ async function run(cmd, prompt, sessionId) {
             const match = /^\/skill:([a-z0-9-]+)\s*([\s\S]*)$/.exec(prompt);
             if (match?.[1])
                 prompt = `${await app.skills.load(match[1])}\n\nUser request: ${match[2] ?? ""}`;
-            await app.runner.run(session, template?.text ?? prompt, controller.signal, {
+            const proof = await import("./proof.js");
+            const judged = proof.proofRequested(proofFlags, app.config.proof);
+            for (const criterion of proofCriteria)
+                app.proof.addCriterion({ sessionId: session, ...criterion });
+            if (judged &&
+                opts.readOnly &&
+                proofCriteria.some((c) => c.verifier?.kind === "command" ||
+                    (c.verifier?.kind === "coverage" && app.config.proof.coverage.enabled)))
+                process.stderr.write("proof: --read-only denies processes, so command and coverage criteria stay not_checked\n");
+            const coverageEnabled = app.config.proof.coverage.enabled;
+            if (proofCriteria.some((c) => c.verifier?.kind === "coverage") && !coverageEnabled)
+                process.stderr.write("proof: coverage verification is off (proof.coverage.enabled is false), so coverage criteria stay not_checked and Proof never runs their command\n");
+            await app.runner.run(session, proof.withProofBrief(template?.text ?? prompt, proofCriteria, { coverageEnabled }), controller.signal, {
                 ...activeRunOptions,
                 ...(template ? { display: template.display } : {}),
             });
             if (!opts.json)
                 process.stdout.write(`\nSession: ${session}\n`);
+            if (judged) {
+                const code = await proof.finishProof({
+                    proof: app.proof,
+                    write: (text) => process.stdout.write(text),
+                    writeErr: (text) => process.stderr.write(text),
+                    publisher: proof.sessionPublisher(app, session),
+                }, session, { json: !!opts.json, codes: app.config.proof.exitCodes });
+                if (code)
+                    process.exitCode = code;
+            }
             return;
         }
         if (opts.json || !process.stdin.isTTY)
@@ -323,6 +352,10 @@ program
     .command("run")
     .description('Run one prompt headless; "/name args" runs a prompt template (e.g. "/init") or a plugin command ("/plugin.id:name")')
     .argument("<prompt>")
+    .option("--proof", "Judge the run against its acceptance criteria: print the Proof ledger (the final JSONL event with --json) and exit 0, 10 (a required criterion failed) or 11 (a required one is not verified); the codes are proof.exitCodes")
+    .option("--criterion <text>", "An acceptance criterion (repeatable); pair it with --verify <command>", collect, [])
+    .option("--verify <command>", "The command that verifies the n-th --criterion; Alisio records the evidence when the agent runs exactly it", collect, [])
+    .option("--proof-file <path>", 'JSON file with {"criteria":[{"text","verify"|"verifier","required","scope"}]} (or a plain array)')
     .action((prompt, _options, cmd) => run(cmd, prompt));
 program
     .command("resume")
@@ -487,6 +520,68 @@ forge
     const { printForgeStatus } = await import("./forge.js");
     await printForgeStatus(options(cmd), !!flags.probe);
 });
+const evalCommand = program
+    .command("eval")
+    .description("Reliability lab: run a task suite k times, report pass rates with Wilson intervals, compare reports or config variants, record cassettes and replay them without a model");
+/** `alisio eval` entry points: lazy, and exit codes are returned, not thrown (0 ok, 1 error, 2 replay diverged, 3 incompatible). */
+async function runEval(cmd, action) {
+    const api = await import("./eval.js");
+    const env = await api.realEvalEnv(async () => options(cmd), async () => cliDefaults());
+    process.exitCode = await action(api, env, cmd.optsWithGlobals());
+}
+const evalRunOptions = (command) => command
+    .option("--tasks <ids>", "Comma-separated task ids (default: every task of the suite)")
+    .option("--k <n>", "Repetitions per task (default 5; below 5 the report warns of low power)")
+    .option("--seed <n>", "Seed of the run order; each run gets seed + repetition")
+    .option("--mode <mode>", "live (default) or replay (serve the recorded cassettes: no provider, no network; measures the harness, not the model)")
+    .option("--cassette-dir <dir>", "Cassette directory (default: <suite>/cassettes; used by --mode replay and by record)")
+    .option("--keep", "Keep each run's temporary directory (it prints the paths)")
+    .option("--out <dir>", "Write the report files here (default: <state>/eval/<runId>/)")
+    .option("--suite-dir <dir>", "A suite, or a directory of suites; third-party code: needs --yes")
+    .option("--allow-suite-full", "Let a suite run tasks that ask for the full permission mode")
+    .option("--yes", "Confirm running a --suite-dir suite without asking (required if not interactive)")
+    .option("--input-rate <usd>", "USD per million input tokens, to estimate cost (needs --output-rate)")
+    .option("--output-rate <usd>", "USD per million output tokens (needs --input-rate)");
+evalCommand
+    .command("list")
+    .description("List the available suites (bundled ones plus --suite-dir)")
+    .option("--suite-dir <dir>", "A suite, or a directory of suites")
+    .action((_flags, cmd) => runEval(cmd, (api, env, flags) => api.evalList(env, flags)));
+evalRunOptions(evalCommand
+    .command("run")
+    .description("Run a suite k times (live, or --mode replay from cassettes) and write report.json, report.md and runs.jsonl; --json prints the run records as JSONL and the report last. Exit 0 when it completed (whatever passed), 1 on a usage or infrastructure error, 2 when a replay diverged from its cassette")
+    .argument("<suite>")).action((suite, _flags, cmd) => runEval(cmd, (api, env, flags) => api.evalRun(env, flags, suite)));
+evalCommand
+    .command("record")
+    .description("Run each task of a suite ONCE live and write <suite>/cassettes/<taskId>.cassette.jsonl for `eval run --mode replay`. Refuses (exit 1) a cassette that holds a secret or is over 256 KB (2 MB per directory)")
+    .argument("<suite>")
+    .option("--tasks <ids>", "Comma-separated task ids (default: every task of the suite)")
+    .option("--seed <n>", "Seed of the run order")
+    .option("--keep", "Keep each run's temporary directory (it prints the paths)")
+    .option("--cassette-dir <dir>", "Write the cassettes here (default: <suite>/cassettes)")
+    .option("--suite-dir <dir>", "A suite, or a directory of suites; third-party code: needs --yes")
+    .option("--allow-suite-full", "Let a suite run tasks that ask for the full permission mode")
+    .option("--yes", "Confirm running a --suite-dir suite without asking (required if not interactive)")
+    .action((suite, _flags, cmd) => runEval(cmd, (api, env, flags) => api.evalRecord(env, flags, suite)));
+evalCommand
+    .command("compare")
+    .description("Compare two reports of the same suite and version; exit 3 when the suites are incompatible")
+    .argument("<reportA>", "Baseline report.json (or the directory that holds it)")
+    .argument("<reportB>", "Candidate report.json (or the directory that holds it)")
+    .option("--md", "Print Markdown (the default; --json prints JSON instead)")
+    .action((a, b, _flags, cmd) => runEval(cmd, (api, env, flags) => api.evalCompare(env, flags, a, b)));
+evalRunOptions(evalCommand
+    .command("variants")
+    .description('Run two or more config variants over the same tasks and seeds and compare them with the first. compare.json: {"suite":"id","variants":[{"id":"baseline","overrides":{}},{"id":"early","overrides":{"compaction.threshold":0.6}}]}')
+    .argument("<suite>")
+    .requiredOption("--variants <file>", "The compare.json file")).action((suite, _flags, cmd) => runEval(cmd, (api, env, flags) => api.evalVariants(env, flags, suite)));
+evalCommand
+    .command("export")
+    .description("Write ONE shareable JSON bundle ({schemaVersion, report, runs, markdown}) of a stored run (<state>/eval/<runId>/) with absolute paths replaced by placeholders and endpoint hosts removed from provider ids. Refuses (exit 1) when a secret is found, naming the field; refuses to overwrite FILE without --force. Local only: nothing is uploaded. Scrubbing is pattern-based, not a guarantee")
+    .argument("<runId>", "Directory name of the run under <state>/eval/")
+    .requiredOption("--out <file>", "The bundle to write")
+    .option("--force", "Overwrite FILE if it exists")
+    .action((runId, _flags, cmd) => runEval(cmd, (api, env, flags) => api.evalExport(env, flags, runId)));
 const trust = program.command("trust").description("Inspect or revoke per-directory project trust");
 trust.command("list").action(async () => {
     const { listTrust } = await import("@alisio/core");

package/dist/proof.d.ts

@@ -0,0 +1,52 @@
+import { type ArtifactStore, type NewCriterion, type ProofExitCodes, type ProofStore } from "@alisio/core";
+import type { ArtifactPublisher } from "@alisio/sdk";
+export interface ProofFlags {
+    proof?: boolean;
+    /** Repeatable `--criterion "text"`. */
+    criterion?: string[];
+    /** Repeatable `--verify "cmd"`: the n-th pairs with the n-th `--criterion`. */
+    verify?: string[];
+    proofFile?: string;
+    json?: boolean;
+    /** `proof.exitCodes` of the configuration. */
+    codes?: ProofExitCodes;
+}
+export type CliCriterion = Omit<NewCriterion, "sessionId">;
+/** Whether the run produces a ledger report: a flag, a criteria source, or `proof.ci`. */
+export declare function proofRequested(flags: ProofFlags, config: {
+    ci: boolean;
+}): boolean;
+/**
+ * The criteria of the run (O4): the proof file first, then the flags. Every one is `origin: "cli"`
+ * and required unless the file says otherwise. Throws a readable error on anything invalid.
+ */
+export declare function collectProofCriteria(flags: Pick<ProofFlags, "criterion" | "verify" | "proofFile">, env?: {
+    readFile?: (path: string) => Promise<string>;
+}): Promise<CliCriterion[]>;
+export interface ProofFinishEnv {
+    proof: Pick<ProofStore, "view">;
+    write: (text: string) => void;
+    writeErr: (text: string) => void;
+    /** Publishes `proof.md` and `proof.json` into the session; absent when it cannot. */
+    publisher?: Pick<ArtifactPublisher, "publishText">;
+}
+/**
+ * Reports the ledger of the session after the run and returns the exit code: 0, or the code of
+ * `proof.exitCodes` (10/11 by default). With `--json` the report is ONE final JSONL line
+ * (`type: "proof_ledger"`); otherwise a plain table on stdout. A failure to publish the
+ * artifacts never changes the exit code.
+ */
+export declare function finishProof(env: ProofFinishEnv, sessionId: string, flags: Pick<ProofFlags, "json" | "codes">): Promise<number>;
+/**
+ * The prompt of a run with criteria: the original text, then the criteria and the exact commands
+ * whose execution (or file read, or dataset query) Alisio records as evidence (D3: the agent cannot declare a criterion met).
+ * Without criteria the prompt is returned untouched (D7).
+ */
+export declare function withProofBrief(prompt: string, criteria: readonly CliCriterion[], options?: {
+    coverageEnabled?: boolean;
+}): string;
+/** The publisher of a session's artifacts (`proof.md`, `proof.json`) for a headless run. */
+export declare function sessionPublisher(app: {
+    artifacts: ArtifactStore;
+    workspace: string;
+}, sessionId: string): Pick<ArtifactPublisher, "publishText">;

package/dist/proof.js

@@ -0,0 +1,121 @@
+/**
+ * `alisio run --proof` (specs/011 3.7, O4, O5). The ledger is judged after the run with the same
+ * pure functions every surface uses (`@alisio/core` `proof/export`); this file only wires flags,
+ * files and output. Functions take an injected environment so they run without a subprocess.
+ */
+import { readFile as readFileFs } from "node:fs/promises";
+import { createArtifactPublisher, DEFAULT_PROOF_EXIT_CODES, PROOF_EXPORT_SCHEMA, parseCriteriaInput, proofExitCode, proofExportV1, publishProofExport, renderProofText, verifierCall, } from "@alisio/core";
+/** Whether the run produces a ledger report: a flag, a criteria source, or `proof.ci`. */
+export function proofRequested(flags, config) {
+    return !!(flags.proof ||
+        config.ci ||
+        flags.criterion?.length ||
+        flags.verify?.length ||
+        flags.proofFile);
+}
+/**
+ * The criteria of the run (O4): the proof file first, then the flags. Every one is `origin: "cli"`
+ * and required unless the file says otherwise. Throws a readable error on anything invalid.
+ */
+export async function collectProofCriteria(flags, env = {}) {
+    const read = env.readFile ?? ((path) => readFileFs(path, "utf8"));
+    const out = [];
+    if (flags.proofFile) {
+        let parsed;
+        try {
+            parsed = JSON.parse(await read(flags.proofFile));
+        }
+        catch (error) {
+            throw new Error(`--proof-file ${flags.proofFile}: ${error instanceof Error ? error.message : "unreadable"}`);
+        }
+        const list = Array.isArray(parsed)
+            ? parsed
+            : parsed?.criteria;
+        const checked = parseCriteriaInput(list, { origin: "cli" });
+        const first = checked.errors[0];
+        if (first)
+            throw new Error(`--proof-file: criterion ${first.index + 1}: ${first.reason}`);
+        out.push(...checked.criteria);
+    }
+    const texts = flags.criterion ?? [];
+    const commands = flags.verify ?? [];
+    if (commands.length > texts.length)
+        throw new Error("--verify needs a --criterion before it (they pair by position)");
+    const entries = texts.map((text, i) => ({
+        text,
+        ...(commands[i] ? { verify: commands[i] } : {}),
+    }));
+    const checked = parseCriteriaInput(entries, { origin: "cli" });
+    const first = checked.errors[0];
+    if (first)
+        throw new Error(`--criterion ${first.index + 1}: ${first.reason}`);
+    out.push(...checked.criteria);
+    return out;
+}
+/**
+ * Reports the ledger of the session after the run and returns the exit code: 0, or the code of
+ * `proof.exitCodes` (10/11 by default). With `--json` the report is ONE final JSONL line
+ * (`type: "proof_ledger"`); otherwise a plain table on stdout. A failure to publish the
+ * artifacts never changes the exit code.
+ */
+export async function finishProof(env, sessionId, flags) {
+    const ledger = env.proof.view(sessionId);
+    const code = proofExitCode(ledger, flags.codes ?? DEFAULT_PROOF_EXIT_CODES);
+    if (env.publisher) {
+        try {
+            await publishProofExport(env.publisher, ledger);
+            env.writeErr("proof: proof.md and proof.json were published as session artifacts\n");
+        }
+        catch (error) {
+            env.writeErr(`proof: the export was not published (${error instanceof Error ? error.message : "error"})\n`);
+        }
+    }
+    if (flags.json)
+        env.write(`${JSON.stringify({
+            type: "proof_ledger",
+            schema: PROOF_EXPORT_SCHEMA,
+            sessionId,
+            exitCode: code,
+            ledger: proofExportV1(ledger),
+        })}\n`);
+    else
+        env.write(`\n${renderProofText(ledger)}\n`);
+    return code;
+}
+/** The one call that counts as evidence for a criterion, said to the agent (empty when none). */
+function hint(verifier, coverageEnabled) {
+    if (verifier?.kind === "command")
+        return ` Run \`${verifier.command}\`.`;
+    if (verifier?.kind === "coverage")
+        return coverageEnabled
+            ? ` Run \`${verifier.command}\` (at least ${verifier.minPercent}% coverage).`
+            : " Coverage verification is disabled (proof.coverage.enabled is false): this criterion stays not_checked.";
+    const call = verifier ? verifierCall(verifier) : undefined;
+    if (!call)
+        return "";
+    if (call.name === "read_file")
+        return ` Read \`${verifier?.kind === "file" ? verifier.path : ""}\` with read_file.`;
+    return ` Run data_query on dataset ${String(call.input.datasetId)} with exactly \`${String(call.input.sql)}\`.`;
+}
+/**
+ * The prompt of a run with criteria: the original text, then the criteria and the exact commands
+ * whose execution (or file read, or dataset query) Alisio records as evidence (D3: the agent cannot declare a criterion met).
+ * Without criteria the prompt is returned untouched (D7).
+ */
+export function withProofBrief(prompt, criteria, options = {}) {
+    if (!criteria.length)
+        return prompt;
+    const lines = criteria.map((c) => {
+        return `- ${c.text}${c.required ? " (required)" : ""}.${hint(c.verifier, options.coverageEnabled === true)}`;
+    });
+    return [
+        prompt,
+        "",
+        "Acceptance criteria. Alisio checks them from the commands you actually run, not from what you say; a criterion with a command is verified only when you run exactly that command and it succeeds:",
+        ...lines,
+    ].join("\n");
+}
+/** The publisher of a session's artifacts (`proof.md`, `proof.json`) for a headless run. */
+export function sessionPublisher(app, sessionId) {
+    return createArtifactPublisher(app.artifacts, { sessionId, rootSessionId: sessionId, workspace: app.workspace }, () => undefined);
+}

package/dist/tui/app.js

@@ -19,7 +19,7 @@ import { formatGoalStatus, GoalBar, goalPickerItems, goalPickerPrefill, goalStop
 import { agentCycleHint, isPermissionMode, modeDisplay, permissionMenuRows, permissionTransition, reloadGuard, shiftTabDecision, } from "./modes.js";
 import { cannotOpenMessage, openPath, revealPath } from "./open-path.js";
 import { initialPanelState, reducePanel, visibleRows } from "./panel.js";
-import { planDiagramsMarkdown, planTranscriptMarkdown } from "./plan-review.js";
+import { planCriteriaMarkdown, planDiagramsMarkdown, planTranscriptMarkdown, } from "./plan-review.js";
 import { summarizeAnswers } from "./questions.js";
 import { InteractiveQueue } from "./queue.js";
 import { settingsMenuRows } from "./settings.js";
@@ -730,6 +730,13 @@ export async function runTui(options) {
                     reasoning: "",
                     done: true,
                 });
+                if (plan.acceptanceCriteria?.length)
+                    push({
+                        kind: "assistant",
+                        text: planCriteriaMarkdown(plan.acceptanceCriteria),
+                        reasoning: "",
+                        done: true,
+                    });
                 if (plan.diagrams?.length) {
                     // The folder is resolved from the store, never from the model.
                     const record = plan.artifact ? app.artifacts.get(plan.artifact.id) : undefined;
@@ -996,6 +1003,10 @@ export async function runTui(options) {
                 applied(outcome, done);
                 return plan.action === "resume" ? kickGoal() : undefined;
             }
+            case "override": {
+                applied(app.goals.overrideComplete(root, { reason: plan.reason }), "Goal completed by your override; the reason is kept with the goal.");
+                return;
+            }
             case "edit": {
                 applied(app.goals.edit(root, plan.objective), "Goal objective updated.");
                 return;
@@ -2644,7 +2655,7 @@ export async function runTui(options) {
         "- `/init` (above) writes AGENTS.md; the shell command `alisio setup` only scaffolds `.alisio/config.json`",
         "- `/plugin.id:name args` or `/command plugin.id:name args` — run a plugin command",
         "",
-        "**Keys**: Enter send · Shift+Enter / Alt+Enter / Ctrl+J newline · Tab complete · ↑↓ history · Esc interrupt · Ctrl+C clear input (twice to exit) · Ctrl+D exit on empty input · c / y copy last response (empty input) · x expand/collapse latest thought/tool batch/output (empty input) · click a collapsible header row to toggle it · PgUp/PgDn or mouse wheel scroll · Ctrl+X agent panel · Ctrl+B background running agents · Shift+Tab cycle the main agents (build, plan, your own)",
+        "**Keys**: Enter send · Shift+Enter / Alt+Enter / Ctrl+J newline · Tab complete · ↑↓ history · Esc interrupt · Ctrl+C clear input (twice to exit) · Ctrl+D exit on empty input · c / y copy last response (empty input) · x expand/collapse latest thought/tool batch/output (empty input) · click a collapsible header row to toggle it · PgUp/PgDn or mouse wheel scroll (Ctrl+Home / Ctrl+End jump to the top / bottom) · Ctrl+X agent panel · Ctrl+B background running agents · Shift+Tab cycle the main agents (build, plan, your own)",
         `**Paste**: multi-line text pastes as one block automatically · Ctrl+V attach a clipboard image (PNG/JPEG/GIF/WebP, up to ${(MAX_IMAGE_BYTES / (1024 * 1024)).toFixed(0)} MB, up to ${MAX_ATTACHMENTS_PER_MESSAGE} per message) · Ctrl+R remove the last attached image`,
     ].join("\n");
     // `/btw` side questions: answered in the picker slot, never appended to the transcript. One
@@ -2807,6 +2818,17 @@ export async function runTui(options) {
                     return showTasks();
                 case "goal":
                     return goalCommand(parsed.args);
+                case "proof": {
+                    const { runProofCommand } = await import("./proof.js");
+                    const { sessionPublisher } = await import("../proof.js");
+                    const proofSession = goalRoot();
+                    const result = await runProofCommand(parsed.args, {
+                        proof: app.proof,
+                        sessionId: proofSession,
+                        publisher: sessionPublisher(app, proofSession),
+                    });
+                    return result.tone === "notice" ? notice(result.text) : info(result.text);
+                }
                 case "permission": {
                     const action = parsePermissionCommand(parsed.args);
                     if (action.type === "menu")

package/dist/tui/goal.d.ts

@@ -29,6 +29,11 @@ export type GoalPlan = {
 } | {
     kind: "act";
     action: "pause" | "resume" | "clear";
+}
+/** The user completes the goal over unmet required Proof criteria. */
+ | {
+    kind: "override";
+    reason: string;
 } | {
     kind: "edit";
     objective: string;

package/dist/tui/goal.js

@@ -43,6 +43,8 @@ export function planGoalCommand(command, context) {
         case "resume":
         case "clear":
             return goal ? { kind: "act", action: command.type } : say(NO_GOAL_TEXT);
+        case "override":
+            return goal ? { kind: "override", reason: command.reason } : say(NO_GOAL_TEXT);
         case "edit":
             if (!goal)
                 return say(NO_GOAL_TEXT);

package/dist/tui/plan-review.d.ts

@@ -4,7 +4,7 @@
  * {state, effect}, fully testable without a terminal. Esc means "Skip for now" while choosing and
  * "back to the choices" while typing; Enter submits; an empty text never submits.
  */
-import type { PlanDiagramInfo } from "@alisio/sdk";
+import type { PlanCriterionDraft, PlanDiagramInfo } from "@alisio/sdk";
 import { type ConnectInputState } from "./connect-input.ts";
 export interface PlanReviewOption {
     value: string;
@@ -61,3 +61,9 @@ export declare function planDiagramsMarkdown(plan: {
     /** Display path of the plan folder on disk (absent when the plan could not be saved). */
     folder?: string;
 }): string;
+/**
+ * The acceptance criteria the plan proposes (Proof), as Markdown for the transcript. The terminal
+ * keeps the review all-or-nothing: approving activates every one of them (`/proof` edits or marks
+ * them afterwards); the web review lets the user keep, edit or reject each one first.
+ */
+export declare function planCriteriaMarkdown(drafts: readonly PlanCriterionDraft[] | undefined): string;

package/dist/tui/plan-review.js

@@ -108,3 +108,27 @@ export function planDiagramsMarkdown(plan) {
             : "The plan folder could not be saved, so these diagrams are only shown here.",
     ].join("\n\n");
 }
+/**
+ * The acceptance criteria the plan proposes (Proof), as Markdown for the transcript. The terminal
+ * keeps the review all-or-nothing: approving activates every one of them (`/proof` edits or marks
+ * them afterwards); the web review lets the user keep, edit or reject each one first.
+ */
+export function planCriteriaMarkdown(drafts) {
+    if (!drafts?.length)
+        return "";
+    const lines = drafts.map((draft, index) => {
+        const how = draft.verifier?.kind === "command"
+            ? ` · verified by \`${draft.verifier.command}\``
+            : draft.verifier?.kind === "coverage"
+                ? ` · coverage ≥ ${draft.verifier.minPercent}% by \`${draft.verifier.command}\``
+                : draft.verifier?.kind === "manual"
+                    ? " · manual review"
+                    : "";
+        return `${index + 1}. ${draft.text}${draft.required ? " (required)" : ""}${how}`;
+    });
+    return [
+        `**Acceptance criteria (${drafts.length})** · proposed by the plan`,
+        ...lines,
+        "Approving the plan activates all of them as acceptance criteria (use `/proof` to edit or mark them later, or review them one by one in the web UI).",
+    ].join("\n\n");
+}

package/dist/tui/proof.d.ts

@@ -0,0 +1,51 @@
+/**
+ * `/proof` in the terminal (specs/011 phase 5). It reads the same ledger as the web card and the
+ * `--json` event (`renderProofText` is the one formatter) and carries the user's own actions: add,
+ * edit, mark required, mark not applicable (with a reason), export. Criteria are addressed by
+ * their position in the list shown. Everything here is the USER acting; a tool result or the model
+ * never reaches this module.
+ */
+import { type ProofStore } from "@alisio/core";
+import type { ArtifactPublisher } from "@alisio/sdk";
+export declare const PROOF_USAGE = "Usage: /proof | add [required] <text> [-- <command>] | edit <n> <text> | required <n> | optional <n> | na <n> <reason> | export | help";
+export declare const PROOF_HELP: string;
+export type ProofCommand = {
+    type: "show";
+} | {
+    type: "help";
+} | {
+    type: "add";
+    text: string;
+    command?: string;
+    required: boolean;
+} | {
+    type: "edit";
+    index: number;
+    text: string;
+} | {
+    type: "required";
+    index: number;
+    required: boolean;
+} | {
+    type: "na";
+    index: number;
+    reason: string;
+} | {
+    type: "export";
+} | {
+    type: "error";
+    message: string;
+};
+export declare function parseProofCommand(args: string): ProofCommand;
+export interface ProofCommandEnv {
+    proof: ProofStore;
+    sessionId: string;
+    /** Publishes the export; absent when the session cannot publish artifacts. */
+    publisher?: Pick<ArtifactPublisher, "publishText">;
+}
+export interface ProofCommandResult {
+    text: string;
+    tone: "info" | "notice";
+}
+/** Runs a typed `/proof …`; every failure is a notice, never an exception. */
+export declare function runProofCommand(args: string, env: ProofCommandEnv): Promise<ProofCommandResult>;

package/dist/tui/proof.js

@@ -0,0 +1,126 @@
+/**
+ * `/proof` in the terminal (specs/011 phase 5). It reads the same ledger as the web card and the
+ * `--json` event (`renderProofText` is the one formatter) and carries the user's own actions: add,
+ * edit, mark required, mark not applicable (with a reason), export. Criteria are addressed by
+ * their position in the list shown. Everything here is the USER acting; a tool result or the model
+ * never reaches this module.
+ */
+import { parseCriteriaInput, publishProofExport, renderProofText, } from "@alisio/core";
+export const PROOF_USAGE = "Usage: /proof | add [required] <text> [-- <command>] | edit <n> <text> | required <n> | optional <n> | na <n> <reason> | export | help";
+export const PROOF_HELP = [
+    "**/proof** shows the acceptance criteria of this session and the evidence behind each one.",
+    "",
+    "- `/proof` lists them: `verified` needs evidence of a command that really ran; `not_checked` has none yet.",
+    "- `/proof add [required] <text> [-- <command>]` adds a criterion; with a command it is verified when the agent runs exactly that command and it succeeds.",
+    "- `/proof edit <n> <text>`, `/proof required <n>`, `/proof optional <n>` change the criterion at that position.",
+    "- `/proof na <n> <reason>` marks it not applicable (only you can; the reason is kept).",
+    "- `/proof export` publishes `proof.md` and `proof.json` (`proof/v1`) as session artifacts.",
+    "",
+    "Proof records operational evidence; it does not prove that the code is correct.",
+].join("\n");
+const bad = (message) => ({ type: "error", message });
+const position = (word) => word && /^[1-9]\d*$/.test(word) ? Number(word) : undefined;
+export function parseProofCommand(args) {
+    const text = args.trim();
+    if (!text)
+        return { type: "show" };
+    const [verb = "", ...rest] = text.split(/\s+/);
+    const tail = (skip) => text.split(/\s+/).slice(skip).join(" ").trim();
+    switch (verb.toLowerCase()) {
+        case "help":
+            return { type: "help" };
+        case "export":
+            return { type: "export" };
+        case "add": {
+            let body = tail(1);
+            let required = false;
+            if (/^required(\s|$)/i.test(body)) {
+                required = true;
+                body = body.replace(/^required\s*/i, "");
+            }
+            const split = body.split(/\s+--\s+/);
+            const statement = (split[0] ?? "").trim();
+            const command = split.slice(1).join(" -- ").trim();
+            if (!statement)
+                return bad("/proof add needs the criterion text.");
+            return { type: "add", text: statement, ...(command ? { command } : {}), required };
+        }
+        case "edit": {
+            const index = position(rest[0]);
+            const wording = tail(2);
+            if (index === undefined || !wording)
+                return bad("/proof edit needs a position and the text.");
+            return { type: "edit", index, text: wording };
+        }
+        case "required":
+        case "optional": {
+            const index = position(rest[0]);
+            if (index === undefined)
+                return bad(`/proof ${verb} needs a position.`);
+            return { type: "required", index, required: verb.toLowerCase() === "required" };
+        }
+        case "na": {
+            const index = position(rest[0]);
+            const reason = tail(2);
+            if (index === undefined || !reason)
+                return bad("/proof na needs a position and a reason.");
+            return { type: "na", index, reason };
+        }
+        default:
+            return bad(`Unknown /proof verb "${verb}".`);
+    }
+}
+/** Runs a typed `/proof …`; every failure is a notice, never an exception. */
+export async function runProofCommand(args, env) {
+    const command = parseProofCommand(args);
+    const notice = (text) => ({ text, tone: "notice" });
+    const show = () => ({
+        text: renderProofText(env.proof.view(env.sessionId)),
+        tone: "info",
+    });
+    try {
+        switch (command.type) {
+            case "error":
+                return notice(`${command.message}\n${PROOF_USAGE}`);
+            case "help":
+                return { text: PROOF_HELP, tone: "info" };
+            case "show":
+                return show();
+            case "export": {
+                if (!env.publisher)
+                    return notice("This session cannot publish artifacts.");
+                await publishProofExport(env.publisher, env.proof.view(env.sessionId));
+                return notice("Published proof.md and proof.json (proof/v1) as session artifacts.");
+            }
+            case "add": {
+                const parsed = parseCriteriaInput([
+                    {
+                        text: command.text,
+                        required: command.required,
+                        ...(command.command ? { verify: command.command } : {}),
+                    },
+                ], { origin: "user", defaultRequired: false });
+                const criterion = parsed.criteria[0];
+                if (!criterion)
+                    return notice(parsed.errors[0]?.reason ?? "Invalid criterion.");
+                env.proof.addCriterion({ sessionId: env.sessionId, ...criterion });
+                return show();
+            }
+            default: {
+                const target = env.proof.criteria(env.sessionId)[command.index - 1];
+                if (!target)
+                    return notice(`There is no criterion ${command.index}.`);
+                if (command.type === "na")
+                    env.proof.markNotApplicable(target.criterionId, command.reason);
+                else
+                    env.proof.updateCriterion(target.criterionId, {
+                        ...(command.type === "edit" ? { text: command.text } : { required: command.required }),
+                    });
+                return show();
+            }
+        }
+    }
+    catch (error) {
+        return notice(error instanceof Error ? error.message : String(error));
+    }
+}

package/dist/tui/state.js

@@ -857,6 +857,12 @@ function reduceEventItems(state, event) {
             }
             return ended;
         }
+        case "proof_divergence":
+            // D8: the claim is only shown; no status changes and nothing is corrected in silence.
+            return addItem(state, {
+                kind: "notice",
+                text: `Proof: "${oneLine(String(d.claim ?? ""))}" has no backing evidence (${String(d.actual ?? "not_checked")}). /proof shows the ledger.`,
+            });
         case "truncation_recovery":
             return { ...state, recovery: { attempt: Number(d.attempt) || 1, of: Number(d.of) || 1 } };
         case "request_retry":