loopforge 3.9.2 → 4.0.7

package/dist/protocol.d.ts

@@ -2,66 +2,71 @@
  *
  * All types exchanged between the Main Agent and LoopForge flow through
  * these interfaces. This is the contract layer — no implementation logic.
- *
- * v3.3: 41 types — 2 enums + 35 interfaces + 4 type aliases.
+ * The generated JSON Schema in `loopforge-protocol.json` is the complete,
+ * machine-readable wire contract; `$defs` is the authoritative type set.
  */
-export declare enum Mode {
-    LOOP_COMPILE = "loop_compile",
-    FEEDBACK = "feedback"
-}
 export declare enum AgentStatus {
     OK = "ok",
     ERROR = "error",
     STALLED = "stalled"
 }
-export interface ExecutionFeedback {
-    output: string;
-    success: boolean;
-    constraint_violations: string[];
-    manual_fixes_needed: string;
-}
-export declare function makeExecutionFeedback(overrides?: Partial<ExecutionFeedback>): ExecutionFeedback;
-/** 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;
-}
 /** 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. */
+ *  v1.5 (P4–P5): Execution evidence, progress tracking, and self-correction.
+ *
+ *  v4.0.6: `outcome` is the ONE round conclusion (it replaces `success` and
+ *  `agent_stop_reason`); `execution_report.claims` is the ONE claims channel
+ *  (it replaces `criterion_claims` + `contract_item_claims`); `round_contract`
+ *  is the ONE contract channel (an optional `supersedes` modifier replaces
+ *  `contract_transition`). The required field set is still exactly four:
+ *  `outcome`, `output_summary`, `constraint_violations`, `should_continue`.
+ *
+ *  Optional fields are normalized leniently and never dropped silently: the
+ *  normalizer returns stable diagnostics for every correction, and a committed
+ *  transaction persists them with the submitted-field manifest. Two fields are
+ *  structural exceptions validated BEFORE the round advances —
+ *  `subgoal_updates` and `round_contract` (including its `supersedes` and the
+ *  `rci-` entries of `execution_report.claims`) — because each references the
+ *  exact derived set the Agent was shown. `scope` is deliberately not
+ *  structural: optional, report-only intent, normalized leniently and never
+ *  rejected.
+ *
+ *  `objective_refinement` evolves the OVERALL starting objective (the working
+ *  version of `OperatorAcceptance.task`), not the current round's slice. It is
+ *  event-driven and never changes criteria or hard constraints. */
 export interface SelfEvaluation {
-    /** true ONLY if all hard constraints were met and the task goal was achieved. */
-    success: boolean;
+    /** The ONE round conclusion. `success` requires `should_continue=false`;
+     *  `blocked` requires `should_continue=false` and a non-empty `blocker`;
+     *  `partial` and `failed` may continue or stop. */
+    outcome: RoundOutcome;
     /** Specific, actionable summary of what was DONE this round.
-     *  Feeds: buildRollingSummary (key_outcomes),
-     *  computeConstraintRetirement (activity detection), vault lineage. */
+     *  Feeds: committed record, state file, audit/replay/explain, backtrack
+     *  facts, and the BOUNDED fresh-prompt Working Memory. It is always an
+     *  Agent report — never machine evidence, never current governance, and
+     *  never an independent history. */
     output_summary: string;
     /** Constraints the agent actually violated this round.
      *  Feeds: deriveRecurringFlags (the constraint_violation kind) and
      *  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. */
+    /** The Agent's logical round-boundary decision: false stops the loop after
+     *  this accepted round; true asks the runner to prepare a successor round.
+     *  A Round Contract scopes that successor's work and acceptance conditions,
+     *  but does not decide whether this round ends. `maxRounds` remains the
+     *  runner's hard stop. */
     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.
-     *  v3.7.1: this is the ONLY creation channel. A text matching the
-     *  sg-XXXXXXXX ID pattern is rejected — creation never accepts an
-     *  ID reference (that would fabricate a phantom hashed item). */
+    /** Sub-problems that surfaced during execution. This is the ONLY
+     *  sub-goal creation channel; the runtime derives stable sg- ids and tracks
+     *  their lifecycle. Omit or leave empty if none emerged.
+     *  v3.7.1: a text matching the sg-XXXXXXXX ID pattern is rejected —
+     *  creation never accepts an ID reference. */
     emerged_subtasks?: string[];
     /** v3.7.1: Explicit status transitions for EXISTING sub-goals. Each
      *  entry must reference a committed sub-goal ID (sg-XXXXXXXX) and a
@@ -78,37 +83,45 @@ export interface SelfEvaluation {
      *  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. */
+    /** Assumptions the agent made in earlier rounds that turned out to be
+     *  wrong. A committed Agent report; it surfaces in bounded Working Memory
+     *  and recovery brief facts, never as a LoopForge conclusion or machine
+     *  evidence. 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;
+    /** v4.0.2: unresolved questions that still affect later slices. Strictly
+     *  report-only: it feeds Working Memory, replay and explain, never the
+     *  verification gate, success, contract closure or machine evidence.
+     *  At most 3 entries, 300 chars each. It is a question list, not a todo
+     *  list and not a completion checklist. */
+    open_questions?: string[];
+    /** v4.0.2: stable ids of questions resolved in this round. IDs are derived
+     *  from normalized open-question text and are report-only. */
+    resolved_open_question_ids?: string[];
+    /** v4.0.3 (renamed from compression_checkpoint): the Agent declares a
+     *  subtask boundary. When true, the next compile uses an L2 rehydration
+     *  boundary; no milestone or phase narrative is generated. It is not a
+     *  workspace checkpoint. */
+    subtask_boundary?: boolean;
+    /** v4.0.3 (renamed from checkpoint_label): a label stored on the committed
+     *  report. It does not create a later prompt heading and is not a real
+     *  checkpoint reference. */
+    subtask_boundary_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. */
+     *  The main agent reports what it delegated; the report is saved inside the
+     *  committed transaction for audit. Omit or leave empty if none occurred. */
     worker_results?: WorkerResult[];
-    /** 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 outcome (four values). 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. */
+    /** v4.0.6: the Agent's working version of the OVERALL starting objective
+     *  (`OperatorAcceptance.task`). When present, the latest committed
+     *  refinement on the current branch replaces the working objective used by
+     *  the next prompt and goalId. It never rewrites Operator Acceptance,
+     *  success criteria or hard constraints, and it is not the round task or
+     *  contract. Event-driven: omit when the overall objective is unchanged.
+     *  Strict at the submission boundary: string, trim non-empty, ≤ 1000 chars. */
+    objective_refinement?: string;
+    /** v2.12 / v4.0.6: Flat blocker description, required when
+     *  outcome==="blocked" (trim non-empty, ≤ 500 chars). When another outcome
+     *  is declared it is dropped with a diagnostic and never rejects the round.
+     *  Also feeds the user/agent gate classification (P2). */
     blocker?: string;
     /** v2.12: Retroactive claims that a PRIOR round satisfied a criterion.
      *  The runtime verifies these against the prior round's git evidence.
@@ -130,76 +143,161 @@ export interface SelfEvaluation {
      *  the round is rejected. Safe pre-work (investigation, dry-runs,
      *  rollback evidence) never needs a gate. */
     gate_ids?: 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. */
+    /** v3.3/v4.0.6: THE Round Contract channel. A PROPOSAL for the NEXT
+     *  round's contract. Omit it to continue the active contract unchanged;
+     *  declare it to start the next slice; add the optional `supersedes`
+     *  modifier to replace an active contract that is no longer the right
+     *  slice. Becomes the ACTIVE contract only once this round commits; it is
+     *  then derived at compile time from committed rounds — see
+     *  round-contract.ts. With contract capability, a continuing round that has
+     *  a successor available must leave an active contract for the next round;
+     *  the final configured round has no successor consumer. */
     round_contract?: RoundContractProposal;
 }
