@martinloop/mcp 0.7.1 → 0.8.0

package/dist/vendor/contracts/external-outcome.d.ts

@@ -0,0 +1,102 @@
+export declare const EXTERNAL_OUTCOME_SCHEMA_VERSION: "external-outcome/1";
+export declare const EXTERNAL_OUTCOME_RESULT_SCHEMA_VERSION: "external-outcome-result/1";
+export declare const EXTERNAL_OUTCOME_LIMITS: Readonly<{
+    maxActions: 100;
+    maxAssertionsPerAction: 50;
+    maxContractBytes: number;
+    maxResponseBytes: number;
+    maxDeadlineMs: 30000;
+    maxConcurrency: 4;
+}>;
+export type ExternalOutcomeJsonScalar = string | number | boolean | null;
+export type ExternalOutcomeStatus = "passed" | "failed" | "unknown";
+export type ExternalOutcomeReasonCode = "passed" | "record_missing" | "value_mismatch" | "wrong_identity" | "duplicate_record" | "stale_record" | "source_unavailable" | "auth_denied" | "invalid_response" | "response_too_large" | "redirect_blocked" | "deadline_exceeded" | "cancelled";
+export interface ExternalOutcomeExpectation {
+    pointer: string;
+    equals: ExternalOutcomeJsonScalar;
+}
+export interface ExternalOutcomeFreshness {
+    pointer: string;
+    notEquals?: ExternalOutcomeJsonScalar;
+    notBefore?: string;
+}
+export interface ExternalOutcomeActionContract {
+    actionId: string;
+    claimedDone: boolean;
+    source: {
+        url: string;
+        authEnv?: string;
+    };
+    recordPointer: string;
+    identity: ExternalOutcomeExpectation;
+    expectedCount: number;
+    assertions: ExternalOutcomeExpectation[];
+    freshness?: ExternalOutcomeFreshness;
+}
+export interface ExternalOutcomeContract {
+    schemaVersion: typeof EXTERNAL_OUTCOME_SCHEMA_VERSION;
+    contractId: string;
+    allowedOrigins: string[];
+    deadlineMs: number;
+    pollIntervalMs: number;
+    requestTimeoutMs: number;
+    actions: ExternalOutcomeActionContract[];
+}
+export interface ExternalOutcomeAssertionResult {
+    pointer: string;
+    passed: boolean;
+    reasonCode: "passed" | "missing_pointer" | "value_mismatch" | "stale_record";
+}
+export interface ExternalOutcomeActionResult {
+    actionId: string;
+    claimedDone: boolean;
+    status: ExternalOutcomeStatus;
+    reasonCode: ExternalOutcomeReasonCode;
+    observationCount: number;
+    firstObservedAt?: string;
+    lastObservedAt?: string;
+    elapsedMs: number;
+    source: {
+        origin: string;
+    };
+    assertions: ExternalOutcomeAssertionResult[];
+}
+export interface ExternalOutcomeEvidenceReference {
+    kind: "external_outcome";
+    contractId: string;
+    sha256: string;
+    path: string;
+}
+export interface ExternalOutcomeResult {
+    schemaVersion: typeof EXTERNAL_OUTCOME_RESULT_SCHEMA_VERSION;
+    contractId: string;
+    contractSha256: string;
+    startedAt: string;
+    completedAt: string;
+    binding?: {
+        runId?: string;
+        attemptId?: string;
+        workspaceId?: string;
+    };
+    aggregate: {
+        claimedDone: number;
+        checked: number;
+        passed: number;
+        failed: number;
+        unknown: number;
+        rejectedClaimRate: number;
+        unknownClaimRate: number;
+        coverage: number;
+    };
+    actions: ExternalOutcomeActionResult[];
+}
+export interface ExternalOutcomeValidationError {
+    path: string;
+    message: string;
+}
+export declare function validateExternalOutcomeContract(value: unknown): ExternalOutcomeValidationError[];
+export declare function resolveExternalOutcomeJsonPointer(value: unknown, pointer: string): {
+    found: boolean;
+    value?: unknown;
+};
+export declare function externalOutcomeValuesEqual(left: unknown, right: ExternalOutcomeJsonScalar): boolean;

