@alisio/core 0.6.0 → 0.8.0

package/dist/eval/verifiers.js

@@ -0,0 +1,264 @@
+/**
+ * Deterministic, local verifiers of the reliability lab (specs/010 D4). A verifier answers
+ * `pass`, `fail` or `error`; `error` means it could not run (bad path, missing input, command that
+ * cannot start) and is never folded into `fail`. Details never echo file contents.
+ *
+ * `command` runs a subprocess with a clean environment and a timeout. A subprocess is NOT a
+ * sandbox: suites are trusted repository code and the command runs with the user's privileges.
+ */
+import { spawn } from "node:child_process";
+import { createHash } from "node:crypto";
+import { existsSync, lstatSync, readdirSync, readFileSync, readlinkSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { EvalPathError, resolveInside, unsafeRelativeReason } from "./paths.js";
+const IGNORED_DIRS = new Set([".git", "node_modules"]);
+const MAX_COMMAND_OUTPUT = 1_000_000;
+const sha256 = (data) => createHash("sha256").update(data).digest("hex");
+/**
+ * Hashes every file under `dir` (symlinks by their target text, never followed). `.git` and
+ * `node_modules` are skipped at any depth: they are tooling state, not task output.
+ */
+export function snapshotTree(dir) {
+    const files = {};
+    const walk = (current, prefix) => {
+        for (const entry of readdirSync(current, { withFileTypes: true })) {
+            const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
+            const full = join(current, entry.name);
+            if (entry.isSymbolicLink())
+                files[rel] = sha256(`symlink:${readlinkSync(full)}`);
+            else if (entry.isDirectory()) {
+                if (!IGNORED_DIRS.has(entry.name))
+                    walk(full, rel);
+            }
+            else if (entry.isFile())
+                files[rel] = sha256(readFileSync(full));
+        }
+    };
+    walk(dir, "");
+    const hash = sha256(Object.keys(files)
+        .sort()
+        .map((path) => `${path}\0${files[path]}`)
+        .join("\n"));
+    return { files, hash };
+}
+const result = (v, status, detail) => ({
+    id: v.id,
+    status,
+    ...(detail === undefined ? {} : { detail }),
+});
+function isMissing(error) {
+    return error?.code === "ENOENT";
+}
+function runCommand(v, cwd, tmpDir) {
+    return new Promise((resolve) => {
+        const [bin, ...args] = v.command;
+        if (bin === undefined)
+            return resolve(result(v, "error", "command is empty."));
+        if (!existsSync(cwd) || !statSync(cwd).isDirectory())
+            return resolve(result(v, "error", "working directory does not exist."));
+        const env = { PATH: process.env.PATH ?? "", NODE_NO_WARNINGS: "1" };
+        if (process.env.SystemRoot)
+            env.SystemRoot = process.env.SystemRoot;
+        if (tmpDir) {
+            env.HOME = tmpDir;
+            env.TMPDIR = tmpDir;
+        }
+        let stdout = "";
+        let timedOut = false;
+        let settled = false;
+        const done = (value) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolve(value);
+        };
+        // The child leads its own process group (POSIX) so a timeout can stop grandchildren too.
+        const detached = process.platform !== "win32";
+        const child = spawn(bin, args, {
+            cwd,
+            env,
+            stdio: ["ignore", "pipe", "ignore"],
+            shell: false,
+            detached,
+        });
+        const timer = setTimeout(() => {
+            timedOut = true;
+            try {
+                if (detached && child.pid !== undefined)
+                    process.kill(-child.pid, "SIGKILL");
+                else
+                    child.kill("SIGKILL");
+            }
+            catch {
+                child.kill("SIGKILL");
+            }
+        }, v.timeoutMs);
+        child.stdout.on("data", (chunk) => {
+            if (stdout.length < MAX_COMMAND_OUTPUT)
+                stdout += chunk.toString("utf8");
+        });
+        child.on("error", (error) => done(result(v, "error", `command could not start: ${error.message}`)));
+        child.on("close", (code, signal) => {
+            // The command is the task's own check running agent-written code: a hang is the agent's
+            // failure, not an infrastructure error (a command that cannot start stays `error`).
+            if (timedOut)
+                return done(result(v, "fail", `command timed out after ${v.timeoutMs} ms.`));
+            const expected = v.expectExit ?? 0;
+            if (code !== expected)
+                return done(result(v, "fail", signal ? `terminated by ${signal}.` : `exit ${code}, expected exit ${expected}.`));
+            if (v.expectStdoutIncludes !== undefined && !stdout.includes(v.expectStdoutIncludes))
+                return done(result(v, "fail", "stdout does not include the expected text."));
+            done(result(v, "pass"));
+        });
+    });
+}
+function readTarget(path) {
+    try {
+        return { data: readFileSync(path) };
+    }
+    catch (error) {
+        if (isMissing(error))
+            return { missing: true };
+        throw error;
+    }
+}
+function diffTree(baseline, current) {
+    const added = [];
+    const deleted = [];
+    const modified = [];
+    for (const [path, hash] of Object.entries(current.files)) {
+        const before = baseline.files[path];
+        if (before === undefined)
+            added.push(path);
+        else if (before !== hash)
+            modified.push(path);
+    }
+    for (const path of Object.keys(baseline.files))
+        if (!(path in current.files))
+            deleted.push(path);
+    return { added, deleted, modified };
+}
+/** `a/b.ts` allows exactly that file; `a/` allows everything below the directory `a`. */
+const isAllowed = (path, allowed) => allowed.some((entry) => (entry.endsWith("/") ? path.startsWith(entry) : path === entry));
+function checkSequence(rule, events) {
+    switch (rule.type) {
+        case "before": {
+            const firstAt = events.findIndex((e) => e.tool === rule.first);
+            const thenAt = events.findIndex((e) => e.tool === rule.then);
+            if (thenAt === -1)
+                return { ok: true };
+            return firstAt !== -1 && firstAt < thenAt
+                ? { ok: true }
+                : { ok: false, detail: `"${rule.then}" was called without a prior "${rule.first}".` };
+        }
+        case "never":
+            return events.some((e) => e.tool === rule.tool)
+                ? { ok: false, detail: `"${rule.tool}" must never be called.` }
+                : { ok: true };
+        case "max-calls": {
+            const calls = events.filter((e) => e.tool === rule.tool).length;
+            return calls > rule.max
+                ? { ok: false, detail: `"${rule.tool}" was called ${calls} times, maximum ${rule.max}.` }
+                : { ok: true };
+        }
+        case "no-repeat-failure": {
+            const failed = new Set();
+            for (const e of events) {
+                if (e.tool !== rule.tool)
+                    continue;
+                const key = e.argsKey ?? "";
+                if (failed.has(key))
+                    return {
+                        ok: false,
+                        detail: `"${rule.tool}" repeated an identical call that had failed.`,
+                    };
+                if (!e.ok)
+                    failed.add(key);
+            }
+            return { ok: true };
+        }
+    }
+}
+async function evaluate(v, ctx) {
+    switch (v.kind) {
+        case "command":
+            return runCommand(v, ctx.cwd, ctx.tmpDir);
+        case "file-equals": {
+            const target = readTarget(resolveInside(ctx.cwd, v.path, "path"));
+            if ("missing" in target)
+                return result(v, "fail", `${v.path} does not exist.`);
+            return sha256(target.data) === v.sha256.toLowerCase()
+                ? result(v, "pass")
+                : result(v, "fail", `${v.path} sha256 differs from the expected value.`);
+        }
+        case "file-contains": {
+            const target = readTarget(resolveInside(ctx.cwd, v.path, "path"));
+            if ("missing" in target)
+                return result(v, "fail", `${v.path} does not exist.`);
+            return target.data.toString("utf8").includes(v.text)
+                ? result(v, "pass")
+                : result(v, "fail", `${v.path} does not contain the expected text.`);
+        }
+        case "file-absent": {
+            const absolute = resolveInside(ctx.cwd, v.path, "path");
+            try {
+                lstatSync(absolute);
+            }
+            catch (error) {
+                if (isMissing(error))
+                    return result(v, "pass");
+                throw error;
+            }
+            return result(v, "fail", `${v.path} exists.`);
+        }
+        case "tree-diff-within": {
+            if (!ctx.baseline)
+                return result(v, "error", "no fixture snapshot was provided to compare against.");
+            for (const entry of v.allowed) {
+                const reason = unsafeRelativeReason(entry);
+                if (reason)
+                    return result(v, "error", `allowed entry "${entry}" ${reason}.`);
+            }
+            const { added, deleted, modified } = diffTree(ctx.baseline, snapshotTree(ctx.cwd));
+            const outside = (paths) => paths.filter((p) => !isAllowed(p, v.allowed)).sort();
+            const parts = [
+                ["modified", outside(modified)],
+                ["added", outside(added)],
+                ["deleted", outside(deleted)],
+            ]
+                .filter(([, paths]) => paths.length > 0)
+                .map(([label, paths]) => `${label}: ${paths.join(", ")}`);
+            return parts.length === 0
+                ? result(v, "pass")
+                : result(v, "fail", `changes outside the allowed list (${parts.join("; ")}).`);
+        }
+        case "tool-sequence": {
+            if (!ctx.toolEvents)
+                return result(v, "error", "no tool events were recorded for this run.");
+            const checked = checkSequence(v.rule, ctx.toolEvents);
+            return checked.ok ? result(v, "pass") : result(v, "fail", checked.detail);
+        }
+        default:
+            return result(v, "error", `unknown verifier kind "${v.kind}".`);
+    }
+}
+/** Runs one verifier; anything that prevents a verdict (including exceptions) is `error`. */
+export async function runVerifier(v, ctx) {
+    try {
+        return await evaluate(v, ctx);
+    }
+    catch (error) {
+        const detail = error instanceof EvalPathError
+            ? error.message
+            : `verifier could not run: ${error.code ?? error.message}`;
+        return result(v, "error", detail);
+    }
+}
+/** Runs the verifiers in order (sequentially: `command` verifiers may share the working directory). */
+export async function runVerifiers(verifiers, ctx) {
+    const results = [];
+    for (const v of verifiers)
+        results.push(await runVerifier(v, ctx));
+    return results;
+}

