@alisio/core 0.7.0 → 0.8.0

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,

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

@@ -70,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";

package/dist/index.js

@@ -69,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";

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;