package/dist/vendor/contracts/external-outcome.js

@@ -0,0 +1,226 @@
+export const EXTERNAL_OUTCOME_SCHEMA_VERSION = "external-outcome/1";
+export const EXTERNAL_OUTCOME_RESULT_SCHEMA_VERSION = "external-outcome-result/1";
+export const EXTERNAL_OUTCOME_LIMITS = Object.freeze({
+    maxActions: 100,
+    maxAssertionsPerAction: 50,
+    maxContractBytes: 256 * 1024,
+    maxResponseBytes: 1024 * 1024,
+    maxDeadlineMs: 30_000,
+    maxConcurrency: 4,
+});
+const SAFE_ID = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u;
+const ENV_NAME = /^[A-Za-z_][A-Za-z0-9_]*$/u;
+export function validateExternalOutcomeContract(value) {
+    const errors = [];
+    if (!isRecord(value))
+        return [{ path: "", message: "contract must be an object" }];
+    let encodedBytes = Number.POSITIVE_INFINITY;
+    try {
+        encodedBytes = new TextEncoder().encode(JSON.stringify(value)).byteLength;
+    }
+    catch {
+        errors.push({ path: "", message: "contract must be JSON-serializable" });
+    }
+    if (encodedBytes > EXTERNAL_OUTCOME_LIMITS.maxContractBytes) {
+        errors.push({ path: "", message: `contract exceeds ${EXTERNAL_OUTCOME_LIMITS.maxContractBytes} bytes` });
+    }
+    if (value.schemaVersion !== EXTERNAL_OUTCOME_SCHEMA_VERSION) {
+        errors.push({ path: "schemaVersion", message: `must equal ${EXTERNAL_OUTCOME_SCHEMA_VERSION}` });
+    }
+    validateId(value.contractId, "contractId", errors);
+    if (!Array.isArray(value.allowedOrigins) || value.allowedOrigins.length === 0) {
+        errors.push({ path: "allowedOrigins", message: "at least one allowed origin is required" });
+    }
+    else {
+        const seen = new Set();
+        value.allowedOrigins.forEach((origin, index) => {
+            if (typeof origin !== "string") {
+                errors.push({ path: `allowedOrigins[${index}]`, message: "must be a URL origin string" });
+                return;
+            }
+            try {
+                const parsed = new URL(origin);
+                if ((parsed.protocol !== "https:" && parsed.protocol !== "http:")
+                    || parsed.username || parsed.password || parsed.pathname !== "/" || parsed.search || parsed.hash
+                    || parsed.origin !== origin.replace(/\/$/u, "")) {
+                    errors.push({ path: `allowedOrigins[${index}]`, message: "must be a canonical http(s) origin without path, query, fragment, or credentials" });
+                    return;
+                }
+                if (seen.has(parsed.origin))
+                    errors.push({ path: `allowedOrigins[${index}]`, message: "duplicate origin" });
+                seen.add(parsed.origin);
+            }
+            catch {
+                errors.push({ path: `allowedOrigins[${index}]`, message: "must be a valid URL origin" });
+            }
+        });
+    }
+    validateInteger(value.deadlineMs, "deadlineMs", 1, EXTERNAL_OUTCOME_LIMITS.maxDeadlineMs, errors);
+    validateInteger(value.pollIntervalMs, "pollIntervalMs", 25, EXTERNAL_OUTCOME_LIMITS.maxDeadlineMs, errors);
+    validateInteger(value.requestTimeoutMs, "requestTimeoutMs", 25, EXTERNAL_OUTCOME_LIMITS.maxDeadlineMs, errors);
+    if (typeof value.deadlineMs === "number" && typeof value.pollIntervalMs === "number" && value.pollIntervalMs > value.deadlineMs) {
+        errors.push({ path: "pollIntervalMs", message: "must not exceed deadlineMs" });
+    }
+    if (typeof value.deadlineMs === "number" && typeof value.requestTimeoutMs === "number" && value.requestTimeoutMs > value.deadlineMs) {
+        errors.push({ path: "requestTimeoutMs", message: "must not exceed deadlineMs" });
+    }
+    if (!Array.isArray(value.actions) || value.actions.length === 0) {
+        errors.push({ path: "actions", message: "at least one action is required" });
+        return errors;
+    }
+    if (value.actions.length > EXTERNAL_OUTCOME_LIMITS.maxActions) {
+        errors.push({ path: "actions", message: `must contain at most ${EXTERNAL_OUTCOME_LIMITS.maxActions} actions` });
+    }
+    const actionIds = new Set();
+    if (!value.actions.some((candidate) => isRecord(candidate) && candidate.claimedDone === true)) {
+        errors.push({ path: "actions", message: "at least one action must have claimedDone=true" });
+    }
+    value.actions.forEach((candidate, index) => {
+        const base = `actions[${index}]`;
+        if (!isRecord(candidate)) {
+            errors.push({ path: base, message: "must be an object" });
+            return;
+        }
+        validateId(candidate.actionId, `${base}.actionId`, errors);
+        if (typeof candidate.actionId === "string") {
+            if (actionIds.has(candidate.actionId))
+                errors.push({ path: `${base}.actionId`, message: "must be unique" });
+            actionIds.add(candidate.actionId);
+        }
+        if (typeof candidate.claimedDone !== "boolean")
+            errors.push({ path: `${base}.claimedDone`, message: "must be boolean" });
+        if (!isRecord(candidate.source)) {
+            errors.push({ path: `${base}.source`, message: "must be an object" });
+        }
+        else {
+            if (typeof candidate.source.url !== "string") {
+                errors.push({ path: `${base}.source.url`, message: "must be a URL string" });
+            }
+            else {
+                try {
+                    const parsed = new URL(candidate.source.url);
+                    if (!["https:", "http:"].includes(parsed.protocol))
+                        errors.push({ path: `${base}.source.url`, message: "only http(s) read-back URLs are supported" });
+                    if (parsed.username || parsed.password)
+                        errors.push({ path: `${base}.source.url`, message: "URL credentials are forbidden" });
+                    if (parsed.search)
+                        errors.push({ path: `${base}.source.url`, message: "query strings are forbidden; use path identity and authEnv instead" });
+                    if (parsed.hash)
+                        errors.push({ path: `${base}.source.url`, message: "URL fragments are forbidden" });
+                    if (Array.isArray(value.allowedOrigins) && !value.allowedOrigins.map((item) => {
+                        try {
+                            return new URL(String(item)).origin;
+                        }
+                        catch {
+                            return "";
+                        }
+                    }).includes(parsed.origin)) {
+                        errors.push({ path: `${base}.source.url`, message: "origin is not present in allowedOrigins" });
+                    }
+                }
+                catch {
+                    errors.push({ path: `${base}.source.url`, message: "must be a valid URL" });
+                }
+            }
+            if (candidate.source.authEnv !== undefined && (typeof candidate.source.authEnv !== "string" || !ENV_NAME.test(candidate.source.authEnv))) {
+                errors.push({ path: `${base}.source.authEnv`, message: "must be a valid environment variable name" });
+            }
+        }
+        validatePointer(candidate.recordPointer, `${base}.recordPointer`, errors);
+        validateExpectation(candidate.identity, `${base}.identity`, errors);
+        validateInteger(candidate.expectedCount, `${base}.expectedCount`, 1, EXTERNAL_OUTCOME_LIMITS.maxActions, errors);
+        if (!Array.isArray(candidate.assertions)) {
+            errors.push({ path: `${base}.assertions`, message: "must be an array" });
+        }
+        else {
+            if (candidate.assertions.length > EXTERNAL_OUTCOME_LIMITS.maxAssertionsPerAction) {
+                errors.push({ path: `${base}.assertions`, message: `must contain at most ${EXTERNAL_OUTCOME_LIMITS.maxAssertionsPerAction} assertions` });
+            }
+            candidate.assertions.forEach((assertion, assertionIndex) => validateExpectation(assertion, `${base}.assertions[${assertionIndex}]`, errors));
+        }
+        if (candidate.freshness !== undefined) {
+            if (!isRecord(candidate.freshness)) {
+                errors.push({ path: `${base}.freshness`, message: "must be an object" });
+            }
+            else {
+                validatePointer(candidate.freshness.pointer, `${base}.freshness.pointer`, errors);
+                const hasNotEquals = Object.prototype.hasOwnProperty.call(candidate.freshness, "notEquals");
+                const hasNotBefore = candidate.freshness.notBefore !== undefined;
+                if (!hasNotEquals && !hasNotBefore)
+                    errors.push({ path: `${base}.freshness`, message: "must define notEquals or notBefore" });
+                if (hasNotEquals && !isScalar(candidate.freshness.notEquals))
+                    errors.push({ path: `${base}.freshness.notEquals`, message: "must be a JSON scalar" });
+                if (hasNotBefore && (typeof candidate.freshness.notBefore !== "string" || !isCanonicalIso(candidate.freshness.notBefore))) {
+                    errors.push({ path: `${base}.freshness.notBefore`, message: "must be a canonical ISO timestamp" });
+                }
+            }
+        }
+    });
+    return errors;
+}
+export function resolveExternalOutcomeJsonPointer(value, pointer) {
+    if (!isValidPointer(pointer))
+        return { found: false };
+    if (pointer === "")
+        return { found: true, value };
+    let current = value;
+    for (const raw of pointer.slice(1).split("/")) {
+        const segment = raw.replaceAll("~1", "/").replaceAll("~0", "~");
+        if (Array.isArray(current)) {
+            if (!/^(?:0|[1-9]\d*)$/u.test(segment))
+                return { found: false };
+            const index = Number(segment);
+            if (index >= current.length)
+                return { found: false };
+            current = current[index];
+            continue;
+        }
+        if (!isRecord(current) || !Object.prototype.hasOwnProperty.call(current, segment))
+            return { found: false };
+        current = current[segment];
+    }
+    return { found: true, value: current };
+}
+export function externalOutcomeValuesEqual(left, right) {
+    return isScalar(left) && typeof left === typeof right && Object.is(left, right);
+}
+function validateExpectation(value, path, errors) {
+    if (!isRecord(value)) {
+        errors.push({ path, message: "must be an object" });
+        return;
+    }
+    validatePointer(value.pointer, `${path}.pointer`, errors);
+    if (!Object.prototype.hasOwnProperty.call(value, "equals") || !isScalar(value.equals)) {
+        errors.push({ path: `${path}.equals`, message: "must be a JSON scalar" });
+    }
+}
+function validatePointer(value, path, errors) {
+    if (typeof value !== "string" || !isValidPointer(value))
+        errors.push({ path, message: "must be an RFC 6901 JSON Pointer" });
+}
+function isValidPointer(value) {
+    if (value === "")
+        return true;
+    if (!value.startsWith("/"))
+        return false;
+    return !/(?:~(?![01]))/u.test(value);
+}
+function validateId(value, path, errors) {
+    if (typeof value !== "string" || !SAFE_ID.test(value))
+        errors.push({ path, message: "must be a stable 1-128 character identifier" });
+}
+function validateInteger(value, path, min, max, errors) {
+    if (typeof value !== "number" || !Number.isSafeInteger(value) || value < min || value > max) {
+        errors.push({ path, message: `must be an integer between ${min} and ${max}` });
+    }
+}
+function isCanonicalIso(value) {
+    const time = Date.parse(value);
+    return Number.isFinite(time) && new Date(time).toISOString() === value;
+}
+function isScalar(value) {
+    return value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

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

@@ -9,8 +9,11 @@
  */
 import type { TerminationEnvelopeV1 } from "./exits.js";
 import type { AgentExecutionIntent } from "./agent-execution.js";
+import type { SwarmChildReceiptLink } from "./swarm.js";
 export { DEFAULT_AGENT_EXECUTION_INTENT, DEFAULT_PROVIDER_EXECUTION_TIMEOUT_MS, GOVERNED_AUTONOMOUS_BOUNDARY, normalizeProviderExecutionTimeoutMs } from "./agent-execution.js";
 export type { AgentExecutionIntent } from "./agent-execution.js";
+export { EXTERNAL_OUTCOME_LIMITS, EXTERNAL_OUTCOME_RESULT_SCHEMA_VERSION, EXTERNAL_OUTCOME_SCHEMA_VERSION, externalOutcomeValuesEqual, resolveExternalOutcomeJsonPointer, validateExternalOutcomeContract, } from "./external-outcome.js";
+export type { ExternalOutcomeActionContract, ExternalOutcomeActionResult, ExternalOutcomeAssertionResult, ExternalOutcomeContract, ExternalOutcomeEvidenceReference, ExternalOutcomeFreshness, ExternalOutcomeJsonScalar, ExternalOutcomeReasonCode, ExternalOutcomeResult, ExternalOutcomeStatus, ExternalOutcomeValidationError, } from "./external-outcome.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" | "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"];
@@ -42,7 +45,7 @@ export interface LoopTask {
     acceptanceCriteria?: string[];
 }
 export type ExecutionProfile = "strict_local" | "ci_safe" | "staging_controlled" | "research_untrusted";
