loopforge 3.0.0 → 3.6.0

package/skills/perception/SKILL.md

@@ -1,228 +1,210 @@
 ---
 name: perception
-description: Drive a recoverable multi-round task through the LoopForge MCP runtime while the Agent remains the execution owner.
+description: Drive a recoverable multi-round coding task through LoopForge MCP while the external Agent remains the execution owner.
 ---
 
 # Perception
 
-Use LoopForge for work that spans multiple context windows, needs an auditable
-record, or must survive a process restart. LoopForge stores canonical facts and
-compiles prompts; you remain responsible for inspecting the repository,
-editing files, running tools, and making technical decisions.
+Use LoopForge when a coding task needs several rounds, must survive context
+compression or process restart, or benefits from an auditable record of goals,
+constraints, evidence, and decisions.
 
-There is one public execution path. Do not create a second plan scheduler,
-background Agent, MCP Task, or local shadow state machine.
+LoopForge has one factual source, the committed typed round documents in the
+Vault, and one cognitive source, the Canonical State compiled from them. You
+remain the Agent that reads files, edits code, runs commands, delegates work,
+and decides how to reason.
 
-## 1. Start one loop
+## Start
 
 Call `loopforge_start` with:
 
-- `task`: the complete user objective, not a short reminder;
-- `constraints`: hard boundaries that must survive every round;
-- `successCriteria`: explicit verifiable completion criteria when the task has
-  more than the default objective-level criterion;
-- `maxRounds`: an explicit safety limit when the default (100) is unsuitable;
-- `domain`: an optional technology or repository hint;
-- `planSource`: an optional path to a user-provided plan (reference only).
-
-Keep the returned `sessionId`, `loopId`, `roundId`, prompt, and hashes. Execute
-the returned prompt in the bound workspace before submitting a report.
-
-## 2. Submit `RoundReport`
-
-Call `loopforge_next` after an accepted round. Call `loopforge_retry` only when
-the previous logical round was rejected. Both calls require `sessionId` and a
-canonical report; free-form text and the old `status` report are invalid.
+- `task`: the complete user objective.
+- `constraints`: hard boundaries that must survive every round.
+- `maxRounds`: optional positive safety limit. The default is 20.
+- `domain`: optional context label.
+
+Keep the returned `sessionId`, `roundId`, prompt, and level. Always pass the
+most recent `roundId` to `loopforge_next`. It anchors the submission to the
+exact round being reported.
+
+## Plan round boundaries
+
+LoopForge does not decide how the Agent thinks about a large task. The Agent
+chooses the next useful slice of work, while LoopForge checks the submitted
+facts and evidence at the round boundary. Do not try to predict an exact number
+of rounds before inspecting the repository. Re-plan after each committed round.
+
+Choose a round around a coherent, verifiable change:
+
+1. Start with the dependency or discovery work that determines later choices.
+2. Group changes that must be edited and tested together; split unrelated work
+   or work with different rollback risks.
+3. End the round when its slice has a concrete result, a known blocker, or a
+   machine-checkable next boundary. A round may be small when uncertainty or
+   risk is high, and larger when the changes are tightly coupled.
+4. Before submitting, check the actual diff, relevant tests, hard constraints,
+   and the next action. Do not mark the whole task complete because one slice
+   is complete.
+
+For work that spans several rounds, declare a `round_contract` as a proposal for
+the next slice. Keep its `work_item` narrow, list observable `done_when` items,
+name only configured evidence commands in `verification_plan`, and constrain
+`scope` to the files or directories that slice may touch. The proposal becomes
+active only after the current round commits. If the slice is blocked, report
+`outcome: "blocked"` with a concrete `blocker`; do not silently replace the
+active contract.
+
+This is a granularity preflight, not another gate: ask whether the slice has a
+clear boundary, evidence, and recovery path. LoopForge cannot see an implicit
+plan inside the model. It learns only from committed evaluation fields,
+Round Contract proposals, observed evidence, and the resulting changes. A
+reasonable split may therefore be revised by the next prompt, a verification
+finding, or a backtrack diagnosis.
+
+## Execute a round
+
+1. Execute the returned prompt and do real repository work.
+2. Use the tools and reasoning approach that fit the task.
+3. Check actual evidence before claiming success.
+4. Submit one structured `evaluation` with `loopforge_next`.
+
+The four core evaluation fields are strict:
+
+| Field | Rule |
+| --- | --- |
+| `success` | Boolean. Use `true` only when the whole objective and every hard constraint are satisfied. |
+| `output_summary` | String. State what changed and what was verified this round. |
+| `constraint_violations` | Array of strings. Report real violations; prefer constraint IDs such as `c-XXXXXXXX`. |
+| `should_continue` | Boolean. Use `false` only when the entire task is complete. |
+
+All other evaluation fields are optional and normalized by LoopForge. Useful
+fields include `execution_evidence`, `discovered_constraints`,
+`emerged_subtasks`, `completed_subtasks`, `blocked_subtasks`,
+`canceled_subtasks`, `next_action`, `drift_clarification`, `prompt_requests`,
+`outcome`, `blocker`, `round_contract`, `retroactiveClaims`, and
+`worker_results`.
+
+Optional malformed values are ignored or defaulted. They do not turn a valid
+submission into a transport error. Missing or mistyped core fields return
+`evaluation_invalid` with `details.missing` and `details.invalid`. Correct the
+payload and resubmit the same `roundId`. This does not save session state,
+write a round, enter either gate, increment rejection state, or record metrics.
+
+Minimal evaluation:
 
 ```json
 {
-  "format": "loopforge.round-report",
-  "outcome": "partial",
-  "continuation": "continue",
-  "summary": "Implemented the parser and ran focused tests.",
-  "violations": [],
-  "evidence": {
-    "files": ["src/parser.ts", "test/parser.test.ts"],
-    "checks": [{"name": "npm test -- parser", "status": "passed", "counts": {"passed": 8, "failed": 0, "skipped": 0}}],
-    "claims": [{"id": "claim-0123456789ab", "targetId": "cr-abcdef12", "evidenceRefs": ["command:npm test -- parser"]}],
-    "provenance": {}
-  },
-  "agentIntent": "Add parser regression coverage next"
+  "success": false,
+  "output_summary": "Implemented the parser and added 8 passing tests.",
+  "constraint_violations": [],
+  "should_continue": true,
+  "execution_evidence": {
+    "files_changed": ["src/parser.ts", "tests/parser.test.ts"],
+    "test_results": { "passed": 8, "failed": 0, "skipped": 0 },
+    "success_criteria_met": [],
+    "success_criteria_remaining": ["All parser edge cases covered"],
+    "progress_estimate": 0.4
+  }
 }
 ```
 
