@martinloop/mcp 0.3.2 → 0.3.4

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.d.ts

@@ -43,7 +43,7 @@ export interface OpenAiCompatibleAdapterOptions {
     systemPrompt?: string;
     /** Request timeout in milliseconds. Default: 300_000 (5 min). */
     timeoutMs?: number;
-    /** Verifier timeout in milliseconds. Default: 60_000. */
+    /** Verifier timeout in milliseconds. Default: 120_000. */
     verifyTimeoutMs?: number;
     /** Working directory for git artifact collection and verification. */
     workingDirectory?: string;

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";
@@ -120,7 +120,7 @@ function buildPrompt(request) {
 export function createOpenAiCompatibleAdapter(options) {
     const workingDirectory = options.workingDirectory ?? process.cwd();
     const timeoutMs = options.timeoutMs ?? 300_000;
-    const verifyTimeoutMs = options.verifyTimeoutMs ?? 60_000;
+    const verifyTimeoutMs = options.verifyTimeoutMs ?? 120_000;
     const systemPrompt = options.systemPrompt ?? DEFAULT_SYSTEM_PROMPT;
     const fetchFn = options.fetchImpl ?? globalThis.fetch;
     const runtimeConfig = resolveOpenAiCompatibleRuntimeConfig();

package/dist/vendor/adapters/verifier-only.js

@@ -2,7 +2,7 @@ import { readGitChangedFiles, runVerification } from "./cli-bridge.js";
 import { createAdapterCapabilities, normalizeUsage } from "./runtime-support.js";
 export function createVerifierOnlyAdapter(options = {}) {
     const workingDirectory = options.workingDirectory ?? process.cwd();
-    const verifyTimeoutMs = options.verifyTimeoutMs ?? 60_000;
+    const verifyTimeoutMs = options.verifyTimeoutMs ?? 120_000;
     return {
         adapterId: "direct:verifier:verify-only",
         kind: "direct-provider",

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 }
+            : {})
+    };
+}

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

@@ -0,0 +1,28 @@
+export type VerifierExitReason = "passed" | "non_zero_exit" | "timed_out" | "spawn_error" | "invalid_command";
+export type VerifierStepType = "lint" | "typecheck" | "test_targeted" | "test_full" | "custom";
+export interface VerifierStepSnapshot {
+    command: string;
+    type: VerifierStepType;
+    fastFail: boolean;
+    passed: boolean;
+    exitCode: number;
+    exitReason: VerifierExitReason;
+    startedAt: string;
+    completedAt: string;
+    durationMs: number;
+    stdout?: string;
+    stderr?: string;
+}
+export interface VerifierSnapshot {
+    passed: boolean;
+    summary: string;
+    startedAt: string;
+    completedAt: string;
+    durationMs: number;
+    stepCount: number;
+    failedStepCount: number;
+    commands: string[];
+    steps: VerifierStepSnapshot[];
+    combinedOutput?: string;
+}
+export declare function cloneVerifierSnapshot(snapshot: VerifierSnapshot): VerifierSnapshot;

package/dist/vendor/contracts/verification.js

@@ -0,0 +1,7 @@
+export function cloneVerifierSnapshot(snapshot) {
+    return {
+        ...snapshot,
+        commands: [...snapshot.commands],
+        steps: snapshot.steps.map((step) => ({ ...step }))
+    };
+}

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

@@ -0,0 +1,3 @@
+import { type ContextGraphBuildOptions, type ContextGraphHit, type ContextGraphSnapshot, type ContextQuery } from "../contracts/index.js";
+export declare function buildContextGraphSnapshot(repoRoot: string, options?: ContextGraphBuildOptions): Promise<ContextGraphSnapshot>;
+export declare function queryContextGraph(snapshot: ContextGraphSnapshot, query: ContextQuery): ContextGraphHit[];