@alisio/core 0.7.0 → 0.8.0

package/dist/application.d.ts

@@ -21,6 +21,8 @@ import { GoalService } from "./goal/service.ts";
 import { HerdrBridge } from "./integrations/herdr.ts";
 import { McpConnector } from "./mcp/connector.ts";
 import { PluginHost } from "./plugins/host.ts";
+import { ProofVerifierRegistry } from "./proof/plugin-verifiers.ts";
+import { ProofStore } from "./proof/store.ts";
 import { ActiveProvider, ProviderRegistry } from "./providers/registry.ts";
 import { ProviderSettingsStore } from "./providers/settings.ts";
 import { ProjectContext } from "./resources/context.ts";
@@ -44,6 +46,8 @@ export interface AppOptions {
     /** Extra directories the tools may touch outside the workspace (per-run `--add-dir`). */
     addDirs?: string[];
     noHerdr?: boolean;
+    /** Home directory for user-level resources (skills, agents); defaults to `os.homedir()`. */
+    home?: string;
     model?: string;
     baseURL?: string;
     apiMode?: string;
@@ -183,6 +187,17 @@ export declare function createApplication(options?: AppOptions): Promise<{
     tasks: BackgroundTasks;
     /** Session goals (`/goal`): state, user actions, the continuation controller. */
     goals: GoalService;
+    /** The Proof ledger (specs/011): criteria and evidence of every session; user surfaces only. */
+    proof: ProofStore;
+    /** Verifiers plugins registered with `api.proof.registerVerifier`, keyed `<plugin>:<id>`. */
+    proofVerifiers: ProofVerifierRegistry;
+    /**
+     * Runs the verifier of one criterion on demand (`file`, `data-check`, `coverage`, `plugin`): a USER
+     * action, never reachable by the model. Core tool calls go through the normal gate.
+     */
+    verifyCriterion: (sessionId: string, criterionId: string, verifyOptions?: {
+        signal?: AbortSignal;
+    }) => Promise<import("./index.ts").VerifyOutcome>;
     /** Python discovery and job folders of `python_run`; `enabled` is false under --read-only. */
     analysis: {
         enabled: boolean;

package/dist/application.js

@@ -32,6 +32,10 @@ import { GoalStore } from "./goal/store.js";
 import { HerdrBridge } from "./integrations/herdr.js";
 import { McpConnector } from "./mcp/connector.js";
 import { discoverPlugins, PluginHost } from "./plugins/host.js";
+import { ProofVerifierRegistry } from "./proof/plugin-verifiers.js";
+import { ProofRecorder } from "./proof/recorder.js";
+import { ProofStore } from "./proof/store.js";
+import { verifyCriterion } from "./proof/verify.js";
 import { ActiveProvider, ProviderRegistry, UnconfiguredProvider } from "./providers/registry.js";
 import { availableProviderModels, resolveProviderModel as resolveConfiguredModel, } from "./providers/routing.js";
 import { ProviderSettingsStore } from "./providers/settings.js";
@@ -197,6 +201,9 @@ export async function createApplication(options = {}) {
             },
         },
     });