-### Outcome versus continuation
+Do not put a guessed evaluation in free text. The structured object is the
+authoritative submission; `output` is optional supporting context.
 
-- `outcome` is only this round's result: `success`, `partial`, `failed`, or
-  `blocked`.
-- `continuation` is only the request to start another round: `continue` or
-  `stop`.
-- `success` does not prove the total objective is complete. Completion requires
-  runtime-verified claims for every remaining criterion, no contradictory
-  checks, and no unresolved User Gate.
-- `blocked` requires a `blocker` object. Use `continuation: "stop"` for a
-  user decision, external dependency, or side effect that must not be guessed.
-  An Agent-resolvable blocker may use `continue`, but state the required
-  evidence and resolution.
+If a submission warns that its `roundId` no longer matches, the reported round
+already committed. Use the returned held prompt and its `roundId` rather than
+submitting against a later round.
 
-### Report fields
+## Stable IDs and contracts
 
-| Field | How to use it |
-| --- | --- |
-| `summary` | Describe concrete work and observations from this round. |
-| `violations` | List every actual hard-constraint violation; do not hide one to obtain acceptance. Prefer `c-XXXXXXXX` IDs. |
-| `evidence` | Report files, checks, claims and references. Agent provenance is only a claim until a runtime provider observes it. |
-| `discoveries` | Record wrong assumptions, emerged work, durable facts and newly discovered constraints. |
-| `subGoalEvents` | Report completed, blocked or canceled existing sub-goals. Do not invent a second sub-goal lifecycle. Prefer `sg-XXXXXXXX` IDs. |
-| `constraintEvents` | Retire a constraint only when repository evidence shows it is no longer valid. |
-| `criterionRevisions` | Propose an old-to-new criterion change; never silently replace the user's objective. |
-| `objectiveRefinement` | Add a safe clarification when evidence changes the interpretation; it is validated by the runtime. |
-| `phaseBoundaryProposal` | Suggest a phase label and reason. The runtime decides whether the boundary is real. |
-| `contextRequest` | Per-round emphasis, expansion or confusion requests. It is consumed once and is not durable state. |
-| `agentIntent` | Optional Agent suggestion used only for audit and drift comparison. Runtime-derived Focus, Todo and Suggested Next Action take precedence. |
-| `driftClarification` | When drift is detected, provide a concrete explanation and a criterion/constraint ID or observed file path. Runtime validates it; do not submit a waiver boolean. |
-
-Do not submit derived `currentFocus`, `todoProjection`, `handoff`,
-`progress`, `failedPatterns`, `nextAction`, or `verifiedFacts` as alternate
-facts. These are internal or derived views. A progress estimate, if present in
-the evidence supplied to an embedding, is never authoritative.
-
-## 3. Evidence discipline
-
-Use stable IDs shown in the prompt:
-
-- constraints: `[c-a3f2b1c0]`;
-- criteria: `[cr-b5a6c7d8]`;
-- sub-goals: `[sg-f1e2d3c4]`.
-
-Claims should reference a concrete file, check, or provider observation. Do not
-mark your own provenance `verified` to force progress. Runtime providers may
-replace claimed evidence with `verified`, `contradicted`, or `unavailable`.
-Missing provider output is unavailable, not a pass. A rejected attempt and its
-claims are not canonical facts.
-
-## 4. Retry, backtrack and continuation
-
-Read the returned `decision` and `enforcementAction`:
-
-- `accepted`: execute the returned prompt for the next round;
-- `rejected`: correct the evidence or work and call `loopforge_retry`; keep the
-  same logical `roundId` and do not call `next` to bypass rejection;
-- `backtracked`: use the returned restore round and requirements, then continue
-  from the new prompt;
-- `stopped` or `terminated`: do not submit another report unless a new loop is
-  explicitly started.
-
-Backtrack is advisory and bounded. It never changes workspace files. Follow the
-exact paths and checks returned by LoopForge, inspect the resulting workspace,
-and report the restoration evidence. Never improvise an unbounded destructive
-command such as `git clean -fd` or `git reset --hard`; ask for a User Gate when
-the required action is destructive or authorization is unclear.
-
-## 5. User Gate and Agent Gate
-
-For a risky action, call `loopforge_gate_check` with:
+Prompts render stable IDs beside constraints, criteria, and sub-goals:
 
