loopforge 3.0.0 → 3.2.1

package/README.md

@@ -1,13 +1,71 @@
-# LoopForge package
+# LoopForge
 
-LoopForge is a cognitive state runtime for AI coding agents. It keeps a long
-task's objective, constraints, evidence, decisions and recovery state stable
-across many Agent-driven rounds.
+**A context window is not memory. Memory needs a runtime.**
 
-The Agent remains the executor: it reads code, edits files, runs tools and
-decides how to reason. LoopForge is the external round boundary that checks
-claims, commits canonical facts and rebuilds the next prompt. It is not a model,
-scheduler, unattended worker or second planning system.
+> **v3.2.1** — `npm install -g loopforge`. Node.js ≥ 18. Zero runtime dependencies.
+> [中文文档](../README.zh-CN.md)
+
+---
+
+## The real problems with long-horizon tasks
+
+Any AI coding agent, given a long enough task, hits three walls. Not because the model isn't smart enough. Not because the context window isn't large enough. These are **architectural** problems.
+
+### Problem 1: The summary cascade
+
+Context fills up → compress. Fills up again → compress again. The third compression is a summary of a summary of a summary. Every cycle evaporates information — critical constraints get silently deleted because the summarizer judged them "no longer relevant." Researchers found that after 3–4 summary cycles, constraint violation rates spike from 0% to 59%. The agent doesn't know what it forgot, because the forgetting itself was compressed away.
+
+### Problem 2: Self-correction doesn't work
+
+Models cannot reliably improve themselves through introspection — they talk themselves out of correct answers. Effective recovery requires an **external verifier** — an independent observer that doesn't share the agent's context, doesn't participate in its reasoning, and only looks at inputs and outputs.
+
+### Problem 3: Compound error (p^N)
+
+If each step succeeds with probability p, N sequential steps succeed with probability p^N. Frontier agents nail nearly 100% of tasks under 4 minutes but crater to under 10% on tasks over 4 hours. Small errors at each step become the correct input for the next step.
+
+**These three problems amplify each other. The summary cascade loses information → lost information becomes errors → the agent can't self-correct because those errors look reasonable within its own context.**
+
+---
+
+## What LoopForge does about it
+
+LoopForge doesn't compete on context window size. It runs **outside** the agent and provides three things:
+
+### 1. Breaks the summary cascade: Vault → compile, not summary → summary
+
+Each round's self-evaluation is written to a **typed vault** (JSON documents). The next round's prompt is not generated from the previous prompt's summary — it's **recompiled from the vault**. Milestones aren't summaries of summaries; they're recomputed from raw vault entries. Constraints and criteria carry stable IDs (`c-XXXXXXXX`, `cr-XXXXXXXX`) for exact matching — no Jaccard guesswork.
+
+```
+❌ Traditional: prompt → summary → next prompt → re-summarize → … (information evaporates each cycle)
+✅ LoopForge:  prompt → vault entry → next prompt (recompiled from vault, zero evaporation)
+```
+
+### 2. External judgment: the perspective the agent cannot provide for itself
+
+The verification gate cross-checks every agent claim against independent evidence — Git snapshots, test runner output, explicit verification commands. The enforcement gate detects what the agent cannot self-diagnose:
+
+- R1: You claimed success but criteria remain unmet → **you're deceiving yourself**
+- R3: You claimed success with no verifiable evidence → **your claim is empty**
+- R4: You've been stuck for 3 rounds → **you're stalled and you don't know it**
+- R5: Your progress is exactly zero → **you're going through the motions**
+- R7: You said you'd do X but did Y → **your intent and actions are disconnected**
+
+**The agent cannot self-detect these. The agent is the system that produced those narratives. External judgment is necessary.**
+
+### 3. Walk back from dead ends
+
+Progress stall or flatline → roll back to the last clean round instead of terminating. A diagnosis of why the path failed is injected. The backtrack prompt includes concrete workspace restore commands — `git checkout -- . && git clean -fd` with affected file lists. The verification gate checks that the workspace was actually restored before the next submission. Valid discoveries from skipped rounds are preserved.
+
+---
+
+## What LoopForge is not
+
+- ❌ **Not a memory system** — the state file is a derived view. The vault is truth. No RAG, no vector DB.
+- ❌ **Not a context compressor** — doesn't compress prompts, doesn't do smart summarization. Recompiles from vault, not from the previous prompt.
+- ❌ **Not a constraint tracker** — constraints are one signal the verification gate monitors. The core value is external judgment.
+- ❌ **Not a replacement for the agent** — the agent still reads code, edits files, runs tools, and decides how to reason. LoopForge owns the **round boundary**.
+
+---
 
 ## Install
 
