@martinloop/mcp 0.3.3 → 0.3.4

package/dist/vendor/adapters/cli-bridge.js

@@ -137,8 +137,30 @@ export async function runVerification(commands, cwd, timeoutMs, verificationStac
     const stepOutcomes = [];
     const warnings = [];
     for (const step of steps) {
-        const parts = splitCommand(step.command);
-        const [bin, ...args] = parts;
+        let bin;
+        let args;
+        if (containsShellOperator(step.command)) {
+            // Shell operators (&&, ||, ;, |) cannot be passed as literal arguments
+            // to spawn(). Route through the platform shell so the operator is
+            // interpreted correctly.
+            if (process.platform === "win32") {
+                bin = process.env.ComSpec || "cmd.exe";
+                args = ["/d", "/c", step.command];
+            }
+            else {
+                bin = "sh";
+                args = ["-c", step.command];
+            }
+        }
+        else {
+            const parts = splitCommand(step.command);
+            const first = parts[0];
+            if (!first) {
+                continue;
+            }
+            bin = first;
+            args = parts.slice(1);
+        }
         if (!bin) {
             continue;
         }
@@ -342,6 +364,44 @@ function windowsPathDirectories() {
         .map((entry) => entry.trim().replace(/^"|"$/g, ""))
         .filter(Boolean);
 }
+/**
+ * Returns true if the command string contains shell operators that cannot be
+ * passed as literal arguments to spawn(). These must be routed through a
+ * platform shell (cmd.exe /c or sh -c) so the operator is interpreted.
+ */
+export function containsShellOperator(command) {
+    // Match &&, ||, ;, or | that are NOT inside quotes.
+    // Simple heuristic: scan outside of single/double quoted regions.
+    let inSingle = false;
+    let inDouble = false;
+    for (let i = 0; i < command.length; i += 1) {
+        const ch = command[i];
+        if (ch === "'" && !inDouble) {
+            inSingle = !inSingle;
+            continue;
+        }
+        if (ch === '"' && !inSingle) {
+            inDouble = !inDouble;
+            continue;
+        }
+        if (inSingle || inDouble) {
+            continue;
+        }
+        if (ch === "&" && command[i + 1] === "&") {
+            return true;
+        }
+        if (ch === "|" && command[i + 1] === "|") {
+            return true;
+        }
+        if (ch === ";") {
+            return true;
+        }
+        if (ch === "|" && command[i + 1] !== "|") {
+            return true;
+        }
+    }
+    return false;
+}
 export function splitCommand(command) {
     const tokens = [];
     let current = "";

package/dist/vendor/adapters/codex-launcher.js

@@ -248,24 +248,81 @@ function hasSuccessfulCommandExecution(events) {
 }
 export function resolveCliCommandAvailability(command, options = {}) {
     const platform = options.platform ?? process.platform;
+    const env = options.env ?? process.env;
     const spawnSyncImpl = options.spawnSyncImpl ?? spawnSync;
     const discovery = readLocatorCandidates(command, platform, spawnSyncImpl);
-    const resolvedPath = discovery.candidates[0];
-    return discovery.candidates.length > 0
-        ? {
+    if (discovery.candidates.length > 0) {
+        const resolvedPath = discovery.candidates[0];
+        return {
             command,
             available: true,
             locator: discovery.locator,
             detail: `${command} is available on PATH.`,
             ...(resolvedPath ? { resolvedPath } : {}),
             candidatePaths: discovery.candidates
-        }
-        : {
+        };
+    }
+    // PATH didn't find it — search common install locations before giving up.
+    const offPathCandidate = discoverCommandOffPath(command, platform, env);
+    if (offPathCandidate) {
+        return {
             command,
-            available: false,
-            locator: discovery.locator,
-            detail: `${command} is not available on PATH.`
+            available: true,
+            locator: "off-path-discovery",
+            detail: `${command} found at ${offPathCandidate} (not on PATH, auto-discovered).`,
+            resolvedPath: offPathCandidate,
+            candidatePaths: [offPathCandidate]
         };
+    }
+    return {
+        command,
+        available: false,
+        locator: discovery.locator,
+        detail: `${command} is not installed. ${suggestInstall(command)}`
+    };
+}
+function discoverCommandOffPath(command, platform, env) {
+    const home = env.HOME ?? env.USERPROFILE ?? "";
+    const dirs = [];
+    if (platform === "win32") {
+        const appData = env.APPDATA;
+        if (appData)
+            dirs.push(join(appData, "npm"));
+        const localAppData = env.LOCALAPPDATA;
+        if (localAppData)
+            dirs.push(join(localAppData, "OpenAI", "Codex", "bin"));
+        if (home)
+            dirs.push(join(home, "scoop", "shims"));
+    }
+    else {
+        dirs.push("/usr/local/bin", "/opt/homebrew/bin");
+        if (home) {
+            dirs.push(join(home, ".local", "bin"), join(home, ".npm-global", "bin"), join(home, ".bun", "bin"), join(home, ".cargo", "bin"));
+        }
+        const nvmDir = env.NVM_DIR;
+        if (nvmDir)
+            dirs.push(join(nvmDir, "current", "bin"));
+    }
+    const extensions = platform === "win32"
+        ? (env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD").split(";").map((e) => e.trim().toLowerCase()).filter(Boolean)
+        : [""];
+    for (const dir of dirs) {
+        for (const ext of extensions) {
+            const candidate = ext ? join(dir, `${command}${ext}`) : join(dir, command);
+            if (existsSync(candidate)) {
+                return candidate;
+            }
+        }
+    }
+    return undefined;
+}
+function suggestInstall(command) {
+    const installs = {
+        claude: "Install with: npm install -g @anthropic-ai/claude-code",
+        codex: "Install with: npm install -g @openai/codex",
+        gemini: "Install with: npm install -g @google/gemini-cli"
+    };
+    return installs[command] ?? `Install ${command} and ensure it is available.`;
 }
 export function detectCodexHostPlatform(env = process.env, platform = process.platform) {
     if (platform === "win32") {

package/dist/vendor/adapters/openai-compatible.js

@@ -72,12 +72,12 @@ function estimateCost(model, inputChars, outputChars) {
 // ---------------------------------------------------------------------------
 // Prompt builder
 // ---------------------------------------------------------------------------
-const DEFAULT_SYSTEM_PROMPT = `You are an expert software engineer executing a governed coding task.
-Follow these rules exactly:
-- Read the task description carefully and implement only what is asked.
-- Do not add features, refactors, or improvements beyond the stated task.
-- If the task asks you to write or modify code, output the complete file content with changes applied.
-- Be precise, minimal, and test-backed in all changes.
+const DEFAULT_SYSTEM_PROMPT = `You are an expert software engineer executing a governed coding task.
+Follow these rules exactly:
+- Read the task description carefully and implement only what is asked.
+- Do not add features, refactors, or improvements beyond the stated task.
+- If the task asks you to write or modify code, output the complete file content with changes applied.
+- Be precise, minimal, and test-backed in all changes.
 - State what you changed and why at the end of your response.`;
 export const DEFAULT_OPENAI_BASE_URL = "https://api.openai.com";
 export const DEFAULT_OPENAI_MODEL = "gpt-4.1-mini";

package/dist/vendor/contracts/adapter-capabilities.d.ts

@@ -0,0 +1,17 @@
+export type DiffVisibilityLevel = "none" | "git" | "adapter_reported";
+export type VerifierCompatibility = "full" | "verify_only" | "unsupported";
+export type SandboxExpectation = "host_process" | "workspace_write" | "provider_managed" | "not_applicable";
+export type LaunchReadiness = "path_lookup" | "configured_endpoint" | "built_in";
+export type AdapterUsageSettlement = "actual" | "estimated" | "unavailable";
+export interface AdapterCapabilityDescriptor {
+    preflight: boolean;
+    usageSettlement: AdapterUsageSettlement;
+    diffVisibility: DiffVisibilityLevel;
+    structuredErrors: boolean;
+    cachingSignals: boolean;
+    verifierCompatibility: VerifierCompatibility;
+    sandboxExpectation: SandboxExpectation;
+    launchReadiness: LaunchReadiness;
+}
+export declare function createAdapterCapabilityDescriptor(overrides?: Partial<AdapterCapabilityDescriptor>): AdapterCapabilityDescriptor;
+export declare function getBuiltInEngineCapabilityDescriptor(engine: "claude" | "codex"): AdapterCapabilityDescriptor;

package/dist/vendor/contracts/adapter-capabilities.js

@@ -0,0 +1,35 @@
+export function createAdapterCapabilityDescriptor(overrides = {}) {
+    return {
+        preflight: true,
+        usageSettlement: "unavailable",
+        diffVisibility: "none",
+        structuredErrors: false,
+        cachingSignals: false,
+        verifierCompatibility: "full",
+        sandboxExpectation: "host_process",
+        launchReadiness: "path_lookup",
+        ...overrides
+    };
+}
+export function getBuiltInEngineCapabilityDescriptor(engine) {
+    if (engine === "claude") {
+        return createAdapterCapabilityDescriptor({
+            usageSettlement: "actual",
+            diffVisibility: "git",
+            structuredErrors: true,
+            cachingSignals: true,
+            verifierCompatibility: "full",
+            sandboxExpectation: "host_process",
+            launchReadiness: "path_lookup"
+        });
+    }
+    return createAdapterCapabilityDescriptor({
+        usageSettlement: "estimated",
+        diffVisibility: "git",
+        structuredErrors: true,
+        cachingSignals: false,
+        verifierCompatibility: "full",
+        sandboxExpectation: "workspace_write",
+        launchReadiness: "path_lookup"
+    });
+}

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

@@ -0,0 +1,48 @@
+export type ContextGraphNodeKind = "source_file" | "document" | "manifest" | "script" | "config";
+export type ContextGraphEdgeKind = "imports" | "documents";
+export interface ContextGraphNode {
+    nodeId: string;
+    path: string;
+    kind: ContextGraphNodeKind;
+    language?: string;
+    sizeBytes: number;
+    headings: string[];
+    symbols: string[];
+    keywords: string[];
+    imports: string[];
+}
+export interface ContextGraphEdge {
+    fromNodeId: string;
+    toNodeId: string;
+    kind: ContextGraphEdgeKind;
+}
+export interface ContextGraphSnapshot {
+    schemaVersion: "martin.context-graph.v1";
+    repoRoot: string;
+    createdAt: string;
+    nodeCount: number;
+    edgeCount: number;
+    truncated: boolean;
+    nodes: ContextGraphNode[];
+    edges: ContextGraphEdge[];
+}
+export interface ContextQuery {
+    text?: string;
+    terms?: string[];
+    pathPrefix?: string;
+    kinds?: ContextGraphNodeKind[];
+    limit?: number;
+}
+export interface ContextGraphBuildOptions {
+    maxFiles?: number;
+    maxFileBytes?: number;
+}
+export interface ContextGraphHit {
+    nodeId: string;
+    path: string;
+    kind: ContextGraphNodeKind;
+    score: number;
+    matchedTerms: string[];
+    reasons: string[];
+}
+export declare function cloneContextGraphSnapshot(snapshot: ContextGraphSnapshot): ContextGraphSnapshot;

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

@@ -0,0 +1,26 @@
+export function cloneContextGraphSnapshot(snapshot) {
+    return {
+        schemaVersion: snapshot.schemaVersion,
+        repoRoot: snapshot.repoRoot,
+        createdAt: snapshot.createdAt,
+        nodeCount: snapshot.nodeCount,
+        edgeCount: snapshot.edgeCount,
+        truncated: snapshot.truncated,
+        nodes: snapshot.nodes.map((node) => ({
+            nodeId: node.nodeId,
+            path: node.path,
+            kind: node.kind,
+            ...(node.language ? { language: node.language } : {}),
+            sizeBytes: node.sizeBytes,
+            headings: [...node.headings],
+            symbols: [...node.symbols],
+            keywords: [...node.keywords],
+            imports: [...node.imports]
+        })),
+        edges: snapshot.edges.map((edge) => ({
+            fromNodeId: edge.fromNodeId,
+            toNodeId: edge.toNodeId,
+            kind: edge.kind
+        }))
+    };
+}

package/dist/vendor/contracts/execution-policy.d.ts

@@ -0,0 +1,62 @@
+import type { ApprovalPolicy, LoopBudget, LoopTask, MutationMode } from "./index.js";
+import type { DestructiveActionPolicy, PolicyProfile, TelemetryDestination } from "./governance.js";
+export interface ExecutionPolicy {
+    configPath: string;
+    budget: LoopBudget;
+    governance: {
+        policyProfile: PolicyProfile;
+        telemetryDestination: TelemetryDestination;
+        destructiveActionPolicy: DestructiveActionPolicy;
+    };
+    task: {
+        verificationPlan: string[];
+        mutationMode?: MutationMode;
+        repoRoot?: string;
+        allowedPaths?: string[];
+        deniedPaths?: string[];
+        acceptanceCriteria?: string[];
+        approvalPolicy?: ApprovalPolicy;
+    };
+    provenance: ExecutionPolicyProvenanceEntry[];
+}
+export interface ExecutionPolicyProvenanceEntry {
+    field: string;
+    source: "default" | "config" | "request";
+    value: string;
+}
+export interface ExecutionPolicyDefaults {
+    budget: LoopBudget;
+    policyProfile: PolicyProfile;
+    telemetryDestination: TelemetryDestination;
+    destructiveActionPolicy: DestructiveActionPolicy;
+    verifierRules: string[];
+}
+export interface ExecutionPolicyConfigInput {
+    policyProfile?: string;
+    budget?: Partial<LoopBudget>;
+    governance?: {
+        destructiveActionPolicy?: string;
+        telemetryDestination?: string;
+        verifierRules?: string[];
+    };
+}
+export interface ExecutionPolicyRequestInput {
+    budget: LoopBudget;
+    budgetOverrides?: Partial<Record<keyof LoopBudget, true>>;
+    policyProfile?: string;
+    telemetryDestination?: string;
+    verificationPlan?: string[];
+    mutationMode?: LoopTask["mutationMode"];
+    repoRoot?: string;
+    allowedPaths?: string[];
+    deniedPaths?: string[];
+    acceptanceCriteria?: string[];
+    approvalPolicy?: ApprovalPolicy;
+}
+export interface ExecutionPolicyCompileInput {
+    configPath: string;
+    defaults: ExecutionPolicyDefaults;
+    config?: ExecutionPolicyConfigInput;
+    request: ExecutionPolicyRequestInput;
+}
+export declare function cloneExecutionPolicy(policy: ExecutionPolicy): ExecutionPolicy;

package/dist/vendor/contracts/execution-policy.js

@@ -0,0 +1,34 @@
+export function cloneExecutionPolicy(policy) {
+    return {
+        configPath: policy.configPath,
+        budget: {
+            maxUsd: policy.budget.maxUsd,
+            softLimitUsd: policy.budget.softLimitUsd,
+            maxIterations: policy.budget.maxIterations,
+            maxTokens: policy.budget.maxTokens
+        },
+        governance: {
+            policyProfile: policy.governance.policyProfile,
+            telemetryDestination: policy.governance.telemetryDestination,
+            destructiveActionPolicy: policy.governance.destructiveActionPolicy
+        },
+        task: {
+            verificationPlan: [...policy.task.verificationPlan],
+            ...(policy.task.mutationMode ? { mutationMode: policy.task.mutationMode } : {}),
+            ...(policy.task.repoRoot ? { repoRoot: policy.task.repoRoot } : {}),
+            ...(policy.task.allowedPaths ? { allowedPaths: [...policy.task.allowedPaths] } : {}),
+            ...(policy.task.deniedPaths ? { deniedPaths: [...policy.task.deniedPaths] } : {}),
+            ...(policy.task.acceptanceCriteria
+                ? { acceptanceCriteria: [...policy.task.acceptanceCriteria] }
+                : {}),
+            ...(policy.task.approvalPolicy
+                ? {
+                    approvalPolicy: {
+                        ...policy.task.approvalPolicy
+                    }
+                }
+                : {})
+        },
+        provenance: policy.provenance.map((entry) => ({ ...entry }))
+    };
+}

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

@@ -1,16 +1,19 @@
+export type PolicyProfile = "strict" | "balanced" | "overnight" | "debug";
+export type DestructiveActionPolicy = "never" | "approval" | "allowed";
+export type TelemetryDestination = "local-only" | "control-plane";
 export type GovernanceSnapshot = {
-    policyProfile: "strict" | "balanced" | "overnight" | "debug";
+    policyProfile: PolicyProfile;
     maxUsd: number;
     softLimitUsd: number;
     maxTokens: number;
     maxIterations: number;
     allowedAdapters: string[];
     allowedModels: string[];
-    destructiveActionPolicy: "never" | "approval" | "allowed";
+    destructiveActionPolicy: DestructiveActionPolicy;
     approvalRequired: boolean;
     verifierRules: string[];
     escalationRoute: string;
-    telemetryDestination: "local-only" | "control-plane";
+    telemetryDestination: TelemetryDestination;
     retentionPolicy: string;
     provenance: Array<{
         field: string;

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

@@ -0,0 +1,29 @@
+export type IdentityAlgorithm = "ed25519";
+export type IdentityRole = "governor" | "verifier" | "worker" | "reviewer" | "observer";
+export interface IdentityClaims {
+    subject: string;
+    issuer: string;
+    role: IdentityRole;
+    scopes: string[];
+    issuedAt: string;
+    expiresAt?: string;
+    workspaceId?: string;
+    sessionId?: string;
+    metadata?: Record<string, string>;
+}
+export interface IdentityToken {
+    schemaVersion: "martin.identity.v1";
+    algorithm: IdentityAlgorithm;
+    keyId: string;
+    claims: IdentityClaims;
+    signature: string;
+}
+export interface IdentityAttestation {
+    valid: boolean;
+    verifiedAt: string;
+    reason: string;
+    token: IdentityToken;
+}
+export declare function cloneIdentityClaims(claims: IdentityClaims): IdentityClaims;
+export declare function cloneIdentityToken(token: IdentityToken): IdentityToken;
+export declare function cloneIdentityAttestation(attestation: IdentityAttestation): IdentityAttestation;

package/dist/vendor/contracts/identity.js

@@ -0,0 +1,30 @@
+export function cloneIdentityClaims(claims) {
+    return {
+        subject: claims.subject,
+        issuer: claims.issuer,
+        role: claims.role,
+        scopes: [...claims.scopes],
+        issuedAt: claims.issuedAt,
+        ...(claims.expiresAt ? { expiresAt: claims.expiresAt } : {}),
+        ...(claims.workspaceId ? { workspaceId: claims.workspaceId } : {}),
+        ...(claims.sessionId ? { sessionId: claims.sessionId } : {}),
+        ...(claims.metadata ? { metadata: { ...claims.metadata } } : {})
+    };
+}
+export function cloneIdentityToken(token) {
+    return {
+        schemaVersion: token.schemaVersion,
+        algorithm: token.algorithm,
+        keyId: token.keyId,
+        claims: cloneIdentityClaims(token.claims),
+        signature: token.signature
+    };
+}
+export function cloneIdentityAttestation(attestation) {
+    return {
+        valid: attestation.valid,
+        verifiedAt: attestation.verifiedAt,
+        reason: attestation.reason,
+        token: cloneIdentityToken(attestation.token)
+    };
+}

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

@@ -9,6 +9,7 @@ export interface LoopTask {
     objective: string;
     repoRoot?: string;
     verificationPlan: string[];
+    verificationTimeoutMs?: number;
     verificationStack?: VerificationStep[];
     mutationMode?: MutationMode;
     executionProfile?: ExecutionProfile;
@@ -73,7 +74,7 @@ export interface ReceiptScope {
     invocationRoot?: string;
     runsRoot?: string;
 }
-export type ReceiptIntegrityState = "verified" | "unsigned" | "tamper_detected";
+export type ReceiptIntegrityState = "verified" | "unsigned" | "tamper_detected" | "relocated" | "material_missing" | "selector_noncanonical";
 export interface ReceiptIntegritySummary {
     state: ReceiptIntegrityState;
     keyId?: string;
@@ -101,6 +102,8 @@ export interface LoopAttempt {
     summary?: string;
     failureClass?: FailureClass;
     intervention?: InterventionType;
+    /** Actionable diagnosis from failure classification, injected into the next attempt's prompt. */
+    diagnosticHint?: string;
 }
 export interface LoopEvent {
     eventId: string;
@@ -371,4 +374,12 @@ export interface RollbackOutcomeArtifact {
     error?: string;
 }
 export { createGovernanceSnapshot } from "./governance.js";
-export type { GovernanceSnapshot } from "./governance.js";
+export type { DestructiveActionPolicy, GovernanceSnapshot, PolicyProfile, TelemetryDestination } from "./governance.js";
+export { cloneExecutionPolicy } from "./execution-policy.js";
+export type { ExecutionPolicy, ExecutionPolicyCompileInput, ExecutionPolicyConfigInput, ExecutionPolicyDefaults, ExecutionPolicyProvenanceEntry, ExecutionPolicyRequestInput } from "./execution-policy.js";
+export { cloneContextGraphSnapshot } from "./context-graph.js";
+export type { ContextGraphBuildOptions, ContextGraphEdge, ContextGraphHit, ContextGraphNode, ContextGraphNodeKind, ContextGraphSnapshot, ContextQuery } from "./context-graph.js";
+export { cloneIdentityAttestation, cloneIdentityClaims, cloneIdentityToken } from "./identity.js";
+export type { IdentityAttestation, IdentityClaims, IdentityToken } from "./identity.js";
+export { cloneCircuitBreakDecision, cloneTrajectoryAssessment } from "./trajectory.js";
+export type { CircuitBreakDecision, TrajectoryAssessment, TrajectorySignal } from "./trajectory.js";

package/dist/vendor/contracts/index.js

@@ -217,3 +217,7 @@ function hasText(value) {
     return typeof value === "string" && value.trim().length > 0;
 }
 export { createGovernanceSnapshot } from "./governance.js";
+export { cloneExecutionPolicy } from "./execution-policy.js";
+export { cloneContextGraphSnapshot } from "./context-graph.js";
+export { cloneIdentityAttestation, cloneIdentityClaims, cloneIdentityToken } from "./identity.js";
+export { cloneCircuitBreakDecision, cloneTrajectoryAssessment } from "./trajectory.js";

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

@@ -0,0 +1,21 @@
+export type ChangeObservationStatus = "verified" | "mismatch" | "adapter_only" | "repo_only" | "unavailable";
+export interface ChangeObservationEvidence {
+    available: boolean;
+    changedFiles: string[];
+    diffStats?: {
+        filesChanged: number;
+        addedLines: number;
+        deletedLines: number;
+    };
+}
+export interface ChangeObservationReconciliation {
+    status: ChangeObservationStatus;
+    summary: string;
+    adapterReported: ChangeObservationEvidence;
+    repoObserved: ChangeObservationEvidence;
+    effectiveChangedFiles: string[];
+    matchedFiles: string[];
+    adapterOnlyFiles: string[];
+    repoOnlyFiles: string[];
+}
+export declare function cloneChangeObservationReconciliation(input: ChangeObservationReconciliation): ChangeObservationReconciliation;

package/dist/vendor/contracts/observation.js

@@ -0,0 +1,27 @@
+export function cloneChangeObservationReconciliation(input) {
+    return {
+        status: input.status,
+        summary: input.summary,
+        adapterReported: cloneObservationEvidence(input.adapterReported),
+        repoObserved: cloneObservationEvidence(input.repoObserved),
+        effectiveChangedFiles: [...input.effectiveChangedFiles],
+        matchedFiles: [...input.matchedFiles],
+        adapterOnlyFiles: [...input.adapterOnlyFiles],
+        repoOnlyFiles: [...input.repoOnlyFiles]
+    };
+}
+function cloneObservationEvidence(input) {
+    return {
+        available: input.available,
+        changedFiles: [...input.changedFiles],
+        ...(input.diffStats
+            ? {
+                diffStats: {
+                    filesChanged: input.diffStats.filesChanged,
+                    addedLines: input.diffStats.addedLines,
+                    deletedLines: input.diffStats.deletedLines
+                }
+            }
+            : {})
+    };
+}

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

@@ -0,0 +1,26 @@
+import type { InterventionType } from "./index.js";
+export type TrajectoryStatus = "healthy" | "watch" | "drifting" | "stalled";
+export type TrajectoryConfidence = "low" | "medium" | "high";
+export type TrajectorySignalCode = "failure_oscillation" | "attempt_repetition" | "verification_stall" | "objective_drift";
+export interface TrajectorySignal {
+    code: TrajectorySignalCode;
+    severity: "low" | "medium" | "high";
+    summary: string;
+    attemptIndexes: number[];
+    matchedTerms?: string[];
+}
+export interface TrajectoryAssessment {
+    status: TrajectoryStatus;
+    confidence: TrajectoryConfidence;
+    summary: string;
+    signals: TrajectorySignal[];
+    recommendedIntervention?: InterventionType;
+}
+export interface CircuitBreakDecision {
+    shouldStop: boolean;
+    reason: string;
+    assessment: TrajectoryAssessment;
+    recommendedIntervention?: InterventionType;
+}
+export declare function cloneTrajectoryAssessment(assessment: TrajectoryAssessment): TrajectoryAssessment;
+export declare function cloneCircuitBreakDecision(decision: CircuitBreakDecision): CircuitBreakDecision;

package/dist/vendor/contracts/trajectory.js

@@ -0,0 +1,27 @@
+export function cloneTrajectoryAssessment(assessment) {
+    return {
+        status: assessment.status,
+        confidence: assessment.confidence,
+        summary: assessment.summary,
+        ...(assessment.recommendedIntervention
+            ? { recommendedIntervention: assessment.recommendedIntervention }
+            : {}),
+        signals: assessment.signals.map((signal) => ({
+            code: signal.code,
+            severity: signal.severity,
+            summary: signal.summary,
+            attemptIndexes: [...signal.attemptIndexes],
+            ...(signal.matchedTerms ? { matchedTerms: [...signal.matchedTerms] } : {})
+        }))
+    };
+}
+export function cloneCircuitBreakDecision(decision) {
+    return {
+        shouldStop: decision.shouldStop,
+        reason: decision.reason,
+        assessment: cloneTrajectoryAssessment(decision.assessment),
+        ...(decision.recommendedIntervention
+            ? { recommendedIntervention: decision.recommendedIntervention }
+            : {})
+    };
+}