-```json
-{
-  "description": "Apply the production database migration",
-  "scope": ["db/migrations/2026-01.sql"],
-  "effects": ["data_migration", "production"],
-  "reversibility": "recoverable",
-  "authorization": "user_required"
-}
-```
+- Constraints: `[c-a3f2b1c0] No plaintext passwords`
+- Criteria: `[cr-b5a6c7d8] Unit test coverage >= 90%`
+- Sub-goals: `[sg-f1e2d3c4] Add error handling to login`
 
-User Gate is required for production, credentials, data migration, publishing,
-payment, external communication, public API changes, irreversible or unknown
-actions, and unknown authorization. Limit the blocked scope and continue only
-with allowed read-only investigation or dry runs. Agent Gate is for bounded,
-reversible, explicitly `agent_allowed` workspace work or ordinary technical
-blockers. Resolve a User Gate with `loopforge_gate_resolve` using the exact same
-descriptor; its `actionHash` invalidates an approval if the action changes.
+Prefer IDs for `constraint_violations`, criteria lists, subtask status changes,
+and drift clarifications. Natural-language matching remains a policy-controlled
+fallback when an ID is unavailable.
 
-## 6. Status, history and audit
+An optional `round_contract` is a proposal for the next round. It becomes
+active only after the declaring round commits. While active, its `done_when`,
+`verification_plan`, and `scope` govern the current task until a committed eval
+completes it or reports `outcome: "blocked"`. A verification plan must be
+observed passing in the closing round.
 