@@ -17,154 +75,79 @@ loopforge init --client claude
 claude mcp add loopforge -- npx loopforge mcp
 ```
 
-For Codex use `loopforge init --client codex` and register the same MCP command.
-The generic initializer prints an MCP configuration fragment. The package
-requires Node.js 18 or newer and has zero runtime dependencies.
-
-## How a loop works
-
-1. The Agent calls `loopforge_start` with one objective and its hard constraints.
-2. LoopForge compiles a prompt from canonical state.
-3. The Agent executes that prompt and submits a structured `RoundReport`.
-4. Runtime evidence is checked, the round boundary is enforced, and the result is accepted, rejected, backtracked or stopped.
-5. If work remains, the next prompt is compiled again from committed facts.
-
-The report deliberately separates `outcome` (`success`, `partial`, `failed` or
-`blocked`) from `continuation` (`continue` or `stop`). This prevents a local
-round result from being mistaken for completion of the whole objective. The old
-`status` report and free-form evaluation text are not accepted at the public
-boundary.
-
-```json
-{
-  "format": "loopforge.round-report",
-  "outcome": "partial",
-  "continuation": "continue",
-  "summary": "Implemented the parser and ran focused tests.",
-  "violations": [],
-  "agentIntent": "Add parser regression coverage next",
-  "evidence": {"files": ["src/parser.ts"], "checks": [], "claims": [], "provenance": {}},
-  "discoveries": {"wrongAssumptions": [], "emergedWork": [], "facts": [], "newConstraints": []},
-  "subGoalEvents": {"completed": [], "blocked": [], "canceled": []}
-}
-```
+Works with Claude Code, Codex CLI, or any MCP-compatible client.
+
+The MCP server path (`loopforge mcp`) is the primary integration. It provides
+the full cognitive infrastructure: verification gate, enforcement gate,
+backtrack, evidence collection, and crash recovery. The engine is also
+available as a library for custom integrations.
+
+---
+
+## Architecture
 
-`blocked` reports include a blocker. User decisions and external side effects
-must stop at a User Gate; an Agent-resolvable technical blocker may continue
-only with concrete evidence requirements.
-
-## State model and prompt artifact
-
-The package follows a single-source rule: Goal, RoundEvent, EvidenceEnvelope,
-Constraint, SubGoal and GateDecision are durable facts; phase history, Current
-Focus, Todo, Handoff, progress, failed patterns and prompt diagnostics are
-rebuildable projections, never a competing plan or persistence layer. Compiler
-responses keep those derived views in one `projection` object. The full model,
-the L0/L1/L2 prompt levels and the immutable prompt artifact are described in
-the [project README](https://github.com/kyrielrving11/LoopForge/blob/main/README.md)
-under “Canonical cognitive state” and “One prompt artifact per attempt”.
-
-The default store is `.loopforge`. Events are written through the canonical
-writer and receive a monotonic `event_sequence` within each loop. Prompt and
-state hashes make a restart or replay auditable. Markdown state is only a
-replaceable view, not the recovery truth.
-
-Evidence collection and recovery are asynchronous. A malformed report is an
-input error; corrupt JSON, an invalid event format, or a sequence gap is a
-`storage_corruption` error and is never auto-repaired. The configured
-`maxRounds` must be a positive integer no greater than the policy limit.
-
-## Verification, enforcement and gates
-
-Git evidence is enabled by default. Explicit command providers run with an
-executable and argument array (`shell: false`), bounded output, a timeout and a
-workspace path check; required command failures contradict an unsupported
-success claim. Agent claims remain `claimed` until a provider observes them —
-provenance is owned by the runtime, and criteria coverage comes from verified
-claims, never from a progress estimate. A successful report that requests a
-stop is accepted as completion only when a live evidence provider produced
-verifiable evidence; with no provider, completion stays unresolved.
-
-Gate checks use `GateActionDescriptor` to make risk explicit: production,
-credentials, data migration, publishing, payment, external communication,
-public API changes, irreversible actions and unknown authorization are User
-Gates; bounded, reversible, explicitly agent-allowed workspace work is an
-Agent Gate. Decisions bind to an `actionHash`, so changing an action
-invalidates an earlier approval.
-
-For the full decision semantics — what the gate detects, how enforcement
-decides accept, reject, backtrack and stop — see the corresponding sections in
-the [project README](https://github.com/kyrielrving11/LoopForge/blob/main/README.md).
-
-## Recovery semantics
-
-A rejected attempt is zero-commit: its report does not enter canonical state.
-`loopforge_retry` keeps the same logical round ID and increments the attempt;
-`loopforge_next` cannot bypass a rejection. `loopforge_backtrack` returns a
-bounded restore point and verification requirements but never changes workspace
-files. Pause and resume preserve the transaction across client or process
-boundaries. Stop records termination without deleting the vault.
-
-`agentIntent` is an optional, non-authoritative suggestion retained inside the
-report for audit and drift comparison. It never overwrites Current Focus, Todo,
-runtime progress, completion, or the compiler's Suggested Next Action.
-
-Terminal enforcement escalation is tracked per rule. A rule can issue one
-guided retry before a repeated hit terminates it; accepting progress or
-backtracking clears the active rejection episode.
-
-## MCP surface
-
-The server exposes exactly twelve Agent-driven tools:
-
-```text
-loopforge_start       loopforge_next        loopforge_retry
-loopforge_backtrack   loopforge_resume      loopforge_pause
-loopforge_stop        loopforge_status      loopforge_history
-loopforge_gate_check  loopforge_gate_resolve loopforge_audit
 ```
+┌─────────────────────────────────────────────────────┐
+│                  Agent executes round                 │
+│  Reads code · Edits files · Runs tools · Reasons      │
+└──────────────────────┬──────────────────────────────┘
+                       │ Agent submits SelfEvaluation
+                       ▼
+┌─────────────────────────────────────────────────────┐
+│               LoopForge round boundary                │
+│                                                       │
+│  Evidence → Verify → Enforce → Commit → Compile       │
+│  (Git/cmd) (19 checks) (10 rules) (vault) (next)    │
+│                                                       │
+│  accept:  commit state, compile next round             │
+│  reject:  retry same round, zero state mutation        │
+│  backtrack: roll back to last clean round, restore     │
+│  terminate: persist terminal state                     │
+└──────────────────────┬──────────────────────────────┘
+                       │ Recompile prompt from vault
+                       ▼
+┌─────────────────────────────────────────────────────┐
+│             Vault (typed JSON persistence)            │
+│  loops/<id>/rounds/<n>.json · session.json · policy   │
+│  Source of truth. Not a summary chain.                 │
+└─────────────────────────────────────────────────────┘
+```
+
+---
 