-export type MutationMode = "edit";
+export type MutationMode = "edit" | "read_only";
 export interface ApprovalPolicy {
     dependencyAdds?: boolean;
     migrations?: boolean;
@@ -114,6 +117,8 @@ export interface ReceiptScope {
     providerExecutionTimeoutMs?: number;
     /** Enforced demo changes (DEMO.md-only enforcement output). */
     demoChangedFiles?: string[];
+    /** Optional lineage for a child launched by a governed swarm. */
+    swarmChild?: SwarmChildReceiptLink;
 }
 export type ReceiptIntegrityState = "verified" | "unsigned" | "tamper_detected" | "relocated" | "material_missing" | "selector_noncanonical";
 export interface ReceiptIntegritySummary {
@@ -468,3 +473,5 @@ 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';
+export { SWARM_LIVE_ENGINES, SWARM_ORCHESTRATION_STRATEGIES, SWARM_EVENT_TYPES, SWARM_PARENT_RECEIPT_SCHEMA_VERSION, SWARM_SCHEMA_VERSION, computeSwarmLivePlanHash, createSwarmLivePlan, createSwarmRunRecord, normalizeSwarmPathPattern, swarmConcretePathMatchesPattern, swarmPathPatternContains, swarmPathPatternsOverlap, validateSwarmConcretePath, validateSwarmChildReceiptLink, validateSwarmDeterministicDemoReceiptEvidence, validateSwarmChildContract, validateSwarmLiveEvent, validateSwarmLivePlan, validateSwarmLiveRevision, validateSwarmParentContract, validateSwarmRunRecord } from "./swarm.js";
+export type { SwarmAgentRecord, SwarmAgentStatus, SwarmBudgetLedger, SwarmBudgetLease, SwarmBudgetUsage, SwarmCandidate, SwarmChildContract, SwarmChildReceiptLink, SwarmChildWorkspaceRecord, SwarmCleanupRecord, SwarmCleanupState, SwarmConcretePathResult, SwarmConflictRecord, SwarmDependencyWaiver, SwarmDemoReferentialBindingState, SwarmDeterministicDemoReceiptEvidence, SwarmEvent, SwarmEventType, SwarmGlobalVerification, SwarmGlobalVerificationCommandState, SwarmIntegrationWorkspaceRecord, SwarmIntegrationStrategy, SwarmLeaseStatus, SwarmLiveEngine, SwarmLiveEngineProfile, SwarmLiveEvent, SwarmLivePlan, SwarmLivePlanDraft, SwarmLiveRevision, SwarmOrchestrationStrategy, SwarmOutcome, SwarmOutcomeState, SwarmParentContract, SwarmParentReceipt, SwarmPatchAdmission, SwarmPatchAdmissionReasonCode, SwarmPatchAdmissionState, SwarmPathPatternResult, SwarmPermissions, SwarmProcessCloseState, SwarmRecoveryPolicy, SwarmReceiptBlockedAction, SwarmReceiptReassignment, SwarmRunDraft, SwarmRunRecord, SwarmScope, SwarmStopDisposition, SwarmStopPolicy, SwarmTaskNode, SwarmTaskStatus, SwarmValidationError, SwarmValidationResult, SwarmVerifierMutationState, SwarmVerifierSubprocessResult, SwarmVerificationRecord, SwarmVerifierAuthority, SwarmVerifierWorkspaceRecord, SwarmWorkspaceKind, SwarmWorkspaceRecord, SwarmWorkspaceRemovalState, SwarmWorkspaceState } from "./swarm.js";

package/dist/vendor/contracts/index.js

@@ -8,6 +8,7 @@
  * portfolio snapshots and routing economics.
  */
 export { DEFAULT_AGENT_EXECUTION_INTENT, DEFAULT_PROVIDER_EXECUTION_TIMEOUT_MS, GOVERNED_AUTONOMOUS_BOUNDARY, normalizeProviderExecutionTimeoutMs } from "./agent-execution.js";
+export { EXTERNAL_OUTCOME_LIMITS, EXTERNAL_OUTCOME_RESULT_SCHEMA_VERSION, EXTERNAL_OUTCOME_SCHEMA_VERSION, externalOutcomeValuesEqual, resolveExternalOutcomeJsonPointer, validateExternalOutcomeContract, } from "./external-outcome.js";
 export const FAILURE_CLASSES = [
     "logic_error",
     "hallucination",
@@ -247,3 +248,4 @@ export { EVIDENCE_STATUSES, EXECUTION_MODES, TEST_INTEGRITY_STATUSES, TEST_INTEG
 // ─── Context Handoff — A-CTX-2 ───────────────────────────────────────────────
 export { HANDOFF_SCHEMA_VERSION } from "./context-handoff.js";
 export { MISSION_SCHEMA_VERSION, MISSION_STATUSES, ALLOWED_MISSION_TRANSITIONS, createMissionRecord, isMissionTransitionAllowed } from './mission.js';
+export { SWARM_LIVE_ENGINES, SWARM_ORCHESTRATION_STRATEGIES, SWARM_EVENT_TYPES, SWARM_PARENT_RECEIPT_SCHEMA_VERSION, SWARM_SCHEMA_VERSION, computeSwarmLivePlanHash, createSwarmLivePlan, createSwarmRunRecord, normalizeSwarmPathPattern, swarmConcretePathMatchesPattern, swarmPathPatternContains, swarmPathPatternsOverlap, validateSwarmConcretePath, validateSwarmChildReceiptLink, validateSwarmDeterministicDemoReceiptEvidence, validateSwarmChildContract, validateSwarmLiveEvent, validateSwarmLivePlan, validateSwarmLiveRevision, validateSwarmParentContract, validateSwarmRunRecord } from "./swarm.js";

package/dist/vendor/contracts/swarm-hosted.d.ts

@@ -0,0 +1,204 @@
+import { type FailureClass, type ReceiptIntegrityState } from "./index.js";
+import { SWARM_PARENT_RECEIPT_SCHEMA_VERSION, SWARM_SCHEMA_VERSION, type SwarmAgentStatus, type SwarmEventType, type SwarmOutcomeState, type SwarmTaskStatus, type SwarmValidationResult } from "./swarm.js";
+export declare const SWARM_HOSTED_SCHEMA_VERSION: "martin.swarm-hosted.v1";
+export declare const SWARM_EVIDENCE_INDEX_SCHEMA_VERSION: "martin.swarm-evidence-index.v1";
+export type SwarmHostedTaskVerificationState = "passed" | "failed" | "unknown";
+export type SwarmHostedGlobalVerificationState = "passed" | "failed" | "unknown";
+export type SwarmTraceDerivationKind = "observed" | "deterministic_graph_derivation";
+export type SwarmTraceFactKind = "blocking_dependency" | "failure" | "reassignment" | "recovery" | "verification_boundary";
+export interface SwarmHostedEvidenceReference {
+    eventId: string;
+    sequence: number;
+}
+export interface SwarmHostedTask {
+    taskId: string;
+    required: boolean;
+    dependsOn: string[];
+    plannedAgentId?: string;
+    effectiveAgentId?: string;
+    status: SwarmTaskStatus;
+}
+export interface SwarmHostedAgent {
+    agentId: string;
+    role: string;
+    status: SwarmAgentStatus;
+    taskIds: string[];
+    childRunId?: string;
+}
+export interface SwarmHostedChild {
+    childRunId: string;
+    agentId: string;
+    attemptId: string;
+    taskIds: string[];
+    status: SwarmAgentStatus;
+    receiptIntegrityState: ReceiptIntegrityState;
+    evidence: SwarmHostedEvidenceReference[];
+}
+export interface SwarmHostedEvent {
+    eventId: string;
+    /** Exact persisted Phase 4 event idempotencyKey, retained to make the hosted rename checkable. */
+    sourceIdempotencyKey: string;
+    sequence: number;
+    type: SwarmEventType;
+    timestamp: string;
+    taskId?: string;
+    agentId?: string;
+    childRunId?: string;
+    attemptId?: string;
+    relatedAttemptId?: string;
+    toAgentId?: string;
+    candidateId?: string;
+    verificationId?: string;
+    failureClass?: FailureClass;
+}
+export interface SwarmHostedBlockedAction {
+    action: string;
+    reasonCode: string;
+    taskId: string;
+    agentId: string;
+    attemptId: string;
+    evidence: SwarmHostedEvidenceReference[];
+}
+export interface SwarmHostedReassignment {
+    taskId: string;
+    fromAgentId: string;
+    toAgentId: string;
+    fromAttemptId: string;
+    toAttemptId: string;
+    reasonCode: string;
+    evidence: SwarmHostedEvidenceReference[];
+}
+export interface SwarmHostedIntegrationDecision {
+    candidateId: string;
+    taskId: string;
+    agentId: string;
+    childRunId: string;
+    state: "admitted" | "rejected";
+    evidence: SwarmHostedEvidenceReference[];
+}
+export interface SwarmHostedConflict {
+    conflictId: string;
+    taskIds: string[];
+    state: "detected" | "resolved" | "blocking";
+    evidence: SwarmHostedEvidenceReference[];
+}
+export interface SwarmHostedEnvelope {
+    schemaVersion: typeof SWARM_HOSTED_SCHEMA_VERSION;
+    envelopeId: string;
+    sourceSchemas: {
+        swarm: typeof SWARM_SCHEMA_VERSION;
+        receipt: typeof SWARM_PARENT_RECEIPT_SCHEMA_VERSION;
+        evidenceIndex: typeof SWARM_EVIDENCE_INDEX_SCHEMA_VERSION;
+    };
+    sourceIdentities: {
+        receiptId: string;
+        receiptSha256: string;
+        evidenceIndexSha256: string;
+        eventChainSha256: string;
+    };
+    runtimeVersion: string;
+    createdAt: string;
+    swarm: {
+        swarmId: string;
+        workspaceId: string;
+        projectId: string;
+        planHash: string;
+        baselineCommit: string;
+    };
+    topology: {
+        tasks: SwarmHostedTask[];
+        agents: SwarmHostedAgent[];
+        children: SwarmHostedChild[];
+    };
+    budget: {
+        capUsd: number;
+        capTokens?: number;
+        settledUsd: number;
+        settledTokens: number;
+    };
+    interventions: {
+        blockedActions: SwarmHostedBlockedAction[];
+        reassignments: SwarmHostedReassignment[];
+    };
+    integration: {
+        admissions: SwarmHostedIntegrationDecision[];
+        rejections: SwarmHostedIntegrationDecision[];
+        conflicts: SwarmHostedConflict[];
+        integratedTreeHash?: string;
+    };
+    events: SwarmHostedEvent[];
+    globalVerification: {
+        state: SwarmHostedGlobalVerificationState;
+        verificationId?: string;
+        integratedTreeHash?: string;
+        evidence: SwarmHostedEvidenceReference[];
+    };
+    parentOutcome: {
+        state: Exclude<SwarmOutcomeState, "running">;
+        source: "sealed_parent_receipt";
+        evidence: SwarmHostedEvidenceReference[];
+    };
+    taskVerificationState: SwarmHostedTaskVerificationState;
+    receiptIntegrityState: ReceiptIntegrityState;
+    transportSignature: {
+        algorithm: "hmac-sha256";
+        keyId: string;
+        keyLocatorHash: string;
+        signatureHmacSha256: string;
+    };
+    extensions?: Record<string, unknown>;
+}
+export interface SwarmAtlasView {
+    schemaVersion: "martin.swarm-atlas-view.v1";
+    envelopeId: string;
+    sourceIdentities: SwarmHostedEnvelope["sourceIdentities"];
+    swarm: SwarmHostedEnvelope["swarm"];
+    tasks: SwarmHostedTask[];
+    dependencyEdges: Array<{
+        fromTaskId: string;
+        toTaskId: string;
+    }>;
+    agents: SwarmHostedAgent[];
+    children: SwarmHostedChild[];
+    budget: SwarmHostedEnvelope["budget"];
+    interventions: SwarmHostedEnvelope["interventions"];
+    integration: SwarmHostedEnvelope["integration"];
+    globalVerification: SwarmHostedEnvelope["globalVerification"];
+    parentOutcome: SwarmHostedEnvelope["parentOutcome"];
+    taskVerificationState: SwarmHostedTaskVerificationState;
+    receiptIntegrityState: ReceiptIntegrityState;
+}
+export interface SwarmTraceFact {
+    factId: string;
+    kind: SwarmTraceFactKind;
+    derivationKind: SwarmTraceDerivationKind;
+    taskIds: string[];
+    agentIds: string[];
+    childRunIds: string[];
+    attemptIds: string[];
+    verificationIds: string[];
+    evidence: SwarmHostedEvidenceReference[];
+}
+export interface SwarmSansaView {
+    schemaVersion: "martin.swarm-sansa-view.v1";
+    envelopeId: string;
+    sourceIdentities: SwarmHostedEnvelope["sourceIdentities"];
+    facts: SwarmTraceFact[];
+    parentOutcome: SwarmHostedEnvelope["parentOutcome"];
+    globalVerification: SwarmHostedEnvelope["globalVerification"];
+}
+export interface SwarmDashboardView {
+    schemaVersion: "martin.swarm-dashboard-view.v1";
+    envelopeId: string;
+    sourceIdentities: SwarmHostedEnvelope["sourceIdentities"];
+    swarmId: string;
+    children: SwarmHostedChild[];
+    parentOutcome: SwarmHostedEnvelope["parentOutcome"];
+    globalVerification: SwarmHostedEnvelope["globalVerification"];
+    taskVerificationState: SwarmHostedTaskVerificationState;
+    receiptIntegrityState: ReceiptIntegrityState;
+    budget: SwarmHostedEnvelope["budget"];
+}
+export declare function canonicalSwarmHostedTransportBytes(envelope: SwarmHostedEnvelope): string;
+export declare function computeSwarmHostedEnvelopeIdentity(envelope: SwarmHostedEnvelope): string;
+export declare function validateSwarmHostedEnvelope(value: unknown): SwarmValidationResult;