@cleocode/core 2026.10.18 → 2026.10.19

package/dist/goal/judge.js

@@ -1,193 +0,0 @@
-/**
- * Evidence-gate-aware goal judge (Layer 4 of SG-COGNITIVE-SUBSTRATE).
- *
- * This is CLEO's core differentiator over Claude-Code (transcript judge) and
- * Hermes (post-turn loop, still transcript-judged for fuzzy intent). For a
- * `task-completion` goal, the judge NEVER reads the transcript: it resolves the
- * target task's REAL status and re-uses the shipped ADR-051 evidence
- * infrastructure ({@link validateEvidenceForGate} +
- * {@link GATE_EVIDENCE_REQUIREMENTS} via `tasks/evidence.ts`). A goal is
- * satisfied ONLY when the task is `status === 'done'` AND every required gate
- * ({@link CRITICAL_GATES}) is backed by evidence atoms of the kinds ADR-051
- * mandates. Transcript text can never satisfy a task-completion goal.
- *
- * `fuzzy` goals — those with no machine-checkable artifact — delegate to an
- * INJECTABLE LLM judge ({@link GoalJudge}). The judge interface, not a concrete
- * model client, is the dependency, so vitest passes a deterministic mock and
- * stays fully offline/hermetic. The fuzzy path NEVER touches the evidence
- * infrastructure.
- *
- * @module @cleocode/core/goal/judge
- *
- * @epic T11290 EP-CLEO-GOAL-SYSTEM
- * @task T11378
- * @saga T11283 SG-COGNITIVE-SUBSTRATE
- * @adr ADR-051
- */
-// Re-use the EXISTING ADR-051 evidence path — do NOT re-implement atom parsing.
-// `validateEvidenceForGate` + `GATE_EVIDENCE_REQUIREMENTS` are the shipped SSoT
-// in @cleocode/contracts; `core/src/tasks/evidence.ts` is the matching core
-// surface (it imports the SAME two symbols and is the gate machinery's home).
-import { GATE_EVIDENCE_REQUIREMENTS } from '@cleocode/contracts/evidence-atom-schema.js';
-import { isTaskCompletionGoal } from '@cleocode/contracts/goal.js';
-import { getTaskAccessor } from '../store/data-accessor.js';
-// Sourced from tasks/evidence.ts so the judge sits on the canonical core
-// evidence module rather than re-deriving validation (AC: no re-implementation).
-import { checkGateEvidenceMinimum } from '../tasks/evidence.js';
-/**
- * The gates a task-completion goal demands be evidence-backed before it is
- * judged satisfied. These are the ADR-051 critical gates that reject
- * override-only evidence (`implemented` + `testsPassed`) — the same two gates
- * `cleo complete` enforces hardest. A goal that says "complete T123" therefore
- * means exactly what CLEO means by complete: code landed (commit+files) AND
- * tests proven (test-run/tool/pr), with real, validated atoms.
- *
- * @task T11378
- * @adr ADR-051
- */
-export const CRITICAL_GATES = Object.freeze([
-    'implemented',
-    'testsPassed',
-]);
-/**
- * Judge a goal and return a uniform {@link GoalJudgeVerdict}.
- *
- * Routing:
- * - `task-completion` → {@link judgeTaskCompletion} (evidence path, no LLM).
- * - `fuzzy`           → the injected {@link GoalJudge} (LLM fallback).
- *
- * The `llmJudge` is REQUIRED only for fuzzy goals; a task-completion goal never
- * calls it. Passing the judge by parameter (dependency injection) is what keeps
- * vitest hermetic.
- *
- * @param goal - The goal under evaluation.
- * @param llmJudge - The injectable LLM judge used for fuzzy goals.
- * @param cwd - Project root override for task lookup.
- * @returns The verdict (same shape for both paths).
- * @task T11378
- */
-export async function judgeGoal(goal, llmJudge, cwd) {
-    if (isTaskCompletionGoal(goal.goalKind)) {
-        return judgeTaskCompletion(goal.goalKind.targetTaskId, cwd);
-    }
-    // Fuzzy goal — delegate to the injected LLM judge. No evidence path touched.
-    return llmJudge.judge(goal);
-}
-/**
- * Evidence-gate-aware judgement for a single task-completion goal.
- *
- * Decision table (first match wins):
- * 1. Task not found → `impossible` (the goal references a task that no longer
- *    exists).
- * 2. Task `cancelled` / `archived` → `impossible` (terminal non-done state —
- *    it can never become `done`).
- * 3. Task not `done` → `ok: false` (still in flight; reason carries the real
- *    status so the continuation tells the agent what remains).
- * 4. Task `done` but a critical gate lacks the ADR-051-required evidence atoms
- *    → `ok: false` (done-without-proof is NOT satisfied — the whole point).
- * 5. Task `done` AND every critical gate is evidence-backed → `ok: true`.
- *
- * @param targetTaskId - The task the goal wants completed.
- * @param cwd - Project root override.
- * @returns The verdict, with `evidence[]` listing the atom kinds inspected.
- * @task T11378
- * @adr ADR-051
- */
-export async function judgeTaskCompletion(targetTaskId, cwd) {
-    const accessor = await getTaskAccessor(cwd);
-    const task = await accessor.loadSingleTask(targetTaskId);
-    if (!task) {
-        return {
-            ok: false,
-            impossible: true,
-            reason: `Goal target ${targetTaskId} does not exist — it cannot be completed.`,
-        };
-    }
-    if (task.status === 'cancelled' || task.status === 'archived') {
-        return {
-            ok: false,
-            impossible: true,
-            reason: `Goal target ${targetTaskId} is ${task.status} — a terminal non-done state; it can never be completed.`,
-        };
-    }
-    if (task.status !== 'done') {
-        return {
-            ok: false,
-            impossible: false,
-            reason: `Goal target ${targetTaskId} is ${task.status}, not done. Continue working until it reaches done with evidence-backed gates.`,
-        };
-    }
-    // Task IS done — but "done" alone is not enough. Re-use the ADR-051 evidence
-    // path via the core-side `checkGateEvidenceMinimum`, which filters `override`
-    // atoms and delegates to `validateEvidenceForGate` (the contracts SSoT). Every
-    // critical gate MUST be backed by atoms of the required kinds.
-    const verification = task.verification;
-    const evidenceByGate = verification?.evidence ?? {};
-    const inspectedAtomKinds = [];
-    const unbacked = [];
-    for (const gate of CRITICAL_GATES) {
-        const gateEvidence = evidenceByGate[gate];
-        const atoms = gateEvidence?.atoms ?? [];
-        for (const atom of atoms)
-            inspectedAtomKinds.push(`${gate}:${atom.kind}`);
-        const failure = checkGateEvidenceMinimum(gate, atoms);
-        if (failure !== null) {
-            unbacked.push(`${gate} (${failure})`);
-        }
-    }
-    if (unbacked.length > 0) {
-        return {
-            ok: false,
-            impossible: false,
-            reason: `Goal target ${targetTaskId} is done but its evidence gates are not satisfied: ` +
-                `${unbacked.join('; ')}. A goal is satisfied only when the task is done AND its ` +
-                `critical gates (${CRITICAL_GATES.join(', ')}) carry valid ADR-051 evidence atoms.`,
-            evidence: inspectedAtomKinds,
-        };
-    }
-    return {
-        ok: true,
-        impossible: false,
-        reason: `Goal target ${targetTaskId} is done and its critical gates (${CRITICAL_GATES.join(', ')}) are evidence-backed.`,
-        evidence: inspectedAtomKinds,
-    };
-}
-/**
- * A deterministic, offline {@link GoalJudge} that always returns a fixed
- * verdict. Wired in tests (and as a safe default in non-LLM contexts) so the
- * fuzzy path is fully exercised without a live model call.
- *
- * Production wires a real LLM-backed implementation of {@link GoalJudge}; this
- * stub exists so the goal loop has a hermetic fallback and so the gate
- * `GATE_EVIDENCE_REQUIREMENTS` import stays referenced for downstream tooling.
- *
- * @task T11378
- */
-export class StaticGoalJudge {
-    verdict;
-    /**
-     * @param verdict - The verdict every {@link judge} call returns.
-     */
-    constructor(verdict) {
-        this.verdict = verdict;
-    }
-    /**
-     * Return the configured verdict, ignoring the goal entirely (deterministic).
-     *
-     * @param _goal - The goal under evaluation (unused — deterministic stub).
-     * @returns The fixed verdict.
-     */
-    async judge(_goal) {
-        return this.verdict;
-    }
-}
-/**
- * The number of distinct critical gates the evidence judge inspects. Exposed so
- * callers/tests can assert the judge consulted the full {@link CRITICAL_GATES}
- * set without hard-coding the count, and to keep {@link GATE_EVIDENCE_REQUIREMENTS}
- * referenced as the SSoT the judge validates against.
- *
- * @task T11378
- */
-export const CRITICAL_GATE_COUNT = CRITICAL_GATES.filter((gate) => GATE_EVIDENCE_REQUIREMENTS[gate] !== undefined).length;
-//# sourceMappingURL=judge.js.map

