loopforge 3.0.0 → 3.6.0

package/dist/protocol.d.ts

@@ -3,88 +3,261 @@
  * All types exchanged between the Main Agent and LoopForge flow through
  * these interfaces. This is the contract layer — no implementation logic.
  *
- * v1.15: 40 types — 4 enums + 35 interfaces + 1 type alias.
+ * v3.3: 41 types — 2 enums + 35 interfaces + 4 type aliases.
  */
 export declare enum Mode {
-    LOOP_COMPILE = "loop_compile"
+    LOOP_COMPILE = "loop_compile",
+    FEEDBACK = "feedback"
 }
+import type { PresentedStateSnapshot } from "./canonical-state.js";
 export declare enum AgentStatus {
     OK = "ok",
     ERROR = "error",
     STALLED = "stalled"
 }
-export type EvidenceStatus = "verified" | "claimed" | "contradicted" | "unavailable";
-export interface RoundCheckReport {
-    name: string;
-    status: "passed" | "failed" | "not_run";
-    required?: boolean;
-    summary?: string;
-    counts?: {
-        passed: number;
-        failed: number;
-        skipped: number;
-    };
-}
-export interface RoundEvidenceClaim {
-    id: string;
-    targetId: string;
-    evidenceRefs: string[];
-}
-export interface EvidenceProvenance {
-    source: "agent" | "command" | "provider" | "verification";
-    observedAt: string;
-    status: EvidenceStatus;
-    detail?: string;
-}
-export interface EvidenceEnvelope {
-    files: string[];
-    checks: RoundCheckReport[];
-    claims: RoundEvidenceClaim[];
-    provenance: Record<string, EvidenceProvenance>;
-    noChangeReason?: string;
-}
-/** Runtime-derived evidence view. It is rebuilt from a RoundReport and
- * provider snapshots; it is never persisted as an independent fact. */
-export interface EvidenceDerivedView {
-    reportedFiles: string[];
-    observedFiles: string[];
-    checks: RoundCheckReport[];
-    verifiedClaims: string[];
-    contradictedClaims: string[];
-    unavailableClaims: string[];
-    criteriaMet: string[];
-    criteriaRemaining: string[];
-    progressRatio: number | null;
-    testCounts: {
+export interface ExecutionFeedback {
+    output: string;
+    success: boolean;
+    constraint_violations: string[];
+    manual_fixes_needed: string;
+}
+export declare function makeExecutionFeedback(overrides?: Partial<ExecutionFeedback>): ExecutionFeedback;
+/** P4: Structured execution evidence reported by the agent after each round.
+ *  Gives LoopForge visibility into what actually happened — files changed,
+ *  test results, success criteria met, and a subjective progress estimate.
+ *  Enables the compiler to cross-validate agent claims and compute real progress. */
+export interface ExecutionEvidence {
+    /** Files changed in this round. Empty if no files were modified. */
+    files_changed: string[];
+    /** Test results. null if no tests were run. */
+    test_results: {
         passed: number;
         failed: number;
         skipped: number;
     } | null;
-    requiredCommandFailures: string[];
-    /** Whether completion evidence came from a live provider. */
-    providerStatus: "verified" | "unavailable" | "absent";
+    /** Success criteria from the Loop Objective that were MET this round. */
+    success_criteria_met: string[];
+    /** Success criteria from the Loop Objective that REMAIN unmet. */
+    success_criteria_remaining: string[];
+    /** Agent's own estimate of overall progress (0.0 to 1.0). */
+    progress_estimate: number;
+}
+export declare function makeExecutionEvidence(overrides?: Partial<ExecutionEvidence>): ExecutionEvidence;
+/** P5: A revision to a success criterion — the old form and the new form.
+ *  The agent proposes this when it discovers the original criterion was
+ *  wrong, unrealistic, or needs refinement. */
+export interface CriterionRevision {
+    old: string;
+    new: string;
 }
-/** Durable decision event for a derived user/agent gate.  The gate itself is
- * rebuilt from canonical facts; only the decision is persisted. */
-export interface GateDecision {
-    gateId: string;
-    kind: "user" | "agent";
-    approved: boolean;
+/** v3.3: Round Contract. v3.4 semantics: the field on a submission is a
+ *  PROPOSAL for the NEXT round — it becomes the ACTIVE contract (rendered
+ *  as the Current Task and checked for execution conformance) only after
+ *  the declaring round commits, and stays active until a committed eval
+ *  lists every done_when item in success_criteria_met (complete) or
+ *  reports outcome="blocked". While active it is restated unchanged each
+ *  round; on completion or block, the next contract is declared instead.
+ *  The ACTIVE contract is machine-derived from committed rounds
+ *  (round-contract.ts) — never read from last_round_result. Optional:
+ *  absent = no contract this round, all contract checks stay silent and
+ *  rendering is identical to a contract-less round.
+ *
+ *  Every field is machine-checkable:
+ *  - done_when items are claimed satisfied by listing them in
+ *    execution_evidence.success_criteria_met (verified per-round claim
+ *    model); leaving them out while success is claimed is premature_boundary
+ *    against the ACTIVE contract.
+ *  - verification_plan names must reference configured, enabled
+ *    evidence.commands (round_unverifiable otherwise).
+ *  - scope lists the files/directories the round may touch; actual git
+ *    changes outside it trigger round_scope_drift against the ACTIVE
+ *    contract. */
+export interface RoundContract {
+    /** Round focus, one line. Rendered as the Current Task's first line. */
+    work_item?: string;
+    /** Completion conditions: cr-XXXXXXXX criterion IDs or free text.
+     *  Claimed met = listed in success_criteria_met; still open = listed in
+     *  success_criteria_remaining. ≤ 20 items. */
+    done_when: string[];
+    /** Verification plan: names of configured, enabled evidence commands
+     *  (policy.evidence.commands[].name). ≤ 20 items. */
+    verification_plan: string[];
+    /** Files/directories this round may touch (workspace-relative paths,
+     *  forward or back slashes, "./" prefix and trailing slashes accepted).
+     *  Out-of-scope git changes = round_scope_drift. ≤ 50 items. */
     scope: string[];
-    note: string;
-    decidedAt: string;
-    /** Stable hash of the structured action that was approved. */
-    actionHash: string;
-}
-export interface RegressionObligation {
-    id: string;
-    description: string;
-    sourceRound: number;
-    evidenceRefs: string[];
-    status: "open" | "satisfied" | "contradicted";
 }
+/** Structured self-evaluation submitted at the round boundary.
+ *  The agent outputs this after completing each round.
+ *  Every field is consumed by at least one downstream function.
+ *
+ *  v1.4 (P0–P2): Three new optional fields enable cognitive evolution.
+ *  v1.5 (P4–P5): Execution evidence, progress tracking, and self-correction. */
+export interface SelfEvaluation {
+    /** true ONLY if all hard constraints were met and the task goal was achieved. */
+    success: boolean;
+    /** Specific, actionable summary of what was DONE this round.
+     *  Feeds: buildRollingSummary (key_outcomes),
+     *  computeConstraintRetirement (activity detection), vault lineage. */
+    output_summary: string;
+    /** Constraints the agent actually violated this round.
+     *  Feeds: checkLoopHealth (constraint_integrity),
+     *  buildRollingSummary (recurring_issues), computeConstraintRetirement. */
+    constraint_violations: string[];
+    /** false ONLY when the entire task is complete. Tells the autonomous
+     *  runner to stop the loop. Not consumed by the compiler. */
+    should_continue: boolean;
+    /** P0: New constraints discovered during this round that were not
+     *  known before. Merged into the active constraint set by the compiler.
+     *  Omit or leave empty if none discovered. */
+    discovered_constraints?: string[];
+    /** P1: A refinement / deepening of the task objective based on this
+     *  round's discoveries. Appended to (never replaces) the original
+     *  objective. Omit if understanding is unchanged. */
+    objective_refinement?: string;
+    /** P2: Sub-problems that surfaced during execution and may need
+     *  separate attention. Feed into the next-task suggestion.
+     *  Omit or leave empty if none emerged. */
+    emerged_subtasks?: string[];
+    /** P4: Structured evidence of what was executed this round.
+     *  Files changed, test results, criteria met/remaining, progress estimate.
+     *  Enables the compiler to validate claims and compute real progress. */
+    execution_evidence?: ExecutionEvidence;
+    /** P5: Constraints that the agent now believes are wrong or irrelevant.
+     *  Removed from the active constraint set by the compiler.
+     *  Omit or leave empty if none. */
+    retracted_constraints?: string[];
+    /** P5: Success criteria that need revision. The agent discovered the
+     *  original criterion was incorrect and proposes a new formulation.
+     *  Applied to the Loop Objective by the compiler (version++). */
+    revised_success_criteria?: CriterionRevision[];
+    /** P5: Assumptions the agent made in earlier rounds that turned out to
+     *  be wrong. Recorded in the rolling summary as key lessons.
+     *  Omit or leave empty if none. */
+    wrong_assumptions?: string[];
+    /** v1.10: Agent declares a subtask boundary. When true, the compiler
+     *  generates an agent_declared milestone. */
+    compression_checkpoint?: boolean;
+    /** v1.10: Human-readable label for this checkpoint (e.g. "数据模型层完成").
+     *  Used as the checkpoint heading in subsequent prompts. */
+    checkpoint_label?: string;
+    /** Multi-agent: Results of sub-agent / Worker delegations this round.
+     *  The main agent (or Coordinator) reports what it delegated.
+     *  The engine automatically writes these to the delegation journal.
+     *  Omit or leave empty if no delegations occurred. */
+    worker_results?: WorkerResult[];
+    /** v1.16: Agent's declared next action — what it plans to do in the
+     *  following round. Stored as loop state and rendered in the next prompt
+     *  so the agent's self-planning persists across rounds. Optional —
+     *  no next_action means the compiler generates the next task as before. */
+    next_action?: string;
+    /** v2.2: Sub-tasks the agent completed this round. Each entry may be a
+     *  sub-goal ID (e.g. "sg-a3f2b1c0" from the Sub-Goal Dashboard) for
+     *  exact matching, or a natural-language description for Jaccard
+     *  similarity fallback. Omit if none. */
+    completed_subtasks?: string[];
+    /** v2.2: Sub-tasks that are now blocked (cannot proceed). Same ID-or-
+     *  description matching as completed_subtasks. Omit if none. */
+    blocked_subtasks?: string[];
+    /** v2.2: Sub-tasks the agent is canceling (no longer needed). Same ID-or-
+     *  description matching as completed_subtasks. Omit if none. */
+    canceled_subtasks?: string[];
+    /** v2.5: Why the agent is stopping. Only meaningful when
+     *  should_continue=false and success=false. Defaults to "gave_up"
+     *  (current behavior) when absent. "blocked" means work cannot proceed
+     *  under current constraints; "needs_human_input" requires intervention. */
+    stop_reason?: "gave_up" | "blocked" | "needs_human_input";
+    /** v2.12: Declared tri-state outcome. When absent, derived from success
+     *  (true → "success", false → "failed"). "partial" and "blocked" can only
+     *  be declared explicitly. A declared non-success outcome suppresses the
+     *  success-class verification checks even when success=true. */
+    outcome?: RoundOutcome;
+    /** v2.12: Flat blocker description, meaningful only when outcome==="blocked".
+     *  Also feeds the user/agent gate classification (P2). ≤ 500 chars. */
+    blocker?: string;
+    /** v2.12: Retroactive claims that a PRIOR round satisfied a criterion.
+     *  The runtime verifies these against the prior round's git evidence.
+     *  Max 20 entries. */
+    retroactiveClaims?: {
+        round: number;
+        claim: string;
+    }[];
+    /** v2.12: Declared reason for claiming success with no machine-verifiable
+     *  evidence (e.g. "no code changes required — documentation-only round").
+     *  Downgrades the success_without_verified_evidence check from error to
+     *  info. Flat string, ≤ 200 chars. */
+    no_change_reason?: string;
+    /** v2.8: When the previous round's verification flagged intent_drift or
+     *  subgoal_drift, the agent explains why its actions diverged from its
+     *  stated plan. Populated from the self-eval block when the prompt
+     *  injected the field. Empty or absent when no drift was flagged.
+     *  Used by the enforcement gate R7 to distinguish intentional pivots
+     *  from unacknowledged drift. */
+    drift_clarification?: string;
+    /** Model's information needs for the next round's prompt.
+     *  Consumed by the Compiler — not durable across rounds. */
+    prompt_requests?: PromptRequests;
+    /** v3.3: Round Contract. v3.4: a PROPOSAL for the NEXT round's contract
+     *  (restated unchanged while the current one is active; a new one after
+     *  it completes or blocks). Becomes the ACTIVE contract only once this
+     *  round commits; it is then derived at compile time from committed
+     *  rounds — see round-contract.ts. Optional. */
+    round_contract?: RoundContract;
+}
+/** v2.12: Tri-state round outcome. Declared via SelfEvaluation.outcome;
+ *  derived from `success` when absent. Shared by the dual gates, the stop
+ *  mapping, and the audit view. */
 export type RoundOutcome = "success" | "partial" | "failed" | "blocked";
-export type RoundContinuation = "continue" | "stop";
+/** v2.12: Typed cognitive state projection — runtime-derived facts shipped
+ *  with advance/status outputs. All fields are derived, zero persistence.
+ *  Consumers: advance output (main agent), status (human/tooling), resume
+ *  handoff. The runtime provides facts; the agent decides actions. */
+export interface LoopProjection {
+    /** Current focus — last non-failed round's output summary. */
+    focus: {
+        what: string;
+        since_round: number;
+    } | null;
+    /** Suggested next steps: agent-declared intent vs compiler-derived
+     *  pending/blocked sub-goals. Non-authoritative. */
+    todo: Array<{
+        id: string;
+        item: string;
+        reason: string;
+        source: "derived" | "agent_intent";
+        priority: number;
+    }>;
+    /** Phase boundaries from milestone history. */
+    phase: {
+        current: string;
+        label: string;
+        boundaries: Array<{
+            label: string;
+            round: number;
+        }>;
+    } | null;
+    /** Record view of the main agent's reported delegation state — facts
+     *  only, never a task book for sub-agents. */
+    delegation: {
+        pending: number;
+        last_results: Array<{
+            agentId: string;
+            outcome: string;
+            round: number;
+            summary: string;
+        }>;
+    };
+    /** Handoff capsule for resume / process handover. `verified` holds
+     *  cr-IDs backed by the P0 provenance layer. */
+    handoff: {
+        summary: string;
+        verified: string[];
+        open_risks: string[];
+    };
+}
+export declare function makeLoopProjection(overrides?: Partial<LoopProjection>): LoopProjection;
+/** v2.12: Structured high-risk action descriptor (internal — audit display
+ *  and gate classification). The MCP surface uses a flat gate text instead. */
 export interface GateActionDescriptor {
     description: string;
     scope: string[];
@@ -92,122 +265,32 @@ export interface GateActionDescriptor {
     reversibility: "reversible" | "recoverable" | "irreversible" | "unknown";
     authorization: "agent_allowed" | "user_required" | "unknown";
 }
-export interface RoundReport {
-    format: "loopforge.round-report";
-    outcome: RoundOutcome;
-    continuation: RoundContinuation;
-    summary: string;
-    violations: string[];
-    evidence?: EvidenceEnvelope;
-    blocker?: {
-        kind: "dependency" | "external" | "needs_human_input" | "agent";
-        reason: string;
-        references: string[];
-        action?: GateActionDescriptor;
-    };
-    discoveries?: {
-        wrongAssumptions: string[];
-        emergedWork: string[];
-        facts: string[];
-        newConstraints: string[];
-    };
-    subGoalEvents?: {
-        completed: string[];
-        blocked: string[];
-        canceled: string[];
-    };
-    /** Irreducible Constraint facts; unlike Focus/Todo these cannot be derived. */
-    constraintEvents?: {
-        retired: string[];
-    };
-    /** Irreducible Goal facts for correcting a criterion without replacing it silently. */
-    criterionRevisions?: CriterionRevision[];
-    objectiveRefinement?: string;
-    phaseBoundaryProposal?: {
-        label: string;
-        reason: string;
-    };
-    contextRequest?: PromptRequests;
-    /** Agent suggestion only. Runtime-derived focus and todo always win. */
-    agentIntent?: string;
-    /** Structured explanation used only when the runtime detects intent drift. */
-    driftClarification?: {
-        explanation: string;
-        anchors: string[];
-    };
-}
-export interface PhaseHistoryEntry {
-    id: string;
-    label: string;
-    status: "active" | "completed" | "abandoned";
-    enteredAtRound: number;
-    closedAtRound?: number;
-    outcome: string;
-    evidenceRefs: string[];
-}
-export interface TodoProjection {
-    id: string;
-    sourceType: "verification" | "criterion" | "sub_goal" | "blocker";
-    sourceId: string;
-    action: string;
-    completionSignal: string;
-    evidenceRequirements: string[];
-    gate: "none" | "agent" | "user";
-}
-export type DerivedGate = {
-    kind: "user";
-    question: string;
-    blockedScope: string[];
-    allowedWork: string[];
-} | {
-    kind: "agent";
-    problem: string;
-    requiredEvidence: string[];
-    suggestedResolution: string;
-};
-export interface HandoffProjection {
-    goalId: string;
-    roundId: string;
-    phaseId?: string;
-    focus: string;
-    verifiedFacts: string[];
-    unresolvedBlockers: string[];
-    carriedConstraints: string[];
-    failedAttempts: string[];
-    wrongAssumptions: string[];
-    evidenceRefs: string[];
-    regressionObligations: RegressionObligation[];
-    suggestedNextAction?: string;
-    gate?: DerivedGate;
-}
-/** Narrow compiler input derived from a verified canonical report. */
-export interface CompilerRoundProjection {
-    round: number;
-    outcome: RoundOutcome;
-    continuation: RoundContinuation;
-    summary: string;
-    violations: string[];
-    evidence: EvidenceDerivedView;
-    discoveries?: RoundReport["discoveries"];
-    subGoalEvents?: RoundReport["subGoalEvents"];
-    constraintEvents?: RoundReport["constraintEvents"];
-    criterionRevisions?: RoundReport["criterionRevisions"];
-    objectiveRefinement?: string;
-    phaseBoundaryProposal?: RoundReport["phaseBoundaryProposal"];
-    agentIntent?: string;
-    /** v2.9: Model-expressed information needs carried from the report
-     *  into the next prompt compilation. Transient — never persisted. */
-    contextRequest?: PromptRequests;
-}
-/** P5: A revision to a success criterion — the old form and the new form.
- *  The agent proposes this when it discovers the original criterion was
- *  wrong, unrealistic, or needs refinement. */
-export interface CriterionRevision {
-    old: string;
-    new: string;
+/** v2.12: Classified gate — user gates need human authorization, agent
+ *  gates are resolved by the agent submitting verifiable evidence. */
+export interface DerivedGate {
+    kind: "user" | "agent";
+    question?: string;
+    blockedScope?: string[];
+    allowedWork?: string[];
+    problem?: string;
+    requiredEvidence?: string[];
+    suggestedResolution?: string;
+}
+/** v2.12: A persisted user decision for a gate. The actionHash binds the
+ *  approval to the exact canonicalized action — an edited action changes
+ *  the hash, so stale approvals fail the gateId match automatically. */
+export interface GateDecision {
+    gateId: string;
+    kind: "user" | "agent";
+    approved: boolean;
+    scope: string[];
+    note: string;
+    decidedAt: string;
+    actionHash: string;
 }
+export declare function makeGateDecision(overrides?: Partial<GateDecision>): GateDecision;
 /** v2.9: Model-expressed information needs for the next round.
- *  Submitted via RoundReport.contextRequest, consumed by the
+ *  Submitted via SelfEvaluation.prompt_requests, consumed by the
  *  Compiler when assembling the next prompt. Transient — each round's
  *  requests apply to that round only. */
 export interface PromptRequests {
@@ -217,9 +300,6 @@ export interface PromptRequests {
      *  only reordered. Max entries: policy-driven (L2: 5, L1: 3).
      *  L0: ignored. */
     emphasize?: string[];
-    /** Structured sections to expand to full detail.
-     *  L2: ignored (already expanded). L1: max 1 section. L0: ignored. */
-    expand?: ("milestones" | "sub_goals" | "constraint_lifecycle" | "agent_trust" | "progress" | "loop_synthesis")[];
     /** Things the model is confused about. Rendered at the prompt top
      *  as "Confusion Alerts" before the Objective section. Compiler
      *  auto-matches each entry against state sections and provides
@@ -252,7 +332,7 @@ export interface MilestoneSummary {
     carried_constraints: string[];
     /** Constraints resolved during this phase. */
     resolved_constraints: string[];
-    /** Runtime-derived verified progress at the milestone boundary. */
+    /** Agent's progress_estimate at the milestone boundary. */
     progress_at_boundary: number;
     /** How this milestone was created. */
     kind: "agent_declared" | "criteria_milestone" | "auto";
@@ -267,11 +347,17 @@ export interface WorkerResult {
     subTask: string;
     resultSummary: string;
     success: boolean;
+    /** v2.12: Declared worker outcome. When absent, derived from success
+     *  (true → "success", false → "failed"). "partial" is explicit only. */
+    outcome?: "success" | "partial" | "failed";
     discoveredConstraints?: string[];
 }
+export declare function makeSelfEvaluation(overrides?: Partial<SelfEvaluation>): SelfEvaluation;
+/** Regex to extract a self-evaluation JSON block from agent output. */
 export interface LoopForgeRequest {
     task: string;
     mode: Mode;
+    feedback: ExecutionFeedback | null;
     skill_name: string | null;
     task_id: string | null;
     [key: string]: unknown;
@@ -289,6 +375,35 @@ export interface LoopObjective {
      *  Each entry is the refinement text from a single round. */
     refinement_history?: string[];
 }
+/** v3.2: Derived per-criterion status for the progress dashboard — the
+ *  "goal → criteria → evidence" vertical view. Zero persistence: derived from
+ *  vault entries each round (met/remaining reports + Jaccard sub-goal links). */
+export interface CriterionStatus {
+    /** Stable ID derived from the criterion text (cr-XXXXXXXX). */
+    id: string;
+    /** The criterion text as declared in the objective. */
+    text: string;
+    status: "met" | "remaining" | "unknown";
+    /** Round when the criterion was first reported met (machine-backed). */
+    met_at_round?: number;
+    /** Sub-goals whose description matches this criterion (Jaccard). */
+    related_subgoal_ids: string[];
+}
+export declare function makeCriterionStatus(overrides?: Partial<CriterionStatus>): CriterionStatus;
+/** v3.2: A deterministic "lesson learned" — a constraint or verification
+ *  check that failed repeatedly across rounds. Rendered in the prompt to
+ *  immunize the agent against repeating the same mistakes. Zero persistence:
+ *  derived from vault entries each round; presentation only — never feeds
+ *  the enforcement gate's decisions. */
+export interface Lesson {
+    /** Constraint text or verification check name. */
+    text: string;
+    kind: "constraint_violation" | "verification_error" | "verification_warning";
+    /** How many rounds this lesson occurred in. */
+    count: number;
+    /** The rounds it occurred in, ascending. */
+    rounds: number[];
+}
 export declare function makeLoopObjective(overrides?: Partial<LoopObjective>): LoopObjective;
 export interface LoopHealth {
     goal_alignment: number;
@@ -315,10 +430,6 @@ export interface RollingSummary {
      *  (agent_declared > criteria_milestone > auto). Rendered in L2 prompts
      *  and always written to the state file. */
     milestones?: MilestoneSummary[];
-    /** v2.1: Single-paragraph structural synthesis of the entire loop.
-     *  Generated at L2 level. Formulaic, not NLP. Contains round count,
-     *  phase count, overall progress, and active constraint summary. */
-    loop_synthesis?: string;
 }
 export declare function makeRollingSummary(overrides?: Partial<RollingSummary>): RollingSummary;
 /** v2.2: A structured sub-goal tracked by the compiler across rounds.
@@ -372,6 +483,62 @@ export interface TaskAlignment {
     escalation: string;
 }
 export declare function makeTaskAlignment(overrides?: Partial<TaskAlignment>): TaskAlignment;
+export interface LoopRoundResult {
+    round: number;
+    success: boolean;
+    output_summary: string;
+    constraint_violations: string[];
+    manual_fixes_needed: string;
+    /** P0: Constraints discovered during this round. */
+    discovered_constraints?: string[];
+    /** P1: Objective refinement from this round. */
+    objective_refinement?: string;
+    /** P2: Sub-problems that emerged during this round. */
+    emerged_subtasks?: string[];
+    /** P4: Execution evidence from this round. */
+    execution_evidence?: ExecutionEvidence;
+    /** P5: Constraints retracted this round. */
+    retracted_constraints?: string[];
+    /** P5: Success criteria revised this round. */
+    revised_success_criteria?: CriterionRevision[];
+    /** P5: Wrong assumptions identified this round. */
+    wrong_assumptions?: string[];
+    /** Multi-agent: Delegation results from this round.
+     *  Set from SelfEvaluation.worker_results during buildLoopRequest. */
+    worker_results?: WorkerResult[];
+    /** v1.10: Agent declared a subtask boundary in this round. */
+    compression_checkpoint?: boolean;
+    /** v1.10: Human-readable label for the checkpoint. */
+    checkpoint_label?: string;
+    /** v1.16: Agent's declared next action for the following round. */
+    next_action?: string;
+    /** v2.2: Sub-tasks completed this round. */
+    completed_subtasks?: string[];
+    /** v2.2: Sub-tasks blocked this round. */
+    blocked_subtasks?: string[];
+    /** v2.2: Sub-tasks canceled this round. */
+    canceled_subtasks?: string[];
+    /** v2.8: Agent's explanation for intent/subgoal drift detected in
+     *  the previous round. Carried forward from SelfEvaluation. */
+    drift_clarification?: string;
+    /** Model's information needs for the next round's prompt.
+     *  Carried forward from SelfEvaluation. Consumed by the Compiler. */
+    prompt_requests?: PromptRequests;
+    /** v2.12: Declared tri-state outcome. Carried forward from SelfEvaluation. */
+    outcome?: RoundOutcome;
+    /** v2.12: Flat blocker description (outcome==="blocked" only). */
+    blocker?: string;
+    /** v2.12: Retroactive claims against prior rounds. */
+    retroactiveClaims?: {
+        round: number;
+        claim: string;
+    }[];
+    /** v2.12: Declared reason for success without machine evidence.
+     *  Carried forward from SelfEvaluation. */
+    no_change_reason?: string;
+}
+export declare function makeRoundContract(overrides?: Partial<RoundContract>): RoundContract;
+export declare function makeLoopRoundResult(overrides?: Partial<LoopRoundResult>): LoopRoundResult;
 export interface LoopCompileRequest {
     mode: Mode;
     loop_id: string;
@@ -384,7 +551,7 @@ export interface LoopCompileRequest {
     plan_source: string | null;
     constraints_from_plan: string[];
     new_since_last_round: string;
-    last_round_view: CompilerRoundProjection | null;
+    last_round_result: LoopRoundResult | null;
     force_level: string;
     health_check_interval: number;
     /** Optional context supplied explicitly by the embedding Agent. */
@@ -401,13 +568,13 @@ export interface LoopCompileRequest {
     attempt: number;
     /** Consecutive zero-commit enforcement rejections for this round. */
     consecutive_rejections: number;
-    /** Structured enforcement guidance rendered into retry prompts. */
+    /** Structured enforcement feedback rendered into retry prompts. */
     rejection_notice: string;
 }
 export declare function makeLoopCompileRequest(overrides?: Partial<LoopCompileRequest>): LoopCompileRequest;
 /** Immutable record of the exact prompt delivered for one round attempt. */
 export interface PromptArtifact {
-    format: "loopforge.prompt";
+    schemaVersion: 1;
     roundId: string;
     attempt: number;
     level: "l0" | "l1" | "l2";
@@ -417,19 +584,14 @@ export interface PromptArtifact {
     stateHash: string;
     basePromptVersion: string;
     includedSections: string[];
-    omittedSections: string[];
     budgetChars: number;
     charCount: number;
     budgetExceeded: boolean;
-    /** Vault-derived history (filled by the compiler from prior entries);
-     *  undefined when the compile path cannot resolve a value. */
-    lastL2Round?: number;
-    lastMeaningfulProgressRound?: number;
-    stateAgeRounds?: number;
-    phaseId?: string;
-    focusId?: string;
-    todoId?: string;
     generatedAt: number;
+    /** v3.2: What the rendered prompt actually presented (L1 only). Persisted
+     *  on the lineage entry as the diff baseline for L1 collapse. Absent for
+     *  L0/L2 compiles. */
+    presentedState?: PresentedStateSnapshot;
 }
 export interface LoopCompileResponse {
     status: AgentStatus;
@@ -461,40 +623,30 @@ export interface LoopCompileResponse {
     /** v2.5: Trust scores from the last 10 rounds, newest last. Empty for
      *  round 1. Reconstructed from vault entries — zero new persistence. */
     agent_trust_trend?: number[];
-    /** Rebuildable runtime projection. Kept together so derived fields cannot
-     * be mistaken for independent response facts. */
-    projection?: LoopCompileProjection;
+    /** v3.2: Derived per-criterion status (goal → criteria → evidence view).
+     *  Zero persistence — re-derived from vault entries each round. */
+    criterion_statuses?: CriterionStatus[];
+    /** v3.2: Deterministic lessons learned (repeated violations / repeated
+     *  verification failures). Presentation only — never feeds enforcement. */
+    lessons?: Lesson[];
+    suggested_next_task: string;
     plan_source: string | null;
     warnings: string[];
     error: string;
     /** v1.14: Content for the loop state file. Written by the caller
-     *  (SessionManager) to .loopforge/state/{loopId}-state.md.
-     *  Undefined for L0/L1 compilations — only L2 produces state file content. */
+     *  (SessionManager or Runtime) to .loopforge/state/{loopId}-state.md.
+     *  Present on every level when `state_file.enabled` (default true) —
+     *  L0/L1/L2 all render it. Undefined only when the state file is
+     *  disabled or the compile produced no prompt. */
     state_file_content?: string;
     /** Exact, hashed prompt record used by transaction replay and audit. */
     prompt_artifact?: PromptArtifact;
-    /** Rebuildable canonical projection for status/replay consumers. */
-    canonical_state?: Record<string, unknown>;
 }
 export declare function makeLoopCompileResponse(overrides?: Partial<LoopCompileResponse>): LoopCompileResponse;
-export interface LoopCompileProjection {
-    suggestedNextAction: string;
-    /** Accumulated, runtime-verified claim targets reconstructed from Vault. */
-    verifiedFacts: string[];
-    /** Evidence references supporting verifiedFacts. */
-    verifiedEvidenceRefs: string[];
-    /** Rebuildable regression checks accumulated from accepted evidence. */
-    regressionObligations: RegressionObligation[];
-    /** Claimed discoveries from the latest accepted RoundEvent. */
-    discoveredFacts: string[];
-    /** Current blocker facts from the latest accepted RoundEvent. */
-    activeBlockers: string[];
-}
-export declare function makeLoopCompileProjection(overrides?: Partial<LoopCompileProjection>): LoopCompileProjection;
 /** Aggregated evidence snapshot for the state file Evidence section.
  *  Four categories give the agent a clear picture of what's been confirmed,
  *  what remains, what was wrong, and what's newly discovered — all derived
- *  from accepted RoundReport events across rounds. */
+ *  from accumulated SelfEvaluation data across rounds. */
 export interface EvidenceSnapshot {
     /** Criteria met + successful outcomes confirmed across rounds. */
     verified: string[];
@@ -516,26 +668,38 @@ export interface LoopForgeResponse {
     prompt_artifact?: PromptArtifact;
     /** Structured warnings from the compiler — preferred over parsing prompt text. */
     warnings?: string[];
-    /** Rebuildable canonical projection for status consumers. */
-    canonical_state?: Record<string, unknown>;
+    /** v2.12: Compiler-derived state passed through for typed projections
+     *  (zero extra persistence — derived fresh each compile). */
+    loop_objective?: LoopObjective | null;
+    rolling_summary?: RollingSummary | null;
+    sub_goals?: SubGoal[];
+    criterion_statuses?: CriterionStatus[];
+    suggested_next_task?: string;
 }
 export interface SessionState {
     task_id: string;
+    call_count: number;
+    success_trend: boolean[];
+    current_version: string;
+    feedback_buffer: Record<string, unknown>[];
 }
 export declare function makeSessionState(taskId: string): SessionState;
 export interface AgentLoopResult {
     status: AgentStatus;
     response: LoopForgeResponse | null;
 }
-/** Why a loop stopped. Used by MCP session and vault persistence. */
-export type StopReason = "completed" | "failed" | "blocked" | "cancelled" | "max_rounds" | "circuit_breaker" | "stalled" | "executor_failure" | "enforcement_terminated"
-/** v1.18: Loop was paused by user or signal. */
+/** Why a loop stopped. Used by MCP session and vault persistence.
+ *  `completed` requires both success=true and should_continue=false.
+ *  `failed` is success=false + should_continue=false (agent gave up).
+ *  `cancelled` is manual stop via loopforge_stop. */
+export type StopReason = "completed" | "failed" | "blocked" | "cancelled" | "max_rounds" | "stalled" | "enforcement_terminated"
+/** Loop was paused by user or signal. */
  | "paused";
 /** Result of round-boundary enforcement. Decides whether to accept the round,
  *  reject it (force the agent to redo the SAME round), or terminate the loop.
  *
  *  accept:    round passes; proceed to next round as normal.
- *  reject:    agent's round report or output is invalid; the agent receives
+ *  reject:    agent's self-evaluation or output is invalid; the agent receives
  *             a rejection prompt and must redo the same round. Round counter
  *             does NOT increment.
  *  terminate: loop has reached an unrecoverable state; stop immediately with
@@ -555,8 +719,6 @@ export interface EnforcementResult {
      *  drift_clarification waiver (R7). The caller uses this to track
      *  clarification streaks independently of rejection streaks. */
     clarification_accepted?: boolean;
-    /** True when a terminal rule was converted into one final escalated reject. */
-    escalation_issued?: boolean;
 }
 export declare function makeEnforcementResult(overrides?: Partial<EnforcementResult>): EnforcementResult;
 /** Context supplied to an embedding-owned provider before compilation. */
@@ -565,8 +727,8 @@ export interface ExternalContextRequest {
     round: number;
     task: string;
     domain: string;
-    /** The previously accepted compiler view, when one exists. */
-    lastRoundView?: CompilerRoundProjection;
+    /** The previously accepted evaluation, when one exists. */
+    lastEvaluation?: SelfEvaluation;
 }
 export type ExternalContextProvider = (request: ExternalContextRequest) => Promise<string>;
 export interface LoopTerminalEvent {
@@ -576,16 +738,16 @@ export interface LoopTerminalEvent {
     successTrajectory: boolean[];
     loopId: string;
     task: string;
-    lastRoundView?: CompilerRoundProjection;
+    lastEvaluation?: SelfEvaluation;
 }
 export type LoopTerminalSink = (event: LoopTerminalEvent) => Promise<void> | void;
-/** A single flag raised during round report verification.
+/** A single flag raised during self-evaluation verification.
  *  Each flag identifies a specific inconsistency between the agent's
  *  self-reported data and the loop's cross-round lineage. */
 export interface VerificationFlag {
     /** info | warn | error — determines how aggressively the compiler reacts. */
     severity: "info" | "warn" | "error";
-    /** Stable report or evidence path that triggered this flag. */
+    /** Which SelfEvaluation field triggered this flag (e.g. "progress_estimate"). */
     field: string;
     /** Check name for debugging / audit (e.g. "progress_regression"). */
     check: string;
@@ -593,7 +755,7 @@ export interface VerificationFlag {
     detail: string;
 }
 export declare function makeVerificationFlag(overrides?: Partial<VerificationFlag>): VerificationFlag;
-/** Result of cross-round round report verification.
+/** Result of cross-round self-evaluation verification.
  *
  *  Verdict semantics:
  *  - trusted:   all checks passed; flags are informational only.