-Use only the current twelve tools:
+## Backtrack
 
-```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
-```
+R4 or R5 progress stalls can trigger backtrack to the last clean committed
+round. The prompt includes a diagnosis and workspace-restore requirements.
+
+When backtrack occurs:
+
+1. Restore the workspace exactly as requested before doing more work.
+2. Read the restored prompt and derived state.
+3. Do not repeat the failed approach without addressing the diagnosis.
+4. Keep valid discoveries from skipped rounds in later evaluations.
+
+If the workspace is not restored, the next submission is rejected with
+`backtrack_workspace_not_restored`. A stalled active contract should be closed
+with `outcome: "blocked"` and a blocker while proposing the revision.
+
+## Drift
+
+The verification gate compares the previous `next_action` with the current
+work. When intentionally changing direction, provide a substantive
+`drift_clarification` with a concrete constraint, criterion, sub-goal ID, or
+file path. Three consecutive weak clarifications terminate the loop.
+
+## Interpret results
+
+- `prompt` is non-null: execute it and submit the next evaluation.
+- `enforcementAction: "reject"`: redo the same logical round. The round ID is
+  stable and the attempt increases.
+- `enforcementAction: "backtrack"`: restore the workspace, then continue from
+  the restored prompt and round.
+- `prompt` is null: inspect `stopReason`.
+
+`completed` means the task ended with success. `failed` means the Agent gave
+up. `blocked` means current constraints prevent progress. `max_rounds` is the
+safety limit. `stalled` means no usable next state was produced.
+`enforcement_terminated` means repeated integrity failures reached a terminal
+ladder. `paused` means the durable session remains available for resume.
+
+## Prompt levels and views
+
+L0 is a lean same-round retry, L1 is normal continuation, and L2 is full
+rehydration. They control state density only and never prescribe a reasoning
+technique. Mandatory prompt sections and the token budget remain enforced.
+
+Use `loopforge_status` with `view: "session"` for the live round and typed
+projection, `view: "loop"` for alignment and drift, `view: "all"` after a
+restart, and `view: "audit"` for the read-only completeness and evidence audit.
+Use `loopforge_replay` for the committed timeline and round diffs. Replay
+answers what happened; Audit checks whether facts and claims are supported.
+
+The optional `.loopforge/state/<loopId>-state.md` file is derived and can be
+regenerated. Read it in L2 pointer mode when the prompt asks for full context,
+but do not treat it as an independent source of truth.
+
+## Control and delegation
+
+Use `loopforge_pause` before an intentional interruption,
+`loopforge_resume` to reconstruct a durable session, and `loopforge_stop` only
+for an intentional terminal stop. Use `loopforge_gate_check` and
+`loopforge_gate_resolve` for recorded human or agent gates.
+
+Delegation does not create a separate LoopForge mode. Give each worker a
+self-contained subtask and relevant hard constraints, then place its result in
+`worker_results` so discoveries can enter the next Canonical State.
+
+## Rules
 