package/dist/goal/judge.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"judge.js","sourceRoot":"","sources":["../../src/goal/judge.ts"],"names":[],"mappings":"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"}

package/dist/goal/loop.d.ts

@@ -1,75 +0,0 @@
-/**
- * Turn-budgeted goal loop (Layer 4 of SG-COGNITIVE-SUBSTRATE).
- *
- * The loop is the Hermes-style post-turn driver, hardened: it consumes one turn
- * per advance, enforces a hard {@link GoalRecord.turnBudget}, surfaces
- * `impossible` verdicts as a terminal state (no further turns), and — the Hermes
- * pattern that prevents silent crashes — AUTO-PAUSES on a judge/parse failure
- * rather than aborting.
- *
- * `advanceGoal` is PURE and DETERMINISTIC over `(goal, judgeFn)`: it performs no
- * I/O itself (the judge is injected; persistence is the caller's job via the
- * store's `updateGoal`). This makes every transition trivially unit-testable
- * offline and keeps the budget/impossible/pause logic in one auditable place.
- *
- * Transition table (the four AC-mandated outcomes):
- * - `verdict.ok`         → `satisfied` (terminal).
- * - `verdict.impossible` → `impossible` (terminal; consumes NO turn).
- * - judge/parse failure  → `paused` (auto-pause, `pausedReason` set).
- * - turn budget reached  → `abandoned` (terminal).
- * - otherwise            → `active` (one turn consumed; keep going).
- *
- * @module @cleocode/core/goal/loop
- *
- * @epic T11290 EP-CLEO-GOAL-SYSTEM
- * @task T11379
- * @saga T11283 SG-COGNITIVE-SUBSTRATE
- */
-import type { GoalAdvanceResult, GoalJudgeVerdict, GoalRecord } from '@cleocode/contracts';
-/**
- * A judge function the loop invokes once per advance. Injected so the loop is
- * pure over `(goal, judgeFn)` — production passes a closure over `judgeGoal`,
- * tests pass a deterministic stub.
- *
- * @param goal - The goal being advanced.
- * @returns The verdict for this turn.
- * @task T11379
- */
-export type GoalJudgeFn = (goal: GoalRecord) => Promise<GoalJudgeVerdict>;
-/**
- * A minimal, well-formed {@link GoalJudgeVerdict}-shaped object check.
- *
- * A judge that returns a malformed value (missing `ok`/`impossible`, wrong
- * types) is treated as a PARSE FAILURE — the goal auto-pauses rather than
- * trusting a garbage verdict. This is the structural half of the Hermes
- * parse-failure pattern (the thrown-error half is handled by the try/catch in
- * {@link advanceGoal}).
- *
- * @param value - The judge's return value.
- * @returns `true` when `value` is a structurally-valid verdict.
- * @task T11379
- */
-export declare function isWellFormedVerdict(value: unknown): value is GoalJudgeVerdict;
-/**
- * Advance a goal one turn through the budgeted loop.
- *
- * Pure and deterministic over `(goal, judgeFn)` — NO persistence here; the
- * caller persists the returned `nextStatus` / `turnsRemaining` via the goal
- * store's `updateGoal`. Already-terminal goals are returned unchanged (no turn
- * is consumed, no judge is called) so the loop is idempotent at its boundaries.
- *
- * Ordering rationale:
- * - The judge runs FIRST so a goal that became satisfiable/impossible since the
- *   last turn is detected before a turn is "spent".
- * - `impossible` consumes NO turn (the verdict is final regardless of budget).
- * - `ok` consumes NO turn (work is done).
- * - Only the "keep going" path consumes a turn, and the budget check fires AFTER
- *   incrementing so `turnsRemaining` never goes negative.
- *
- * @param goal - The current goal record.
- * @param judgeFn - The injected judge (see {@link GoalJudgeFn}).
- * @returns The verdict, the next status, and the remaining turns.
- * @task T11379
- */
-export declare function advanceGoal(goal: GoalRecord, judgeFn: GoalJudgeFn): Promise<GoalAdvanceResult>;
-//# sourceMappingURL=loop.d.ts.map