-`status` combines session, loop and persisted-loop views. `history` combines
-single-round inspection and event-timeline replay with sequence pagination. The
-old `list`, `health`, `inspect` and `replay` MCP names are not aliases. MCP
-Tasks and background Agent execution are intentionally outside this package.
-
-## Long-horizon use
-
-LoopForge can support dozens or hundreds of explicit rounds, context
-compression, restart, rejection and backtrack because every prompt is compiled
-from durable facts rather than from a summary of the previous prompt. It does
-not keep an Agent running after the client task ends. Use one loop per clear
-objective; for a large roadmap, let the Agent carry explicit outcomes between
-independent loops instead of creating an endless session.
-
-## Reliability boundaries
-
-Malformed canonical reports are rejected without changing the current session,
-round or vault, so callers can retry the same logical round. Persistence
-failures are returned as errors and never become a successful or partial
-commit. Drift clarification requires an explanation and a runtime-verifiable
-anchor; agent waiver flags are not accepted. `loopforge doctor` diagnoses
-unknown, deprecated, type-invalid and removed policy keys. Automatic Git
-restore is intentionally not implemented. Persistence and evidence collection
-are asynchronous; corrupt JSON, invalid event formats and sequence gaps return
-`storage_corruption` instead of a partial status. `maxRounds` must be a positive
-integer within the configured policy limit.
+## Key capabilities
+
+**Vault → compile, not summary → summary.** Every round's self-evaluation is written to the vault. The next prompt is recompiled from vault entries. Stable IDs (`c-` / `cr-` / `sg-XXXXXXXX`) enable exact constraint, criterion, and sub-goal matching — no Jaccard false positives.
+
+**External judgment.** The verification gate cross-checks agent claims against independent evidence. The enforcement gate detects cognitive integrity violations — progress stalls, intent-action gaps, empty success claims. The judge never shares the agent's context.
+
+**Model expresses information needs.** Each round, the agent tells the compiler: what to emphasize, which sections to expand, where it's confused. The compiler reorders within safety boundaries — mandatory sections untouched, budget respected.
+
+**Walk back from dead ends.** Progress stall → roll back to last clean round with a diagnosis. Workspace restore is prompted and verified — the next submission is rejected if files from skipped rounds are still dirty.
+
+**Substantive drift, not filler.** R7 accepts intentional pivots only when the clarification references concrete IDs or file paths. Three consecutive weak clarifications terminate the loop.
+
+**Thin prompt, fat state file.** L0 (retry) / L1 (continuation) / L2 (full rehydration) control density only — reasoning strategy belongs to the agent. Truth is in the vault.
+
+**Pause · Resume · Replay.** Cross-process session leases. Idempotent resume after interruption. Time-travel queries over committed rounds.
+
+**Nine MCP tools.** `start` · `next` · `status` · `stop` · `pause` · `resume` · `replay` + `gate_check` · `gate_resolve`. `status` is the unified inspection tool (`view=session|loop|all|audit`). Every tool returns JSON content blocks.
+
+**Zero dependencies. Policy-driven.** Node.js stdlib only. All thresholds, budgets, and intervals live in `loop_policy.json`. 715 tests.
+
+---
 
 ## Development
 
 ```bash
 npm run check
 npm test
-npm run build
-npm run verify:artifacts
-npm pack --dry-run --json --ignore-scripts
+npm pack --dry-run --json
 ```
 
