@alisio/core 0.7.0 → 0.8.0

package/dist/plan/criteria.js

@@ -0,0 +1,256 @@
+export const CRITERIA_MAX = 20;
+export const CRITERION_TEXT_MAX = 500;
+const COMMAND_MAX = 1000;
+const PATH_MAX = 500;
+const PATTERN_MAX = 200;
+const SCOPE_ENTRIES_MAX = 20;
+const SCOPE_ENTRY_MAX = 256;
+const EXIT_CODES_MAX = 10;
+const DATASET_ID_MAX = 64;
+const IDENTIFIER_MAX = 200;
+const EXPECTED_MAX = 500;
+const PLUGIN_INPUT_MAX = 4096;
+const PLUGIN_VERIFIER_ID = /^[a-z0-9][a-z0-9._-]{0,63}:[a-z0-9][a-z0-9._-]{0,63}$/;
+const DATA_CHECKS = new Set(["row_count", "sum", "equals"]);
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const text = (value, max) => typeof value === "string" && value.trim() && value.length <= max ? value : undefined;
+function verifierOf(raw) {
+    if (!isRecord(raw))
+        return "verifier must be an object";
+    if (raw.kind === "manual")
+        return { kind: "manual" };
+    if (raw.kind === "command") {
+        const command = text(raw.command, COMMAND_MAX)?.trim();
+        if (!command)
+            return "a command verifier needs a command";
+        const cwd = raw.cwd === undefined ? undefined : text(raw.cwd, PATH_MAX);
+        if (raw.cwd !== undefined && !cwd)
+            return "cwd must be a short string";
+        if (cwd && (isAbsoluteLike(cwd) || hasParentSegment(cwd)))
+            return "cwd must stay in the workspace";
+        const codes = raw.successExitCodes;
+        if (codes !== undefined &&
+            !(Array.isArray(codes) &&
+                codes.length > 0 &&
+                codes.length <= EXIT_CODES_MAX &&
+                codes.every((c) => Number.isInteger(c) && c >= 0 && c <= 255)))
+            return "successExitCodes must be a short list of exit codes";
+        const pattern = raw.outputPattern === undefined ? undefined : text(raw.outputPattern, PATTERN_MAX);
+        if (raw.outputPattern !== undefined && !pattern)
+            return "outputPattern must be a short string";
+        return {
+            kind: "command",
+            command,
+            ...(cwd ? { cwd } : {}),
+            ...(codes ? { successExitCodes: codes } : {}),
+            ...(pattern ? { outputPattern: pattern } : {}),
+        };
+    }
+    if (raw.kind === "file") {
+        const path = text(raw.path, PATH_MAX)?.trim();
+        if (!path || isAbsoluteLike(path) || hasParentSegment(path))
+            return "a file verifier needs a workspace-relative path";
+        const sha = typeof raw.sha256 === "string" && /^[0-9a-f]{64}$/.test(raw.sha256);
+        const pattern = raw.pattern === undefined ? undefined : text(raw.pattern, PATTERN_MAX);
+        if (raw.pattern !== undefined && !pattern)
+            return "pattern must be a short string";
+        if (raw.sha256 !== undefined && !sha)
+            return "sha256 must be 64 hex characters";
+        return {
+            kind: "file",
+            path,
+            ...(sha ? { sha256: raw.sha256 } : {}),
+            ...(pattern ? { pattern } : {}),
+        };
+    }
+    if (raw.kind === "data-check")
+        return dataCheckOf(raw);
+    if (raw.kind === "coverage") {
+        const command = text(raw.command, COMMAND_MAX)?.trim();
+        if (!command)
+            return "a coverage verifier needs a command";
+        const min = raw.minPercent;
+        if (typeof min !== "number" || !Number.isFinite(min) || min < 0 || min > 100)
+            return "a coverage verifier needs minPercent between 0 and 100";
+        return { kind: "coverage", command, minPercent: min };
+    }
+    if (raw.kind === "plugin") {
+        const verifierId = typeof raw.verifierId === "string" ? raw.verifierId : "";
+        if (!PLUGIN_VERIFIER_ID.test(verifierId))
+            return "a plugin verifier needs a verifierId like pluginId:verifier";
+        if (raw.input === undefined)
+            return { kind: "plugin", verifierId };
+        let size = Number.POSITIVE_INFINITY;
+        try {
+            size = JSON.stringify(raw.input)?.length ?? Number.POSITIVE_INFINITY;
+        }
+        catch {
+            /* Not serializable: refused below. */
+        }
+        if (size > PLUGIN_INPUT_MAX)
+            return "a plugin verifier input must be short JSON";
+        return { kind: "plugin", verifierId, input: raw.input };
+    }
+    return "that verifier kind cannot be proposed (use command, file, data-check, coverage, plugin or manual)";
+}
+function dataCheckOf(raw) {
+    const datasetId = text(raw.datasetId, DATASET_ID_MAX)?.trim();
+    if (!datasetId)
+        return "a data-check verifier needs a datasetId";
+    const check = typeof raw.check === "string" ? raw.check : "";
+    if (!DATA_CHECKS.has(check))
+        return "check must be row_count, sum or equals";
+    const expected = raw.expected;
+    const expectedOk = (typeof expected === "number" && Number.isFinite(expected)) ||
+        (typeof expected === "string" && expected.length > 0 && expected.length <= EXPECTED_MAX);
+    if (!expectedOk)
+        return "a data-check verifier needs an expected number or short string";
+    const column = raw.column === undefined ? undefined : text(raw.column, IDENTIFIER_MAX);
+    if (raw.column !== undefined && !column)
+        return "column must be a short string";
+    if (check !== "row_count" && !column)
+        return `a ${check} check needs a column`;
+    const table = raw.table === undefined ? undefined : text(raw.table, IDENTIFIER_MAX);
+    if (raw.table !== undefined && !table)
+        return "table must be a short string";
+    return {
+        kind: "data-check",
+        datasetId,
+        check: check,
+        ...(column ? { column } : {}),
+        expected: expected,
+        ...(table ? { table } : {}),
+    };
+}
+const isAbsoluteLike = (path) => path.startsWith("/") || path.startsWith("\\") || /^[A-Za-z]:/.test(path);
+const hasParentSegment = (path) => path.split(/[\\/]/).includes("..");
+function scopeOf(raw) {
+    if (!Array.isArray(raw) || raw.length === 0 || raw.length > SCOPE_ENTRIES_MAX)
+        return "scope must be a short list of globs";
+    const out = [];
+    for (const entry of raw) {
+        const glob = text(entry, SCOPE_ENTRY_MAX)?.trim();
+        if (!glob)
+            return "every scope entry must be a short string";
+        if (isAbsoluteLike(glob) || hasParentSegment(glob))
+            return "scope entries must stay inside the workspace";
+        out.push(glob);
+    }
+    return out;
+}
+/** Turns the model's `acceptanceCriteria` input into drafts, reporting what it could not keep. */
+export function validateCriteriaDrafts(raw) {
+    const accepted = [];
+    const dropped = [];
+    if (!Array.isArray(raw)) {
+        return { accepted, dropped: [{ index: 0, reason: "acceptanceCriteria must be an array" }] };
+    }
+    raw.forEach((entry, index) => {
+        if (accepted.length >= CRITERIA_MAX) {
+            dropped.push({ index, reason: `more than ${CRITERIA_MAX} criteria were proposed` });
+            return;
+        }
+        if (!isRecord(entry)) {
+            dropped.push({ index, reason: "a criterion must be an object" });
+            return;
+        }
+        const statement = typeof entry.text === "string" ? entry.text.replace(/\s+/g, " ").trim() : "";
+        if (!statement) {
+            dropped.push({ index, reason: "a criterion needs text" });
+            return;
+        }
+        let verifier;
+        if (entry.verifier !== undefined) {
+            const checked = verifierOf(entry.verifier);
+            if (typeof checked === "string") {
+                dropped.push({ index, reason: checked });
+                return;
+            }
+            verifier = checked;
+        }
+        let scope;
+        if (entry.scope !== undefined) {
+            const checked = scopeOf(entry.scope);
+            if (typeof checked === "string") {
+                dropped.push({ index, reason: checked });
+                return;
+            }
+            scope = checked;
+        }
+        accepted.push({
+            text: statement.length > CRITERION_TEXT_MAX ? statement.slice(0, CRITERION_TEXT_MAX) : statement,
+            required: entry.required === true,
+            ...(verifier ? { verifier } : {}),
+            ...(scope ? { scope } : {}),
+            origin: "inferred",
+        });
+    });
+    return { accepted, dropped };
+}
+/**
+ * Applies the user's per-draft decisions (`plan:criteria`) to the drafts of the plan they approved.
+ * `undefined` selection keeps every draft (the plain "approve"). Anything malformed, any index
+ * outside the list or an empty edit returns `undefined` for "nothing is activated": a selection
+ * the user did not make cleanly never activates a criterion (fail closed).
+ */
+export function applyCriteriaSelection(drafts, raw) {
+    if (raw === undefined || raw === "")
+        return { kept: [...drafts], rejected: 0 };
+    let selection;
+    try {
+        selection = typeof raw === "string" ? JSON.parse(raw) : undefined;
+    }
+    catch {
+        return undefined;
+    }
+    if (!isRecord(selection))
+        return undefined;
+    const index = (key) => {
+        const n = typeof key === "string" ? Number(key) : key;
+        return Number.isInteger(n) && n >= 0 && n < drafts.length ? n : undefined;
+    };
+    const rejected = new Set();
+    if (selection.reject !== undefined) {
+        if (!Array.isArray(selection.reject))
+            return undefined;
+        for (const entry of selection.reject) {
+            const i = index(entry);
+            if (i === undefined)
+                return undefined;
+            rejected.add(i);
+        }
+    }
+    const edits = new Map();
+    if (selection.edit !== undefined) {
+        if (!isRecord(selection.edit))
+            return undefined;
+        for (const [key, value] of Object.entries(selection.edit)) {
+            const i = index(key);
+            const statement = typeof value === "string" ? value.replace(/\s+/g, " ").trim() : "";
+            if (i === undefined || !statement)
+                return undefined;
+            edits.set(i, statement.slice(0, CRITERION_TEXT_MAX));
+        }
+    }
+    const required = new Map();
+    if (selection.required !== undefined) {
+        if (!isRecord(selection.required))
+            return undefined;
+        for (const [key, value] of Object.entries(selection.required)) {
+            const i = index(key);
+            if (i === undefined || typeof value !== "boolean")
+                return undefined;
+            required.set(i, value);
+        }
+    }
+    const kept = drafts.flatMap((draft, i) => rejected.has(i)
+        ? []
+        : [
+            {
+                ...draft,
+                text: edits.get(i) ?? draft.text,
+                required: required.get(i) ?? draft.required,
+            },
+        ]);
+    return { kept, rejected: rejected.size };
+}

