@martinloop/mcp 0.3.8 → 0.5.0

package/dist/vendor/contracts/context-handoff.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Context Handoff — A-CTX-2 contracts.
+ *
+ * Chain verification circuit breaker for upstream-to-downstream context handoff.
+ *
+ * Rule: a downstream agent MUST NOT execute before verifyContextHandoff returns ok=true.
+ * Healthy handoffs are silent. Broken handoffs stop execution and return one reason code
+ * plus one recovery instruction. Never silently discard excluded or unverifiable context.
+ */
+/**
+ * Overall integrity state of the upstream chain.
+ * "verified"          — all upstream receipts and artifacts check out
+ * "evidence_boundary" — upstream integrity could not be established (no receipt)
+ * "tamper_detected"   — receipt hash or artifact hash does not match
+ * "incomplete"        — required fields or artifacts are absent
+ * "unsupported_schema"— handoff schemaVersion is not recognised
+ */
+export type ChainIntegrityState = "verified" | "evidence_boundary" | "tamper_detected" | "incomplete" | "unsupported_schema";
+export type HandoffClaimState = "verified" | "unverified" | "rejected" | "unknown";
+/** A single verifiable statement carried across the handoff boundary. */
+export interface ContextHandoffClaim {
+    claimId: string;
+    statement: string;
+    evidenceRefs: string[];
+    verificationState: HandoffClaimState;
+}
+/** A content-addressed artifact that must be present and hash-stable across the boundary. */
+export interface ContextHandoffArtifact {
+    path?: string;
+    sha256: string;
+    required: boolean;
+    label?: string;
+}
+export declare const HANDOFF_SCHEMA_VERSION: "martin.handoff.v1";
+/**
+ * Immutable record produced by the upstream agent and verified before the
+ * downstream agent executes.
+ *
+ * upstreamIntegrity propagates from the parent handoff — it can never be
+ * upgraded by downstream success. A "tamper_detected" upstream remains
+ * "tamper_detected" regardless of what the current agent does.
+ */
+export interface ContextHandoffReceipt {
+    schemaVersion: typeof HANDOFF_SCHEMA_VERSION;
+    handoffId: string;
+    chainId: string;
+    missionId?: string;
+    producerRunId: string;
+    /** SHA-256 of the upstream run's canonical receipt file. */
+    producerReceiptHash: string;
+    /** Parent handoff IDs for multi-hop chain lineage. */
+    parentHandoffIds?: string[];
+    claims: ContextHandoffClaim[];
+    artifacts: ContextHandoffArtifact[];
+    /** Free-text assumptions that have not yet been verified at handoff time. */
+    unresolvedAssumptions: string[];
+    upstreamIntegrity: "verified" | "evidence_boundary" | "tamper_detected" | "incomplete";
+    createdAt: string;
+}
+/**
+ * Safe ledger record for a context object that was denied before reaching
+ * executable context.
+ *
+ * MUST NOT contain the secret value or raw denied content — only safe
+ * identity, hashes, and reason codes.
+ */
+export interface ContextExclusionDecision {
+    decision: "excluded";
+    objectId: string;
+    reasonCode: "secret_detected" | "policy_denied" | "authority_boundary" | "integrity_unverified";
+    reason: string;
+    /** SHA-256 of the denied content — never the content itself. */
+    sourceHash?: string;
+    excludedAt: string;
+}
+export interface ContextHandoffVerification {
+    ok: boolean;
+    integrity: ChainIntegrityState;
+    reasons: Array<{
+        code: string;
+        message: string;
+        claimId?: string;
+        artifactSha256?: string;
+    }>;
+}
+/**
+ * Decision produced by decideContextCircuitBreak.
+ *
+ * Healthy:  { shouldStop: false, silent: true }
+ * Broken:   { shouldStop: true, silent: false, reasonCode, message, nextAction }
+ */
+export interface ContextCircuitBreakResult {
+    shouldStop: boolean;
+    /** true = healthy, no human-visible output; false = must surface to caller */
+    silent: boolean;
+    verification: ContextHandoffVerification;
+    reasonCode?: string;
+    message?: string;
+    nextAction?: string;
+}