-The schema in the repository's `loopforge-protocol.json` is generated from
-`src/protocol.ts`.
-Do not edit it by hand. `init` installs `skills/perception/SKILL.md` for the
-selected client and prints its MCP registration command.
+The protocol schema in `../loopforge-protocol.json` is generated from `src/protocol.ts`. Do not edit it by hand.
+
+---
 
 ## License
 

package/dist/audit.d.ts

@@ -0,0 +1,50 @@
+/** v2.12: Read-only, replayable end-of-loop audit — the verification view.
+ *
+ *  Positioning vs loopforge_replay: replay is the factual timeline (what
+ *  happened per round); audit is the assessment layer (which claims are
+ *  machine-verified, which gates were decided, is the sequence intact).
+ *  Everything is derived from committed vault entries — audit never writes.
+ */
+import type { LoopStore } from "./loop-store.js";
+import type { VaultEntry } from "./loop-store.js";
+export interface AuditRound {
+    round: number;
+    outcome: string;
+    claims: Array<{
+        text: string;
+        status: "verified" | "unverified" | "no_evidence";
+    }>;
+    checks: Array<{
+        check: string;
+        severity: string;
+        verdict: "failed" | "warn" | "info";
+    }>;
+}
+export interface AuditGate {
+    gateId: string;
+    kind: "user" | "agent";
+    actionHash: string;
+    approved: boolean;
+    decidedAt: string;
+    round: number;
+}
+export interface AuditResult {
+    loopId: string;
+    verdict: "passed" | "incomplete" | "contradicted";
+    rounds: AuditRound[];
+    gates: AuditGate[];
+    unresolvedUserGates: string[];
+    criteria: {
+        declared: number;
+        evidenced: number;
+        missing: number;
+    };
+    sequenceComplete: boolean;
+    /** False when no LoopStore was provided (sequence/provenance degraded). */
+    provenanceAvailable: boolean;
+}
+/** Build the audit from committed vault entries. Pure, read-only.
+ *  @param store Optional LoopStore — when provided, sequence integrity is
+ *  checked and provenanceAvailable becomes true. */
+export declare function buildAudit(loopId: string, entries: VaultEntry[], store?: LoopStore): AuditResult;
+//# sourceMappingURL=audit.d.ts.map

