@alisio/core 0.6.0 → 0.8.0

package/dist/goal/service.d.ts

@@ -1,6 +1,6 @@
-import type { GoalEvidence, GoalInfo, GoalWaiting } from "@alisio/sdk";
+import type { GoalEvidence, GoalInfo, GoalWaiting, ProofLedger } from "@alisio/sdk";
 import { type GoalBlocker, type GoalHostState } from "./blockers.ts";
-import { type GoalLimits, type GoalLog, type GoalRecord, type GoalRunOutcome } from "./machine.ts";
+import { type GoalLimits, type GoalLog, type GoalRecord, type GoalRunOutcome, type GoalUnmet } from "./machine.ts";
 import { type GoalPrompt } from "./prompts.ts";
 import { type GoalExpectation, type GoalStore } from "./store.ts";
 /** `config.goal`, as the service reads it (live: a settings change applies to the next call). */
@@ -58,6 +58,13 @@ export interface GoalServiceOptions {
     onChange?: (sessionId: string, goal: GoalRecord | undefined) => void;
     /** Breaker observations (counts only; never the objective or the reply). */
     onLog?: (sessionId: string, log: GoalLog) => void;
+    /**
+     * Where the Proof ledger comes from (`ProofStore` fits). Without it criteria do not exist for
+     * the goal: completion behaves as in 0.7.x and a declared `evidenceId` is dropped.
+     */
+    proof?: {
+        ledger(sessionId: string): ProofLedger;
+    };
 }
 export declare class GoalService {
     private readonly options;
@@ -93,6 +100,10 @@ export declare class GoalService {
     next(sessionId: string, view: GoalHostView): GoalDecision;
     /** The claimed continuation could not start: give the claim back (the next call may retry). */
     abandon(sessionId: string, requestId: string, kind: GoalPrompt["kind"]): void;
+    /** Runs whose `complete` the ledger refused, per goal (memory only: a restart pauses goals). */
+    private readonly refusals;
+    /** Records a refused completion of `runId`; true once enough different runs were refused. */
+    private refusedRuns;
     /** `update_goal` (the model): the only transitions the model can cause. */
     report(sessionId: string, runId: string | undefined, report: {
         status: "complete" | "blocked";
@@ -107,7 +118,16 @@ export declare class GoalService {
         ok: false;
         code: GoalErrorCode;
         message: string;
+        unmet?: GoalUnmet[];
     };
+    /**
+     * The USER completes the goal over unmet required criteria (O6). A separate method on purpose:
+     * `report` is the model's only door and has no way to carry an override, so the model cannot
+     * reach this path whatever it sends. Hosts call it from a user action only (Phase 5 surfaces).
+     */
+    overrideComplete(sessionId: string, input: {
+        reason: string;
+    }, expect?: GoalExpectation): GoalOutcome;
     /** Startup: goals whose driver process is gone pause with reason `restart`. */
     recover(): GoalRecord[];
 }

package/dist/goal/service.js

@@ -18,7 +18,7 @@
 import { randomUUID } from "node:crypto";
 import { goalBlocker, waitingOf } from "./blockers.js";
 import { objectiveError } from "./command.js";
-import { checkCaps, DEFAULT_GOAL_LIMITS, modelBlocked, modelComplete, newGoal, settleRun, toGoalInfo, userBudget, userEdit, userPause, userResume, } from "./machine.js";
+import { COMPLETION_REFUSAL_LIMIT, checkCaps, criteriaForGoal, DEFAULT_GOAL_LIMITS, modelBlocked, modelComplete, newGoal, pauseForRefusedCompletions, settleRun, toGoalInfo, userBudget, userEdit, userOverrideComplete, userPause, userResume, } from "./machine.js";
 import { buildGoalPrompt } from "./prompts.js";
 export const settingsToLimits = (settings) => ({
     maxTurns: settings.maxTurns,
@@ -27,6 +27,24 @@ export const settingsToLimits = (settings) => ({
     noToolTurnsLimit: settings.noToolTurnsLimit,
     blockedRepeats: settings.blockedRepeats,
 });
+/**
+ * The declared evidence with every `evidenceId` that does not resolve to captured evidence of the
+ * session removed (such a declaration is free text and backs nothing), and the ids that resolved.
+ */
+function linkEvidence(evidence, ledger) {
+    const known = new Set(ledger?.evidence.map((e) => e.evidenceId));
+    const linked = [];
+    const out = evidence.map((item) => {
+        const { evidenceId, ...rest } = item;
+        if (evidenceId === undefined)
+            return item;
+        if (!known.has(evidenceId))
+            return rest;
+        linked.push(evidenceId);
+        return item;
+    });
+    return { evidence: out, linked };
+}
 export class GoalService {
     options;
     store;
@@ -109,6 +127,9 @@ export class GoalService {
         if (!this.enabled)
             return { ok: false, code: "disabled", message: "Goals are turned off (goal.enabled)." };
         const limits = this.limits();
+        const current = this.store.get(sessionId);
+        if (current)
+            this.refusals.delete(current.goalId);
         return this.act(sessionId, expect, (goal) => userResume(goal, this.clock(), limits, this.pid));
     }
     edit(sessionId, objective, expect) {
@@ -232,17 +253,49 @@ export class GoalService {
         if (result.ok)
             this.emit(sessionId, result.goal);
     }
+    /** Runs whose `complete` the ledger refused, per goal (memory only: a restart pauses goals). */
+    refusals = new Map();
+    /** Records a refused completion of `runId`; true once enough different runs were refused. */
+    refusedRuns(goalId, runId) {
+        const runs = this.refusals.get(goalId) ?? new Set();
+        runs.add(runId);
+        this.refusals.set(goalId, runs);
+        if (runs.size < COMPLETION_REFUSAL_LIMIT)
+            return false;
+        this.refusals.delete(goalId);
+        return true;
+    }
     /** `update_goal` (the model): the only transitions the model can cause. */
     report(sessionId, runId, report) {
         const limits = this.limits();
         const outcome = this.store.update(sessionId, (goal) => {
+            // The ledger is read inside this transaction, so the verdict and the write see one state.
+            // Only a completion, or a declaration that links evidence, needs it (D7: no extra reads).
+            const needsLedger = report.status === "complete" || report.evidence.some((e) => e.evidenceId !== undefined);
+            const ledger = needsLedger ? this.options.proof?.ledger(sessionId) : undefined;
+            const linked = linkEvidence(report.evidence, ledger);
             if (report.status === "complete") {
-                const result = modelComplete(goal, this.clock(), report);
-                return result.ok
-                    ? { goal: result.goal, value: { ok: true, stopped: true, needed: undefined } }
-                    : { value: { ok: false, message: result.message } };
+                const proof = ledger
+                    ? { criteria: criteriaForGoal(ledger, goal.goalId), linkedEvidence: linked.linked }
+                    : undefined;
+                const result = modelComplete(goal, this.clock(), { summary: report.summary, evidence: linked.evidence }, proof);
+                if (result.ok)
+                    return { goal: result.goal, value: { ok: true, stopped: true, needed: undefined } };
+                // A refusal over the ledger counts per run; the third run that tries pauses the goal.
+                if (result.unmet?.length && runId && this.refusedRuns(goal.goalId, runId)) {
+                    return {
+                        goal: pauseForRefusedCompletions(goal, this.clock()),
+                        value: {
+                            ok: false,
+                            message: `${result.message} The goal is paused: completion was refused in ${COMPLETION_REFUSAL_LIMIT} different runs. The user decides: resume, or complete it with an override.`,
+                            unmet: result.unmet,
+                            paused: true,
+                        },
+                    };
+                }
+                return { value: { ok: false, message: result.message, unmet: result.unmet } };
             }
-            const result = modelBlocked(goal, this.clock(), { summary: report.summary, evidence: report.evidence, runId }, limits);
+            const result = modelBlocked(goal, this.clock(), { summary: report.summary, evidence: linked.evidence, runId }, limits);
             return result.ok
                 ? {
                     goal: result.goal.goal,
@@ -253,8 +306,15 @@ export class GoalService {
         if (!outcome.ok)
             return { ok: false, code: outcome.code, message: outcome.message };
         const value = outcome.value;
+        if (!value.ok && value.paused)
+            this.emit(sessionId, outcome.goal);
         if (!value.ok)
-            return { ok: false, code: "not_allowed", message: value.message };
+            return {
+                ok: false,
+                code: "not_allowed",
+                message: value.message,
+                ...(value.unmet ? { unmet: value.unmet } : {}),
+            };
         this.emit(sessionId, outcome.goal);
         return {
             ok: true,
@@ -263,6 +323,33 @@ export class GoalService {
             ...(value.needed ? { needed: value.needed } : {}),
         };
     }
+    /**
+     * The USER completes the goal over unmet required criteria (O6). A separate method on purpose:
+     * `report` is the model's only door and has no way to carry an override, so the model cannot
+     * reach this path whatever it sends. Hosts call it from a user action only (Phase 5 surfaces).
+     */
+    overrideComplete(sessionId, input, expect) {
+        const reason = input.reason.trim();
+        if (!reason)
+            return { ok: false, code: "invalid", message: "An override needs a reason." };
+        const outcome = this.store.update(sessionId, (goal) => {
+            const ledger = this.options.proof?.ledger(sessionId);
+            const result = userOverrideComplete(goal, this.clock(), {
+                reason,
+                proof: {
+                    criteria: ledger ? criteriaForGoal(ledger, goal.goalId) : [],
+                    linkedEvidence: goal.proof?.linkedEvidence ?? [],
+                },
+            });
+            return result.ok ? { goal: result.goal, value: result } : { value: result };
+        }, expect);
+        if (!outcome.ok)
+            return { ok: false, code: outcome.code, message: outcome.message };
+        const result = outcome.value;
+        if (!result.ok)
+            return { ok: false, code: "not_allowed", message: result.message };
+        return this.done(sessionId, { ok: true, goal: result.goal });
+    }
     /** Startup: goals whose driver process is gone pause with reason `restart`. */
     recover() {
         const paused = this.store.pauseOrphans(this.clock());

package/dist/goal/store.js

@@ -13,6 +13,24 @@ function parseEvidence(raw) {
         return undefined;
     }
 }
+function parseProof(raw) {
+    if (typeof raw !== "string" || !raw)
+        return undefined;
+    try {
+        const value = JSON.parse(raw);
+        return value && Array.isArray(value.criteria) && Array.isArray(value.unmet)
+            ? {
+                criteria: value.criteria,
+                unmet: value.unmet,
+                linkedEvidence: Array.isArray(value.linkedEvidence) ? value.linkedEvidence : [],
+                ...(value.override ? { override: value.override } : {}),
+            }
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 export function goalFromRow(row) {
     const status = String(row.status);
     return {
@@ -26,6 +44,7 @@ export function goalFromRow(row) {
         ...(parseEvidence(row.evidence)
             ? { evidence: parseEvidence(row.evidence) }
             : {}),
+        ...(parseProof(row.proof_json) ? { proof: parseProof(row.proof_json) } : {}),
         epoch: Number(row.epoch ?? 1),
         ...(num(row.token_budget) !== undefined
             ? { tokenBudget: num(row.token_budget) }
@@ -55,7 +74,7 @@ export function goalFromRow(row) {
 const COLUMNS = `session, goal_id, objective, status, reason, detail, summary, evidence, epoch,
   token_budget, tokens_used, turns_used, max_turns, max_wall_ms, active_ms, no_tool_streak,
   repeat_streak, last_reply_hash, blocked_streak, blocked_run, continuations, inflight,
-  last_run_id, kickoff_sent, owner_pid, created_at, updated_at, completed_at`;
+  last_run_id, kickoff_sent, owner_pid, created_at, updated_at, completed_at, proof_json`;
 export class GoalStore {
     db;
     constructor(db) {
@@ -89,8 +108,8 @@ export class GoalStore {
            continuations=excluded.continuations, inflight=excluded.inflight,
            last_run_id=excluded.last_run_id, kickoff_sent=excluded.kickoff_sent,
            owner_pid=excluded.owner_pid, updated_at=excluded.updated_at,
-           completed_at=excluded.completed_at`)
-            .run(goal.sessionId, goal.goalId, goal.objective, goal.status, goal.reason ?? null, goal.detail ?? null, goal.summary ?? null, goal.evidence?.length ? JSON.stringify(goal.evidence) : null, goal.epoch, goal.tokenBudget ?? null, goal.tokensUsed, goal.turnsUsed, goal.maxTurns, goal.maxWallMs, goal.activeMs, goal.noToolStreak, goal.repeatStreak, goal.lastReplyHash ?? null, goal.blockedStreak, goal.blockedRun ?? null, goal.continuations, goal.inflight ?? null, goal.lastRunId ?? null, goal.kickoffSent ? 1 : 0, goal.ownerPid ?? null, goal.createdAt, goal.updatedAt, goal.completedAt ?? null);
+           completed_at=excluded.completed_at, proof_json=excluded.proof_json`)
+            .run(goal.sessionId, goal.goalId, goal.objective, goal.status, goal.reason ?? null, goal.detail ?? null, goal.summary ?? null, goal.evidence?.length ? JSON.stringify(goal.evidence) : null, goal.epoch, goal.tokenBudget ?? null, goal.tokensUsed, goal.turnsUsed, goal.maxTurns, goal.maxWallMs, goal.activeMs, goal.noToolStreak, goal.repeatStreak, goal.lastReplyHash ?? null, goal.blockedStreak, goal.blockedRun ?? null, goal.continuations, goal.inflight ?? null, goal.lastRunId ?? null, goal.kickoffSent ? 1 : 0, goal.ownerPid ?? null, goal.createdAt, goal.updatedAt, goal.completedAt ?? null, goal.proof ? JSON.stringify(goal.proof) : null);
     }
     /**
      * Replaces (or creates) the goal of a session. `build` gets the previous goal, if any, so the

package/dist/index.d.ts

@@ -41,6 +41,21 @@ export { ToolRegistry } from "./core/registry.ts";
 export { RunClock } from "./core/run-clock.ts";
 export { AgentRunner, type CompactionResult, defaultTokenBudget, type RunnerOptions, type RunnerSettingsPatch, type RunOptions, } from "./core/runner.ts";
 export { CircuitBreaker, type CircuitBreakerOptions, type CircuitState, DECISION_LIMITS, DEFAULT_DECISIONS_CONFIG, type DecisionAttempt, DecisionError, type DecisionMetricEntry, DecisionMetrics, type DecisionMetricsSnapshot, type DecisionOutcome, DecisionRegistry, DecisionService, type DecisionServiceDeps, type DecisionStatus, type DecisionsConfig, formatDecisionStatsSection, formatDecisionsReport, HEALTH_TIMEOUT_MS, type RegisteredDecisionProvider, splitSupported, validateAnswers, validateRequest, } from "./decisions/index.ts";
+export { canonicalJson, hashCanonical } from "./eval/canonical.ts";
+export { CASSETTE_SUFFIX, type Cassette, type CassetteCall, CassetteFormatError, type CassetteHeader, type CassetteMeta, CassetteRecorder, CassetteWriteError, MAX_CASSETTE_BYTES, MAX_CASSETTE_DIR_BYTES, parseCassette, RecordingProvider, ReplayDivergenceError, ReplayExhausted, ReplayProvider, ReplayUnconsumedError, readCassette, serializeCassette, type WriteOptions, writeCassette, } from "./eval/cassette.ts";
+export { type Conditions, compareReports, compareVariants, EvalCompareError, type EvalComparison, type Interval, type MetricDelta, parseReport, renderComparisonMarkdown, renderVariantComparisonMarkdown, type TaskComparison, type TokenComparison, type VariantComparison, type Verdict, } from "./eval/compare.ts";
+export { CONFIG_HASH_COVERAGE, type ConfigHashExtras, checkTaskPolicy, computeConfigHash, type EvalApplication, EvalBudgetExceeded, type EvalRunMode, EvalRunRefusedError, type InvokerPermissions, type RunTaskOptions, runTask, } from "./eval/engine.ts";
+export { buildExportBundle, type EvalExportBundle, EvalExportRefusedError, type ExportContext, } from "./eval/export.ts";
+export { computeFingerprint, type FingerprintDiff, type FingerprintDiffEntry, } from "./eval/fingerprint.ts";
+export { EvalPathError, resolveInside } from "./eval/paths.ts";
+export { interleaveVariants, mulberry32, type PlannedRun, planRuns, type VariantStep, } from "./eval/plan.ts";
+export { type BuildReportOptions, buildReport, EvalReportError, estimateRunCost, lowPowerTasks, MIN_POWER_K, renderReportMarkdown, } from "./eval/report.ts";
+export { type RunEvaluationOptions, type RunEvaluationResult, type RunVariantsOptions, runEvaluation, runVariantEvaluations, } from "./eval/run-suite.ts";
+export { findSecrets, redactSecrets } from "./eval/secrets.ts";
+export { median, passAtK, passPowK, sampleVariance, wilsonInterval, } from "./eval/stats.ts";
+export { EvalSuiteError, type LoadedSuite, loadSuite, MAX_VERIFIER_TIMEOUT_MS, } from "./eval/suite.ts";
+export { applyConfigOverrides, EvalVariantError, loadVariantsFile, resolveVariants, type VariantsFile, } from "./eval/variants.ts";
+export { runVerifier, runVerifiers, snapshotTree, type ToolEvent, type TreeSnapshot, type VerifierContext, type VerifierResult, type VerifierStatus, } from "./eval/verifiers.ts";
 export { type ExtensionConflict, ExtensionRegistry } from "./extensions/registry.ts";
 export { ForgeError } from "./forge/errors.ts";
 export { downloadSize as pyodideDownloadSize, inspectPyodide, installPyodide, PyodideIntegrityError, pyodideDir, } from "./forge/python/pyodide-install.ts";
@@ -55,9 +70,10 @@ export { McpConnector, type McpServerInfo, type McpStatus, type McpToolInfo, } f
 export { describePermissionStatus, type EffectState, effectState, FULL_ACCESS_WARNING, type ModeFlags, type ModePolicy, modeFromFlags, modeToPreset, PERMISSION_MODE_TABLE, PERMISSION_MODES, PERMISSION_MODES_LOCKED, PERMISSION_USAGE, type PermissionCommand, type PermissionModeLabel, type PermissionModeSpec, parsePermissionCommand, parsePermissionMode, presetToMode, READ_ONLY_POLICY, } from "./permissions/modes.ts";
 export { DIAGRAM_MAX_BYTES, DIAGRAM_MAX_NODES, DIAGRAM_SYNTAXES, DIAGRAMS_MAX_ALLOWED, mermaidProblem, type PlanDiagram, validateDiagrams, } from "./plan/diagrams.ts";
 export { buildPlanManifest, parsePlanHeadings, slugifyHeading, } from "./plan/manifest.ts";
-export { claimApprovedPlan, currentPlan, discardApprovedPlan, IMPLEMENTATION_AGENT_ID, implementationPrompt, PLAN_CONTEXT_MAX_CHARS, PLAN_OPTIONS, PLAN_QUESTION_ID, PLAN_REVIEW_TITLE, PLAN_TEXT_KEY, type PlanFollowUp, type PlanState, type PlanStatus, planHash, readPlanState, settlePlanRun, withdrawPendingPlan, } from "./plan/state.ts";
+export { claimApprovedPlan, currentPlan, discardApprovedPlan, IMPLEMENTATION_AGENT_ID, implementationPrompt, PLAN_CONTEXT_MAX_CHARS, PLAN_CRITERIA_KEY, PLAN_OPTIONS, PLAN_QUESTION_ID, PLAN_REVIEW_TITLE, PLAN_TEXT_KEY, type PlanFollowUp, type PlanState, type PlanStatus, planHash, readPlanState, settlePlanRun, withdrawPendingPlan, } from "./plan/state.ts";
 export { discoverPlugins, type PluginEnvironment, PluginHost, type PluginHostOptions, pluginPrefix, type ViewInfo, ViewRunError, } from "./plugins/host.ts";
 export { type CliInstallOptions, cliInstall, cliUpdateAll, INSTALL_TIMEOUT_MS, type InstallPluginInput, type InstallPluginResult, type InstallRunner, installedGlobalPluginPackages, installedNpmPlugins, installPlugin, isPeerConflict, npmInstallTarget, type PluginSpec, parsePluginSpec, pluginTrustRemark, printInstallResult, registerPluginInstallTool, sanitizeNpmError, updateAllPlugins, } from "./plugins/install.ts";
+export * from "./proof/index.ts";
 export { ActiveProvider, ProviderRegistry, UnconfiguredProvider } from "./providers/registry.ts";
 export { availableProviderModels, type ProviderModelCatalog, resolveProviderModel, } from "./providers/routing.ts";
 export { maskSecret, type ProviderProfile, type ProviderSettings, ProviderSettingsStore, } from "./providers/settings.ts";
@@ -69,7 +85,7 @@ export { type ExternalDirectoryDecision, type ExternalDirectoryHandler, type Ext
 export { BlobStore, type BlobStoreOptions, BlobTooLarge } from "./runtime/blobs.ts";
 export { clipLines, unifiedPatch } from "./runtime/diff.ts";
 export { exists, fileSize, readHead, readJson, readText, which } from "./runtime/fs.ts";
-export { newId, ulid } from "./runtime/ids.ts";
+export { type IdSource, newId, newUuid, seededIdSource, setIdSource, ulid, } from "./runtime/ids.ts";
 export { defaultGlobalRoots, isPathSpec, PLUGIN_KEYWORD, resolvePluginSpec, } from "./runtime/modules.ts";
 export { findWorkspace, inside, outsideRootsMessage, safePath, workspaceKey, } from "./runtime/paths.ts";
 export { isMissingCommand, type ProcessResult, RIPGREP_INSTALL_HINT, runProcess, } from "./runtime/process.ts";

package/dist/index.js

@@ -40,6 +40,21 @@ export { ToolRegistry } from "./core/registry.js";
 export { RunClock } from "./core/run-clock.js";
 export { AgentRunner, defaultTokenBudget, } from "./core/runner.js";
 export { CircuitBreaker, DECISION_LIMITS, DEFAULT_DECISIONS_CONFIG, DecisionError, DecisionMetrics, DecisionRegistry, DecisionService, formatDecisionStatsSection, formatDecisionsReport, HEALTH_TIMEOUT_MS, splitSupported, validateAnswers, validateRequest, } from "./decisions/index.js";
+export { canonicalJson, hashCanonical } from "./eval/canonical.js";
+export { CASSETTE_SUFFIX, CassetteFormatError, CassetteRecorder, CassetteWriteError, MAX_CASSETTE_BYTES, MAX_CASSETTE_DIR_BYTES, parseCassette, RecordingProvider, ReplayDivergenceError, ReplayExhausted, ReplayProvider, ReplayUnconsumedError, readCassette, serializeCassette, writeCassette, } from "./eval/cassette.js";
+export { compareReports, compareVariants, EvalCompareError, parseReport, renderComparisonMarkdown, renderVariantComparisonMarkdown, } from "./eval/compare.js";
+export { CONFIG_HASH_COVERAGE, checkTaskPolicy, computeConfigHash, EvalBudgetExceeded, EvalRunRefusedError, runTask, } from "./eval/engine.js";
+export { buildExportBundle, EvalExportRefusedError, } from "./eval/export.js";
+export { computeFingerprint, } from "./eval/fingerprint.js";
+export { EvalPathError, resolveInside } from "./eval/paths.js";
+export { interleaveVariants, mulberry32, planRuns, } from "./eval/plan.js";
+export { buildReport, EvalReportError, estimateRunCost, lowPowerTasks, MIN_POWER_K, renderReportMarkdown, } from "./eval/report.js";
+export { runEvaluation, runVariantEvaluations, } from "./eval/run-suite.js";
+export { findSecrets, redactSecrets } from "./eval/secrets.js";
+export { median, passAtK, passPowK, sampleVariance, wilsonInterval, } from "./eval/stats.js";
+export { EvalSuiteError, loadSuite, MAX_VERIFIER_TIMEOUT_MS, } from "./eval/suite.js";
+export { applyConfigOverrides, EvalVariantError, loadVariantsFile, resolveVariants, } from "./eval/variants.js";
+export { runVerifier, runVerifiers, snapshotTree, } from "./eval/verifiers.js";
 export { ExtensionRegistry } from "./extensions/registry.js";
 export { ForgeError } from "./forge/errors.js";
 export { downloadSize as pyodideDownloadSize, inspectPyodide, installPyodide, PyodideIntegrityError, pyodideDir, } from "./forge/python/pyodide-install.js";
@@ -54,9 +69,10 @@ export { McpConnector, } from "./mcp/connector.js";
 export { describePermissionStatus, effectState, FULL_ACCESS_WARNING, modeFromFlags, modeToPreset, PERMISSION_MODE_TABLE, PERMISSION_MODES, PERMISSION_MODES_LOCKED, PERMISSION_USAGE, parsePermissionCommand, parsePermissionMode, presetToMode, READ_ONLY_POLICY, } from "./permissions/modes.js";
 export { DIAGRAM_MAX_BYTES, DIAGRAM_MAX_NODES, DIAGRAM_SYNTAXES, DIAGRAMS_MAX_ALLOWED, mermaidProblem, validateDiagrams, } from "./plan/diagrams.js";
 export { buildPlanManifest, parsePlanHeadings, slugifyHeading, } from "./plan/manifest.js";
-export { claimApprovedPlan, currentPlan, discardApprovedPlan, IMPLEMENTATION_AGENT_ID, implementationPrompt, PLAN_CONTEXT_MAX_CHARS, PLAN_OPTIONS, PLAN_QUESTION_ID, PLAN_REVIEW_TITLE, PLAN_TEXT_KEY, planHash, readPlanState, settlePlanRun, withdrawPendingPlan, } from "./plan/state.js";
+export { claimApprovedPlan, currentPlan, discardApprovedPlan, IMPLEMENTATION_AGENT_ID, implementationPrompt, PLAN_CONTEXT_MAX_CHARS, PLAN_CRITERIA_KEY, PLAN_OPTIONS, PLAN_QUESTION_ID, PLAN_REVIEW_TITLE, PLAN_TEXT_KEY, planHash, readPlanState, settlePlanRun, withdrawPendingPlan, } from "./plan/state.js";
 export { discoverPlugins, PluginHost, pluginPrefix, ViewRunError, } from "./plugins/host.js";
 export { cliInstall, cliUpdateAll, INSTALL_TIMEOUT_MS, installedGlobalPluginPackages, installedNpmPlugins, installPlugin, isPeerConflict, npmInstallTarget, parsePluginSpec, pluginTrustRemark, printInstallResult, registerPluginInstallTool, sanitizeNpmError, updateAllPlugins, } from "./plugins/install.js";
+export * from "./proof/index.js";
 export { ActiveProvider, ProviderRegistry, UnconfiguredProvider } from "./providers/registry.js";
 export { availableProviderModels, resolveProviderModel, } from "./providers/routing.js";
 export { maskSecret, ProviderSettingsStore, } from "./providers/settings.js";
@@ -68,7 +84,7 @@ export { PathAccess, } from "./runtime/access.js";
 export { BlobStore, BlobTooLarge } from "./runtime/blobs.js";
 export { clipLines, unifiedPatch } from "./runtime/diff.js";
 export { exists, fileSize, readHead, readJson, readText, which } from "./runtime/fs.js";
-export { newId, ulid } from "./runtime/ids.js";
+export { newId, newUuid, seededIdSource, setIdSource, ulid, } from "./runtime/ids.js";
 export { defaultGlobalRoots, isPathSpec, PLUGIN_KEYWORD, resolvePluginSpec, } from "./runtime/modules.js";
 export { findWorkspace, inside, outsideRootsMessage, safePath, workspaceKey, } from "./runtime/paths.js";
 export { isMissingCommand, RIPGREP_INSTALL_HINT, runProcess, } from "./runtime/process.js";

package/dist/plan/criteria.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Validation of the acceptance criteria a model proposes in `exit_plan` (specs/011 3.6, O3).
+ * Pure: no I/O. The result is a DRAFT: nothing here creates a criterion; the plan decision of
+ * the user does (`exit-plan.ts`). The model may only propose verifier kinds Alisio can run today
+ * (`command`, `file`, `data-check`, `coverage`, `plugin`, `manual`) and plain workspace-relative scopes.
+ */
+import type { PlanCriterionDraft } from "@alisio/sdk";
+export declare const CRITERIA_MAX = 20;
+export declare const CRITERION_TEXT_MAX = 500;
+export interface DroppedCriterion {
+    /** Zero-based position in the proposed list. */
+    index: number;
+    reason: string;
+}
+export interface ValidatedCriteria {
+    accepted: PlanCriterionDraft[];
+    dropped: DroppedCriterion[];
+}
+/** Turns the model's `acceptanceCriteria` input into drafts, reporting what it could not keep. */
+export declare function validateCriteriaDrafts(raw: unknown): ValidatedCriteria;
+/**
+ * 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 declare function applyCriteriaSelection(drafts: readonly PlanCriterionDraft[], raw: unknown): {
+    kept: PlanCriterionDraft[];
+    rejected: number;
+} | undefined;

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;