package/dist/plan/exit-plan.d.ts

@@ -1,5 +1,6 @@
 import type { AskQuestionsRequest, AskQuestionsResult } from "@alisio/sdk";
 import type { ToolRegistry } from "../core/registry.ts";
+import type { NewCriterion } from "../proof/types.ts";
 import { type PlanStore } from "./state.ts";
 export interface ExitPlanDeps {
     store: PlanStore;
@@ -14,5 +15,12 @@ export interface ExitPlanDeps {
         enabled: boolean;
         max: number;
     };
+    /**
+     * Where approved acceptance criteria go (`ProofStore` fits). Without it the `acceptanceCriteria`
+     * field is not offered and is ignored: a core without Proof plans exactly as before.
+     */
+    proof?: {
+        addCriterion(input: NewCriterion): unknown;
+    };
 }
 export declare function registerExitPlan(registry: ToolRegistry, deps: ExitPlanDeps): void;

package/dist/plan/exit-plan.js

@@ -17,9 +17,28 @@ import { textResult } from "@alisio/sdk";
 import { EXIT_PLAN_TOOL } from "../core/opt-in.js";
 import { newUuid } from "../runtime/ids.js";
 import { objectSchema } from "../tools/standard.js";
+import { applyCriteriaSelection, validateCriteriaDrafts, } from "./criteria.js";
 import { DIAGRAM_MAX_BYTES, DIAGRAM_MAX_NODES, validateDiagrams, } from "./diagrams.js";
 import { buildPlanManifest } from "./manifest.js";