-- `loopforge_status({scope: "session", sessionId})` shows the live round. Add
-  `detail: "full"` for cognition projections, prompt diagnostics, metrics and
-  audit data.
-- `loopforge_status({scope: "loop", loopId})` reads loop-level health and
-  audit. `scope: "all"` lists persisted loop summaries (including stopped
-  loops for audit/recovery inspection) and accepts no ID.
-- `loopforge_history({loopId, view: "round", round})` reads one persisted
-  round. `view: "timeline"` reads events in `event_sequence` order; use
-  `fromSequence`, `toSequence` and `limit` (1-200) for pagination.
-- `loopforge_audit({loopId})` is read-only and reports criteria coverage,
-  contradictions, evidence availability, unresolved User Gates, regression
-  obligations and `sequenceComplete`.
-
-The old names `loopforge_list`, `loopforge_health`, `loopforge_inspect`, and
-`loopforge_replay` are not public tools.
-
-## 7. Pause and resume
-
-Call `loopforge_pause` before an intentional interruption. After a client or
-process restart, call `loopforge_resume` with the saved `loopId`; do not start a
-new loop just because the in-memory session disappeared. Compare the returned
-`stateHash` and `promptHash`, then execute the rebuilt prompt. A loop can be
-resumed only from its persisted vault state.
-
-## 8. Prompt levels and projections
-
-- **L0**: compact same-round retry with the rejection gap.
-- **L1**: normal continuation with current focus and required evidence.
-- **L2**: full rehydration after the first round, a phase boundary, goal or
-  constraint change, stale or contradictory evidence, drift, recovery, or
-  repeated low-information rounds.
-
-L0/L1/L2 control state density, not reasoning strategy. The prompt compiler
-reads canonical Goal, RoundEvent, EvidenceEnvelope, Constraint, SubGoal and
-GateDecision facts, then derives Phase, Focus, Todo, Handoff, progress and
-diagnostics. Mandatory objective, focus, gate, hard constraints and required
-fixes remain present under a prompt budget.
-
-## 9. Workspace and command safety
-
-When LoopForge requests verification, run commands in the bound workspace only.
-Use executable plus argument arrays, `shell: false`, timeouts, output limits and
-path-boundary checks. Do not concatenate user-controlled strings into shell
-commands. This is LoopForge's evidence boundary; it does not grant or revoke
-the Agent's ordinary tool permissions.
-
-## 10. Long-horizon habits
-
-Keep one loop focused on one user objective. Submit one honest report per
-round, preserve criterion and constraint IDs, and include a concrete next
-verification when continuing. Inspect the full state on L2 rounds. Use pause
-before handoff and audit before claiming final completion. LoopForge supports
-long runs through explicit rounds and durable replay, but it does not execute
-rounds in the background for you.
-
-## 11. Reliability rules
-
-An invalid report is an input error, not a round fact. The runtime leaves the
-current `roundId`, attempt, state and vault unchanged and returns
-`invalid_round_report`; submit a corrected report instead of starting a new
-loop. A persistence error is not recoverable by pretending success: stop and
-retry the operation after the storage boundary is healthy.
-
-Evidence capture and recovery are asynchronous. `maxRounds` must be a positive
-integer no greater than the configured policy limit. Corrupt JSON, an invalid
-event format, or a sequence gap returns `storage_corruption`; the runtime never
-sorts, fills, or rewrites damaged history. Terminal enforcement rules track
-their escalation retry independently; the same rule terminates only after its
-guided retry has already been used.
-
-When intent drift is reported, use `driftClarification` with a concrete
-explanation and an anchor that exists in the current criteria, constraints or
-observed workspace evidence. Do not send `clarification_accepted: true`.
-Runtime verification owns the clarification streak and any escalation.
+1. Execute the prompt instead of generating another prompt.
+2. Submit one honest structured evaluation after each attempt.
+3. Restore the workspace before working after backtrack.
+4. Treat required command evidence and verification errors as authoritative.
+5. Keep one loop focused on one user objective.
+6. Do not advance a paused or stopped session through another process.
+7. Continue within the same Agent task when possible. LoopForge preserves state
+   but does not create a background Agent.

package/dist/canonical-event-writer.d.ts

@@ -1,20 +0,0 @@
-import type { LoopStore } from "./loop-store.js";
-import type { VaultEntry } from "./vault-types.js";
-/** Single write boundary for canonical loop events.
- *
- * Stores may provide their own atomic sequence allocator (FileLoopStore does),
- * but the writer also assigns and validates sequences for lightweight test or
- * embedding backends. Every runtime event therefore enters the Vault through
- * one deterministic path.
- */
-export declare class CanonicalEventWriter {
-    private readonly backend;
-    constructor(backend: LoopStore);
-    private allEntries;
-    private replaceExisting;
-    private existing;
-    append(entry: VaultEntry): VaultEntry;
-    appendBatch(entries: VaultEntry[]): VaultEntry[];
-    private assertSequence;
-}
-//# sourceMappingURL=canonical-event-writer.d.ts.map

