@martinloop/mcp 0.3.3 → 0.3.5

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;
         }
@@ -214,6 +236,36 @@ export async function readGitChangedFiles(repoRoot, timeoutMs, spawnImpl) {
     }
     return parsePorcelainEntries(statusResult.stdout).filter((entry) => typeof entry === "string" && entry.length > 0);
 }
+// Ignore paths that are not meaningful code changes for first-delta detection
+const FIRST_DELTA_IGNORE = [
+    /^\.martin\//u,
+    /^PROGRESS\.md$/u,
+    /\.lock$/u,
+    /^node_modules\//u,
+    /^\.git\//u,
+    /^\.cache\//u,
+];
+/**
+ * Detects whether a meaningful workspace delta has occurred by checking
+ * git status for changed files that aren't MartinLoop metadata, lockfiles,
+ * or cache artifacts. Returns the first meaningful changed file if found.
+ */
+export async function detectFirstDelta(repoRoot, timeoutMs, spawnImpl) {
+    const changedFiles = await readGitChangedFiles(repoRoot, timeoutMs, spawnImpl);
+    for (const file of changedFiles) {
+        if (FIRST_DELTA_IGNORE.some((pattern) => pattern.test(file))) {
+            continue;
+        }
+        // Classify: new file = create, deleted = delete, else modify
+        const diffResult = await runSubprocess("git", ["status", "--porcelain", "--", file], { cwd: repoRoot, timeoutMs: 3000, spawnImpl });
+        const status = diffResult.stdout.trim().slice(0, 2);
+        const changeType = status.includes("?") ? "create"
+            : status.includes("D") ? "delete"
+                : "modify";
+        return { detected: true, filePath: file, changeType };
+    }
+    return { detected: false };
+}
 export function resolveGitRepositoryRoot(workingDirectory) {
     const resolvedWorkingDirectory = resolve(workingDirectory);
     const cached = gitRepositoryRootCache.get(resolvedWorkingDirectory);
@@ -342,6 +394,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.d.ts

@@ -43,6 +43,7 @@ export interface CodexExecArgsOptions {
     mode?: "prompt" | "probe";
 }
 type SpawnSyncLike = typeof spawnSync;
+export declare const DEFAULT_CODEX_CHATGPT_MODEL = "gpt-5.4";
 export interface CodexProbeCandidateResult {
     path: string;
     installKind: CodexInstallKind;
@@ -72,5 +73,6 @@ export declare function probeCodexLaunch(input: {
     env?: NodeJS.ProcessEnv;
     platform?: NodeJS.Platform;
     spawnSyncImpl?: SpawnSyncLike;
+    model?: string;
 }): CodexLaunchProbeResult;
 export {};

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

@@ -2,6 +2,7 @@ import { spawnSync } from "node:child_process";
 import { existsSync, readdirSync, statSync } from "node:fs";
 import { dirname, extname, join, resolve } from "node:path";
 const codexLaunchProbeCache = new Map();
+export const DEFAULT_CODEX_CHATGPT_MODEL = "gpt-5.4";
 const CODEX_LAUNCH_PROBE_PROMPT = [
     "You are validating MartinLoop Codex host readiness.",
     "Do not edit files.",
@@ -14,7 +15,8 @@ function buildProbeCacheKey(input) {
     return JSON.stringify({
         workingDirectory: resolve(input.workingDirectory),
         platform: input.platform,
-        candidatePaths: input.candidatePaths
+        candidatePaths: input.candidatePaths,
+        model: input.model ?? DEFAULT_CODEX_CHATGPT_MODEL
     });
 }
 function isInsideGitRepository(workingDirectory) {
@@ -167,6 +169,39 @@ function detectInvocationMode(resolvedPath, platform) {
 }
 function classifyProbeFailure(stderr, stdout, diagnosis) {
     const combined = `${stderr}\n${stdout}`;
+    if (/MARTIN_REMOTE_TOKEN/iu.test(combined) ||
+        /AuthRequired\(AuthRequiredError/iu.test(combined) ||
+        /www_authenticate_header/iu.test(combined)) {
+        const warnings = [...diagnosis.warnings];
+        const configCollisionWarning = "Codex inherited auth-sensitive MCP or plugin state from the operator's default user config.";
+        if (!warnings.includes(configCollisionWarning)) {
+            warnings.push(configCollisionWarning);
+        }
+        return {
+            summary: "Codex inherited auth-sensitive MCP or plugin state from the operator's default user config. Governed Codex runs should launch with `exec --ignore-user-config` so missing remote tokens or third-party auth do not abort MartinLoop work.",
+            diagnosis: {
+                ...diagnosis,
+                warnings,
+                remediation: "Retry the governed Codex launch with `exec --ignore-user-config`, or remove auth-sensitive MCP/plugin dependencies from the default Codex user config before running MartinLoop."
+            }
+        };
+    }
+    if (/not supported when using Codex with a ChatGPT account/iu.test(combined) ||
+        /gpt-5\.3-codex/iu.test(combined)) {
+        const warnings = [...diagnosis.warnings];
+        const unsupportedModelWarning = "Codex tried to use a model that is not supported for ChatGPT-account authentication.";
+        if (!warnings.includes(unsupportedModelWarning)) {
+            warnings.push(unsupportedModelWarning);
+        }
+        return {
+            summary: `Codex launched with a model that is not supported for ChatGPT-account authentication. Use an explicit supported model such as \`${DEFAULT_CODEX_CHATGPT_MODEL}\` for governed Codex work.`,
+            diagnosis: {
+                ...diagnosis,
+                warnings,
+                remediation: `Override the Codex launch model to a ChatGPT-account-supported option such as \`${DEFAULT_CODEX_CHATGPT_MODEL}\` before running governed Codex work.`
+            }
+        };
+    }
     if (/@openai\/codex-linux-x64/iu.test(combined) ||
         /cannot find module ['"]@openai\/codex-linux-x64['"]/iu.test(combined)) {
         const warnings = [...diagnosis.warnings];
@@ -205,6 +240,24 @@ function classifyProbeFailure(stderr, stdout, diagnosis) {
             }
         };
     }
+    if (/writing is blocked by read-only sandbox/iu.test(combined) ||
+        /read-only filesystem sandbox/iu.test(combined) ||
+        /approval is disabled/iu.test(combined)) {
+        const warnings = [...diagnosis.warnings];
+        const readOnlySandboxWarning = "Codex stayed in a read-only or approval-disabled sandbox even though MartinLoop requested workspace-write.";
+        if (!warnings.includes(readOnlySandboxWarning)) {
+            warnings.push(readOnlySandboxWarning);
+        }
+        return {
+            summary: "Codex stayed in a read-only or approval-disabled sandbox even though MartinLoop requested workspace-write.",
+            diagnosis: {
+                ...diagnosis,
+                sandboxCompatible: false,
+                warnings,
+                remediation: "Launch governed Codex runs with `codex exec --ignore-user-config --sandbox workspace-write`. If the session still reports a read-only sandbox, treat it as a host/runtime mismatch and repair or relocate the affected Codex workspace before resuming governed work."
+            }
+        };
+    }
     return {};
 }
 export function buildCodexExecArgs(options) {
@@ -213,6 +266,8 @@ export function buildCodexExecArgs(options) {
     const extraArgs = options.extraArgs ?? [];
     return [
         "exec",
+        // Governed MartinLoop runs should not inherit auth-sensitive default MCP/plugin state.
+        "--ignore-user-config",
         "--cd",
         options.workingDirectory,
         "--sandbox",
@@ -248,24 +303,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") {
@@ -339,6 +451,7 @@ export function probeCodexLaunch(input) {
     });
     const args = buildCodexExecArgs({
         workingDirectory: input.workingDirectory,
+        model: input.model ?? DEFAULT_CODEX_CHATGPT_MODEL,
         mode: "probe"
     });
     if (!availability.available) {
@@ -374,7 +487,8 @@ export function probeCodexLaunch(input) {
     const cacheKey = buildProbeCacheKey({
         workingDirectory: input.workingDirectory,
         platform,
-        candidatePaths
+        candidatePaths,
+        model: input.model
     });
     if (input.spawnSyncImpl === undefined) {
         const cached = codexLaunchProbeCache.get(cacheKey);

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,78 @@
+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 type RoutingMode = "direct" | "manager" | "adaptive" | "consensus";
+export interface RoutingPolicy {
+    enabled: boolean;
+    mode: RoutingMode;
+    /** Max percentage of total budget that can be spent before first code change. */
+    maxPreworkBudgetPct: number;
+    /** Hard dollar cap on pre-work spend. */
+    maxPreworkCostUsd: number;
+    /** Max model calls allowed for manager/router/planner before worker starts. */
+    maxManagerCalls: number;
+    /** Skip orchestration entirely if task confidence is above this threshold (0-1). */
+    skipOrchestrationIfConfidenceAbove: number;
+    /** Force direct execution for tasks classified as simple. */
+    requireDirectForSimpleTasks: boolean;
+}
+export declare const DEFAULT_ROUTING_POLICY: RoutingPolicy;
+export declare function cloneExecutionPolicy(policy: ExecutionPolicy): ExecutionPolicy;

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

@@ -0,0 +1,43 @@
+export const DEFAULT_ROUTING_POLICY = {
+    enabled: true,
+    mode: "adaptive",
+    maxPreworkBudgetPct: 25,
+    maxPreworkCostUsd: 2.0,
+    maxManagerCalls: 2,
+    skipOrchestrationIfConfidenceAbove: 0.85,
+    requireDirectForSimpleTasks: true
+};
+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;