package/dist/forge/javascript/hosts/worker-host.d.ts

@@ -2,6 +2,15 @@ import type { IsolateHost, IsolateSession } from "../../ports.ts";
 export declare const WORKER_TERMINATE_AFTER_MS = 50;
 /** The worker entry next to this file: `.ts` when running from sources, `.js` from `dist`. */
 export declare function workerEntryUrl(base?: string): URL;
+/**
+ * Node flags for the worker. A `.ts` entry (running from sources) needs type stripping, which Node
+ * enables by default only from 22.18; on 22.16-22.17 the worker would fail to load its entry. Bun
+ * runs TypeScript natively.
+ */
+export declare function workerExecArgv(entry: URL, runtime?: {
+    bun?: string;
+    typescript?: unknown;
+}): string[];
 export interface WorkerHostOptions {
     module: WebAssembly.Module;
     /** Overrides the entry (tests of failure paths). */

package/dist/forge/javascript/hosts/worker-host.js

@@ -17,6 +17,19 @@ export function workerEntryUrl(base = import.meta.url) {
     const extension = base.endsWith(".ts") ? "ts" : "js";
     return new URL(`./worker-entry.${extension}`, base);
 }
+/**
+ * Node flags for the worker. A `.ts` entry (running from sources) needs type stripping, which Node
+ * enables by default only from 22.18; on 22.16-22.17 the worker would fail to load its entry. Bun
+ * runs TypeScript natively.
+ */
+export function workerExecArgv(entry, runtime = {
+    bun: process.versions.bun,
+    typescript: process.features.typescript,
+}) {
+    if (!entry.pathname.endsWith(".ts") || runtime.bun || runtime.typescript)
+        return [];
+    return ["--experimental-strip-types", "--disable-warning=ExperimentalWarning"];
+}
 export class WorkerIsolateHost {
     kind = "worker";
     #options;
@@ -31,8 +44,10 @@ export class WorkerIsolateHost {
             module: this.#options.module,
             flag: flagBuffer,
         };
-        const worker = new Worker(this.#options.entry ?? workerEntryUrl(), {
+        const entry = this.#options.entry ?? workerEntryUrl();
+        const worker = new Worker(entry, {
             workerData: data,
+            execArgv: workerExecArgv(entry),
             env: {},
             stdout: true,
             stderr: true,

package/dist/forge/kernel.js

@@ -9,7 +9,8 @@
  * deadline and cancellation with the host's OWN clock, the output bound and the single terminal
  * state. The engine only knows how to run code in an isolate.
  */
-import { createHash, randomUUID } from "node:crypto";
+import { createHash } from "node:crypto";
+import { newUuid } from "../runtime/ids.js";
 import { CapabilityBroker } from "./broker.js";
 import { BudgetLedger } from "./budget.js";
 import { ForgeError, isForgeError } from "./errors.js";
@@ -42,7 +43,7 @@ export class ExecutionKernel {
         const now = deps.now ?? Date.now;
         const call = invocation.call;
         const startedAt = now();
-        const id = (deps.newId ?? (() => `fx_${randomUUID()}`))();
+        const id = (deps.newId ?? (() => `fx_${newUuid()}`))();
         const config = deps.config();
         const descriptors = deps.engines.descriptors();
         const language = invocation.language ?? "javascript";

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;

package/dist/goal/machine.js

@@ -44,11 +44,46 @@ function moveTo(goal, now, status, reason, extra = {}) {
         ...extra,
     }, true);
 }
-const refuse = (code, message) => ({
+const refuse = (code, message, unmet) => ({
     ok: false,
     code,
     message,
+    ...(unmet ? { unmet } : {}),
 });
+/** The criteria that apply to a goal: its own and the session-wide ones (no `goalId`). */
+export const criteriaForGoal = (ledger, goalId) => ledger.criteria.filter((c) => c.goalId === undefined || c.goalId === goalId);
+/**
+ * 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 function unmetRequired(criteria) {
+    const unmet = [];
+    for (const c of criteria)
+        if (c.required && (c.status === "failed" || c.status === "not_checked"))
+            unmet.push({ criterionId: c.criterionId, text: c.text, status: c.status });
+    return unmet;
+}
+const proofInfo = (proof, unmet, override) => ({
+    criteria: proof.criteria.map((c) => ({
+        criterionId: c.criterionId,
+        required: c.required,
+        status: c.status,
+    })),
+    unmet: unmet.map((u) => u.criterionId),
+    linkedEvidence: [...new Set(proof.linkedEvidence)],
+    ...(override ? { override } : {}),
+});
+const UNMET_LISTED = 5;
+const unmetMessage = (unmet) => {
+    const listed = unmet
+        .slice(0, UNMET_LISTED)
+        .map((u) => `"${clip(u.text, 80)}" (${u.status})`)
+        .join(", ");
+    const more = unmet.length > UNMET_LISTED ? ` and ${unmet.length - UNMET_LISTED} more` : "";
+    return (`Completion refused: required acceptance criteria are not verified: ${listed}${more}. ` +
+        "Run their verifiers and report again, or report the goal blocked. Only the user can " +
+        "override this.");
+};
 /** A new goal (the user's `/goal <objective>`). The caller supplies the id and the limits. */
 export function newGoal(input) {
     return {
@@ -146,17 +181,59 @@ export function userBudget(goal, now, tokens, ownerPid) {
  * The model reports the goal complete. Evidence is mandatory, and only an `active` goal can be
  * completed (a goal the user paused stays paused).
  */
-export function modelComplete(goal, now, report) {
+export function modelComplete(goal, now, report, proof) {
     if (goal.status !== "active")
         return refuse("not_active", `The goal is ${goal.status}; only an active goal can be completed.`);
     if (!report.evidence.length)
         return refuse("not_allowed", "Completion needs evidence (files, tests, logs or commands).");
+    // O6: with criteria the ledger decides, not the model's declaration (free text backs nothing).
+    const unmet = proof ? unmetRequired(proof.criteria) : [];
+    if (unmet.length)
+        return refuse("not_allowed", unmetMessage(unmet), unmet);
     return {
         ok: true,
         goal: moveTo(goal, now, "complete", "model_complete", {
             summary: report.summary,
             evidence: report.evidence,
             inflight: goal.inflight,
+            ...(proof?.criteria.length ? { proof: proofInfo(proof, unmet) } : {}),
+        }),
+    };
+}
+/** Different runs that may be refused a completion over the ledger before the goal pauses. */
+export 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 function pauseForRefusedCompletions(goal, now) {
+    return moveTo(goal, now, "paused", "no_progress", {
+        detail: "completion_refused",
+        inflight: goal.inflight,
+    });
+}
+/** The longest override reason kept. */
+export 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 function userOverrideComplete(goal, now, input) {
+    if (goal.status !== "active" && goal.status !== "paused" && goal.status !== "blocked")
+        return refuse("not_allowed", `The goal is ${goal.status}; only an active, paused or blocked goal can be overridden.`);
+    const unmet = unmetRequired(input.proof.criteria);
+    if (!unmet.length)
+        return refuse("not_allowed", "Nothing to override: no required criterion is failed or not checked.");
+    const reason = clip(input.reason.trim(), GOAL_OVERRIDE_REASON_MAX);
+    return {
+        ok: true,
+        goal: moveTo(goal, now, "complete", "user_override", {
+            proof: proofInfo(input.proof, unmet, { reason, at: now }),
+            inflight: goal.inflight,
         }),
     };
 }
@@ -336,6 +413,7 @@ export function toGoalInfo(goal) {
         maxWallMs: goal.maxWallMs,
         ...(goal.summary ? { summary: goal.summary } : {}),
         ...(goal.evidence?.length ? { evidence: goal.evidence } : {}),
+        ...(goal.proof ? { proof: goal.proof } : {}),
         actions: userActions(goal.status),
         createdAt: goal.createdAt,
         updatedAt: goal.updatedAt,