-/** 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";
-/** 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, derived from the active contract, sub-goals, and
-     *  open gates/recovery requirements. Non-authoritative. v3.8: the
-     *  `agent_intent` source was deleted with `next_action` — the agent's own
-     *  plan is no longer a projection input. */
-    todo: Array<{
-        id: string;
-        item: string;
-        reason: string;
-        source: "derived";
-        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[];
-    };
-    /** v3.8: Sub-goals a machine-verified contract item backs. The machine's
-     *  separate statement about a `done` sub-goal — it never rewrites
-     *  `SubGoal.status`. Derived in cognitive-facts.ts, exposed here so the
-     *  projection carries the same verification view the prompt and state file
-     *  do. */
-    verified_subgoals: VerifiedSubGoalFact[];
+/** v3.9.7: the kind of recovery material a checkpoint represents. `before` is
+ *  the automatic transaction before-image; `mid` is an Agent-created savepoint
+ *  during a round. Both are evidence/recovery material, never progress. */
+export type CheckpointRole = "before" | "mid";
+/** v3.9.7: a checkpoint reference held by a typed transaction snapshot. This
+ *  reference is the authority for ownership, current-branch visibility and the
+ *  redo round. The manifest alone is content-addressed recovery material and
+ *  can never become a recovery point by itself. */
+export interface CheckpointRef {
+    checkpointId: string;
+    contentHash: string;
+    role: CheckpointRole;
+    /** Logical round whose snapshot carries this reference. */
+    round: number;
+    roundId: string;
+    /** Transaction that currently owns this reference (retry may re-bind it). */
+    transactionId: string;
+    branchId: string;
+    /** First round of the child branch if this checkpoint is restored. For
+     *  before/mid checkpoints this equals `round`. */
+    redoRound: number;
+    createdAt: number;
+}
+/** v4.0.0: the ONE transport projection of the held round attempt.
+ *
+ *  It bundles the three identities a held-round call needs — the owning
+ *  session, the logical round, and the exact transaction attempt — so a client
+ *  copies one object instead of three independent strings. It is DERIVED from
+ *  the persisted session snapshot on every response; it is never persisted in
+ *  the session document, a round transaction, a prompt artifact, guidance, or
+ *  a receipt.
+ *
+ *  It is not a security token and grants no authority: the session lease plus
+ *  an exact comparison against the held snapshot remain the only authority. A
+ *  stale handle never submits work; a live session re-anchors through
+ *  `loopforge_status`, and a lost prompt or missing live session is recovered
+ *  through `loopforge_resume`. */
+export interface SubmissionHandle {
+    sessionId: string;
+    roundId: string;
+    transactionId: string;
+}
+/** v4.0.3: the checkpoint manifest version. The wire type, the store and the
+ *  restore preflight all read this ONE constant. */
+export declare const CHECKPOINT_SCHEMA_VERSION: 1;
+/** v3.9.7: the restore-relevant content manifest. `fingerprints` is exactly
+ *  the Git observation boundary; `contents` names the dirty regular files and
+ *  symlinks whose bytes are stored as content-addressed blobs. */
+export interface WorkspaceCheckpointManifest {
+    schemaVersion: typeof CHECKPOINT_SCHEMA_VERSION;
+    checkpointId: string;
+    loopId: string;
+    round: number;
+    role: CheckpointRole;
+    createdAt: number;
+    head?: string;
+    dirty: string[];
+    fingerprints: Record<string, string>;
+    contents: string[];
+    coverage: "tracked_and_non_ignored_untracked";
+    contentHash: string;
+}
+/** v3.9.7: The Agent's request to abandon the current branch and restore a
+ *  checkpoint it selected. This is an ACTION, not an evaluation: it never
+ *  carries success/output_summary/constraint_violations/should_continue and
+ *  never fabricates a SelfEvaluation. The checkpoint must be visible in the
+ *  current held transaction or a committed evaluation transaction on the
+ *  current branch. LoopForge records the directive, executes and verifies the
+ *  restore, and only then issues the redo prompt. The reason is the Agent's
+ *  judgment, recorded verbatim and never judged. */
+export interface RecoveryRequest {
+    target_checkpoint_id: string;
+    reason: string;
 }
-export declare function makeLoopProjection(overrides?: Partial<LoopProjection>): LoopProjection;
+/** v3.9.6: The operator-owned acceptance surface, written once in the root
+ *  branch's round-1 evaluation transaction. Neither the Agent nor LoopForge
+ *  may revise, replace, or retract it. */
+export interface OperatorAcceptance {
+    task: string;
+    success_criteria: string[];
+    hard_constraints: string[];
+}
+/** v3.9.7: the committed recovery target. It references a checkpoint by id and
+ *  content hash; the manifest is the one copy of the boundary. `redo_round`
+ *  is the branch fence: parent rounds with `round < redo_round` are retained,
+ *  and the child branch starts at `redo_round`. */
+export interface RecoveryTarget {
+    checkpoint_id: string;
+    content_hash: string;
+    role: CheckpointRole;
+    /** Round that owns the checkpoint reference. */
+    round: number;
+    round_id: string;
+    /** Transaction that owns the checkpoint reference. */
+    transaction_id: string;
+    /** First round of the child branch. */
+    redo_round: number;
+}
+/** v4.0.1: the compile facts stamped into an evaluation transaction at commit.
+ *  They are the machine-computed state the next compile carries forward, not
+ *  Agent input. `task`/`goalId` serve level and replay; the constraint sets
+ *  are the effective compile result. */
+export interface CompiledRoundFacts {
+    task: string;
+    goalId: string;
+    constraintsActive: string[];
+    constraintsRetired: string[];
+}
+/** v3.9.7: A committed rollback directive. It is a typed event in the same
+ *  round document as the abandoned/triggering transaction, not a normal
+ *  round. `transaction_id` also names the child branch; the redo and all
+ *  later transactions on that branch carry it as `branchId`.
+ *
+ *  The directive deliberately does NOT duplicate the target's HEAD or
+ *  fingerprints: the checkpoint manifest is the one copy, bound by
+ *  `target.content_hash`. `skipped_files` is a report fact derived from the
+ *  target manifest vs. the abandoned boundaries; it is never a restore gate. */
+export interface RecoveryDirective {
+    origin: "agent" | "machine";
+    /** Agent reason or machine failure reason. */
+    reason: string;
+    /** Machine check id; never set for an agent request. */
+    trigger_rule?: string;
+    target: RecoveryTarget;
+    skipped_files: string[];
+    /** v4.0.3: machine-observed vs Agent-reported abandoned files. */
+    observed_skipped_files?: string[];
+    reported_skipped_files?: string[];
+    /** v4.0.3: every committed round abandoned by the directive. */
+    abandoned_rounds?: number[];
+    skipped_discoveries: string[];
+    failed_rounds: number[];
+    /** v4.0.3: compact trigger findings replayed into the redo's Verification
+     *  Gate (machine backtrack). Never inferred on an agent directive. */
+    trigger_findings?: VerificationFlag[];
+    /** Committed Agent reports from abandoned rounds. */
+    approaches: string[];
+    wrong_assumptions: string[];
+    /** The directive transaction; also the child branch identity. */
+    transaction_id: string;
+}
+/** v2.12 / v4.0.6: the ONE round outcome, required on every evaluation.
+ *  Shared by the dual gates, the stop mapping, and every read view. */
+export type RoundOutcome = "success" | "partial" | "failed" | "blocked";
 /** 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 {
@@ -233,23 +331,6 @@ export interface GateDecision {
     actionHash: string;
 }
 export declare function makeGateDecision(overrides?: Partial<GateDecision>): GateDecision;
-/** v2.9: Model-expressed information needs for the next round.
- *  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 {
-    /** Items to emphasize. Matched against active state by stable id or
-     *  normalized-exact text (v3.8.1 — the Jaccard arm is gone). Matching items
-     *  are pulled into a "Critical Context" section rendered before optional
-     *  sections. No content is added — only reordered. An unmatched entry is
-     *  dropped. Max entries: policy-driven (L2: 5, L1: 3). L0: ignored. */
-    emphasize?: string[];
-    /** 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
-     *  pointers. Max 3 entries, each ≤ 200 chars. L0: ignored. */
-    confusion_points?: string[];
-}
 /** v3.9.1: One normalization diagnostic. The submission boundary NEVER drops
  *  an optional value silently: every drop, truncation or normalization is
  *  reported with a stable code and an actionable detail. Strict boundary
@@ -294,6 +375,33 @@ export interface SubmissionReceipt {
      *  a committed record but NOT the submitted evaluation applied. */
     record: "committed" | "rollback_directive" | "none";
     entered_history: boolean;