package/dist/goal/loop.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"loop.d.ts","sourceRoot":"","sources":["../../src/goal/loop.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,OAAO,KAAK,EACV,iBAAiB,EACjB,gBAAgB,EAChB,UAAU,EAEX,MAAM,qBAAqB,CAAC;AAE7B;;;;;;;;GAQG;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,IAAI,EAAE,UAAU,KAAK,OAAO,CAAC,gBAAgB,CAAC,CAAC;AAE1E;;;;;;;;;;;;GAYG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,gBAAgB,CAM7E;AAaD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAsB,WAAW,CAC/B,IAAI,EAAE,UAAU,EAChB,OAAO,EAAE,WAAW,GACnB,OAAO,CAAC,iBAAiB,CAAC,CA2D5B"}

package/dist/goal/loop.js

@@ -1,132 +0,0 @@
-/**
- * Turn-budgeted goal loop (Layer 4 of SG-COGNITIVE-SUBSTRATE).
- *
- * The loop is the Hermes-style post-turn driver, hardened: it consumes one turn
- * per advance, enforces a hard {@link GoalRecord.turnBudget}, surfaces
- * `impossible` verdicts as a terminal state (no further turns), and — the Hermes
- * pattern that prevents silent crashes — AUTO-PAUSES on a judge/parse failure
- * rather than aborting.
- *
- * `advanceGoal` is PURE and DETERMINISTIC over `(goal, judgeFn)`: it performs no
- * I/O itself (the judge is injected; persistence is the caller's job via the
- * store's `updateGoal`). This makes every transition trivially unit-testable
- * offline and keeps the budget/impossible/pause logic in one auditable place.
- *
- * Transition table (the four AC-mandated outcomes):
- * - `verdict.ok`         → `satisfied` (terminal).
- * - `verdict.impossible` → `impossible` (terminal; consumes NO turn).
- * - judge/parse failure  → `paused` (auto-pause, `pausedReason` set).
- * - turn budget reached  → `abandoned` (terminal).
- * - otherwise            → `active` (one turn consumed; keep going).
- *
- * @module @cleocode/core/goal/loop
- *
- * @epic T11290 EP-CLEO-GOAL-SYSTEM
- * @task T11379
- * @saga T11283 SG-COGNITIVE-SUBSTRATE
- */
-/**
- * A minimal, well-formed {@link GoalJudgeVerdict}-shaped object check.
- *
- * A judge that returns a malformed value (missing `ok`/`impossible`, wrong
- * types) is treated as a PARSE FAILURE — the goal auto-pauses rather than
- * trusting a garbage verdict. This is the structural half of the Hermes
- * parse-failure pattern (the thrown-error half is handled by the try/catch in
- * {@link advanceGoal}).
- *
- * @param value - The judge's return value.
- * @returns `true` when `value` is a structurally-valid verdict.
- * @task T11379
- */
-export function isWellFormedVerdict(value) {
-    if (value === null || typeof value !== 'object')
-        return false;
-    const v = value;
-    return (typeof v.ok === 'boolean' && typeof v.impossible === 'boolean' && typeof v.reason === 'string');
-}
-/**
- * The malformed-verdict sentinel used as the verdict in an auto-pause result
- * when the judge returned an unparseable value (vs. threw). Carries
- * `impossible: false` so a resumed goal is not mistaken for terminal.
- *
- * @internal
- */
-function pauseVerdict(reason) {
-    return { ok: false, impossible: false, reason };
-}
-/**
- * Advance a goal one turn through the budgeted loop.
- *
- * Pure and deterministic over `(goal, judgeFn)` — NO persistence here; the
- * caller persists the returned `nextStatus` / `turnsRemaining` via the goal
- * store's `updateGoal`. Already-terminal goals are returned unchanged (no turn
- * is consumed, no judge is called) so the loop is idempotent at its boundaries.
- *
- * Ordering rationale:
- * - The judge runs FIRST so a goal that became satisfiable/impossible since the
- *   last turn is detected before a turn is "spent".
- * - `impossible` consumes NO turn (the verdict is final regardless of budget).
- * - `ok` consumes NO turn (work is done).
- * - Only the "keep going" path consumes a turn, and the budget check fires AFTER
- *   incrementing so `turnsRemaining` never goes negative.
- *
- * @param goal - The current goal record.
- * @param judgeFn - The injected judge (see {@link GoalJudgeFn}).
- * @returns The verdict, the next status, and the remaining turns.
- * @task T11379
- */
-export async function advanceGoal(goal, judgeFn) {
-    const remainingBefore = Math.max(0, goal.turnBudget - goal.turnsUsed);
-    // Already-terminal goals are inert — return them unchanged.
-    if (goal.status === 'satisfied' || goal.status === 'abandoned' || goal.status === 'impossible') {
-        return {
-            verdict: goal.lastVerdict ?? pauseVerdict(`Goal already ${goal.status}; no further turns.`),
-            nextStatus: goal.status,
-            turnsRemaining: remainingBefore,
-        };
-    }
-    // Hermes auto-pause: a judge that THROWS (network blip, parse crash) must
-    // never abort the loop — pause the goal with the cause and let it resume.
-    let verdict;
-    try {
-        const raw = await judgeFn(goal);
-        if (!isWellFormedVerdict(raw)) {
-            return {
-                verdict: pauseVerdict('Judge returned a malformed verdict (auto-paused).'),
-                nextStatus: 'paused',
-                turnsRemaining: remainingBefore,
-            };
-        }
-        verdict = raw;
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        return {
-            verdict: pauseVerdict(`Judge failed: ${message} (auto-paused).`),
-            nextStatus: 'paused',
-            turnsRemaining: remainingBefore,
-        };
-    }
-    // Satisfied — terminal, no turn consumed.
-    if (verdict.ok) {
-        return { verdict, nextStatus: 'satisfied', turnsRemaining: remainingBefore };
-    }
-    // Impossible — terminal, no turn consumed (the verdict is final).
-    if (verdict.impossible) {
-        return { verdict, nextStatus: 'impossible', turnsRemaining: remainingBefore };
-    }
-    // Keep going: consume one turn. Budget is checked AFTER the increment so the
-    // turn that exhausts the budget is the one that triggers abandonment, and
-    // turnsRemaining floors at 0.
-    const turnsRemaining = Math.max(0, remainingBefore - 1);
-    const nextStatus = turnsRemaining === 0 ? 'abandoned' : 'active';
-    const finalVerdict = nextStatus === 'abandoned'
-        ? {
-            ok: false,
-            impossible: false,
-            reason: `Turn budget exhausted (${goal.turnBudget} turns) before satisfaction. Last judge reason: ${verdict.reason}`,
-        }
-        : verdict;
-    return { verdict: finalVerdict, nextStatus, turnsRemaining };
-}
-//# sourceMappingURL=loop.js.map

package/dist/goal/loop.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"loop.js","sourceRoot":"","sources":["../../src/goal/loop.ts"],"names":[],"mappings":"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"}