package/dist/canonical-event-writer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"canonical-event-writer.d.ts","sourceRoot":"","sources":["../src/canonical-event-writer.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACjD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAEnD;;;;;;GAMG;AACH,qBAAa,oBAAoB;IACnB,OAAO,CAAC,QAAQ,CAAC,OAAO;gBAAP,OAAO,EAAE,SAAS;IAE/C,OAAO,CAAC,UAAU;IAelB,OAAO,CAAC,eAAe;IAQvB,OAAO,CAAC,QAAQ;IAMhB,MAAM,CAAC,KAAK,EAAE,UAAU,GAAG,UAAU;IAkCrC,WAAW,CAAC,OAAO,EAAE,UAAU,EAAE,GAAG,UAAU,EAAE;IAuChD,OAAO,CAAC,cAAc;CAiBvB"}

package/dist/canonical-event-writer.js

@@ -1,131 +0,0 @@
-import { StorageCorruptionError } from "./loop-store.js";
-/** Single write boundary for canonical loop events.
- *
- * Stores may provide their own atomic sequence allocator (FileLoopStore does),
- * but the writer also assigns and validates sequences for lightweight test or
- * embedding backends. Every runtime event therefore enters the Vault through
- * one deterministic path.
- */
-export class CanonicalEventWriter {
-    backend;
-    constructor(backend) {
-        this.backend = backend;
-    }
-    allEntries() {
-        // Global replacement needs entries from every loop, including backends
-        // whose default query excludes canonical `:event` records. Keep this
-        // fallback centralized here; per-loop runtime reads use queryLoopEvents.
-        const entries = this.backend.listLoopIds()
-            .flatMap((loopId) => this.backend.queryLoopEvents(loopId));
-        const seen = new Set();
-        return entries.filter((entry) => {
-            const key = `${entry.task_id ?? entry.id ?? ""}:${entry.event_sequence ?? ""}`;
-            if (seen.has(key))
-                return false;
-            seen.add(key);
-            return true;
-        });
-    }
-    replaceExisting(loopId, updated) {
-        const all = this.allEntries();
-        const filtered = all.filter((candidate) => !(candidate.loop_id === loopId && candidate.task_id === updated.task_id));
-        const replacement = [...filtered, updated];
-        this.backend.replaceEntries(replacement);
-    }
-    existing(loopId) {
-        const entries = this.backend.queryLoopEvents(loopId);
-        this.assertSequence(loopId, entries);
-        return entries;
-    }
-    append(entry) {
-        const write = () => {
-            const loopId = entry.loop_id;
-            if (!loopId)
-                throw new Error("Canonical events require loop_id");
-            if (entry.loop_id !== loopId)
-                throw new StorageCorruptionError("sequence_cross_loop", loopId, loopId);
-            const existing = this.existing(loopId);
-            const prior = existing.find((candidate) => candidate.task_id === entry.task_id);
-            if (prior && Number.isInteger(prior.event_sequence)) {
-                const updated = { ...entry, event_sequence: prior.event_sequence };
-                const priorComparable = { ...prior, id: undefined, timestamp: undefined };
-                const updatedComparable = { ...updated, id: undefined, timestamp: undefined };
-                if (JSON.stringify(priorComparable) === JSON.stringify(updatedComparable))
-                    return prior;
-                this.replaceExisting(loopId, updated);
-                return updated;
-            }
-            const max = existing.reduce((value, candidate) => typeof candidate.event_sequence === "number" && Number.isInteger(candidate.event_sequence)
-                ? Math.max(value, candidate.event_sequence)
-                : value, 0);
-            const next = max + 1;
-            const sequenced = { ...entry, event_sequence: entry.event_sequence ?? next };
-            if (!Number.isInteger(sequenced.event_sequence) || sequenced.event_sequence < 1 ||
-                existing.some((candidate) => candidate.event_sequence === sequenced.event_sequence)) {
-                throw new StorageCorruptionError("sequence_duplicate", loopId, loopId, sequenced.event_sequence);
-            }
-            if (sequenced.event_sequence !== next) {
-                throw new StorageCorruptionError("sequence_gap", loopId, loopId, sequenced.event_sequence);
-            }
-            this.backend.appendEntry(sequenced);
-            return sequenced;
-        };
-        return this.backend.withLock(write);
-    }
-    appendBatch(entries) {
-        if (entries.length === 0)
-            return [];
-        const write = () => {
-            const loopIds = new Set(entries.map((entry) => entry.loop_id));
-            if (loopIds.size !== 1 || loopIds.has(undefined)) {
-                throw new Error("A canonical event batch must belong to one loop");
-            }
-            const loopId = [...loopIds][0];
-            const existing = this.existing(loopId);
-            const existingTaskIds = new Set(existing.map((candidate) => candidate.task_id).filter(Boolean));
-            const batchTaskIds = entries.map((entry) => entry.task_id).filter(Boolean);
-            if (batchTaskIds.length !== new Set(batchTaskIds).size ||
-                batchTaskIds.some((taskId) => existingTaskIds.has(taskId))) {
-                throw new Error(`Duplicate canonical task id in event batch for loop ${loopId}`);
-            }
-            const used = new Set(existing
-                .map((candidate) => candidate.event_sequence)
-                .filter((value) => typeof value === "number" && Number.isInteger(value)));
-            let next = existing.reduce((value, candidate) => typeof candidate.event_sequence === "number" && Number.isInteger(candidate.event_sequence)
-                ? Math.max(value, candidate.event_sequence)
-                : value, 0) + 1;
-            const sequenced = entries.map((entry) => ({ ...entry, event_sequence: entry.event_sequence ?? next++ }));
-            const seen = new Set();
-            for (const entry of sequenced) {
-                if (!Number.isInteger(entry.event_sequence) || used.has(entry.event_sequence) || seen.has(entry.event_sequence)) {
-                    throw new StorageCorruptionError("sequence_duplicate", loopId, loopId, entry.event_sequence);
-                }
-                if (entry.event_sequence !== (existing.length ? Math.max(...used) : 0) + 1 + seen.size) {
-                    throw new StorageCorruptionError("sequence_gap", loopId, loopId, entry.event_sequence);
-                }
-                seen.add(entry.event_sequence);
-            }
-            this.backend.appendEntries(sequenced);
-            return sequenced;
-        };
-        return this.backend.withLock(write);
-    }
-    assertSequence(loopId, entries) {
-        const sorted = [...entries].sort((a, b) => (a.event_sequence ?? 0) - (b.event_sequence ?? 0));
-        const seen = new Set();
-        for (let index = 0; index < sorted.length; index++) {
-            const sequence = sorted[index].event_sequence;
-            if (!Number.isInteger(sequence) || sequence < 1) {
-                throw new StorageCorruptionError("sequence_invalid", loopId, loopId, sequence);
-            }
-            if (seen.has(sequence)) {
-                throw new StorageCorruptionError("sequence_duplicate", loopId, loopId, sequence);
-            }
-            seen.add(sequence);
-            if (sequence !== index + 1) {
-                throw new StorageCorruptionError("sequence_gap", loopId, loopId, sequence);
-            }
-        }
-    }
-}
-//# sourceMappingURL=canonical-event-writer.js.map