+    // Proof verifiers contributed by plugins (`api.proof`); bound before any plugin loads.
+    const proofVerifiers = new ProofVerifierRegistry();
+    plugins.setProofVerifiers(proofVerifiers);
     const stateRoot = options.db && options.db !== ":memory:" ? dirname(options.db) : stateHome();
     plugins.setPluginEnvironment({
         stateRoot,
@@ -216,7 +223,7 @@ export async function createApplication(options = {}) {
             cwd,
             stateHome: stateHome(),
             configHome: configHome(),
-            home: homedir(),
+            home: options.home ?? homedir(),
             trusted: !!options.trustProject || !!options.config,
             configDir: dirname(configFile(workspace, options.config ? { file: options.config } : { trustProject: options.trustProject })),
         };
@@ -380,7 +387,7 @@ export async function createApplication(options = {}) {
         await skills.discover(skillRoots({
             workspace,
             cwd,
-            home: homedir(),
+            home: options.home ?? homedir(),
             configHome: configHome(),
             trusted: !!options.trustProject || !!options.config,
             configSkills: config.skills,
@@ -543,6 +550,8 @@ export async function createApplication(options = {}) {
         // tools are opt-in: a run only sees them while its session has an active goal.
         const goals = new GoalService({
             store: new GoalStore(store.db),
+            // Proof (specs/011): `update_goal complete` is judged against the session's criteria.
+            proof: new ProofStore(store.db),
             settings: () => config.goal,
             ...(options.goals?.onChange ? { onChange: options.goals.onChange } : {}),
             ...(options.goals?.onLog ? { onLog: options.goals.onLog } : {}),
@@ -642,6 +651,8 @@ export async function createApplication(options = {}) {
             store,
             ui: plugins.ui,
             readOnly: !!options.readOnly,
+            // Criteria the model proposes become active only when the user approves the plan.
+            proof: new ProofStore(store.db),
             diagrams: () => ({
                 enabled: config.plan.diagrams,
                 max: config.plan.diagrams ? config.plan.maxDiagrams : 0,
@@ -982,6 +993,7 @@ export async function createApplication(options = {}) {
                 return known;
             },
             ...(options.approve && !options.readOnly ? { approve: options.approve } : {}),
+            proof: new ProofRecorder(store.db, { coverage: () => config.proof.coverage.enabled }),
             pathAccess,
             ...(analysisEnabled
                 ? {
@@ -1118,6 +1130,29 @@ export async function createApplication(options = {}) {
             tasks,
             /** Session goals (`/goal`): state, user actions, the continuation controller. */
             goals,
+            /** The Proof ledger (specs/011): criteria and evidence of every session; user surfaces only. */
+            proof: new ProofStore(store.db),
+            /** Verifiers plugins registered with `api.proof.registerVerifier`, keyed `<plugin>:<id>`. */
+            proofVerifiers,
+            /**
+             * Runs the verifier of one criterion on demand (`file`, `data-check`, `coverage`, `plugin`): a USER
+             * action, never reachable by the model. Core tool calls go through the normal gate.
+             */
+            verifyCriterion: (sessionId, criterionId, verifyOptions = {}) => verifyCriterion({
+                store: new ProofStore(store.db),
+                registry: proofVerifiers,
+                db: store.db,
+                coverage: () => config.proof.coverage.enabled,
+                callTool: (id, name, input, signal) => runner.runToolCall(id, name, input, {
+                    signal,
+                    workspace: sessionWorkspace(id),
+                }),
+            }, {
+                sessionId,
+                criterionId,
+                workspace: sessionWorkspace(sessionId),
+                ...(verifyOptions.signal ? { signal: verifyOptions.signal } : {}),
+            }),
             /** Python discovery and job folders of `python_run`; `enabled` is false under --read-only. */
             analysis: {
                 enabled: analysisEnabled,
@@ -1522,7 +1557,7 @@ export async function createApplication(options = {}) {
              */
             agentDefinitions: new AgentDefinitionService({
                 workspace,
-                home: homedir(),
+                home: options.home ?? homedir(),
                 registry: {
                     async reload() {
                         const handler = plugins.commands.get("agents");

package/dist/changelog/data.js

@@ -2,6 +2,29 @@
 export const CHANGELOG_DATA = {
     schema: 1,
     entries: [
+        {
+            version: "0.8.0",
+            date: "2026-10-14",
+            sections: [
+                {
+                    title: "Added",
+                    items: [
+                        "Proof ledger: acceptance criteria whose status (`verified`, `failed`, `not_checked`, `manual_review`, `not_applicable`) is computed from evidence captured from the commands, file reads and data queries the agent really ran. A criterion without a verifier stays `not_checked`.",
+                        "Verifiers `command`, `file`, `data-check`, opt-in `coverage` (`proof.coverage.enabled`) and plugin verifiers (`api.proof.registerVerifier`). An edit after the evidence expires it.",
+                        "The Proof card and tab in the web UI, `/proof` and `/goal override <reason>` in the terminal, and per-criterion review of the criteria a plan proposes (all-or-nothing in the terminal).",
+                        "`alisio run --proof`, `--criterion`, `--verify` and `--proof-file`: the run prints the ledger, ends with a `proof_ledger` JSONL line under `--json`, exits `0`, `10` or `11` (`proof.exitCodes`, `proof.ci`) and publishes `proof.md` and `proof.json`.",
+                        "A warning when the final answer claims tests, types or lint passed without matching evidence.",
+                        "Export in Markdown and versioned JSON (`proof/v1`) and the routes `GET /api/sessions/:sid/proof`, `POST` `…/proof/criteria`, `…/not-applicable` and `…/goal/override`.",
+                    ],
+                },
+                {
+                    title: "Improved",
+                    items: [
+                        "`update_goal` with `complete` is refused while a required criterion is `failed` or `not_checked`; only you can complete the goal over it. Without criteria, goal or plan nothing changes.",
+                    ],
+                },
+            ],
+        },
         {
             version: "0.7.0",
             date: "2026-10-14",

package/dist/commands/builtins.js

@@ -151,6 +151,13 @@ export const BUILTIN_COMMANDS = [
         surfaces: INTERACTIVE,
         execution: "surface",
     },
+    {
+        name: "proof",
+        description: "Show the acceptance criteria of this session and the evidence behind each one",
+        argumentHint: "[add | edit | required | optional | na | export | help]",
+        surfaces: INTERACTIVE,
+        execution: "surface",
+    },
     {
         name: "decisions",
         description: "Show Decision Intelligence status, provider health and session metrics",

package/dist/config.d.ts

@@ -255,6 +255,16 @@ export declare const configSchema: z.ZodPipe<z.ZodObject<{
         noToolTurnsLimit: z.ZodDefault<z.ZodNumber>;
         blockedRepeats: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strict>>;
+    proof: z.ZodDefault<z.ZodObject<{
+        ci: z.ZodDefault<z.ZodBoolean>;
+        exitCodes: z.ZodDefault<z.ZodObject<{
+            failed: z.ZodDefault<z.ZodNumber>;
+            unverified: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strict>>;
+        coverage: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
     plan: z.ZodDefault<z.ZodObject<{
         diagrams: z.ZodDefault<z.ZodBoolean>;
         maxDiagrams: z.ZodDefault<z.ZodNumber>;
@@ -415,6 +425,16 @@ export declare const configSchema: z.ZodPipe<z.ZodObject<{
         noToolTurnsLimit: number;
         blockedRepeats: number;
     };
+    proof: {
+        ci: boolean;
+        exitCodes: {
+            failed: number;
+            unverified: number;
+        };
+        coverage: {
+            enabled: boolean;
+        };
+    };
     plan: {
         diagrams: boolean;
         maxDiagrams: number;
@@ -654,6 +674,16 @@ export declare const configSchema: z.ZodPipe<z.ZodObject<{
         noToolTurnsLimit: number;
         blockedRepeats: number;
     };
+    proof: {
+        ci: boolean;
+        exitCodes: {
+            failed: number;
+            unverified: number;
+        };
+        coverage: {
+            enabled: boolean;
+        };
+    };
     plan: {
         diagrams: boolean;
         maxDiagrams: number;

package/dist/config.js

@@ -528,6 +528,38 @@ const configObjectSchema = z
         noToolTurnsLimit: 3,
         blockedRepeats: 2,
     })),
+    /**
+     * Proof (specs/011): acceptance criteria with evidence. `ci` makes `alisio run` behave as
+     * with `--proof` (the ledger as the final event and the exit codes below). `exitCodes` are
+     * what `--proof` exits with: `failed` when a required criterion failed, `unverified` when a
+     * required one is not checked or needs a manual review (0 when every required one is verified).
+     */
+    proof: z
+        .object({
+        ci: z.boolean().default(false),
+        exitCodes: z
+            .object({
+            failed: z.number().int().min(1).max(125).default(10),
+            unverified: z.number().int().min(1).max(125).default(11),
+        })
+            .strict()
+            .default(() => ({ failed: 10, unverified: 11 })),
+        /**
+         * The `coverage` verifier (opt-in). Off: a `coverage` criterion stays `not_checked` and
+         * Proof records nothing for its command. On: the percentage a coverage command printed
+         * (through the normal permission gate) is compared with the criterion's `minPercent`.
+         */
+        coverage: z
+            .object({ enabled: z.boolean().default(false) })
+            .strict()
+            .default(() => ({ enabled: false })),
+    })
+        .strict()
+        .default(() => ({
+        ci: false,
+        exitCodes: { failed: 10, unverified: 11 },
+        coverage: { enabled: false },
+    })),
     /**
      * Plan diagrams (`exit_plan`): the plan agent may add Mermaid diagrams to a plan. `diagrams`
      * off removes them from the tool and from the agent's instructions; `maxDiagrams` caps how

package/dist/core/runner.d.ts

@@ -1,4 +1,5 @@
 import { type Attachment, type DatasetRef, type Message, type ModelProvider, type RunEvent, type ToolDefinition, type ToolResult } from "@alisio/sdk";
+import type { ProofRecorder } from "../proof/recorder.ts";
 import type { PathAccess } from "../runtime/access.ts";
 import type { ApprovalHandler, ArtifactPublisherFactory, CapabilityGate, ContextSource, DecisionsFactory, Policy, RunnerExtensions, SessionStore } from "./contracts.ts";
 import { HumanWaits } from "./human-wait.ts";
@@ -83,6 +84,8 @@ export interface RunnerOptions {
     artifacts?: ArtifactPublisherFactory;
     /** Decision Intelligence bound to each tool call (`ToolContext.decisions`). */
     decisions?: DecisionsFactory;
+    /** Captures Proof evidence from executed calls (specs/011). Absent: the runner is unchanged. */
+    proof?: ProofRecorder;
     /**
      * Provider-native tool definitions (for example a hosted `web_search` tool) appended to every
      * request's `tools` alongside the registry's function tools. Opt-in, set once for the whole
@@ -285,6 +288,7 @@ export declare class AgentRunner {
         signal?: AbortSignal;
     }): Promise<{
         runId: string;
+        callId: string;
         status: "completed";
         result: ToolResult;
     }>;

package/dist/core/runner.js

@@ -414,6 +414,8 @@ export class AgentRunner {
         /** Set by the call itself (see `CallInternals`): it may have left effects. */
         let effectful = false;
         let dispatcher;
+        /** Proof ledger changes caused by this call, announced after `tool_completed`. */
+        let proofUpdates = [];
         /** Held from the scratchpad quota check until the write is done (L1). */
         let releaseScratch;
         // `effect` rides along so the TUI can group consecutive calls by capability kind
@@ -692,6 +694,25 @@ export class AgentRunner {
                 })),
             });
             result = await p.tool.execute(p.input, toolContext);
+            // Proof reads the RAW result of a call that really ran, before the model-facing bound below.
+            // It never throws into the call: a failed capture only means no evidence.
+            if (o.proof) {
+                try {
+                    proofUpdates = o.proof.capture({
+                        sessionId,
+                        runId,
+                        callId: call.id,
+                        name: call.name,
+                        input: p.input,
+                        result,
+                        workspace,
+                        durationMs: Date.now() - started,
+                    });
+                }
+                catch {
+                    proofUpdates = [];
+                }
+            }
             // The bound applies to what the model sees (the text projection): display-only
             // ui/image parts are bounded by their producers and must not push text over it.
             const projected = textProjection(result);
@@ -702,6 +723,25 @@ export class AgentRunner {
         }
         catch (error) {
             result = textResult(error instanceof Error ? error.message : String(error), true);
+            // A `read_file` of a missing file is evidence for a `file` criterion (specs/011): the call
+            // threw, so it never reached the capture above. Capture never throws into the call.
+            if (o.proof && call.name === "read_file") {
+                try {
+                    proofUpdates = proofUpdates.concat(o.proof.captureFailure({
+                        sessionId,
+                        runId,
+                        callId: call.id,
+                        name: call.name,
+                        input: p.input ?? {},
+                        result,
+                        workspace,
+                        durationMs: Date.now() - started,
+                    }));
+                }
+                catch {
+                    /* A failed capture only means no evidence. */
+                }
+            }
             // A cancellation after execution may have left effects, so the journal stays pending for
             // the user to inspect. A `read` call cannot have left any (and `exit_plan`, which is one,
             // is exactly what a stop or the run limit interrupts while a person decides): it is closed
@@ -725,6 +765,8 @@ export class AgentRunner {
                 .join("\n")
                 .slice(0, 2_000),
         });
+        for (const update of proofUpdates)
+            emit("proof_updated", update);
         return result;
     }
     /**
@@ -813,7 +855,7 @@ export class AgentRunner {
             o.store.append(sessionId, { role: "assistant", text, calls: [] });
             emit("run_completed", { tokens: 0, text });
             finish("completed");
-            return { runId, status: "completed", result };
+            return { runId, callId: call.id, status: "completed", result };
         }
         catch (error) {
             if (combined.aborted && isTimeoutReason(combined.reason)) {
@@ -1270,6 +1312,20 @@ export class AgentRunner {
                         });
                         final.truncated = true;
                     }
+                    if (o.proof) {
+                        // Display only (D8): the claims of the answer that the Proof ledger does not back.
+                        try {
+                            for (const d of o.proof.divergences(sessionId, lastText))
+                                emit("proof_divergence", {
+                                    claim: d.claim,
+                                    ...(d.criterionId ? { criterionId: d.criterionId } : {}),
+                                    actual: d.actualState,
+                                });
+                        }
+                        catch {
+                            // a failed check only means no warning
+                        }
+                    }
                     emit("run_completed", final);
                     finish("completed");
                     return {

package/dist/eval/engine.d.ts

@@ -104,6 +104,7 @@ export declare const CONFIG_HASH_COVERAGE: {
     readonly tasks: "excluded";
     readonly goal: "excluded";
     readonly plan: "excluded";
+    readonly proof: "excluded";
     readonly tui: "excluded";
     readonly agents: "excluded";
     readonly web: "excluded";

package/dist/eval/engine.js

@@ -78,6 +78,7 @@ export const CONFIG_HASH_COVERAGE = {
     tasks: "excluded",
     goal: "excluded",
     plan: "excluded",
+    proof: "excluded",
     tui: "excluded",
     agents: "excluded",
     web: "excluded",
@@ -540,6 +541,8 @@ async function execute(task, opts, plan, fixtureDir) {
                 db: join(dirs.state, "sessions.sqlite"),
                 provider: effectiveProvider,
                 noHerdr: true,
+                // Hermetic: user-level skills and agents never come from the developer's real home.
+                home: dirs.home,
                 trustProject: false,
                 allowWrite: plan.policy.write,
                 allowProcess: plan.policy.process,

package/dist/eval/secrets.d.ts

@@ -10,3 +10,5 @@
 export declare function findSecrets(text: string, exact?: readonly string[]): string[];
 /** `text` with every match replaced by `[redacted]`. */
 export declare function redactSecrets(text: string, exact?: readonly string[]): string;
+/** `redactSecrets` plus generic credential assignments, for excerpts of tool output (Proof). */
+export declare function redactOutput(text: string, exact?: readonly string[]): string;

package/dist/eval/secrets.js

@@ -43,3 +43,13 @@ export function redactSecrets(text, exact = []) {
             out = out.replace(new RegExp(escape(value), "g"), "[redacted]");
     return out;
 }
+/**
+ * Generic `password=`/`TOKEN=` style assignments (also `"api_token": "..."`). Kept apart from
+ * `RULES` on purpose: a hit there REFUSES a cassette, and widening that net would change the
+ * eval harness. Meant for text that is only displayed or stored as an excerpt.
+ */
+const GENERIC_ASSIGNMENT = /\b[\w.-]*(?:password|passwd|secret|token)[\w.-]*["']?\s*[=:]\s*["']?[^\s"',;&]{3,}/gi;
+/** `redactSecrets` plus generic credential assignments, for excerpts of tool output (Proof). */
+export function redactOutput(text, exact = []) {
+    return redactSecrets(text, exact).replace(GENERIC_ASSIGNMENT, "[redacted]");
+}

package/dist/goal/command.d.ts

@@ -1,6 +1,6 @@
 /** The longest objective accepted, in characters (it is sent to the model on the kickoff). */
 export declare const GOAL_OBJECTIVE_MAX = 4000;
-export declare const GOAL_SUBCOMMANDS: readonly ["pause", "resume", "edit", "clear", "help"];
+export declare const GOAL_SUBCOMMANDS: readonly ["pause", "resume", "edit", "clear", "help", "override"];
 export type GoalCommand = {
     type: "show";
 } | {
@@ -12,6 +12,11 @@ export type GoalCommand = {
 } | {
     type: "clear";
 }
+/** The user completes the goal over unmet required Proof criteria (a reason is required). */
+ | {
+    type: "override";
+    reason: string;
+}
 /** `objective` is absent when the UI should ask for the new text. */
  | {
     type: "edit";
@@ -27,7 +32,7 @@ export type GoalCommand = {
     type: "error";
     message: string;
 };
-export declare const GOAL_USAGE = "Usage: /goal [<objective> [budget=50k]] | pause | resume | edit [<objective>] | clear | budget=<n|clear> | help";
+export declare const GOAL_USAGE = "Usage: /goal [<objective> [budget=50k]] | pause | resume | edit [<objective>] | clear | override <reason> | budget=<n|clear> | help";
 /** Markdown help shown by `/goal help` (identical on every surface). */
 export declare const GOAL_HELP: string;
 /** Words of `args` split on whitespace, keeping the original spacing of the objective. */

package/dist/goal/command.js

@@ -5,14 +5,15 @@
  *   /goal <objective> [budget=N]  create (or replace) the goal and start working on it
  *   /goal pause | resume | clear | help
  *   /goal edit [<objective>]      change the objective of the current goal
+ *   /goal override <reason>       complete the goal over unmet required Proof criteria (you only)
  *   /goal budget=50k              set the token budget of the current goal (budget=clear removes it)
  */
 import { parseTokenBudget } from "./budget.js";
 /** The longest objective accepted, in characters (it is sent to the model on the kickoff). */
 export const GOAL_OBJECTIVE_MAX = 4000;
-export const GOAL_SUBCOMMANDS = ["pause", "resume", "edit", "clear", "help"];
+export const GOAL_SUBCOMMANDS = ["pause", "resume", "edit", "clear", "help", "override"];
 const BUDGET_WORD = /^budget=(.*)$/i;
-export const GOAL_USAGE = "Usage: /goal [<objective> [budget=50k]] | pause | resume | edit [<objective>] | clear | budget=<n|clear> | help";
+export const GOAL_USAGE = "Usage: /goal [<objective> [budget=50k]] | pause | resume | edit [<objective>] | clear | override <reason> | budget=<n|clear> | help";
 /** Markdown help shown by `/goal help` (identical on every surface). */
 export const GOAL_HELP = [
     "**/goal** keeps the agent working on one objective until it is done, blocked, paused or out of budget.",
@@ -22,6 +23,7 @@ export const GOAL_HELP = [
     "- `/goal <objective> budget=50k` also sets a token budget (`50k`, `1.5M`, `250000`).",
     "- `/goal pause` stops the automatic continuation; `/goal resume` continues a paused or blocked goal.",
     "- `/goal edit <objective>` changes the objective; `/goal clear` removes the goal.",
+    "- `/goal override <reason>` completes the goal over acceptance criteria that are not verified (Proof); only you can, and the reason is kept.",
     "- `/goal budget=50k` sets the token budget; `/goal budget=clear` (also `none`, `off`, `0`) removes it.",
     "",
     `The objective can be up to ${GOAL_OBJECTIVE_MAX} characters. Only you pause, resume, edit or clear a goal or change its budget; the agent marks it complete or blocked, with evidence.`,
@@ -62,6 +64,12 @@ export function parseGoalCommand(args) {
                 return { type: "edit" };
             return validateObjective(objective, (value) => ({ type: "edit", objective: value }));
         }
+        if (subcommand === "override") {
+            const reason = text.slice(text.search(/\s/) + 1).trim();
+            if (rest.length === 1)
+                return { type: "error", message: "/goal override needs a reason." };
+            return { type: "override", reason };
+        }
         if (rest.length > 1)
             return {
                 type: "error",

package/dist/goal/format.js

@@ -28,10 +28,12 @@ const REASON_TEXT = {
     max_wall: "The time limit was reached",
     no_progress: "No progress",
     restart: "Alisio restarted while the goal was running",
+    user_override: "You completed the goal over unmet acceptance criteria",
 };
 const DETAIL_TEXT = {
     repeated_reply: "the same reply repeated",
     no_tool_turns: "several turns without tool calls",
+    completion_refused: "completion was refused while required criteria were not verified",
 };
 /** Why the goal is in its state, as one short sentence (empty when there is nothing to say). */
 export function goalReasonText(goal) {

package/dist/goal/machine.d.ts

@@ -9,12 +9,14 @@
  *              └──── budget raised / cleared (token_budget only) ── budget_limited
  *
  * Who may do what:
- * - user:   create, pause, resume (paused|blocked), edit, clear, change the budget.
- * - model:  `update_goal` complete / blocked, only while the goal is `active`.
+ * - user:   create, pause, resume (paused|blocked), edit, clear, change the budget, and the Proof
+ *           override (complete over unmet required criteria; never reachable from the model).
+ * - model:  `update_goal` complete / blocked, only while the goal is `active`. `complete` is
+ *           refused while a required criterion of the Proof ledger is failed or not checked.
  * - system: the caps and breakers (pause / budget_limited / blocked on error), user interrupt,
  *           restart. The system never resumes a goal.
  */
-import type { GoalAction, GoalEvidence, GoalInfo, GoalReason, GoalStatus } from "@alisio/sdk";
+import type { GoalAction, GoalEvidence, GoalInfo, GoalProofInfo, GoalReason, GoalStatus, ProofCriterion, ProofLedger } from "@alisio/sdk";
 export type GoalActor = "user" | "model" | "system";
 export declare const GOAL_STATUSES: readonly GoalStatus[];
 /** The longest `detail` kept (an error text is truncated). */
@@ -40,6 +42,8 @@ export interface GoalRecord {
     detail?: string;
     summary?: string;
     evidence?: GoalEvidence[];
+    /** The Proof snapshot taken when the goal completed with criteria (absent without criteria). */
+    proof?: GoalProofInfo;
     epoch: number;
     tokenBudget?: number;
     tokensUsed: number;
@@ -104,6 +108,12 @@ export declare function userActions(status: GoalStatus): GoalAction[];
 export declare const isFinalGoalStatus: (status: GoalStatus) => boolean;
 export declare const clip: (text: string, max?: number) => string;
 export type GoalRefusal = "not_allowed" | "not_active";
+/** A required criterion that blocks completion (`failed` or `not_checked`). */
+export interface GoalUnmet {
+    criterionId: string;
+    text: string;
+    status: "failed" | "not_checked";
+}
 export type GoalResult<T = GoalRecord> = {
     ok: true;
     goal: T;
@@ -111,7 +121,23 @@ export type GoalResult<T = GoalRecord> = {
     ok: false;
     code: GoalRefusal;
     message: string;
+    unmet?: GoalUnmet[];
 };
+/**
+ * What the Proof ledger says about one goal (specs/011 3.6): the criteria that apply to it and
+ * the evidence ids the model declared that resolved to captured evidence.
+ */
+export interface GoalProofInput {
+    criteria: ProofCriterion[];
+    linkedEvidence: string[];
+}
+/** The criteria that apply to a goal: its own and the session-wide ones (no `goalId`). */
+export declare const criteriaForGoal: (ledger: ProofLedger, goalId: string) => ProofCriterion[];
+/**
+ * Required criteria that are `failed` or `not_checked`. `manual_review` and `not_applicable` do
+ * not block (O6 names only the first two; a manual review is the user's own call).
+ */
+export declare function unmetRequired(criteria: readonly ProofCriterion[]): GoalUnmet[];
 /** A new goal (the user's `/goal <objective>`). The caller supplies the id and the limits. */
 export declare function newGoal(input: {
     sessionId: string;
@@ -145,6 +171,27 @@ export declare function userBudget(goal: GoalRecord, now: number, tokens: number
 export declare function modelComplete(goal: GoalRecord, now: number, report: {
     summary: string;
     evidence: GoalEvidence[];
+}, proof?: GoalProofInput): GoalResult;
+/** Different runs that may be refused a completion over the ledger before the goal pauses. */
+export declare const COMPLETION_REFUSAL_LIMIT = 3;
+/**
+ * A model that keeps reporting `complete` over unmet required criteria, run after run, is not
+ * making progress: the goal pauses as `no_progress` (the user resumes or overrides it). The caller
+ * counts the refusals; the in-flight claim stays so the running turn still settles.
+ */
+export declare function pauseForRefusedCompletions(goal: GoalRecord, now: number): GoalRecord;
+/** The longest override reason kept. */
+export declare const GOAL_OVERRIDE_REASON_MAX = 500;
+/**
+ * The USER completes a goal over unmet required criteria (O6). It exists only to bypass that
+ * gate: with nothing unmet there is nothing to override. Only a goal that can still be worked
+ * on (`active`, `paused`, `blocked`) can be overridden; `budget_limited` and `complete` are final
+ * (raise the budget first). The in-flight claim stays, as for a model completion: the running
+ * turn still settles. The caller (the service) has already checked that a person asked for it.
+ */
+export declare function userOverrideComplete(goal: GoalRecord, now: number, input: {
+    reason: string;
+    proof: GoalProofInput;
 }): GoalResult;
 export interface BlockedReport {
     summary: string;