-import { currentPlan, decidePlan, nextPlanRevision, PLAN_CONTEXT_MAX_CHARS, PLAN_MAX_CHARS, PLAN_OPTIONS, PLAN_QUESTION_ID, PLAN_REVIEW_TITLE, PLAN_TEXT_KEY, planHash, planTitle, proposePlan, withdrawPendingPlan, } from "./state.js";
+import { currentPlan, decidePlan, nextPlanRevision, PLAN_CONTEXT_MAX_CHARS, PLAN_CRITERIA_KEY, PLAN_MAX_CHARS, PLAN_OPTIONS, PLAN_QUESTION_ID, PLAN_REVIEW_TITLE, PLAN_TEXT_KEY, planHash, planTitle, proposePlan, withdrawPendingPlan, } from "./state.js";
+const CRITERIA_SCHEMA = {
+    type: "array",
+    description: "Optional acceptance criteria you PROPOSE for this plan. They are drafts: they only become " +
+        "active if the user approves the plan, and a criterion with no verifier stays unchecked.",
+    items: {
+        type: "object",
+        properties: {
+            text: { type: "string", description: "A verifiable statement, e.g. 'Unit tests pass'" },
+            required: { type: "boolean", description: "Must hold before the work counts as done" },
+            verifier: {
+                type: "object",
+                description: "How to check it: {kind:'command', command:'pnpm test'}, {kind:'file', path} or {kind:'manual'}",
+            },
+            scope: { type: "array", items: { type: "string" }, description: "Globs it covers" },
+        },
+        required: ["text"],
+    },
+};
 const DIAGRAM_SCHEMA = {
     type: "array",
     description: `Optional Mermaid diagrams; see the plan agent's instructions`,
@@ -97,7 +116,13 @@ export function registerExitPlan(registry, deps) {
             description: "The whole plan in Markdown",
         },
     }, ["plan"]);