package/dist/canonical-event-writer.js.map

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

package/dist/compiler-subgoals.d.ts

@@ -1,7 +0,0 @@
-import type { CompilerRoundProjection, SubGoal } from "./protocol.js";
-type Entry = Record<string, unknown>;
-type EntryProjection = (entry: Entry) => CompilerRoundProjection | null;
-/** Derive the complete SubGoal lifecycle from prior entries and this projection. */
-export declare function manageSubGoals(loopId: string, currentRound: number, lastRoundResult: CompilerRoundProjection | null, vaultContext: Record<string, unknown> | null, project: EntryProjection): SubGoal[];
-export {};
-//# sourceMappingURL=compiler-subgoals.d.ts.map

package/dist/compiler-subgoals.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"compiler-subgoals.d.ts","sourceRoot":"","sources":["../src/compiler-subgoals.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,uBAAuB,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAItE,KAAK,KAAK,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AACrC,KAAK,eAAe,GAAG,CAAC,KAAK,EAAE,KAAK,KAAK,uBAAuB,GAAG,IAAI,CAAC;AAoBxE,oFAAoF;AACpF,wBAAgB,cAAc,CAC5B,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,MAAM,EACpB,eAAe,EAAE,uBAAuB,GAAG,IAAI,EAC/C,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,EAC5C,OAAO,EAAE,eAAe,GACvB,OAAO,EAAE,CAwDX"}