package/dist/audit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"audit.d.ts","sourceRoot":"","sources":["../src/audit.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAKjD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAIlD,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,UAAU,GAAG,YAAY,GAAG,aAAa,CAAA;KAAE,CAAC,CAAC;IACnF,MAAM,EAAE,KAAK,CAAC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,QAAQ,GAAG,MAAM,GAAG,MAAM,CAAA;KAAE,CAAC,CAAC;CACzF;AAED,MAAM,WAAW,SAAS;IACxB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;IACvB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,OAAO,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,QAAQ,GAAG,YAAY,GAAG,cAAc,CAAC;IAClD,MAAM,EAAE,UAAU,EAAE,CAAC;IACrB,KAAK,EAAE,SAAS,EAAE,CAAC;IACnB,mBAAmB,EAAE,MAAM,EAAE,CAAC;IAC9B,QAAQ,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;IACnE,gBAAgB,EAAE,OAAO,CAAC;IAC1B,2EAA2E;IAC3E,mBAAmB,EAAE,OAAO,CAAC;CAC9B;AAqCD;;oDAEoD;AACpD,wBAAgB,UAAU,CACxB,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,UAAU,EAAE,EACrB,KAAK,CAAC,EAAE,SAAS,GAChB,WAAW,CAgHb"}

package/dist/audit.js