-    const withDiagrams = objectSchema({ ...plain.properties, diagrams: DIAGRAM_SCHEMA }, ["plan"]);
+    const withCriteria = deps.proof ? { acceptanceCriteria: CRITERIA_SCHEMA } : {};
+    const plainCriteria = objectSchema({ ...plain.properties, ...withCriteria }, ["plan"]);
+    const withDiagrams = objectSchema({
+        ...plain.properties,
+        ...withCriteria,
+        diagrams: DIAGRAM_SCHEMA,
+    }, ["plan"]);
     // The input is always VALIDATED with `diagrams` allowed (a call made while they were switched
     // off must not fail), but the model is only OFFERED the field while diagrams are on: the
     // registry compiles the schema once, while the provider reads it on every request.
@@ -106,12 +131,15 @@ export function registerExitPlan(registry, deps) {
         name: EXIT_PLAN_TOOL,
         effect: "read",
         get description() {
-            return offered()
-                ? `${BASE_DESCRIPTION} Optional \`diagrams\`: up to ${settings().max} small Mermaid diagrams (see your instructions).`
+            const base = deps.proof
+                ? `${BASE_DESCRIPTION} Optional \`acceptanceCriteria\`: drafts the user approves together with the plan.`
                 : BASE_DESCRIPTION;
+            return offered()
+                ? `${base} Optional \`diagrams\`: up to ${settings().max} small Mermaid diagrams (see your instructions).`
+                : base;
         },
         get inputSchema() {
-            return registering || offered() ? withDiagrams : plain;
+            return registering || offered() ? withDiagrams : plainCriteria;
         },
         async execute(input, context) {
             const plan = String(input.plan ?? "").trim();
@@ -145,6 +173,15 @@ export function registerExitPlan(registry, deps) {
                     outcome.dropped = validated.dropped;
                 }
             }
+            // Acceptance criteria are DRAFTS here (O3): validated, shown in the review, stored in the plan
+            // state, and turned into real criteria only by the user's approval below. Nothing in this
+            // block writes the ledger.
+            const rawCriteria = deps.proof ? input.acceptanceCriteria : undefined;
+            const proposed = rawCriteria === undefined || (Array.isArray(rawCriteria) && !rawCriteria.length)
+                ? undefined
+                : validateCriteriaDrafts(rawCriteria);
+            const drafts = proposed?.accepted ?? [];
+            const droppedCriteria = proposed?.dropped ?? [];
             const preManifest = buildPlanManifest({
                 planId,
                 revision,
@@ -153,11 +190,12 @@ export function registerExitPlan(registry, deps) {
                 markdown: plan,
                 diagrams: outcome.accepted,
                 ...(previous ? { previous } : {}),
+                ...(drafts.length ? { acceptanceCriteria: drafts } : {}),
             });
             outcome.removed = preManifest.removed;
             if (outcome.removed.length)
                 outcome.involved = true;
-            const hash = planHash(plan, preManifest.diagrams.map((d) => ({ id: d.id, hash: d.hash })));
+            const hash = planHash(plan, preManifest.diagrams.map((d) => ({ id: d.id, hash: d.hash })), drafts);
             const manifest = { ...preManifest, hash };
             const diagrams = manifest.diagrams.map((entry, index) => ({
                 id: entry.id,
@@ -176,7 +214,7 @@ export function registerExitPlan(registry, deps) {
             const publisher = context.artifacts;
             if (publisher) {
                 // A folder (plan.md + plan.json + diagrams) when diagrams are involved, else plan.md alone.
-                if (outcome.accepted.length || outcome.removed.length)
+                if (outcome.accepted.length || outcome.removed.length || drafts.length)
                     try {
                         artifact = await publishPlanFolder(publisher, [
                             { path: "plan.md", text: `${plan}\n` },
@@ -209,12 +247,23 @@ export function registerExitPlan(registry, deps) {
                 title,
                 ...(context.callId ? { callId: context.callId } : {}),
                 ...(artifact ? { artifactId: artifact.id } : {}),
+                ...(drafts.length ? { criteria: drafts } : {}),
                 ...(manifest.diagrams.length
                     ? {
                         diagrams: manifest.diagrams.map((d) => ({ id: d.id, title: d.title, hash: d.hash })),
                     }
                     : {}),
             };
+            const criteriaReport = (activated) => drafts.length || droppedCriteria.length
+                ? {
+                    criteria: {
+                        proposed: drafts.length,
+                        ...(droppedCriteria.length ? { dropped: droppedCriteria } : {}),
+                        ...(activated === undefined ? {} : { activated }),
+                        ...(rejectedDrafts ? { rejected: rejectedDrafts } : {}),
+                    },
+                }
+                : {};
             const report = diagramReport(outcome);
             if (!reviewable) {
                 // Nobody to ask: keep the revision count honest and tell the model what to do instead.
@@ -239,6 +288,7 @@ export function registerExitPlan(registry, deps) {
                 markdown: plan,
                 ...(artifact ? { artifact } : {}),
                 ...(diagrams.length ? { diagrams } : {}),
+                ...(drafts.length ? { acceptanceCriteria: drafts } : {}),
             };
             const result = await deps.ui.askQuestions({
                 questions: [
@@ -271,16 +321,47 @@ export function registerExitPlan(registry, deps) {
                 hash,
                 decision,
             });
+            // The only place a draft becomes a criterion: the user's own approval, applied once by the
+            // compare-and-set above, of exactly the drafts stored with that proposal.
+            let activated;
+            let rejectedDrafts = 0;
+            if (decision === "approve" && deps.proof && decided.criteria?.length) {
+                // The user may approve, edit or reject each draft (`plan:criteria`); a selection that is
+                // not clean activates none of them.
+                const picked = applyCriteriaSelection(decided.criteria, result[PLAN_CRITERIA_KEY]);
+                rejectedDrafts = picked ? picked.rejected : decided.criteria.length;
+                try {
+                    for (const draft of picked?.kept ?? [])
+                        deps.proof.addCriterion({
+                            sessionId,
+                            text: draft.text,
+                            origin: draft.origin,
+                            required: draft.required,
+                            ...(draft.verifier ? { verifier: draft.verifier } : {}),
+                            ...(draft.scope ? { scope: draft.scope } : {}),
+                        });
+                    activated = picked?.kept.length ?? 0;
+                }
+                catch {
+                    activated = "failed";
+                }
+            }
             const base = {
                 planId,
                 revision,
                 ...(artifact ? { artifactId: artifact.id } : {}),
                 ...report,
+                ...criteriaReport(activated),
             };
             const body = decision === "approve"
                 ? answer("approved", "The user approved the plan. The build agent will implement exactly this plan in the " +
                     "next turn. Do not implement anything yourself: reply with one short sentence and " +
-                    "call no more tools.", base)
+                    "call no more tools." +
+                    (typeof activated === "number"
+                        ? ` ${activated} acceptance criteria are now active.`
+                        : activated === "failed"
+                            ? " The acceptance criteria could not be saved; they are not active."
+                            : ""), base)
                 : decision === "context"
                     ? answer("feedback", "The user added context instead of deciding. Revise the plan to account for it and " +
                         "call exit_plan again with the complete updated plan" +

package/dist/plan/manifest.d.ts

@@ -1,4 +1,4 @@
-import type { PlanDiagramStatus, PlanManifest } from "@alisio/sdk";
+import type { PlanCriterionDraft, PlanDiagramStatus, PlanManifest } from "@alisio/sdk";
 import { type PlanDiagram } from "./diagrams.ts";
 export interface PlanHeading {
     id: string;
@@ -31,6 +31,8 @@ export interface ManifestInput {
     diagrams: PlanDiagram[];
     /** Diagrams of the previous revision (from the plan state), when there was one. */
     previous?: DiagramRecord[];
+    /** Acceptance-criteria drafts of this revision (specs/011); absent or empty = none. */
+    acceptanceCriteria?: PlanCriterionDraft[];
 }
 /** The diff of this revision's diagrams against the previous one. */
 export declare function diffDiagrams(diagrams: Array<{
@@ -50,4 +52,4 @@ export declare function buildPlanManifest(input: ManifestInput): PlanManifest;
 export declare function planContentHash(markdown: string, diagrams: Array<{
     id: string;
     hash: string;
-}>): string;
+}>, criteria?: PlanCriterionDraft[]): string;

package/dist/plan/manifest.js

@@ -308,12 +308,17 @@ export function buildPlanManifest(input) {
             };
         }),
         removed,
+        ...(input.acceptanceCriteria?.length ? { acceptanceCriteria: input.acceptanceCriteria } : {}),
     };
 }
 /** The hash of a plan revision: the Markdown alone, or the Markdown plus its diagrams. */
-export function planContentHash(markdown, diagrams) {
+export function planContentHash(markdown, diagrams, criteria = []) {
     const hash = createHash("sha256").update(markdown, "utf8");
     if (diagrams.length)
         hash.update(`\n--diagrams--\n${diagrams.map((d) => `${d.id}:${d.hash}`).join("\n")}`, "utf8");
+    // The criteria are part of what the user approves, so they are part of the hash (only when
+    // present: a plan without criteria keeps the hash it always had).
+    if (criteria.length)
+        hash.update(`\n--criteria--\n${JSON.stringify(criteria.map((c) => [c.text, c.required, c.verifier ?? null, c.scope ?? null]))}`, "utf8");
     return hash.digest("hex");
 }

package/dist/plan/state.d.ts

@@ -8,12 +8,18 @@
  *    ├────skip──────▶ skipped          └─discard─▶ cancelled (the run was cancelled)
  *    └────context───▶ feedback         (a later `exit_plan` call starts a new revision)
  */
-import type { QuestionOption } from "@alisio/sdk";
+import type { PlanCriterionDraft, QuestionOption } from "@alisio/sdk";
 import { type DiagramRecord } from "./manifest.ts";
 /** The decision screen title (web: localized; the TUI prints it as is). */
 export declare const PLAN_REVIEW_TITLE = "Plan complete. What would you like to do?";
 export declare const PLAN_QUESTION_ID = "plan";
 export declare const PLAN_TEXT_KEY = "plan:text";
+/**
+ * Per-draft decisions on the acceptance criteria (specs/011 phase 5): a JSON object
+ * `{reject?: number[], edit?: {"<index>": "text"}, required?: {"<index>": boolean}}` over the
+ * drafts as the review lists them. Only read together with `approve`.
+ */
+export declare const PLAN_CRITERIA_KEY = "plan:criteria";
 /** The agent an approved plan is handed to. */
 export declare const IMPLEMENTATION_AGENT_ID = "build";
 export declare const PLAN_MAX_CHARS = 60000;
@@ -33,6 +39,11 @@ export interface PlanState {
     artifactId?: string;
     /** The accepted diagrams of this revision (absent without any): what the next one is diffed against. */
     diagrams?: DiagramRecord[];
+    /**
+     * Acceptance-criteria DRAFTS of this revision (specs/011, O3). They are not criteria: they only
+     * become active when the user approves this plan (`exit-plan.ts`), and a later revision replaces them.
+     */
+    criteria?: PlanCriterionDraft[];
     /** The approved snapshot; kept only while `approved` (afterwards it lives in the user message). */
     plan?: string;
     updatedAt: number;
@@ -54,7 +65,7 @@ export interface PlanStore {
 export declare const planHash: (plan: string, diagrams?: Array<{
     id: string;
     hash: string;
-}>) => string;
+}>, criteria?: PlanCriterionDraft[]) => string;
 /** The plan state stored in `options`, or undefined when absent or malformed. */
 export declare function readPlanState(options: Record<string, unknown> | undefined): PlanState | undefined;
 export declare const currentPlan: (store: PlanStore, sessionId: string) => PlanState | undefined;

package/dist/plan/state.js

@@ -3,6 +3,12 @@ import { planContentHash } from "./manifest.js";
 export const PLAN_REVIEW_TITLE = "Plan complete. What would you like to do?";
 export const PLAN_QUESTION_ID = "plan";
 export const PLAN_TEXT_KEY = `${PLAN_QUESTION_ID}:text`;
+/**
+ * Per-draft decisions on the acceptance criteria (specs/011 phase 5): a JSON object
+ * `{reject?: number[], edit?: {"<index>": "text"}, required?: {"<index>": boolean}}` over the
+ * drafts as the review lists them. Only read together with `approve`.
+ */
+export const PLAN_CRITERIA_KEY = `${PLAN_QUESTION_ID}:criteria`;
 /** The agent an approved plan is handed to. */
 export const IMPLEMENTATION_AGENT_ID = "build";
 export const PLAN_MAX_CHARS = 60_000;
@@ -22,7 +28,7 @@ export const PLAN_OPTIONS = [
  * The hash of a plan revision. Without diagrams it is the SHA-256 of the Markdown (as before);
  * with diagrams it also covers them, so a change in a diagram alone is a different plan.
  */
-export const planHash = (plan, diagrams = []) => planContentHash(plan, diagrams);
+export const planHash = (plan, diagrams = [], criteria = []) => planContentHash(plan, diagrams, criteria);
 const STATUSES = new Set([
     "pending",
     "approved",

package/dist/plugins/host.d.ts

@@ -5,6 +5,7 @@ import type { ToolRegistry } from "../core/registry.ts";
 import type { DecisionRegistry } from "../decisions/registry.ts";
 import type { DecisionService, DecisionsConfig } from "../decisions/service.ts";
 import { ExtensionRegistry } from "../extensions/registry.ts";
+import type { ProofVerifierRegistry } from "../proof/plugin-verifiers.ts";
 import type { ProviderRegistry } from "../providers/registry.ts";
 export declare const pluginPrefix: (id: string) => string;
 export interface PluginHostOptions {
@@ -165,6 +166,12 @@ export declare class PluginHost implements RunnerExtensions {
      * Binds the directories and options plugins receive (`api.paths`, `api.options`). Plugins
      * activated before this call, or on a host without it, see neither member.
      */
+    /**
+     * Binds the Proof verifier registry. Plugins activated afterwards see `api.proof`; without it
+     * the member is absent, exactly like on a core that predates Proof.
+     */
+    setProofVerifiers(registry: ProofVerifierRegistry): void;
+    private proofVerifiers?;
     setPluginEnvironment(environment: PluginEnvironment): void;
     private environment?;
     /** Binds credential-free model discovery/resolution after provider startup is complete. */

package/dist/plugins/host.js

@@ -178,6 +178,14 @@ export class PluginHost {
      * Binds the directories and options plugins receive (`api.paths`, `api.options`). Plugins
      * activated before this call, or on a host without it, see neither member.
      */
+    /**
+     * Binds the Proof verifier registry. Plugins activated afterwards see `api.proof`; without it
+     * the member is absent, exactly like on a core that predates Proof.
+     */
+    setProofVerifiers(registry) {
+        this.proofVerifiers = registry;
+    }
+    proofVerifiers;
     setPluginEnvironment(environment) {
         this.environment = environment;
     }
@@ -428,6 +436,13 @@ export class PluginHost {
                     };
                 })(this.environment)
                 : {}),
+            ...(this.proofVerifiers
+                ? {
+                    proof: ((registry) => ({
+                        registerVerifier: (verifier) => track(registry.register(plugin.id, verifier)),
+                    }))(this.proofVerifiers),
+                }
+                : {}),
             ...(this.decisionsImpl
                 ? {
                     decisions: (({ registry, service, activation }) => ({

package/dist/proof/command.d.ts

@@ -0,0 +1,24 @@
+export type CommandTool = "run_process" | "shell";
+/** The canonical workspace-relative directory: forward slashes, no `./` prefix, `.` when empty. */
+export declare function normalizeCwd(cwd: string): string;
+/** Directory of a call relative to the workspace (`.` when it is the workspace itself). */
+export declare function relativeCwd(workspace: string, cwd: string | undefined): string;
+export declare function commandFingerprint(argv: readonly string[], cwd: string): string;
+/** Trims and collapses whitespace runs OUTSIDE single/double quotes; quoted text stays verbatim. */
+export declare function normalizeShell(command: string): string;
+/** Fingerprint of a call as the tool received it. */
+export declare function callFingerprint(tool: CommandTool, input: {
+    command: string;
+    args?: readonly string[];
+}, cwd: string): string;
+/**
+ * Splits a plain command line into an argv (single and double quotes group words). Returns
+ * undefined when the line needs a shell (operators, expansions, unbalanced quotes): only the
+ * shell form can then match it.
+ */
+export declare function splitCommand(command: string): string[] | undefined;
+/**
+ * Every fingerprint a call may have to satisfy the criterion command `command` run in `cwd`: the
+ * `shell` form always and the `run_process` form when the line is a plain argv.
+ */
+export declare function criterionFingerprints(command: string, cwd: string): string[];