package/dist/vendor/contracts/context-handoff.js

@@ -0,0 +1,11 @@
+/**
+ * Context Handoff — A-CTX-2 contracts.
+ *
+ * Chain verification circuit breaker for upstream-to-downstream context handoff.
+ *
+ * Rule: a downstream agent MUST NOT execute before verifyContextHandoff returns ok=true.
+ * Healthy handoffs are silent. Broken handoffs stop execution and return one reason code
+ * plus one recovery instruction. Never silently discard excluded or unverifiable context.
+ */
+// ─── Receipt ──────────────────────────────────────────────────────────────────
+export const HANDOFF_SCHEMA_VERSION = "martin.handoff.v1";

package/dist/vendor/contracts/context-manifest.d.ts

@@ -0,0 +1,195 @@
+/**
+ * Context Runtime — A-CTX-1 contracts.
+ *
+ * Defines the governed context layer: objects, budgets, manifests, ledger
+ * entries, fault protocol, and continuation checkpoints.
+ *
+ * Non-negotiable invariants (enforced in implementation, not type system):
+ *   - No `confidence` float anywhere — use UsageEvidence enums only
+ *   - No `outcome_delta` field anywhere — permanently banned
+ *   - `nowMs` is always a captured input; never Date.now() inside a compiler
+ *   - Secret scan hit → deny persistence entirely; reason-coded ledger entry only
+ *   - Fault budget accumulates by taskId, NOT by runId
+ */
+/**
+ * Evidence quality for a metric or measurement.
+ *
+ * "observed"  = distinctive substring from the object appears verbatim in model output
+ * "inferred"  = weak kind correlation, narrow and documented per kind
+ * "unknown"   = default; metrics MUST be withheld, never reported as zero
+ */
+export type UsageEvidence = "observed" | "inferred" | "unknown";
+export type ContextKind = "mission" | "policy" | "security" | "task" | "continuation" | "working_diff" | "diagnostic" | "source" | "test" | "decision" | "todo" | "receipt_summary" | "tool_result";
+export type ContextPriority = "required" | "high" | "normal" | "low";
+export type ContextTrust = "authoritative" | "workspace" | "external" | "untrusted";
+export type ContextSensitivity = "public" | "workspace" | "restricted" | "secret";
+/** A typed, hashed, provenance-tracked object eligible for working-set inclusion. */
+export interface ContextObject {
+    /** Stable identifier across revisions. */
+    id: string;
+    kind: ContextKind;
+    priority: ContextPriority;
+    trust: ContextTrust;
+    sensitivity: ContextSensitivity;
+    /** File path, receipt hash, or MCP URI — where the object originates. */
+    sourceRef: string;
+    /** SHA-256 of raw content. */
+    contentHash: string;
+    /** Git SHA or equivalent revision of the source file, if known. */
+    sourceRevisionHash?: string;
+    /** Pre-render token estimate used during selection. */
+    estimatedTokens: number;
+    /** Set iff the object was manually pinned; counts against pinnedTokensMax. */
+    pinnedBy?: string;
+    tags?: string[];
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Token budget for one context compilation pass.
+ *
+ * pinnedTokensMax REQUIRED: caps manual-pin tokens to prevent deterministic
+ * selector starvation. Any pin that would exceed this cap must be rejected.
+ */
+export interface ContextBudget {
+    modelWindowTokens: number;
+    systemReserveTokens: number;
+    outputReserveTokens: number;
+    toolReserveTokens: number;
+    overflowReserveTokens: number;
+    maxWorkingSetTokens: number;
+    /** Hard cap on manually-pinned token allocation. */
+    pinnedTokensMax: number;
+}
+/**
+ * The compiler's per-object inclusion/exclusion record.
+ *
+ * "included_truncated" is DISTINCT from "included" — truncation must be
+ * explicit in every receipt. Never use "included" for a truncated object.
+ */
+export interface ContextCandidateDecision {
+    objectId: string;
+    decision: "included" | "included_truncated" | "excluded" | "deferred" | "fault_loaded";
+    /**
+     * Only present when decision === "included_truncated".
+     * Records the pre-truncation token count for receipts.
+     */
+    truncatedFromTokens?: number;
+    /** Machine-readable reason code for this decision. */
+    reason: string;
+    /** Actual post-render token count after adapter recount. Omitted pre-render. */
+    renderedTokens?: number;
+}
+export declare const CONTEXT_MANIFEST_VERSION: "context-manifest/1";
+/**
+ * Immutable record of one context compilation pass.
+ *
+ * Determinism invariant:
+ *   same inputs + policyHash + adapterVersion + nowMs → same manifestHash
+ *
+ * nowMs MUST be an explicit captured input — never Date.now() inside the
+ * compiler or rankContextObject.
+ */
+export interface ContextManifest {
+    schemaVersion: typeof CONTEXT_MANIFEST_VERSION;
+    /** SHA-256 of (decisions + budget + policyHash + adapterVersion + nowMs). */
+    manifestHash: string;
+    taskId: string;
+    runId: string;
+    /** Explicit input — never Date.now() inside the compiler. */
+    nowMs: number;
+    adapterVersion: string;
+    policyHash: string;
+    budget: ContextBudget;
+    decisions: ContextCandidateDecision[];
+    totalRenderedTokens: number;
+    /** Render pass count; must be ≤ MAX_RENDER_PASSES (5). */
+    renderPasses: number;
+    compilationDurationMs: number;
+}
+export declare const CONTEXT_LEDGER_VERSION: "context-ledger/1";
+/**
+ * Fourth ledger entry type — on the SAME receipt chain as cost and verification.
+ *
+ * FORBIDDEN: confidence field, outcome_delta field — both permanently banned.
+ * overflowCount and faultBudgetUsed accumulate by taskId, NOT by runId.
+ */
+export interface ContextLedgerEntry {
+    schemaVersion: typeof CONTEXT_LEDGER_VERSION;
+    entryType: "context";
+    taskId: string;
+    runId: string;
+    manifestHash: string;
+    totalIncluded: number;
+    totalExcluded: number;
+    totalFaultLoaded: number;
+    /** Cumulative overflow count — resets per task, never per run. */
+    overflowCount: number;
+    /** Cumulative fault budget consumed — resets per task, never per run. */
+    faultBudgetUsed: number;
+    adapterVersion: string;
+}
+/** Request to demand-load a missing context object on fault. */
+export interface ContextFaultRequest {
+    objectId: string;
+    taskId: string;
+    runId: string;
+    reason: string;
+}
+/** Result of a context fault resolution attempt. */
+export interface ContextFaultResult {
+    objectId: string;
+    status: "loaded" | "unavailable" | "secret_blocked" | "budget_exceeded";
+    /** Post-render token count when status === "loaded". */
+    renderedTokens?: number;
+    ledgerEventEmitted: boolean;
+}
+/** Minimal task item tracked within a ContinuationCheckpoint. */
+export interface TaskItem {
+    id: string;
+    description: string;
+    status: "pending" | "in_progress" | "completed" | "failed";
+    createdAtMs: number;
+    completedAtMs?: number;
+}
+/**
+ * Durable task state preserved outside the provider transcript.
+ *
+ * Write discipline (all enforced in CheckpointStore):
+ *   - All writes MUST go through CheckpointStore.withTaskLock (CAS-locked).
+ *   - Reject if store.read(taskId).sequenceNumber !== checkpoint.sequenceNumber - 1.
+ *   - All array fields MUST be bounded before persistence.
+ *   - Old completed entries MUST be compacted into completedSummaryHash.
+ *
+ * Testing requirement: two real concurrent Node processes, not jest mocks.
+ */
+export interface ContinuationCheckpoint {
+    schemaVersion: "checkpoint/1";
+    taskId: string;
+    /** CAS lock key: reject write if stored sequenceNumber !== this - 1. */
+    sequenceNumber: number;
+    /** SHA-256 of the previous checkpoint — integrity chain. */
+    parentHash: string;
+    /** Old completed[] compacted into a hash-referenced summary to bound size. */
+    completedSummaryHash?: string;
+    pending: TaskItem[];
+    inProgress: TaskItem[];
+    decisions: ContextCandidateDecision[];
+    createdAtMs: number;
+}
+/**
+ * Governs what may enter the working set, how much, and why.
+ * policyHash must be included in every manifestHash computation.
+ */
+export interface ContextPolicy {
+    policyHash: string;
+    /** Sensitivity levels that are unconditionally excluded. */
+    deniedSensitivities: ContextSensitivity[];
+    /** Trust levels that are unconditionally excluded. */
+    deniedTrustLevels: ContextTrust[];
+    /** Behaviour when required objects alone exceed budget. */
+    requiredOverBudgetAction: "explicit_escalation" | "fail_closed";
+    /** Maximum allowed compiler wall-clock duration in ms. */
+    maxCompilerDurationMs: number;
+    /** Maximum overhead ratio: compilationDurationMs / totalRenderedTokens. */
+    maxOverheadRatio: number;
+}

package/dist/vendor/contracts/context-manifest.js

@@ -0,0 +1,17 @@
+/**
+ * Context Runtime — A-CTX-1 contracts.
+ *
+ * Defines the governed context layer: objects, budgets, manifests, ledger
+ * entries, fault protocol, and continuation checkpoints.
+ *
+ * Non-negotiable invariants (enforced in implementation, not type system):
+ *   - No `confidence` float anywhere — use UsageEvidence enums only
+ *   - No `outcome_delta` field anywhere — permanently banned
+ *   - `nowMs` is always a captured input; never Date.now() inside a compiler
+ *   - Secret scan hit → deny persistence entirely; reason-coded ledger entry only
+ *   - Fault budget accumulates by taskId, NOT by runId
+ */
+// ─── ContextManifest ─────────────────────────────────────────────────────────
+export const CONTEXT_MANIFEST_VERSION = "context-manifest/1";
+// ─── ContextLedgerEntry ───────────────────────────────────────────────────────
+export const CONTEXT_LEDGER_VERSION = "context-ledger/1";

package/dist/vendor/contracts/context-shadow.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Context Shadow — A-CTX-0 schema contracts.
+ *
+ * Shadow mode observes the existing prompt without altering it.
+ * No source text is retained in manifests or receipts — only hashes and counts.
+ */
+export declare const CONTEXT_SHADOW_MANIFEST_VERSION: "context-shadow-manifest/1";
+export declare const CONTEXT_C5_VERSION: "context-c5/1";
+export type ContextEvidence = "observed" | "configured" | "inferred" | "unknown";
+export type ContextShadowSegmentKind = "system" | "mission" | "task" | "workspace" | "diagnostic" | "tool" | "other";
+export interface ContextShadowSegmentInput {
+    segmentId: string;
+    kind: ContextShadowSegmentKind;
+    required: boolean;
+    text: string;
+}
+export interface ContextShadowDecisionV1 {
+    segmentId: string;
+    kind: string;
+    /** SHA-256 of segment.text — never the source text itself. */
+    contentHash: string;
+    estimatedTokens: number;
+    /** Always true in shadow mode — actual prompt is never altered. */
+    actuallyIncluded: true;
+    /** What the shadow compiler would have decided if it controlled selection. */
+    proposedDecision: "included" | "excluded";
+    reason: "required" | "within_shadow_budget" | "shadow_budget_exhausted" | "required_over_budget";
+}
+export interface ContextShadowManifestV1 {
+    schemaVersion: typeof CONTEXT_SHADOW_MANIFEST_VERSION;
+    manifestId: string;
+    /** SHA-256 of the canonical JSON of the manifest (excluding manifestId and manifestHash). */
+    manifestHash: string;
+    /** SHA-256 of the canonical compiler input, for cross-run determinism checks. */
+    compilerInputHash: string;
+    runId: string;
+    taskId?: string;
+    adapter: string;
+    model?: string;
+    capturedAt: string;
+    mode: "shadow";
+    modelWindowTokens: number | null;
+    modelWindowEvidence: ContextEvidence;
+    shadowBudgetTokens: number;
+    /** SHA-256 of framed source segments — confirms prompt identity without storing content. */
+    actualPromptHash: string;
+    /** Estimated token count of all segments (actual prompt). */
+    actualEstimatedTokens: number;
+    /** Estimated token count of shadow-selected segments only. */
+    proposedEstimatedTokens: number;
+    /** True if required segments alone exceed shadowBudgetTokens. */
+    requiredOverBudget: boolean;
+    decisions: ContextShadowDecisionV1[];
+}
+export interface ContextC5EnvelopeV1 {
+    schemaVersion: typeof CONTEXT_C5_VERSION;
+    resource: "context";
+    event: "shadow_compiled";
+    runId: string;
+    taskId?: string;
+    manifestId: string;
+    manifestHash: string;
+    adapter: string;
+    model?: string;
+    mode: "shadow";
+    actualEstimatedTokens: number;
+    proposedEstimatedTokens: number;
+    candidateCount: number;
+    includedCount: number;
+    excludedCount: number;
+    requiredOverBudget: boolean;
+    modelWindowTokens: number | null;
+    modelWindowEvidence: ContextEvidence;
+    createdAt: string;
+}

package/dist/vendor/contracts/context-shadow.js

@@ -0,0 +1,8 @@
+/**
+ * Context Shadow — A-CTX-0 schema contracts.
+ *
+ * Shadow mode observes the existing prompt without altering it.
+ * No source text is retained in manifests or receipts — only hashes and counts.
+ */
+export const CONTEXT_SHADOW_MANIFEST_VERSION = "context-shadow-manifest/1";
+export const CONTEXT_C5_VERSION = "context-c5/1";

package/dist/vendor/contracts/exits.d.ts

@@ -0,0 +1,126 @@
+/**
+ * Exit contracts for the MartinLoop Eight-Exit Runtime.
+ *
+ * Precedence rationale (product decision — changing EXIT_PRECEDENCE in core
+ * requires updating this paragraph in the same commit):
+ *   1. human_interrupt and external_event outrank all others — they represent
+ *      authority external to the run's own evidence and cannot be argued with.
+ *   2. wall_clock, budget_cap, and turn_cap all outrank goal_met — governance
+ *      limits (time, cost, iterations) cannot be overridden by a simultaneously
+ *      verified goal; resource limits rank wall_clock > budget_cap > turn_cap.
+ *   3. turn_cap is suppressed at signal-generation time when the goal is already
+ *      met, so goal_met and turn_cap cannot co-occur in a well-formed evaluation.
+ *      Completing on the final permitted iteration is legitimate success, not an
+ *      overrun; turn_cap fires only when iterations are exhausted without
+ *      verified completion.
+ *   4. goal_met outranks error_threshold and no_progress — a deterministically
+ *      verified result takes priority over soft progress signals.
+ */
+export declare const EXIT_POLICY_VERSION: "exit-policy/1";
+export declare const EXIT_EVALUATION_VERSION: "exit-evaluation/1";
+export declare const EXIT_SIGNAL_VERSION: "exit-signal/1";
+export declare const TERMINATION_ENVELOPE_VERSION: "termination/1";
+export declare const EXIT_KINDS: readonly ["goal_met", "turn_cap", "budget_cap", "wall_clock", "no_progress", "human_interrupt", "error_threshold", "external_event"];
+export type ExitKind = (typeof EXIT_KINDS)[number];
+export type ExitEvaluationPhase = "pre_run" | "pre_attempt" | "post_attempt" | "before_retry" | "during_attempt";
+export type ExternalEventDisposition = "satisfied" | "superseded" | "cancelled";
+export interface ExternalExitEvent {
+    source: string;
+    event: string;
+    disposition: ExternalEventDisposition;
+    observedAt: string;
+    subject?: string;
+    reason?: string;
+    evidenceUri?: string;
+}
+export interface ExitPolicyV1 {
+    schemaVersion: typeof EXIT_POLICY_VERSION;
+    goal: {
+        verifierRequired: boolean;
+        minimumScore: number;
+    };
+    turns: {
+        max: number;
+    };
+    budget: {
+        maxUsd: number;
+        maxTokens: number;
+    };
+    wallClock: {
+        maxElapsedMs: number;
+        deadlineAt?: string;
+    };
+    progress: {
+        windowSize: number;
+        unchangedStateLimit: number;
+    };
+    errors: {
+        maxConsecutive: number;
+    };
+    humanInterrupt: {
+        enabled: boolean;
+    };
+    externalEvent: {
+        enabled: boolean;
+    };
+}
+export interface ExitSignalV1 {
+    schemaVersion: typeof EXIT_SIGNAL_VERSION;
+    runId: string;
+    kind: "human_interrupt" | "external_event";
+    requestedAt: string;
+    requestedBy: string;
+    reason?: string;
+    externalEvent?: ExternalExitEvent;
+}
+export interface ExitSnapshotV1 {
+    phase: ExitEvaluationPhase;
+    evaluatedAt: string;
+    runStartedAtMs: number;
+    nowMs: number;
+    turnsUsed: number;
+    actualUsd: number;
+    tokensUsed: number;
+    result?: {
+        status: "completed" | "failed";
+        verificationPassed: boolean;
+        verifierScore: number;
+    };
+    recentStateHashes: string[];
+    consecutiveErrors: number;
+    humanInterrupt?: ExitSignalV1;
+    externalEvent?: ExternalExitEvent;
+    trajectoryStop?: {
+        shouldStop: boolean;
+        reason: string;
+    };
+}
+export interface ExitMatchV1 {
+    kind: ExitKind;
+    reason: string;
+    evidence: Record<string, unknown>;
+}
+export interface ExitEvaluationV1 {
+    schemaVersion: typeof EXIT_EVALUATION_VERSION;
+    policyVersion: typeof EXIT_POLICY_VERSION;
+    shouldExit: boolean;
+    primary?: ExitKind;
+    matched: ExitKind[];
+    phase: ExitEvaluationPhase;
+    evaluatedAt: string;
+    matches: ExitMatchV1[];
+}
+export type TerminationEnvelopeV1 = {
+    schemaVersion: typeof TERMINATION_ENVELOPE_VERSION;
+    class: "operational_exit";
+    exit: ExitEvaluationV1;
+} | {
+    schemaVersion: typeof TERMINATION_ENVELOPE_VERSION;
+    class: "guard_stop";
+    guard: {
+        reasonCode: string;
+        reason: string;
+        failureClass?: string;
+        safetySurface?: string;
+    };
+};

package/dist/vendor/contracts/exits.js

@@ -0,0 +1,32 @@
+/**
+ * Exit contracts for the MartinLoop Eight-Exit Runtime.
+ *
+ * Precedence rationale (product decision — changing EXIT_PRECEDENCE in core
+ * requires updating this paragraph in the same commit):
+ *   1. human_interrupt and external_event outrank all others — they represent
+ *      authority external to the run's own evidence and cannot be argued with.
+ *   2. wall_clock, budget_cap, and turn_cap all outrank goal_met — governance
+ *      limits (time, cost, iterations) cannot be overridden by a simultaneously
+ *      verified goal; resource limits rank wall_clock > budget_cap > turn_cap.
+ *   3. turn_cap is suppressed at signal-generation time when the goal is already
+ *      met, so goal_met and turn_cap cannot co-occur in a well-formed evaluation.
+ *      Completing on the final permitted iteration is legitimate success, not an
+ *      overrun; turn_cap fires only when iterations are exhausted without
+ *      verified completion.
+ *   4. goal_met outranks error_threshold and no_progress — a deterministically
+ *      verified result takes priority over soft progress signals.
+ */
+export const EXIT_POLICY_VERSION = "exit-policy/1";
+export const EXIT_EVALUATION_VERSION = "exit-evaluation/1";
+export const EXIT_SIGNAL_VERSION = "exit-signal/1";
+export const TERMINATION_ENVELOPE_VERSION = "termination/1";
+export const EXIT_KINDS = [
+    "goal_met",
+    "turn_cap",
+    "budget_cap",
+    "wall_clock",
+    "no_progress",
+    "human_interrupt",
+    "error_threshold",
+    "external_event"
+];

package/dist/vendor/contracts/index.d.ts

@@ -1,9 +1,19 @@
+/**
+ * Contracts for the Martin Loop agentic system.
+ *
+ * This module defines the core type contracts and data structures for autonomous agent loop management,
+ * including loop lifecycle states, task definitions, budget tracking, cost accounting, verification,
+ * patch decisions, telemetry, and governance policies. It provides the public API surface for
+ * creating and managing loop records, handling events, validating batches, and tracking
+ * portfolio snapshots and routing economics.
+ */
+import type { TerminationEnvelopeV1 } from "./exits.js";
 export type LoopStatus = "queued" | "running" | "verifying" | "completed" | "failed" | "exited";
-export type LoopLifecycleState = "created" | "running" | "verifying" | "completed" | "budget_exit" | "diminishing_returns" | "stuck_exit" | "human_escalation";
+export type LoopLifecycleState = "created" | "running" | "verifying" | "completed" | "budget_exit" | "diminishing_returns" | "stuck_exit" | "human_escalation" | "wall_clock" | "error_threshold" | "external_event";
 export declare const FAILURE_CLASSES: readonly ["logic_error", "hallucination", "syntax_error", "type_error", "test_regression", "scope_creep", "no_progress", "repo_grounding_failure", "verification_failure", "environment_mismatch", "budget_pressure", "safety_leash_blocked", "sandbox_write_blocked"];
 export type FailureClass = (typeof FAILURE_CLASSES)[number];
 export type InterventionType = "compress_context" | "change_model" | "tighten_task" | "switch_adapter" | "run_verifier" | "escalate_human" | "stop_loop";
-export type LoopEventType = "run.started" | "attempt.started" | "attempt.completed" | "failure.classified" | "intervention.selected" | "verification.completed" | "budget.updated" | "run.completed";
+export type LoopEventType = "run.started" | "attempt.started" | "attempt.completed" | "failure.classified" | "intervention.selected" | "verification.completed" | "budget.updated" | "run.completed" | "run.terminated";
 export interface LoopTask {
     title: string;
     objective: string;
@@ -12,6 +22,8 @@ export interface LoopTask {
     verificationTimeoutMs?: number;
     verificationStack?: VerificationStep[];
     mutationMode?: MutationMode;
+    /** Explicit task-authority evidence that all definition-of-done criteria were satisfied before execution. */
+    definitionOfDonePreSatisfied?: boolean;
     executionProfile?: ExecutionProfile;
     allowedNetworkDomains?: string[];
     approvalPolicy?: ApprovalPolicy;
@@ -73,6 +85,16 @@ export interface ReceiptScope {
     workingDirectory?: string;
     invocationRoot?: string;
     runsRoot?: string;
+    /** Sandbox mode the mission requested before execution. */
+    requestedSandbox?: "read-only" | "workspace-write" | "danger-full-access";
+    /** Effective sandbox capability detected by pre-run filesystem probe. */
+    effectiveSandbox?: "read-only" | "workspace-write" | "unknown";
+    /** Absolute path that the filesystem write probe tested. */
+    writableRoot?: string;
+    /** How the effective sandbox was determined. */
+    capabilitySource?: "probe" | "configured" | "unknown";
+    /** Enforced demo changes (DEMO.md-only enforcement output). */
+    demoChangedFiles?: string[];
 }
 export type ReceiptIntegrityState = "verified" | "unsigned" | "tamper_detected" | "relocated" | "material_missing" | "selector_noncanonical";
 export interface ReceiptIntegritySummary {
@@ -156,6 +178,8 @@ export interface LoopRecord {
     receiptScope?: ReceiptScope;
     receiptIntegrity?: ReceiptIntegritySummary;
     routingEconomics?: RoutingEconomics;
+    /** Canonical termination identity written by finishFromEvaluation. Present when run ended via exit policy. */
+    terminationEnvelope?: TerminationEnvelopeV1;
 }
 export interface LoopRecordDraft {
     loopId?: string;
@@ -175,6 +199,7 @@ export interface LoopRecordDraft {
     updatedAt?: string;
     receiptScope?: ReceiptScope;
     receiptIntegrity?: ReceiptIntegritySummary;
+    terminationEnvelope?: TerminationEnvelopeV1;
 }
 export type { MartinErrorCategory, MartinOutputMode, MartinRunListFilters, MartinRunSelector } from "./operator.js";
 export { MARTIN_ERROR_CATEGORIES } from "./operator.js";
@@ -410,5 +435,17 @@ export { cloneIdentityAttestation, cloneIdentityClaims, cloneIdentityToken } fro
 export type { IdentityAttestation, IdentityClaims, IdentityToken } from "./identity.js";
 export { cloneCircuitBreakDecision, cloneTrajectoryAssessment } from "./trajectory.js";
 export type { CircuitBreakDecision, TrajectoryAssessment, TrajectorySignal } from "./trajectory.js";
+export { EXIT_KINDS, EXIT_POLICY_VERSION, EXIT_EVALUATION_VERSION, EXIT_SIGNAL_VERSION, TERMINATION_ENVELOPE_VERSION } from "./exits.js";
+export type { ExitKind, ExitEvaluationPhase, ExternalEventDisposition, ExternalExitEvent, ExitPolicyV1, ExitSignalV1, ExitSnapshotV1, ExitMatchV1, ExitEvaluationV1, TerminationEnvelopeV1 } from "./exits.js";
 export { ALLOWED_ACTION_TYPES, DELIVERY_MESSAGE_SCHEMA_VERSION, DELIVERY_RECORD_SCHEMA_VERSION, MESSAGE_SELECTION_RESPONSE_SCHEMA_VERSION } from "./delivery.js";
 export type { ActionType, DeliveryMessage, DeliveryRecord, MessageKind, MessageSelectionResponse, UpdateAvailableField } from "./delivery.js";
+export { CONTEXT_SHADOW_MANIFEST_VERSION, CONTEXT_C5_VERSION } from "./context-shadow.js";
+export type { ContextC5EnvelopeV1, ContextEvidence, ContextShadowDecisionV1, ContextShadowManifestV1, ContextShadowSegmentInput, ContextShadowSegmentKind } from "./context-shadow.js";
+export { CONTEXT_MANIFEST_VERSION, CONTEXT_LEDGER_VERSION } from "./context-manifest.js";
+export type { ContinuationCheckpoint, ContextBudget, ContextCandidateDecision, ContextFaultRequest, ContextFaultResult, ContextKind, ContextLedgerEntry, ContextManifest, ContextObject, ContextPolicy, ContextPriority, ContextSensitivity, ContextTrust, TaskItem, UsageEvidence } from "./context-manifest.js";
+export { EVIDENCE_STATUSES, TEST_INTEGRITY_STATUSES, TEST_INTEGRITY_VERDICTS, VERIFIED_HANDOFF_OUTCOMES, } from "./verified-handoff.js";
+export type { EvidenceStatus, TestIntegrityStatus, TestIntegrityVerdict, VerifiedHandoffCheckV1, VerifiedHandoffOutcome, VerifiedHandoffRecoveryV1, VerifiedHandoffRequirementV1, VerifiedHandoffScopeV1, VerifiedHandoffTestIntegrityV1, VerifiedHandoffV1, } from "./verified-handoff.js";
+export { HANDOFF_SCHEMA_VERSION } from "./context-handoff.js";
+export type { ChainIntegrityState, ContextCircuitBreakResult, ContextExclusionDecision, ContextHandoffArtifact, ContextHandoffClaim, ContextHandoffReceipt, ContextHandoffVerification, HandoffClaimState } from "./context-handoff.js";
+export { MISSION_SCHEMA_VERSION, MISSION_STATUSES, ALLOWED_MISSION_TRANSITIONS, createMissionRecord, isMissionTransitionAllowed } from './mission.js';
+export type { MissionStatus, MissionDecision, MissionBudget, MissionCost, MissionRunLink, MissionRunRole, MissionApproval, MissionOutcome, MissionEvent, MissionEventKind, MissionRecord, MissionDraft } from './mission.js';