@@ -0,0 +1,158 @@
+/** v2.12: Read-only, replayable end-of-loop audit — the verification view.
+ *
+ *  Positioning vs loopforge_replay: replay is the factual timeline (what
+ *  happened per round); audit is the assessment layer (which claims are
+ *  machine-verified, which gates were decided, is the sequence intact).
+ *  Everything is derived from committed vault entries — audit never writes.
+ */
+import { eventSequence, StorageCorruptionError } from "./loop-store.js";
+import { auditOrder, deriveGate } from "./cognitive-governance.js";
+import { rederiveClaimViewWithFlags, listVerifiedClaims } from "./evidence-claims.js";
+import { effectiveOutcome } from "./self-eval.js";
+import { isRecord, entryRound as sharedEntryRound } from "./token-utils.js";
+function entryRound(entry) {
+    return sharedEntryRound(entry);
+}
+/** Committed transaction payload from a feedback entry. */
+function committedTransaction(entry) {
+    if (!isRecord(entry.loop_lineage))
+        return null;
+    const transaction = entry.loop_lineage.round_transaction;
+    if (!isRecord(transaction) || !isRecord(transaction.snapshot))
+        return null;
+    const snapshot = transaction.snapshot;
+    const evaluation = isRecord(snapshot.evaluation)
+        ? snapshot.evaluation
+        : null;
+    const result = isRecord(snapshot.result) ? snapshot.result : null;
+    const flags = Array.isArray(result?.verificationFlags)
+        ? result.verificationFlags
+        : [];
+    const evidence = Array.isArray(snapshot.afterEvidence)
+        ? snapshot.afterEvidence
+        : Array.isArray(snapshot.roundEvidence)
+            ? snapshot.roundEvidence
+            : [];
+    return {
+        evaluation,
+        flags,
+        afterEvidence: evidence,
+        action: typeof result?.action === "string" ? result.action : undefined,
+    };
+}
+/** Build the audit from committed vault entries. Pure, read-only.
+ *  @param store Optional LoopStore — when provided, sequence integrity is
+ *  checked and provenanceAvailable becomes true. */
+export function buildAudit(loopId, entries, store) {
+    const ordered = auditOrder(entries);
+    // ── Rounds: per-round claims + checks from committed snapshots ─────────
+    const rounds = [];
+    for (const entry of ordered) {
+        const taskId = String(entry.task_id ?? "");
+        if (!taskId.startsWith(`loop:${loopId}:r`) || !taskId.endsWith(":feedback"))
+            continue;
+        const committed = committedTransaction(entry);
+        if (!committed)
+            continue;
+        // v2.14: rounds committed with action="backtrack" were rolled back —
+        // they are not part of the loop's final history. Counting them would
+        // inflate the round list and let their error flags flip the verdict.
+        if (committed.action === "backtrack")
+            continue;
+        const round = entryRound(entry);
+        const outcome = committed.evaluation
+            ? effectiveOutcome(committed.evaluation)
+            : "unknown";
+        const claimView = committed.evaluation
+            ? rederiveClaimViewWithFlags(committed.evaluation, committed.afterEvidence, committed.flags)
+            : null;
+        rounds.push({
+            round,
+            outcome,
+            claims: claimView
+                ? claimView.claims.map((claim) => ({
+                    text: claim.targetId,
+                    status: claim.status === "verified" ? "verified" : "unverified",
+                }))
+                : [],
+            checks: committed.flags.map((flag) => ({
+                check: flag.check,
+                severity: flag.severity,
+                verdict: flag.severity === "error" ? "failed" : flag.severity,
+            })),
+        });
+    }
+    // ── Gates: latest decision wins; opened-without-decision stays open ────
+    const decisionsByGate = new Map();
+    const openedGates = new Map();
+    for (const entry of ordered) {
+        const gateId = String(entry.gate_id ?? "");
+        if (!gateId)
+            continue;
+        if (entry.task_type === "gate_decision" && isRecord(entry.gate_decision)) {
+            const decision = entry.gate_decision;
+            decisionsByGate.set(gateId, {
+                gateId,
+                kind: decision.kind === "agent" ? "agent" : "user",
+                actionHash: typeof decision.actionHash === "string" ? decision.actionHash : "",
+                approved: decision.approved === true,
+                decidedAt: typeof decision.decidedAt === "string" ? decision.decidedAt : "",
+                round: entryRound(entry),
+            });
+        }
+        else if (entry.task_type === "gate_opened") {
+            openedGates.set(gateId, {
+                description: typeof entry.gate_action === "string" ? entry.gate_action : gateId,
+                round: entryRound(entry),
+            });
+        }
+    }
+    const gates = [...decisionsByGate.values()];
+    const unresolvedUserGates = [];
+    for (const [gateId, opened] of openedGates) {
+        if (decisionsByGate.has(gateId))
+            continue;
+        // Re-derive the classification from the recorded action text.
+        const { gate } = deriveGate(opened.description);
+        if (gate.kind === "user") {
+            unresolvedUserGates.push(`${gateId} (round ${opened.round}): ${opened.description}`);
+        }
+    }
+    // ── Sequence integrity (P0) ────────────────────────────────────────────
+    let sequenceComplete = true;
+    let provenanceAvailable = store !== undefined;
+    if (store) {
+        try {
+            const sequences = eventSequence(store, loopId);
+            const max = sequences.length > 0 ? Math.max(...sequences) : 0;
+            sequenceComplete = sequences.length === max;
+        }
+        catch (error) {
+            sequenceComplete = false;
+            if (!(error instanceof StorageCorruptionError))
+                throw error;
+        }
+    }
+    // ── Criteria accounting + verdict ──────────────────────────────────────
+    const verified = listVerifiedClaims(entries, loopId);
+    const declared = rounds.reduce((sum, round) => sum + round.claims.length, 0);
+    const evidenced = verified.length;
+    let verdict = "passed";
+    if (rounds.some((round) => round.checks.some((check) => check.verdict === "failed"))) {
+        verdict = "contradicted";
+    }
+    else if (unresolvedUserGates.length > 0 || (declared > 0 && evidenced === 0)) {
+        verdict = "incomplete";
+    }
+    return {
+        loopId,
+        verdict,
+        rounds,
+        gates,
+        unresolvedUserGates,
+        criteria: { declared, evidenced, missing: Math.max(0, declared - evidenced) },
+        sequenceComplete,
+        provenanceAvailable,
+    };
+}
+//# sourceMappingURL=audit.js.map