+    /** v4.0.3/v4.0.6: the Agent's success claim — a derived projection of
+     *  `outcome === "success"`, never an input field. */
+    agent_success_claim: boolean;
+    /** v4.0.6: the Agent-declared outcome. */
+    agent_outcome: RoundOutcome | null;
+    /** v4.0.6: the Agent's working objective refinement carried by this
+     *  submission, verbatim; null means the working objective was unchanged. */
+    objective_refinement: string | null;
+    /** v4.0.4: the LoopForge terminal reason, when this submission stopped the
+     *  loop. Derived read-view from the SAME `result.stopReason` that Explain,
+     *  Replay and resume read; never persisted in the receipt and never
+     *  re-derived from the Agent's outcome or the evidence posture. */
+    loop_stop_reason: StopReason | null;
+    /** v3.9.7: the checkpoint this submission was judged against. Present only
+     *  when a pending rollback directive governed the submission — the redo.
+     *  `restore_verified` reads the redo transaction's verified-restore marker;
+     *  the directive itself remains the committed audit record. This is the
+     *  redo's receipt projection of it, never a second ledger. */
+    recovery_checkpoint?: {
+        checkpoint_id: string;
+        redo_round: number;
+        origin: "agent" | "machine";
+        reason: string;
+        /** Machine result: the redo snapshot carries a restore marker produced by
+         *  the verified restore. The directive remains the committed audit record. */
+        restore_verified: boolean;
+    };
     reports: Array<{
         path: string;
         handling: SubmissionReportHandling;
@@ -305,6 +413,12 @@ export interface SubmissionReceipt {
             after_id: string | null;
             activated: boolean;
             closed: boolean;
+            /** v3.9.9/v4.0.6: the ACTIVE contract closed by this round's explicit
+             *  `round_contract.supersedes` (report-only fact, derived from the
+             *  committed redirect — never inferred from `contract_premature`). */
+            superseded?: boolean;
+            /** v3.9.9/v4.0.6: the Agent's redirect reason, verbatim (report-only). */
+            redirect_reason?: string;
         };
         subgoals_created: Array<{
             id: string;
@@ -316,35 +430,51 @@ export interface SubmissionReceipt {
             to: string;
         }>;
         constraints_declared: string[];
+        /** Effective retractions only, from the next compile's retired set. */
         constraints_retracted: string[];
+        /** "observed" only when a next compile exists; never guess. */
+        constraints_retraction: "observed" | "not_observed";
+        /** Requests that resolved to no effective retraction. */
+        constraints_not_retracted: string[];
         /** "observed" only when a next compile (or the next committed round's
          *  stamped active set) exists; "not_observed" for stop/terminate/reject/
          *  backtrack. Never guess an active set from the agent's report. */
         constraints_activation: "observed" | "not_observed";
         constraints_active_after: string[] | null;
         constraints_not_expanded: string[];
-        checkpoint: {
+        subtask_boundary: {
             label: string;
             round: number;
         } | null;
         rollback: {
-            restore_point: number;
+            redo_round: number;
+            target_checkpoint_id: string;
             preserved_discoveries: string[];
             wrong_assumptions: string[];
+            /** v4.0.3: machine-observed vs Agent-reported abandoned files. */
+            observed_skipped_files: string[];
+            reported_skipped_files: string[];
+            abandoned_rounds: number[];
+            /** Stable finding ids that triggered a machine backtrack. */
+            trigger_finding_ids: string[];
+            origin?: "agent" | "machine";
+            reason?: string;
         } | null;
     };
     verification: {
-        /** Contract-item posture (RoundVerificationStatus). */
-        contract_status: "trusted" | "insufficient" | "contradicted";
-        /** Round-level machine evidence posture. A round can have trusted
-         *  contract items while a bare success claim has no machine evidence. */
-        evidence_status: "verified" | "unavailable" | "absent";
+        /** v4.0.3: the ONE persisted evidence posture of this submission. It
+         *  replaces the former `contract_status` + `evidence_status` pair, which
+         *  could disagree about the same round. */
+        evidence_posture: EvidencePosture;
         checks: Array<{
             field: string;
             check: string;
             severity: string;
             detail: string;
+            /** v3.9.4: the concrete subject (command id, path, or stable id). */
+            ref?: string;
         }>;
+        /** Read from the same posture snapshot. */
         contract_items: Array<{
             item_id: string;
             status: ContractItemStatus;
@@ -355,28 +485,29 @@ export interface SubmissionReceipt {
     prompt: {
         level: "l0" | "l1" | "l2";
         dropped_sections: string[];
-        prompt_request_effects: PromptRequestEffect[];
+        /** v4.0.2: the context boundary the NEXT prompt was compiled under, read
+         *  from the same PromptArtifact that produced it. Absent only when no next
+         *  artifact exists (terminal/rejected-without-retry paths). */
+        context_mode?: PromptContextMode;
+        context_reason?: PromptContextReason;
+        /** v4.0.5: the host instruction this prompt carried, projected from the
+         *  same artifact. null means none was provided for that invocation. */
+        current_user_instruction?: string | null;
     } | null;
     diagnostics: SubmissionDiagnostic[];
 }
-/** v3.9.1: What a prompt request actually did in the rendered prompt. This is
- *  an OUTPUT fact about the current render; it is never an instruction for a
- *  later prompt. */
-export interface PromptRequestEffect {
-    field: "emphasize" | "confusion_points";
-    request: string;
-    status: "applied" | "no_match" | "level_ignored" | "capped";
-}
 /** v3.9.1: The live submission-guidance projection returned with a prepared
  *  round. It is derived from current facts only (committed rounds, policy,
  *  the compiled state); it is never persisted and never becomes input to a
  *  later prompt. Real ids are rendered only when the facts exist; a null
  *  example means "not usable at this submission point". */
 export interface SubmissionGuidance {
-    round_id: string;
     active_contract: {
         id: string;
         work_item?: string;
+        /** v3.9.9: the Agent's declared intent boundary. Report-only — it is not
+         *  enforced and never rejects a round. */
+        scope: string[];
         declared_at_round: number;
         items: Array<{
             id: string;
@@ -387,24 +518,46 @@ export interface SubmissionGuidance {
     } | null;
     contract_commands: string[];
     contract_verification_available: boolean;
+    /** v4.0.6: the compiled-time contract coverage requirement. A DERIVED
+     *  projection of current facts through `deriveContractRequirement`; it is
+     *  not a new fact and owns no state. */
+    contract_requirement: {
+        /** If you continue and LoopForge permits a successor round, that round
+         *  must have an active contract when verification capability exists. */
+        required_on_continue: boolean;
+        /** The active contract is still open: closing it this round AND
+         *  continuing requires a successor proposal. */
+        successor_required_if_closed: boolean;
+        reason: "no_active_contract" | "active_contract_continues" | "active_contract_closed" | "no_contract_capability" | "no_successor_round";
+        active_contract_id: string | null;
+    };
     subgoals: Array<{
         id: string;
         description: string;
         status: string;
     }>;
-    /** Current real criteria, for criterion_claims selection/examples. */
+    /** Current real criteria, for `execution_report.claims` selection/examples. */
     criteria: Array<{
         id: string;
         text: string;
-        status: CriterionStatus["status"];
+        /** The same closed status set as `CriterionStatus.status`, written inline
+         *  so the generated JSON Schema publishes the enum instead of an
+         *  unrepresentable indexed-access placeholder. */
+        status: "unknown" | "claimed" | "remaining" | "insufficient" | "contradicted" | "verified";
     }>;
     recovery: {
-        required: boolean;
-        restore_point?: number;
-        target_head?: string;
+        /** The directive is pending until the redo round commits. */
+        pending: boolean;
+        redo_round: number;
+        checkpoint_id: string;
+        /** True after the executor verified the restored boundary. */
+        restore_verified: boolean;
+        origin?: "agent" | "machine";
+        reason?: string;
     } | null;
     prompt: {
-        level: "l0" | "l1" | "l2";
+        /** null when no prompt artifact is observable; never guess a level. */
+        level: "l0" | "l1" | "l2" | null;
         dropped_sections: string[];
         protected_overflow: boolean;
     };
@@ -419,40 +572,10 @@ export interface SubmissionGuidance {
         check: string;
         severity: string;
         detail: string;
+        /** v3.9.4: the concrete subject (command id, path, or stable id). */
+        ref?: string;
     }>;
 }
-/** v2.1: Milestone summary — a phase-boundary snapshot that survives
- *  rolling-window eviction. Triggered by three signals in priority order:
- *
- *  1. agent_declared    — compression_checkpoint === true (agent marks phase complete)
- *  2. criteria_milestone — a new met criterion_claim detected (semantic dedup)
- *  3. auto              — safety net after N rounds without a milestone
- *
- *  Built from raw round data in vault entries — no new persistent storage.
- *  Rendered in L2 prompts and always written to the state file. */
-export interface MilestoneSummary {
-    /** Human-readable label. Examples:
-     *  agent_declared: agent's checkpoint_label or "Round 15"
-     *  criteria_milestone: "Completed: unit tests ≥ 90%"
-     *  auto: "Rounds 1–20" */
-    label: string;
-    /** Which rounds this milestone covers (inclusive). */
-    round_range: {
-        start: number;
-        end: number;
-    };
-    /** Compressed outcome: what was accomplished in this phase. */
-    outcome: string;
-    /** Constraints that were active when this milestone was created. */
-    carried_constraints: string[];
-    /** Constraints resolved during this phase. */
-    resolved_constraints: string[];
-    /** How this milestone was created. */
-    kind: "agent_declared" | "criteria_milestone" | "auto";
-    /** The round number when this milestone was created. */
-    generated_at_round: number;
-}
-export declare function makeMilestoneSummary(overrides?: Partial<MilestoneSummary>): MilestoneSummary;
 /** A single sub-agent / Worker delegation result (v1.9 — multi-agent).
  *  v3.7.1: `outcome` is the single reported fact. `success` is deleted —
  *  entries without a valid outcome are dropped by the parser, never
@@ -461,34 +584,21 @@ export declare function makeMilestoneSummary(overrides?: Partial<MilestoneSummar
  *  is always accepted. */
 export interface WorkerResult {
     agentId: string;
-    subAgentType?: string;
     subTask: string;
     resultSummary: string;
     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;
-}
 export interface LoopObjective {
+    /** v4.0.6: the WORKING objective — the latest committed
+     *  `objective_refinement` on the current branch, else the operator
+     *  acceptance task. Criteria and hard constraints always come from the
+     *  immutable `OperatorAcceptance`; a refinement only changes this text. */
     objective: string;
     success_criteria: string[];
     hard_constraints: string[];
     created_at_round: number;
     loop_id: string;
-    /** P1: Version number for the objective, starting at 1.
-     *  Incremented each time objective_refinement is applied. */
-    version?: number;
-    /** P1: Ordered history of all objective refinements applied.
-     *  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
@@ -504,11 +614,14 @@ export interface CriterionStatus {
     /** The criterion text as declared in the objective. */
     text: string;
     status: "unknown" | "claimed" | "remaining" | "insufficient" | "contradicted" | "verified";
-    /** Round when the criterion was first reported met (machine-backed). */
-    met_at_round?: number;
-    /** Sub-goals an item referencing this criterion also names, via explicit
-     *  `subgoal_refs` (v3.8.1 — never a text-similarity guess). */
-    related_subgoal_ids: string[];
+    /** v4.0.3: the round the CURRENT status was first reached. For an Agent
+     *  claim it is the latest claim round (latest-claim wins); for a machine
+     *  fact it is the round that reached that machine status. Absent for
+     *  `unknown`. */
+    status_at_round?: number;
+    /** v4.0.3: who produced the current status. `agent` for claimed/remaining;
+     *  `machine` for verified/insufficient/contradicted; absent for unknown. */
+    status_source?: "agent" | "machine";
 }
 /** v3.2: A deterministic "lesson learned" — a constraint or verification
  *  check that failed repeatedly across rounds. Rendered in the prompt to
@@ -537,23 +650,9 @@ export interface RecurringFlag {
     rounds: number[];
 }
 export declare function makeLoopObjective(overrides?: Partial<LoopObjective>): LoopObjective;
-export interface RollingSummary {
-    /** v1.12: Unified key outcomes — merged from what_worked + key_lessons.
-     *  Format: "[R{round}] ✓/✗ ({technique}): {summary}" */
-    key_outcomes: string[];
-    rounds_sampled: number;
-    generated_at_round: number;
-    /** v1.7: Detected failure patterns — repeated failed rounds with
-     *  the same technique and similar task text. These are surfaced as
-     *  explicit warnings in the prompt. */
-    failed_patterns?: string[];
-    /** v2.1: Phase-boundary milestone summaries that survive rolling-window
-     *  eviction. Accumulated across all rounds from three trigger signals
-     *  (agent_declared > criteria_milestone > auto). Rendered in L2 prompts
-     *  and always written to the state file. */
-    milestones?: MilestoneSummary[];
-}
-export declare function makeRollingSummary(overrides?: Partial<RollingSummary>): RollingSummary;
+/** The operator acceptance carried by a committed transaction is the same
+ *  immutable surface the compiler used to derive the objective. */
+export declare function operatorAcceptanceFromObjective(objective: LoopObjective): OperatorAcceptance;
 /** v3.7.1: One explicit sub-goal status transition. The closed migration
  *  matrix (loop-compiler.ts, single source) governs legality:
  *  in_progress from pending|blocked; done from pending|in_progress|blocked;
@@ -607,20 +706,28 @@ export interface ConstraintMeta {
     /** Which round this constraint was last violated by the agent.
      *  0 if never violated. */
     last_violated_at_round: number;
-    /** Origin — criteria texts carry the cr-XXXXXXXX namespace (v3.3.1). */
-    source: "hard" | "plan" | "criteria" | "discovered";
+    /** Origin — criteria texts carry the cr-XXXXXXXX namespace (v3.3.1).
+     *  `discovered`/`preserved` are Agent declarations, never machine facts;
+     *  `unrecorded` means committed facts cannot establish an origin. */
+    source: "hard" | "plan" | "criteria" | "discovered" | "preserved" | "unrecorded";
+    /** First committed round of the current active provenance, when derivable.
+     *  Absent (never 0) when the origin round cannot be established from
+     *  committed facts. */
+    source_round?: number;
 }
 export declare function makeConstraintMeta(overrides?: Partial<ConstraintMeta>): ConstraintMeta;
 export interface LoopRoundResult {
     round: number;
-    success: boolean;
+    /** v4.0.3: the Agent's success claim — a derived read projection of
+     *  `outcome === "success"`, never an input field. */
+    agentSuccessClaim: boolean;
+    /** v4.0.6: the Agent-declared outcome. Always present on an evaluation;
+     *  rollback directives use `RoundProcessResult.agentOutcome = null`. */
+    agentOutcome: RoundOutcome;
     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[];
     /** v3.7.1: Explicit sub-goal transitions declared this round.
@@ -630,22 +737,19 @@ export interface LoopRoundResult {
     execution_report?: ExecutionReport;
     /** 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[];
+    /** v4.0.2: unresolved questions reported this round (report-only). */
+    open_questions?: string[];
+    /** v4.0.2: stable ids of questions resolved this round (report-only). */
+    resolved_open_question_ids?: 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;
-    /** Model's information needs for the next round's prompt.
-     *  Carried forward from SelfEvaluation. Consumed by the Compiler. */
-    prompt_requests?: PromptRequests;
-    /** v2.12: Declared outcome. Carried forward from SelfEvaluation. */
-    outcome?: RoundOutcome;
+    /** v4.0.3: Agent declared a subtask boundary in this round. */
+    subtask_boundary?: boolean;
+    /** v4.0.3: Human-readable label for the subtask boundary. */
+    subtask_boundary_label?: string;
     /** v2.12: Flat blocker description (outcome==="blocked" only). */
     blocker?: string;
     /** v2.12: Retroactive claims against prior rounds. */
@@ -659,21 +763,33 @@ export interface LoopRoundResult {
 }
 export declare function makeLoopRoundResult(overrides?: Partial<LoopRoundResult>): LoopRoundResult;
 export interface LoopCompileRequest {
-    mode: Mode;
     loop_id: string;
     round: number;
-    goal_id: string;
+    /** The LOOP's task text for this compile. `goal_id` is no longer a request
+     *  input: v4.0.6 derives it from the WORKING objective (the latest committed
+     *  `objective_refinement`, else Operator Acceptance), so a refinement
+     *  changes goal identity.
+     *
+     *  v4.0.5: this is the LOOP's task. It participates in density and state
+     *  hashing. The latest host-provided user input for this invocation is
+     *  `current_user_instruction`, which never changes `task`. */
     task: string;
-    domain: string;
-    next_task_proposal: string;
+    /** v4.0.5: the host's explicit user instruction for THIS invocation,
+     *  already trimmed by the transport boundary. It is invocation input, not
+     *  loop identity: it never rewrites `task`, the objective, criteria, hard
+     *  constraints, the Round Contract or goal identity. It projects into
+     *  `CanonicalLoopState.currentUserInstruction` and the prompt/artifact; it
+     *  is not evaluation input, not Working Memory and not a gate fact. */
+    current_user_instruction?: string;
+    /** v4.0.5: set only by the held-attempt recompile path when the host
+     *  declares the original invocation is gone (`invocationLost`). It selects
+     *  `fresh_invocation / invocation_recovery` and L2 density for the SAME
+     *  logical round/attempt. Not an Agent evaluation, not machine evidence. */
+    invocation_recovery?: boolean;
     loop_objective: LoopObjective | null;
     plan_source: string | null;
     constraints_from_plan: string[];
-    new_since_last_round: string;
-    last_round_result: LoopRoundResult | null;
     force_level: string;
-    /** Optional context supplied explicitly by the embedding Agent. */
-    external_context?: string;
     /** Maximum rounds for this loop. Used by the state file header to show
      *  accurate progress (Round X / Y). */
     max_rounds?: number;
@@ -681,25 +797,208 @@ export interface LoopCompileRequest {
      *  these to select a rehydrate view and render the gate findings exactly
      *  once as part of the final prompt. */
     verification_flags?: VerificationFlag[];
-    /** One-based attempt within the same logical round. Enforcement rejection
-     * increments this without advancing `round`. */
+    /** One-based submission-attempt number within the same logical round. Only
+     * an enforcement rejection increments it (payload errors such as
+     * `evaluation_invalid`/`contract_invalid` do not change attempt or the
+     * handle). It does not advance `round`. */
     attempt: number;
     /** Consecutive zero-commit enforcement rejections for this round. */
     consecutive_rejections: number;
     /** Structured enforcement feedback rendered into retry prompts. */
     rejection_notice: string;
+    /** v4.0.3: the rejected attempt's transient evidence posture. Rendered only
+     *  for a clean-context retry (`attempt > 1`,
+     *  `contextMode === "fresh_invocation"`); it is never committed history,
+     *  never Working Memory and never a gate input. */
+    retry_evidence_posture?: EvidencePosture;
+    /** v4.0.3: compile-context fact — this prompt was compiled after a verified
+     *  restore of the pending directive. Never Agent input, never persisted. */
+    restore_verified?: boolean;
 }
 export declare function makeLoopCompileRequest(overrides?: Partial<LoopCompileRequest>): LoopCompileRequest;
+/** v3.9.4: ID-level proof that the current prompt rendered every active
+ *  normative object. This is an OUTPUT fact about one render — never an
+ *  instruction for a later prompt and never an input to fact derivation.
+ *
+ *  `active` is the required set derived from the same `CanonicalLoopState`
+ *  the renderer consumed; `rendered` is the union of the IDs the included
+ *  sections declared; `omitted = active - rendered`. `complete` is false only
+ *  when a normative ID was lost; prompt preparation then fails closed.
+ *
+ *  Ordering is deterministic: `active` by (kind rank, id), `rendered` sorted
+ *  unique, `omitted` by id. */
+export interface PromptCoverage {
+    active: Array<{
+        id: string;
+        kind: "constraint" | "criterion" | "contract" | "contract_item" | "subgoal" | "finding" | "recovery";
+    }>;
+    rendered: string[];
+    omitted: Array<{
+        id: string;
+        /** Every normative section is protected, so a normative omission can
+         *  only be a renderer defect. Keeping a single reason prevents a defect
+         *  from being disguised as a level/budget decision. */
+        reason: "defect";
+    }>;
+    complete: boolean;
+}
 /** Immutable record of the exact prompt delivered for one round attempt. */
-/** v3.8.1: the artifact schema version, next to the type it versions. The
- *  transaction envelope parser reads it, so the constant lives here rather
- *  than in the renderer. */
-export declare const PROMPT_ARTIFACT_SCHEMA_VERSION: 3;
+/** v4.0.2 / v4.0.4: the context boundary of one prompt delivery.
+ *
+ *  `fresh_invocation` means CLEAN CONTEXT: the host starts a NEW MODEL
+ *  CONVERSATION with only this prompt, the loop/session identity and the
+ *  committed/derived facts it carries; the previous transcript, tool logs and
+ *  uncommitted reasoning are NOT part of it. A clean context is not a new
+ *  loop and not a workspace reset: the loopId and the current modified
+ *  workspace continue. It may describe the SAME logical round (a rejection
+ *  escalation or recovered retry) or the next logical round after the last
+ *  commit. Read `contextReason` and `attempt`
+ *  together; a fresh invocation alone does not mean a new round.
+ *
+ *  What `fresh_invocation` clears is MODEL CONVERSATION STATE — the previous
+ *  transcript, tool outputs and uncommitted reasoning. It does NOT require
+ *  the host to restart its process, MCP connection, tool services, installed
+ *  skill files or workspace; a host process that stays alive may keep those
+ *  warm, and it holds the submissionHandle for this invocation's tool calls.
+ *  A warm runtime is not model memory: the new conversation knows only what
+ *  this prompt and the host's stable environment provide. LoopForge does not
+ *  manage provider prompt/KV caches or implicit Agent habits and neither
+ *  clears nor relies on them. Only committed facts and the bounded
+ *  projections LoopForge returns for this invocation are guaranteed;
+ *  anything else that must survive belongs to explicit host configuration,
+ *  not a second LoopForge fact source.
+ *
+ *  The legal `fresh_invocation` reasons are `first_round`, `next_round`,
+ *  `recovery_redo`, `rejection_escalation` and `invocation_recovery`;
+ *  `enforcement_retry` belongs only to `same_round_retry`. The one prose
+ *  source for the host contract is `HOST_INVOCATION_CONTRACT` in
+ *  `round-guidance.ts`.
+ *
+ *  `same_round_retry` means IN-CONTEXT REPAIR: a retry below the repeated
+ *  rejection escalation threshold. Prompt density is independent: an L0/L1/L2
+ *  prompt can continue the original invocation when it is still alive. The
+ *  host injects the rejection notice and Verification Gate findings. If the
+ *  invocation is gone, the host must call
+ *  `loopforge_resume(loopId, invocationLost: true)`: LoopForge recompiles the
+ *  SAME logical round and attempt as `fresh_invocation / invocation_recovery`
+ *  instead of reusing this in-context prompt.
+ *
+ *  `rejection_escalation` means the same enforcement check has been rejected
+ *  repeatedly. The host starts a new invocation to break a potentially
+ *  unproductive reasoning trajectory, while the same logical round and
+ *  modified workspace continue. The rejected posture is an observation of
+ *  that attempt, not a snapshot of the current workspace; inspect the current
+ *  workspace before acting.
+ *
+ *  `invocation_recovery` means the host declared the original invocation
+ *  lost. It is a clean context for the SAME logical round/attempt, compiled
+ *  from the held retry facts; the host never starts a new round or attempt.
+ *
+ *  The value is DERIVED by the compiler from compile inputs and committed
+ *  facts. It is never submitted by the Agent and never re-derived by the MCP
+ *  lifecycle; every response projects it from the committed PromptArtifact. */
+export type PromptContextMode = "fresh_invocation" | "same_round_retry";
+/** Why the compiler selected the context boundary. It explains the selection;
+ *  it does not replace the contextStrategy label (`clean context`,
+ *  `in-context repair`, `clean context after restore`, `clean context
+ *  repair`). Repeated same-check rejection escalation has its own reason,
+ *  including when the current round is a recovered redo with a Recovery Brief.
+ *  `invocation_recovery` is the cold-context replacement of an in-context
+ *  retry whose invocation disappeared. */
+export type PromptContextReason = "first_round" | "next_round" | "recovery_redo" | "enforcement_retry" | "rejection_escalation" | "invocation_recovery";
+/** v4.0.5: the ONE runtime whitelist for context modes. The types above stay
+ *  explicit string unions (the schema generator reads them); these arrays are
+ *  the runtime legality boundary shared by the transaction decoder,
+ *  committed-history validation and the MCP output schema. */
+export declare const PROMPT_CONTEXT_MODES: readonly ["fresh_invocation", "same_round_retry"];
+/** v4.0.5: the ONE runtime whitelist for context reasons. See
+ *  `PROMPT_CONTEXT_MODES`. */
+export declare const PROMPT_CONTEXT_REASONS: readonly ["first_round", "next_round", "recovery_redo", "enforcement_retry", "rejection_escalation", "invocation_recovery"];
+export declare function isPromptContextMode(value: unknown): value is PromptContextMode;
+export declare function isPromptContextReason(value: unknown): value is PromptContextReason;
+/** v4.0.3: how many committed items existed BEFORE any cap/dedupe. It is
+ *  derived once by Working Memory and travels through canonical state (and
+ *  therefore stateHash); renderers compare it with the rendered counts so an
+ *  omission is always visible. */
+export interface WorkingMemorySourceCounts {
+    /** Committed rounds in the fixed recent window. */
+    windowRounds: number;
+    reports: number;
+    assumptions: number;
+    openQuestions: number;
+    recoveries: number;
+    redirects: number;
+}
+/** v4.0.2/v4.0.3: what the prompt projection actually rendered from the
+ *  bounded Working Memory. Audit metadata only — it never feeds a decision.
+ *  `rendered: false` means the section was dropped whole (allowPartial=false)
+ *  or no prompt section exists; `sourceCounts` still states what existed. */
+export interface PromptWorkingMemoryProjection {
+    /** v4.0.3: whether the section body actually entered this prompt. */
+    rendered: boolean;
+    /** Report rounds actually rendered, newest first. */
+    reportRounds: number[];
+    /** Rendered per-category counts. */
+    counts: {
+        reports: number;
+        assumptions: number;
+        openQuestions: number;
+        recoveries: number;
+        redirects: number;
+    };
+    /** Pre-cap, pre-dedupe committed counts. */
+    sourceCounts: WorkingMemorySourceCounts;
+    /** sourceCounts minus rendered counts, per category. */
+    omittedCounts: {
+        reports: number;
+        assumptions: number;
+        openQuestions: number;
+        recoveries: number;
+        redirects: number;
+    };
+    /** Stable `oq-` ids actually rendered. */
+    questionIds: string[];
+    /** The latest report's projection facts; null when none was rendered. */
+    previousReport: {
+        round: number;
+        sourceChars: number;
+        renderedChars: number;
+        truncated: boolean;
+    } | null;
+    /** Characters the Working Memory section body produced. */
+    renderedChars: number;
+    /** True when a window, list/item cap, text limit or budget rule omitted any
+     *  content, including details within a rendered recovery. Per-recovery
+     *  source/rendered/omitted detail counts are stated in that item's body;
+     *  `omittedCounts.recoveries` counts whole recovery records only. */
+    truncated: boolean;
+}
+/** v3.8.1: the artifact schema version lives next to the type it versions.
+ *  The transaction envelope parser reads it, so the constant lives here rather
+ *  than in the renderer.
+ *
+ *  v4.0.1: schema 7 removes the prompt-request effects. v4.0.2: schema 8 adds
+ *  the derived context boundary and the optional Working Memory projection.
+ *  v4.0.3: schema 9 adds the expanded Working Memory audit metadata. The
+ *  Machine Evidence projection is rendered INTO the prompt text, not carried as
+ *  a separate artifact field; the committed posture lives on the transaction
+ *  result. v4.0.4: schema 10 renames the clean-context `contextMode` value to
+ *  `fresh_invocation`. v4.0.5: schema 11 is ADDITIVELY extended — it adds the
+ *  optional `currentUserInstruction` fact and the legal
+ *  `invocation_recovery` reason. No required field was removed or renamed, so
+ *  every 4.0.4 artifact still decodes; the shared decoder whitelists
+ *  (`PROMPT_CONTEXT_MODES` / `PROMPT_CONTEXT_REASONS`) are the only legality
+ *  boundary.
+ *
+ *  v4.0.6: schema 12 is a BREAKING shape break — the evaluation block renders
+ *  `outcome` plus one `execution_report.claims` channel and the contract
+ *  coverage requirement, and the old `success` / `agent_stop_reason` /
+ *  `contract_transition` / `tests_reported` paths are gone. Older artifacts
+ *  are a HARD break — a round whose artifact does not parse is not committed
+ *  history, and `legacyTransactionRounds` reports the loss rather than letting
+ *  it vanish. There is no migration. */
+export declare const PROMPT_ARTIFACT_SCHEMA_VERSION: 12;
 export interface PromptArtifact {
-    /** v3.9.1: schema 3 adds prompt-request render effects. Older versions are
-     *  a HARD break — a round whose artifact does not parse is not committed
-     *  history, and `legacyTransactionRounds` reports the loss rather than
-     *  letting it vanish. */
     schemaVersion: typeof PROMPT_ARTIFACT_SCHEMA_VERSION;
     /** Round identity: `loop:<loopId>:round:<n>`. */
     roundId: string;
@@ -707,6 +1006,10 @@ export interface PromptArtifact {
     round: number;
     attempt: number;
     level: "l0" | "l1" | "l2";
+    /** The context boundary of THIS delivery: a new model conversation or an
+     *  in-context retry. It is not a host/tool restart; see PromptContextMode. */
+    contextMode: PromptContextMode;
+    contextReason: PromptContextReason;
     renderedPrompt: string;
     promptHash: string;
     stateHash: string;
@@ -722,28 +1025,39 @@ export interface PromptArtifact {
      *  budgeting because it is never dropped. Measured over the SAME region as
      *  `renderedChars`. */
     budget: number;
-    /** Characters the budgeted region produced: the fixed header, the confusion
-     *  alerts and the rendered sections — everything except the footer. NOT the
-     *  full prompt length; `renderedPrompt` adds the footer on top. */
+    /** Characters the budgeted region produced: the fixed header and the
+     *  rendered sections — everything except the footer. NOT the full prompt
+     *  length; `renderedPrompt` adds the footer on top. */
     renderedChars: number;
-    /** v3.9.1: what the PREVIOUS round's prompt_requests did in this render.
-     *  OUTPUT ONLY — no compile or decision path may read it as control state. */
-    promptRequestEffects?: PromptRequestEffect[];
+    /** v3.9.4: ID-level proof that every active normative object was rendered.
+     *  Required: a schema-4 artifact without it is a hard break. */
+    coverage: PromptCoverage;
+    /** v3.9.6: compile diagnostics delivered with this exact prompt. Replaces
+     *  the session-only `currentWarnings` mirror, so a held prompt remains
+     *  self-contained across a restart. */
+    warnings?: string[];
+    /** v4.0.2: present only when this prompt rendered bounded Working Memory.
+     *  Audit metadata; it is not a second history and is never an input to a
+     *  later prompt. */
+    workingMemory?: PromptWorkingMemoryProjection;
+    /** v4.0.5: the trimmed host-provided user instruction THIS prompt carried,
+     *  even when prompt de-duplication rendered no separate section. It is an
+     *  audit fact about the invocation, not committed governance: it never
+     *  becomes an objective/criterion/constraint/contract, never enters
+     *  `CompiledRoundFacts`, Working Memory or a gate, and read views project it
+     *  from here instead of keeping a second copy. */
+    currentUserInstruction?: string;
 }
 export interface LoopCompileResponse {
     status: AgentStatus;
     prompt: string;
     recompile_level: string;
-    diff_from_previous: string;
-    lineage: string[];
     constraints_active: string[];
     constraints_retired: string[];
     loop_id: string;
     round: number;
     goal_id: string;
-    goal_text_hash: string;
     loop_objective: LoopObjective | null;
-    rolling_summary: RollingSummary | null;
     /** v2.2: Structured sub-goals tracked across rounds. Compiler-managed
      *  lifecycle with derived status. Rendered as Sub-Goal Dashboard. */
     sub_goals?: SubGoal[];
@@ -772,54 +1086,23 @@ export interface LoopCompileResponse {
     state_file_content?: string;
     /** Exact, hashed prompt record used by transaction replay and audit. */
     prompt_artifact?: PromptArtifact;
+    /** v4.0.1: the compile facts the transaction stamps at commit. */
+    compiled?: CompiledRoundFacts;
+    /** v4.0.1: the immutable operator surface this compile used. */
+    operatorAcceptance?: OperatorAcceptance;
 }
 export declare function makeLoopCompileResponse(overrides?: Partial<LoopCompileResponse>): LoopCompileResponse;
-/** 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 accumulated SelfEvaluation data across rounds. */
-export interface EvidenceSnapshot {
-    /** Criteria met + successful outcomes confirmed across rounds. */
-    verified: string[];
-    /** Criteria still unmet — work remaining. */
-    pending: string[];
-    /** Wrong assumptions + retracted constraints — things we were wrong about. */
-    invalidated: string[];
-    /** New constraints + emerged subtasks discovered this round. */
-    discovered: string[];
-}
-export declare function makeEvidenceSnapshot(overrides?: Partial<EvidenceSnapshot>): EvidenceSnapshot;
-export interface LoopForgeResponse {
-    status: AgentStatus;
-    prompt: string | null;
-    error: string | null;
-    /** v1.14: State file content from the compiler. Written to disk by the caller. */
-    state_file_content?: string;
-    /** Exact prompt artifact produced by the compiler. */
-    prompt_artifact?: PromptArtifact;
-    /** Structured warnings from the compiler — preferred over parsing prompt text. */
-    warnings?: string[];
-    /** 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[];
-}
-export interface SessionState {
-    task_id: string;
-    call_count: number;
-    success_trend: boolean[];
-}
-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.
- *  `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. */
+/** Why a LOOP stopped — the LoopForge terminal reason (`loop_stop_reason` in
+ *  read surfaces). It is never the Agent's round outcome; `outcome` and
+ *  `blocker` are the Agent's report.
+ *
+ *  `completed` requires outcome=success, should_continue=false and a closed
+ *  (or absent) active contract. It means the Agent's stop declaration passed
+ *  the gates; it does NOT imply `machineBackedSuccess` (the evidence posture's
+ *  separate machine fact). `failed` is outcome=failed with
+ *  should_continue=false. `cancelled` is manual stop via loopforge_stop.
+ *  `paused` exists in the type but a committed round never carries it; pause
+ *  is expressed by a session status, not a loop terminal reason. */
 export type StopReason = "completed" | "failed" | "blocked" | "cancelled" | "max_rounds" | "stalled" | "enforcement_terminated"
 /** Loop was paused by user or signal. */
  | "paused"
@@ -853,21 +1136,31 @@ export interface EnforcementResult {
     stopReason?: StopReason;
 }
 export declare function makeEnforcementResult(overrides?: Partial<EnforcementResult>): EnforcementResult;
-/** Context supplied to an embedding-owned provider before compilation. */
-export interface ExternalContextRequest {
-    loopId: string;
-    round: number;
-    task: string;
-    domain: string;
-    /** The previously accepted evaluation, when one exists. */
-    lastEvaluation?: SelfEvaluation;
-}
-export type ExternalContextProvider = (request: ExternalContextRequest) => Promise<string>;
 export interface LoopTerminalEvent {
-    success: boolean;
+    /** v4.0.3: the loop lifecycle completed (the Agent's stop declaration
+     *  passed the gates). This is NOT a machine-verified task-success claim. */
+    completed: boolean;
+    /** v4.0.3: the last committed round's machine-backed success fact.
+     *  v4.0.4: null means there is NO committed posture to read (for example a
+     *  loop cancelled before any round commit). It is never synthesized as
+     *  false. */
+    machineBackedSuccess: boolean | null;
+    /** v4.0.3: the last committed round's evidence posture. */
+    evidencePosture: EvidencePosture | null;
     stopReason: StopReason;
+    /** @deprecated v4.0.4: the historical name for `roundCursor`. It is NOT a
+     *  committed-round count. Kept for wire compatibility; new consumers should
+     *  read `roundCursor` / `committedRounds`. */
     roundsCompleted: number;
-    successTrajectory: boolean[];
+    /** v4.0.4: the session's current round cursor (the round it is on or just
+     *  finished). It is not a count of committed rounds. */
+    roundCursor: number;
+    /** v4.0.4: committed evaluation rounds on the current branch, derived from
+     *  the same `loadCommittedHistory` window every read surface uses. Rollback
+     *  directives are events, not rounds, and are not counted. */
+    committedRounds: number;
+    /** v4.0.3: only machine-backed successful rounds, in order. */
+    machineBackedSuccessTrajectory: boolean[];
     loopId: string;
     task: string;
     lastEvaluation?: SelfEvaluation;
@@ -875,7 +1168,7 @@ export interface LoopTerminalEvent {
 export type LoopTerminalSink = (event: LoopTerminalEvent) => Promise<void> | void;
 /** 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. */
+ *  self-reported data and the committed round history. */
 export interface VerificationFlag {
     /** info | warn | error — determines how aggressively the compiler reacts. */
     severity: "info" | "warn" | "error";
@@ -912,68 +1205,102 @@ export interface VerificationResult {
     machineBackedSuccess: boolean;
 }
 export declare function makeVerificationResult(overrides?: Partial<VerificationResult>): VerificationResult;
-/** v3.8: The agent's self-report for a round — renamed from ExecutionReport
- *  because these fields are claims, not evidence. The whole object is
- *  optional; a mistyped optional field is dropped with a warning and never
- *  rejects the round. */
+/** v3.8 / v4.0.6: The agent's self-report for a round. These fields are
+ *  claims, not evidence. The whole object is optional; a mistyped optional
+ *  field is dropped with a warning and never rejects the round. */
 export interface ExecutionReport {
     /** Files the agent says it changed. Informational — compared against the
      *  git observation, never trusted as the observation. */
     files_changed?: string[];
-    /** Test counts the agent reports. Informational. */
-    tests_reported?: {
-        passed: number;
-        failed: number;
-        skipped: number;
-    } | null;
-    /** Advisory claims about objective criteria. LENIENT: unknown/duplicate
-     *  criterion ids and malformed outcomes are dropped with a warning. */
-    criterion_claims?: CriterionClaim[];
-    /** Claims about ACTIVE contract items. STRICT: an unknown/duplicate item id
-     *  or an illegal outcome is a structural defect (contract_invalid). */
-    contract_item_claims?: ContractItemClaim[];
+    /** v4.0.6: THE claims channel. `cr-` ids are advisory objective-criterion
+     *  claims (lenient: unknown/malformed entries are dropped with a
+     *  diagnostic); `rci-` ids are strict ACTIVE contract-item claims (an
+     *  unknown/duplicate id or illegal outcome is `contract_invalid`). */
+    claims?: ExecutionClaim[];
 }
 export declare function makeExecutionReport(overrides?: Partial<ExecutionReport>): ExecutionReport;
-/** v3.8: An advisory claim about an objective criterion. Lenient by design —
- *  the criterion layer is advisory; the contract item layer is the machine
- *  verification skeleton. */
-export interface CriterionClaim {
-    /** cr-XXXXXXXX (or the criterion text for plain-text matching). */
-    criterion_id: string;
-    outcome: "met" | "remaining";
-}
-/** v3.8: A claim about an ACTIVE contract item, cited by the derived
- *  rci-XXXXXXXX id the prompt rendered. */
-export interface ContractItemClaim {
-    item_id: string;
+/** v4.0.6: ONE claim entry. The id prefix routes strictness: `cr-` is an
+ *  advisory criterion claim; `rci-` is a strict active-contract item claim.
+ *  A claim NEVER verifies anything — only machine observation can. */
+export interface ExecutionClaim {
+    /** cr-XXXXXXXX criterion id or rci-XXXXXXXX active contract item id. */
+    id: string;
     outcome: "met" | "remaining";
 }
-/** v3.8: One declared contract item. `verify_with` must name configured,
- *  enabled, after-capable evidence commands — the declaration is strict.
- *
- *  `subgoal_refs` lives HERE, not on the contract: a machine-verified item
- *  backs exactly the sub-goals it names, so "item A verifies SubGoal 1, item B
- *  verifies SubGoal 2" is expressible and `VerifiedSubGoalFact` attribution is
- *  per-item instead of "every verified item backs every sub-goal". */
+/** v3.8/v3.9.5: One acceptance condition inside a Round Contract slice.
+ *  `description` states what must be true, not an activity. `verify_with`
+ *  must name configured, enabled, after-capable evidence commands — the
+ *  declaration is strict. A command may back several conditions, and one
+ *  condition may bind several commands. */
 export interface ContractItemProposal {
+    /** The acceptance condition: what must be true for this slice. */
     description: string;
-    /** cr-XXXXXXXX criterion ids this item is evidence for (or free text). */
-    criterion_refs: string[];
-    /** sg-XXXXXXXX sub-goals this item is evidence for. */
-    subgoal_refs: string[];
-    /** Evidence command ids (policy.evidence.commands[].name). */
+    /** v3.9.4/v4.0.6: real cr-XXXXXXXX ids of ACTIVE criteria rendered in the
+     *  current prompt. Optional (defaults to `[]`). Free text and unknown ids
+     *  are `contract_invalid` when present. */
+    criterion_refs?: string[];
+    /** Evidence command ids (policy.evidence.commands[].name) that check this
+     *  acceptance condition. */
     verify_with: string[];
 }
-/** v3.8: A Round Contract proposal for the NEXT round. It becomes ACTIVE only
- *  after the declaring round commits. Identity (rc-/rci-) is derived from
- *  CONTENT ONLY — restating an unchanged contract keeps the same identity,
- *  unlike a SubGoal whose id includes its declaration round. */
+/** v3.9.5: A Round Contract proposal for the NEXT round. It becomes ACTIVE
+ *  only after the declaring round commits. Identity (rc-/rci-) is derived
+ *  from CONTENT ONLY — restating an unchanged contract keeps the same
+ *  identity, unlike a SubGoal whose id includes its declaration round.
+ *
+ *  `work_item` is the bounded deliverable this slice produces (an outcome,
+ *  not an activity). New declarations must provide it; it stays optional in
+ *  this persisted type because committed history may contain legacy
+ *  contracts without a label. `items[]` are the acceptance conditions;
+ *  `verify_with` remains item-level.
+ *
+ *  The runtime validates structure, command bindings and references. It never
+ *  judges whether `work_item` sounds like a deliverable, whether an item
+ *  matches a command semantically, or whether a command is the right
+ *  acceptance test; that is Agent/operator semantic judgment. */
+/** A contract PROPOSAL carried by one evaluation. Three related objects must
+ *  not be conflated:
+ *  - the proposal: this object, for the NEXT round;
+ *  - the ACTIVE contract: the proposal once its declaring round commits,
+ *    governing the round that follows;
+ *  - `work_item`: the bounded deliverable for the slice governed by the
+ *    active contract. It becomes the prompt's `Current Task` only when
+ *    contract verification is available and the invocation has no explicit
+ *    `currentUserInstruction`; otherwise the contract remains a separate
+ *    committed fact and Current Task follows the invocation instruction or
+ *    working objective.
+ *  The proposal is never the contract of the round that declared it. */
 export interface RoundContractProposal {
+    /** The bounded deliverable this slice produces. Required for NEW
+     *  declarations, optional when reading legacy committed history. This is
+     *  the text the next prompt uses as `Current Task` when contract verification
+     *  is available and no explicit invocation instruction overrides it. */
     work_item?: string;
-    /** Files/directories the round may touch. Empty = no scope constraint. */
-    scope: string[];
+    /** v3.9.9/v4.0.6: the Agent's declared intended file boundary — an
+     *  optional, report-only intent statement. Omission and `[]` both mean "no
+     *  declared intent". It is rendered in prompts/receipts/audit and drives
+     *  drift reporting, but it does NOT participate in `rc-` identity and
+     *  grants no permission. Required for legacy reads of pre-3.9.9 proposals;
+     *  new declarations may omit it. */
+    scope?: string[];
+    /** v4.0.6: explicit replacement of the ACTIVE contract. This is the ONE
+     *  redirect modifier on the ONE contract channel; the target id binds it to
+     *  the exact contract the Agent saw, so a stale prompt cannot close a
+     *  different contract. The successor proposal is this same object's
+     *  `work_item` + `items`; its acceptance items must differ from the target's.
+     *  It does not participate in `rc-` identity. */
+    supersedes?: ContractSupersede;
     items: ContractItemProposal[];
 }
+/** v4.0.6: the redirect modifier of a Round Contract proposal. It replaces the
+ *  former standalone `contract_transition` field. */
+export interface ContractSupersede {
+    /** Must equal the ACTIVE contract id (`rc-XXXXXXXX`) rendered in this
+     *  round's prompt. */
+    contract_id: string;
+    /** Agent report, audit only, ≤ 500 chars. */
+    reason?: string;
+}
 /** v3.8: The machine's record of what a contract bound at its declaration
  *  round. Stamped by the runtime when the declaring round COMMITS (policy is
  *  not part of the Vault, so the command configuration in force at
@@ -987,10 +1314,104 @@ export interface ContractBinding {
 /** v3.8: Runtime-derived contract item status. The agent may only claim
  *  `met` / `remaining`; the other three are machine-derived. */
 export type ContractItemStatus = "pending" | "insufficient" | "contradicted" | "verified";
-/** v3.8: The round-level verification posture. `trusted` means every claim in
- *  the round is machine-backed; `insufficient` means claims are unbacked but
- *  not contradicted; `contradicted` means machine facts deny a claim. */
-export type RoundVerificationStatus = "trusted" | "insufficient" | "contradicted";
+/** v4.0.3: the ONE round-level evidence posture.
+ *
+ *  It answers a deliberately narrow question: how well did this round's
+ *  machine observations cover its claims and its active contract? It is NOT a
+ *  task-success verdict and never decides `completed` — the Agent's stop
+ *  declaration still does that. `insufficient` and `unknown` are honest
+ *  coverage statements, not failures.
+ *
+ *  The posture is DERIVED ONCE by the coordinator inside the committed
+ *  transaction and then persisted with it. Every read surface (prompt, state
+ *  file, replay, explain, audit, receipt, metrics, terminal) reads that one
+ *  copy; none re-derives it. The raw observations/evaluation/flags remain the
+ *  underlying facts — the posture is a compact projection of the same
+ *  transaction, not a second store.
+ *
+ *  `unknown` never degrades to `verified` or to an empty result. */
+export type EvidencePostureStatus = "verified" | "insufficient" | "contradicted" | "unknown" | "not_applicable";
+/** v4.0.3: a compact, capped projection of one round's machine evidence.
+ *
+ *  It deliberately carries no stdout/stderr, no file fingerprints and no full
+ *  command output: full observations stay in the committed transaction and are
+ *  read through `explain`/`replay`. Array caps are code constants (never
+ *  policy); `omitted` records how many entries the cap hid, while `status` is
+ *  computed from the COMPLETE data before any cap is applied. */
+export interface EvidencePosture {
+    /** Logical round this posture describes. */
+    round: number;
+    /** Evaluation rounds carry observations; a rollback directive carries none. */
+    kind: "evaluation" | "rollback";
+    status: EvidencePostureStatus;
+    /** ONLY `VerificationResult.machineBackedSuccess` may set this. No read
+     *  surface and no posture consumer re-derives it. */
+    machineBackedSuccess: boolean;
+    /** Policy fact at commit time: at least one enabled, after-capable
+     *  verification command existed. It explains `insufficient`/`unknown`; it
+     *  never decides completion. */
+    verificationConfigured: boolean;
+    /** The committed Git delta boundary. `observed` means the before/after pair
+     *  was comparable; `unknown` means Git participated but the boundary could
+     *  not be compared; `not_applicable` means Git did not participate. */
+    workspace: {
+        status: "observed" | "unknown" | "not_applicable";
+        changedPathCount: number;
+    };
+    /** Agent-reported files vs the machine-observed Git change set. This is a
+     *  reconciliation, never a ledger of "verified files". */
+    files: {
+        reconciliation: "match" | "mismatch" | "unknown" | "not_applicable";
+        reported: number;
+        observed: number;
+    } | null;
+    /** Stable order: kind (git, custom), then providerId. `command` providers
+     *  are listed under `commands`, not here. */
+    providers: Array<{
+        providerId: string;
+        kind: "git" | "custom";
+        status: ObservationStatus;
+    }>;
+    /** Stable order: commandId. */
+    commands: Array<{
+        commandId: string;
+        status: ObservationStatus;
+        required: boolean;
+    }>;
+    /** Snapshot of the contract item statuses AT COMMIT TIME. Later policy or
+     *  command-configuration changes never rewrite it. */
+    contract: {
+        id: string;
+        closure: "open" | "verified" | "blocked" | "superseded";
+        items: Array<{
+            id: string;
+            status: ContractItemStatus;
+            criterionRefs: string[];
+            /** Deduped, capped historical explanation — never re-judged. */
+            reasons: string[];
+        }>;
+        verifiedCount: number;
+        insufficientCount: number;
+        contradictedCount: number;
+        pendingCount: number;
+    } | null;
+    /** Stable order: severity (error, warn, info), then check, ref, id. */
+    findings: Array<{
+        /** Stable `f-XXXXXXXX` finding id (`deriveFindingId`). */
+        id: string;
+        check: string;
+        severity: "info" | "warn" | "error";
+        ref?: string;
+    }>;
+    /** Entries hidden by the code caps. `status`/counts are computed from the
+     *  complete data, never from this capped projection. */
+    omitted: {
+        providers: number;
+        commands: number;
+        contractItems: number;
+        findings: number;
+    };
+}
 /** v3.8: Machine observation status. A configured provider always produces an
  *  observation — the failure modes are recorded, not filtered away.
  *
@@ -1001,6 +1422,26 @@ export type RoundVerificationStatus = "trusted" | "insufficient" | "contradicted
  *  its own capture was aborted — a command killed mid-flight, say. A
  *  collector deadline aborts the capture AS a timeout, so the round records
  *  the runtime's measured cause, not the provider's. */
+/** v3.9.7: the four-state progress verdict shared by every consumer.
+ *  `not_applicable` = no progress-capable provider participated;
+ *  `unknown` = a progress-capable provider participated but its signal could
+ *  not be compared. Neither ever proves "no progress". */
+export type ProgressState = "changed" | "unchanged" | "unknown" | "not_applicable";
+/** v3.9.7: prompt-level freshness derived over one committed round. The
+ *  prompt level is a density decision; it never changes governance facts. */
+export type PromptFreshnessReason = "progress_changed" | "progress_unchanged" | "progress_unknown" | "no_progress_provider" | "after_command_activity" | "declared_evolution" | "no_observable_activity" | "no_previous_committed_round";
+export interface PromptFreshness {
+    machineProgress: ProgressState;
+    providers: string[];
+    /** An after-phase command produced a structured, attributable result. */
+    machineActivity: boolean;
+    /** The committed evaluation declared evolution the compiler consumes. */
+    declaredEvolution: boolean;
+    /** false ONLY when no-activity is proven; unknown counts as fresh. */
+    observableNewInformation: boolean;
+    /** Stable, deterministic order. */
+    reasons: PromptFreshnessReason[];
+}
 export type ObservationStatus = "observed" | "passed" | "failed" | "timeout" | "unavailable" | "error" | "aborted";
 /** v3.8: Common machine-observation fields. Observations are the factual
  *  record of what the machine saw; they are persisted with the round and are
@@ -1076,8 +1517,25 @@ export interface CommandObservation extends MachineObservationBase {
     kind: "command";
     data: CommandObservationData;
 }
+/** v3.9.9: the normalized identity of the evidence range a progress fact
+ *  covers. `domain/object/scope` is a logical identity, not a file path:
+ *  matching is exact — no wildcards, no normalization, no subset inference —
+ *  and `version` must be equal because a different version means the
+ *  provider's fingerprint semantics changed. */
+export interface ProgressCoverage {
+    /** Evidence domain, e.g. "workspace". */
+    domain: string;
+    /** Object/rule inside the domain, e.g. "git-motion". */
+    object: string;
+    /** Normalized coverage identity, e.g. "tracked_and_non_ignored_untracked". */
+    scope: string;
+    /** The provider's own evidence semantics version. */
+    version: number;
+}
 export interface CustomObservation extends MachineObservationBase {
     kind: "custom";
+    /** Provider-defined display data. It is a report, not a progress fact:
+     *  only Git workspace progress participates in stall/freshness rules. */
     data: Record<string, unknown>;
 }
 export type MachineObservation = GitObservation | CommandObservation | CustomObservation;
@@ -1146,34 +1604,31 @@ export interface EvidenceCapability {
     /** Human-readable capability gaps (the same text start/resume/status show). */
     warnings: string[];
 }
-/** v3.8: A machine-verified sub-goal fact. DERIVED in cognitive-facts.ts,
- *  never persisted: it exists only while a committed contract item references
- *  the sub-goal AND that item is verified. It never writes SubGoal.status —
- *  `done` stays the agent's declaration. */
-export interface VerifiedSubGoalFact {
-    subgoal_id: string;
-    contract_item_ids: string[];
-    verified_at_round: number;
-}
 /** v3.8: The STABLE error codes every tool answers with. A client can branch
  *  on these; the human sentence rides in `ToolError.message` and never doubles
  *  as the code.
  *
  *  - `evaluation_invalid` / `contract_invalid` / `policy_invalid` — a payload
- *    or configuration defect; the same roundId may be retried.
- *  - `round_id_required` / `round_id_mismatch` — the anchor is missing or no
- *    longer names the current round.
+ *    or configuration defect; the same submissionHandle may be retried.
+ *  - `projection_incomplete` — a code defect in the prompt projection: an
+ *    active normative ID was not rendered, so no prompt is delivered. Not
+ *    retryable by the agent.
+ *  - `submission_handle_required` — the handle is missing or structurally
+ *    malformed. The same call may be retried after obtaining the current
+ *    handle from `loopforge_status` (live session) or `loopforge_resume`
+ *    (lost prompt or no live session).
+ *  - `submission_handle_mismatch` — the handle no longer names the held
+ *    attempt. A `next`/`recover` submission returns the held prompt with a
+ *    warning and `ok: true` when one exists so the agent can recover the
+ *    response it missed; with no held prompt, or for `checkpoint`/
+ *    `gate_check`, it is this stable error.
  *  - `session_not_found` / `state_unavailable` — the named session or read
  *    model is not there.
  *  - `invalid_argument` — the request itself is malformed at the tool boundary.
- *  - `gate_disabled` / `loop_already_running` — a state condition, not a defect.
- *
- *  Note: a `loopforge_next` submission whose roundId no longer matches is NOT
- *  `round_id_mismatch` — it returns the held prompt with a warning and
- *  `ok: true` so the agent can recover the response it missed. That recovery
- *  contract (v3.0.1) is deliberate; `round_id_mismatch` is for the places with
- *  no held prompt to return (the gate preflight). */
-export type ToolErrorCode = "evaluation_invalid" | "contract_invalid" | "policy_invalid" | "session_not_found" | "round_id_required" | "round_id_mismatch" | "state_unavailable" | "invalid_argument" | "gate_disabled" | "loop_already_running";
+ *  - `gate_disabled` / `gate_invalid` / `loop_already_running` /
+ *    `lease_conflict` — a state
+ *    condition, not a defect. */
+export type ToolErrorCode = "evaluation_invalid" | "contract_invalid" | "policy_invalid" | "projection_incomplete" | "session_not_found" | "submission_handle_required" | "submission_handle_mismatch" | "state_unavailable" | "invalid_argument" | "gate_disabled" | "gate_invalid" | "loop_already_running" | "lease_conflict" | "start_failed" | "loop_exists" | "legacy_history" | "operator_acceptance_conflict" | "recovery_invalid" | "recovery_disabled" | "recovery_unavailable" | "checkpoint_invalid" | "checkpoint_unavailable" | "checkpoint_failed" | "checkpoint_limit" | "restore_failed" | "restore_pending";
 /** v3.8: The structured error inside the uniform `{ok: false}` envelope. */
 export interface ToolError {
     code: ToolErrorCode;
@@ -1182,8 +1637,9 @@ export interface ToolError {
     /** Whether the fix is a corrected payload the agent may resend. */
     retryable: boolean;
     sessionId?: string;
-    roundId?: string;
+    /** v4.0.0: the current held handle, when one exists, so the caller can
+     *  re-anchor without reconstructing it. */
+    submissionHandle?: SubmissionHandle;
     details?: Record<string, unknown>;
 }
-export declare function makeTaskId(taskDescription: string): string;
 //# sourceMappingURL=protocol.d.ts.map