package/dist/audit.js.map

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

package/dist/canonical-state.d.ts

@@ -3,16 +3,33 @@
  * The canonical state is data, not Markdown. Prompt and state-file renderers
  * consume the same value so they cannot silently drift apart.
  */
-import type { ConstraintMeta, LoopCompileRequest, LoopCompileResponse, SubGoal, VerificationFlag, DerivedGate, HandoffProjection, PhaseHistoryEntry, TodoProjection } from "./protocol.js";
-export declare const CANONICAL_STATE_FORMAT: "loopforge.state";
+import type { ConstraintMeta, CriterionStatus, Lesson, LoopCompileRequest, LoopCompileResponse, MilestoneSummary, SubGoal, VerificationFlag } from "./protocol.js";
+export declare const CANONICAL_STATE_SCHEMA_VERSION: 1;
+/** v3.2: Durable snapshot of what an L1 prompt actually presented last round.
+ *  Used as the diff baseline for L1 collapse. Persisted inside the lineage
+ *  entry's loop_lineage (field extension — no new persistence format) and
+ *  carried on PromptArtifact for the compile-to-persist round-trip. */
+export interface PresentedStateSnapshot {
+    /** Round whose presentation this snapshot describes (the baseline round). */
+    round: number;
+    /** Stable IDs (c-XXXXXXXX) of constraints rendered in the L1 Active
+     *  Constraints section (post-emphasize, non-hard). */
+    constraintIds: string[];
+    /** [sub-goal id, status] pairs rendered in the L1 Active Sub-Goals section
+     *  (in_progress + pending only). Statuses enable transition detection. */
+    subGoals: Array<[string, string]>;
+    /** [start, end] round ranges of all milestones at presentation time. */
+    milestoneRanges: Array<[number, number]>;
+}
 export interface CanonicalLoopState {
-    format: "loopforge.state";
+    schemaVersion: typeof CANONICAL_STATE_SCHEMA_VERSION;
     loopId: string;
     round: number;
     maxRounds: number;
     goalId: string;
     objective: string;
     objectiveVersion: number;
+    currentTask: string;
     successCriteria: string[];
     hardConstraints: string[];
     activeConstraints: string[];
@@ -26,17 +43,25 @@ export interface CanonicalLoopState {
     blockers: string[];
     verificationFlags: VerificationFlag[];
     discoveries: string[];
+    nextAction: string;
     rollingOutcomes: string[];
     recurringIssues: string[];
     failedPatterns: string[];
+    /** v2.1: Phase-boundary milestone summaries that survive window eviction. */
+    milestones: MilestoneSummary[];
     /** v2.1: Single-paragraph loop-level synthesis (formulaic). */
     loopSynthesis: string;
     /** v2.2: Structured sub-goals with compiler-managed lifecycle. */
     subGoals: SubGoal[];
+    /** v3.2: Derived per-criterion status (goal → criteria → evidence view). */
+    criterionStatuses: CriterionStatus[];
+    /** v3.2: Deterministic lessons learned (repeated violations / failures). */
+    lessons: Lesson[];
     /** v2.5: Agent trust score [0, 1] from verification flags. */
     agentTrustScore: number | undefined;
     /** v2.5: Trust trend over last 10 rounds. */
     agentTrustTrend: number[];
+    suggestedNextTask: string;
     externalContext: string;
     stateFilePath: string;
     progress: {
@@ -50,23 +75,6 @@ export interface CanonicalLoopState {
             skipped: number;
         } | null;
     };
-    /** Derived obligations that must be rechecked after a change. */
-    regressionObligations: Array<{
-        id: string;
-        description: string;
-        sourceRound: number;
-        evidenceRefs: string[];
-        status: "open" | "satisfied" | "contradicted";
-    }>;
-    /** Derived views. They are rebuilt on every compile and are not a
-     * second transaction truth. */
-    phaseHistory: PhaseHistoryEntry[];
-    currentFocus: string;
-    todoProjection: TodoProjection | null;
-    suggestedNextAction: string;
-    activeGate: DerivedGate | null;
-    stateFreshness: "fresh" | "stale" | "missing";
-    handoff: HandoffProjection;
 }
 /** Deterministic JSON serialization used by state and prompt hashes. */
 export declare function stableStringify(value: unknown): string;

package/dist/canonical-state.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"canonical-state.d.ts","sourceRoot":"","sources":["../src/canonical-state.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"canonical-state.d.ts","sourceRoot":"","sources":["../src/canonical-state.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,KAAK,EACV,cAAc,EACd,eAAe,EACf,MAAM,EACN,kBAAkB,EAClB,mBAAmB,EACnB,gBAAgB,EAChB,OAAO,EACP,gBAAgB,EACjB,MAAM,eAAe,CAAC;AAIvB,eAAO,MAAM,8BAA8B,EAAG,CAAU,CAAC;AAEzD;;;uEAGuE;AACvE,MAAM,WAAW,sBAAsB;IACrC,6EAA6E;IAC7E,KAAK,EAAE,MAAM,CAAC;IACd;0DACsD;IACtD,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB;8EAC0E;IAC1E,QAAQ,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAClC,wEAAwE;IACxE,eAAe,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;CAC1C;AAED,MAAM,WAAW,kBAAkB;IACjC,aAAa,EAAE,OAAO,8BAA8B,CAAC;IACrD,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,gBAAgB,EAAE,MAAM,CAAC;IACzB,WAAW,EAAE,MAAM,CAAC;IACpB,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAC5B,kBAAkB,EAAE,MAAM,EAAE,CAAC;IAC7B,wEAAwE;IACxE,mBAAmB,EAAE,MAAM,EAAE,CAAC;IAC9B,+CAA+C;IAC/C,kBAAkB,EAAE,cAAc,EAAE,CAAC;IACrC,qBAAqB,EAAE,MAAM,EAAE,CAAC;IAChC,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAC5B,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,iBAAiB,EAAE,gBAAgB,EAAE,CAAC;IACtC,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;IACnB,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,6EAA6E;IAC7E,UAAU,EAAE,gBAAgB,EAAE,CAAC;IAC/B,+DAA+D;IAC/D,aAAa,EAAE,MAAM,CAAC;IACtB,kEAAkE;IAClE,QAAQ,EAAE,OAAO,EAAE,CAAC;IACpB,4EAA4E;IAC5E,iBAAiB,EAAE,eAAe,EAAE,CAAC;IACrC,4EAA4E;IAC5E,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,8DAA8D;IAC9D,eAAe,EAAE,MAAM,GAAG,SAAS,CAAC;IACpC,6CAA6C;IAC7C,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B,iBAAiB,EAAE,MAAM,CAAC;IAC1B,eAAe,EAAE,MAAM,CAAC;IACxB,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE;QACR,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;QACxB,WAAW,EAAE,MAAM,EAAE,CAAC;QACtB,iBAAiB,EAAE,MAAM,EAAE,CAAC;QAC5B,YAAY,EAAE,MAAM,EAAE,CAAC;QACvB,KAAK,EAAE;YAAE,MAAM,EAAE,MAAM,CAAC;YAAC,MAAM,EAAE,MAAM,CAAC;YAAC,OAAO,EAAE,MAAM,CAAA;SAAE,GAAG,IAAI,CAAC;KACnE,CAAC;CACH;AAID,wEAAwE;AACxE,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAYtD;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,kBAAkB,GAAG,MAAM,CAEpE;AAwCD;kEACkE;AAClE,wBAAgB,4BAA4B,CAAC,KAAK,EAAE,kBAAkB,GAAG,MAAM,CAgM9E;AAED,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,kBAAkB,EAC3B,QAAQ,EAAE,mBAAmB,EAC7B,aAAa,EAAE,MAAM,GACpB,kBAAkB,CAyEpB"}