@martinloop/mcp 0.3.5 → 0.3.7

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

@@ -522,10 +522,14 @@ export function createAgentCliAdapter(options) {
                 };
             }
             if (agentResult.exitCode !== 0 && agentResult.stdout.trim().length === 0) {
+                const fullStderr = agentResult.stderr.trim();
+                const stderrSnippet = fullStderr ? fullStderr.slice(0, 2000) : "(no stderr)";
+                const stdoutLen = agentResult.stdout.length;
+                const diagnosticSummary = `${options.command} exited (code ${String(agentResult.exitCode)}) with empty stdout (${String(stdoutLen)} bytes). stderr: ${stderrSnippet}`;
                 const failureMessage = formatPreVerifierSubprocessFailure(options.command, agentResult.stderr, agentResult.exitCode);
                 return {
                     status: "failed",
-                    summary: `${options.command} subprocess exited before verifier execution.`,
+                    summary: diagnosticSummary,
                     usage: normalizeUsage({
                         actualUsd: 0,
                         tokensIn: 0,
@@ -534,6 +538,9 @@ export function createAgentCliAdapter(options) {
                     }),
                     verification: { passed: false, summary: `Verifier not run: ${failureMessage}` },
                     failure: {
+                        // Raw stderr is preserved in diagnosticSummary above; use the
+                        // normalized/classified message here so downstream consumers and
+                        // tests get a consistent, parseable failure signal.
                         message: failureMessage
                     }
                 };
@@ -796,11 +803,15 @@ export function createClaudeCliAdapter(options = {}) {
             "--verbose",
             "--print",
             "--dangerously-skip-permissions",
-            // Prevent the child Claude process from loading the parent's MCP servers.
-            // Without this, a MartinLoop MCP server in the user's config gets spawned
-            // inside the governed subprocess, causing conflicts and "MCP server being
-            // overwritten" errors.
-            "--strict-mcp-config",
+            // Subprocess isolation strategy:
+            // --bare: skips hooks (prevents SessionEnd/hook failures causing non-zero exits),
+            //   MCP server loading, LSP, CLAUDE.md discovery, and background prefetches.
+            //   Requires ANTHROPIC_API_KEY (OAuth/keychain auth not available in bare mode).
+            // --strict-mcp-config: fallback when ANTHROPIC_API_KEY is not set — still
+            //   prevents parent MCP servers from being inherited by the subprocess.
+            ...(process.env["ANTHROPIC_API_KEY"] ? ["--bare"] : ["--strict-mcp-config"]),
+            // NOTE: --max-tokens does not exist in the claude CLI. Token cap enforcement
+            // is handled at the MartinLoop layer via streamingUsageCap, not via subprocess flags.
             ...modelArgs,
             ...extraArgs
         ],
@@ -900,21 +911,13 @@ function buildPrompt(request) {
     const lines = [];
     const mutationMode = request.context.mutationMode ?? "edit";
     lines.push("You are running in autonomous agentic mode.");
-    if (mutationMode === "verify_only") {
-        lines.push("DO NOT EDIT FILES. Run the verifier only and report whether it passes.");
-        lines.push("Do not ask for confirmation. Do not ask clarifying questions.");
-    }
-    else {
-        lines.push("MAKE ALL REQUIRED FILE EDITS NOW. Do not ask for confirmation. Do not ask clarifying questions.");
-        lines.push("Do not explain what you found without also making the changes. Edit the files and complete the task.");
-    }
+    lines.push("MAKE ALL REQUIRED FILE EDITS NOW. Do not ask for confirmation. Do not ask clarifying questions.");
+    lines.push("Do not explain what you found without also making the changes. Edit the files and complete the task.");
     lines.push("");
     lines.push("If PROGRESS.md exists in your working directory, read it first for context from prior attempts.");
     lines.push("If it does not exist, proceed with the objective below.");
     lines.push("");
-    lines.push(mutationMode === "verify_only"
-        ? "Complete the following verification-only task without making file changes."
-        : "Complete the following coding task. Make all necessary file changes.");
+    lines.push("Complete the following coding task. Make all necessary file changes.");
     lines.push("When you are done, the verification commands listed below must pass.");
     lines.push("");
     lines.push("OBJECTIVE:");
@@ -952,9 +955,7 @@ function buildPrompt(request) {
     lines.push(`  Attempt ${String(attemptNumber)}`);
     lines.push(`  Remaining budget: $${String(request.context.remainingBudgetUsd)} USD`);
     lines.push(`  Remaining iterations: ${String(request.context.remainingIterations)}`);
-    lines.push(mutationMode === "verify_only"
-        ? "  Do not modify files; only run verification."
-        : "  Do not expand scope beyond what is needed to pass verification.");
+    lines.push("  Do not expand scope beyond what is needed to pass verification.");
     lines.push("");
     if (request.previousAttempts.length > 0) {
         lines.push("PRIOR FAILED ATTEMPTS (learn from these — do not repeat the same mistakes):");

package/dist/vendor/adapters/cli-bridge.d.ts

@@ -87,6 +87,13 @@ export interface SpawnPlan {
     args: string[];
 }
 export declare function createSpawnPlan(command: string, args: string[], cwd: string, preserveRawForInjectedSpawn: boolean): SpawnPlan;
+/**
+ * npm generates Windows shims (.cmd/.ps1, occasionally .bat) that ultimately just exec
+ * `node <real-cli-script>.js <args>` relative to the shim's own directory. Parse the shim text to
+ * find that real script path and return it if it resolves to a file that actually exists on disk;
+ * otherwise return undefined so callers fall back to the existing wrapper-shell behavior unchanged.
+ */
+export declare function resolveNpmShimScript(shimPath: string): string | undefined;
 /**
  * Returns true if the command string contains shell operators that cannot be
  * passed as literal arguments to spawn(). These must be routed through a

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

@@ -1,6 +1,6 @@
 import { spawn } from "node:child_process";
 import { delimiter, dirname, extname, isAbsolute, join, resolve } from "node:path";
-import { existsSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import { diffStatsFromNumstat } from "./runtime-support.js";
 const gitRepositoryRootCache = new Map();
 export async function runSubprocess(command, args, options) {
@@ -319,20 +319,106 @@ export function createSpawnPlan(command, args, cwd, preserveRawForInjectedSpawn)
         };
     }
     const extension = extname(resolvedOrUndefined).toLowerCase();
-    if (extension === ".cmd" || extension === ".bat") {
+    if (extension === ".cmd" || extension === ".bat" || extension === ".ps1") {
+        // npm-installed CLIs resolve to a generated shim on Windows. Wrapping that shim through an
+        // extra cmd.exe/powershell.exe hop adds a process layer that can lose the OS-level
+        // workspace-write sandbox permission when the whole tree is already nested inside another
+        // restricted parent process (e.g. VS Code's extension host), even though the same shim works
+        // fine from a top-level PowerShell window. When we can statically resolve the shim's real
+        // wrapped `node <script>` target, invoke that directly instead — this removes the extra hop
+        // for every Windows launch, nested or not, with no behavior change when resolution fails.
+        const directScript = resolveNpmShimScript(resolvedOrUndefined);
+        if (directScript !== undefined) {
+            // Use the system node rather than process.execPath. When MartinLoop runs
+            // inside Claude Code desktop or VS Code, process.execPath is Electron's
+            // bundled Node — which has different module resolution and may fail to
+            // load native CLI scripts. Prefer an explicit `node` from PATH instead.
+            const systemNode = resolveSystemNode();
+            return { command: systemNode, args: [directScript, ...args] };
+        }
+        if (extension === ".ps1") {
+            return {
+                command: "powershell.exe",
+                args: ["-NoProfile", "-ExecutionPolicy", "Bypass", "-File", resolvedOrUndefined, ...args]
+            };
+        }
         return {
             command: process.env.ComSpec || "cmd.exe",
             args: ["/d", "/c", resolvedOrUndefined, ...args]
         };
     }
-    if (extension === ".ps1") {
-        return {
-            command: "powershell.exe",
-            args: ["-NoProfile", "-ExecutionPolicy", "Bypass", "-File", resolvedOrUndefined, ...args]
-        };
-    }
     return { command: resolvedOrUndefined, args };
 }
+/**
+ * npm generates Windows shims (.cmd/.ps1, occasionally .bat) that ultimately just exec
+ * `node <real-cli-script>.js <args>` relative to the shim's own directory. Parse the shim text to
+ * find that real script path and return it if it resolves to a file that actually exists on disk;
+ * otherwise return undefined so callers fall back to the existing wrapper-shell behavior unchanged.
+ */
+export function resolveNpmShimScript(shimPath) {
+    let contents;
+    try {
+        contents = readFileSync(shimPath, "utf8");
+    }
+    catch {
+        return undefined;
+    }
+    const shimDir = dirname(shimPath);
+    const scriptPathPattern = /["']?(?:%~?dp0%?|\$basedir)[\\/]([^"'\s]+\.[cm]?js)["']?/gi;
+    const matches = contents.matchAll(scriptPathPattern);
+    for (const match of matches) {
+        const relativeScript = match[1];
+        if (!relativeScript) {
+            continue;
+        }
+        const segments = relativeScript.split(/[\\/]+/u).filter(Boolean);
+        const resolvedScript = resolve(shimDir, ...segments);
+        if (existsSync(resolvedScript)) {
+            return resolvedScript;
+        }
+    }
+    return undefined;
+}
+/**
+ * Resolve a reliable `node` executable for spawning CLI scripts on Windows.
+ *
+ * When MartinLoop runs inside Claude Code desktop, VS Code, or the Codex IDE,
+ * `process.execPath` points to the host application's bundled Electron Node —
+ * not the system Node. Electron's Node has different module resolution paths
+ * and may fail to load native npm CLI scripts that expect the system Node.
+ *
+ * Strategy:
+ * 1. Use MARTIN_NODE_PATH env var if explicitly set (escape hatch for CI)
+ * 2. Look for `node` / `node.exe` on PATH — the system install
+ * 3. Fall back to process.execPath (Electron Node) if nothing else found
+ */
+function resolveSystemNode() {
+    // Explicit override — useful in CI or restricted environments
+    const envOverride = process.env.MARTIN_NODE_PATH?.trim();
+    if (envOverride && envOverride.length > 0 && existsSync(envOverride)) {
+        return envOverride;
+    }
+    // Search PATH for a real `node` executable, skipping Electron binaries.
+    // Electron's node path typically contains "electron" or "Claude" in it.
+    for (const dir of windowsPathDirectories()) {
+        for (const candidate of ["node.exe", "node.cmd", "node"]) {
+            const fullPath = join(dir, candidate);
+            if (existsSync(fullPath) && !isElectronNode(fullPath)) {
+                return fullPath;
+            }
+        }
+    }
+    // Last resort: use process.execPath even if it's Electron's node
+    return process.execPath;
+}
+function isElectronNode(nodePath) {
+    const lower = nodePath.toLowerCase();
+    return (lower.includes("electron") ||
+        lower.includes("claude") ||
+        lower.includes("vscode") ||
+        lower.includes("code.exe") ||
+        lower.includes("cursor"));
+}
 function resolveWindowsCommand(command, cwd) {
     const hasPathSegment = command.includes("\\") || command.includes("/");
     const baseCandidates = expandWindowsCommandCandidates(hasPathSegment ? resolve(cwd, command) : command);

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

@@ -1,6 +1,7 @@
 import { spawnSync } from "node:child_process";
 import { existsSync, readdirSync, statSync } from "node:fs";
 import { dirname, extname, join, resolve } from "node:path";
+import { resolveNpmShimScript } from "./cli-bridge.js";
 const codexLaunchProbeCache = new Map();
 export const DEFAULT_CODEX_CHATGPT_MODEL = "gpt-5.4";
 const CODEX_LAUNCH_PROBE_PROMPT = [
@@ -121,17 +122,27 @@ function buildProbeCommand(command, args, platform) {
     switch (extension) {
         case ".cmd":
         case ".bat":
+        case ".ps1": {
+            // Bypass the npm shim's cmd.exe/powershell.exe wrapper hop when we can statically resolve
+            // the real `node <script>` target it wraps — keeps the live probe's process-nesting depth
+            // consistent with the real run's invocation (see createSpawnPlan in cli-bridge.ts).
+            const directScript = resolveNpmShimScript(command);
+            if (directScript !== undefined) {
+                return { command: process.execPath, args: [directScript, ...args], invocationMode: "direct" };
+            }
+            if (extension === ".ps1") {
+                return {
+                    command: "powershell.exe",
+                    args: ["-NoProfile", "-ExecutionPolicy", "Bypass", "-File", command, ...args],
+                    invocationMode: "powershell"
+                };
+            }
             return {
                 command: process.env.ComSpec || "cmd.exe",
                 args: ["/d", "/c", command, ...args],
                 invocationMode: "cmd_shell"
             };
-        case ".ps1":
-            return {
-                command: "powershell.exe",
-                args: ["-NoProfile", "-ExecutionPolicy", "Bypass", "-File", command, ...args],
-                invocationMode: "powershell"
-            };
+        }
         default:
             return { command, args, invocationMode: "direct" };
     }
@@ -236,7 +247,7 @@ function classifyProbeFailure(stderr, stdout, diagnosis) {
                 ...diagnosis,
                 sandboxCompatible: false,
                 warnings,
-                remediation: "Update or reinstall Codex on this Windows host until `codex exec --sandbox workspace-write` can launch a simple shell command before running governed Codex work."
+                remediation: "MartinLoop already invokes Codex's underlying binary directly when it can resolve the npm shim (bypassing the cmd.exe/PowerShell wrapper hop), so this failure persisted even at the shallowest invocation depth available. Update or reinstall Codex on this Windows host until `codex exec --sandbox workspace-write` can launch a simple shell command before running governed Codex work."
             }
         };
     }

package/dist/vendor/adapters/contracts/src/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/adapters/contracts/src/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/adapters/contracts/src/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/adapters/contracts/src/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/adapters/contracts/src/governance.d.ts

@@ -0,0 +1,24 @@
+export type PolicyProfile = "strict" | "balanced" | "overnight" | "debug";
+export type DestructiveActionPolicy = "never" | "approval" | "allowed";
+export type TelemetryDestination = "local-only" | "control-plane";
+export type GovernanceSnapshot = {
+    policyProfile: PolicyProfile;
+    maxUsd: number;
+    softLimitUsd: number;
+    maxTokens: number;
+    maxIterations: number;
+    allowedAdapters: string[];
+    allowedModels: string[];
+    destructiveActionPolicy: DestructiveActionPolicy;
+    approvalRequired: boolean;
+    verifierRules: string[];
+    escalationRoute: string;
+    telemetryDestination: TelemetryDestination;
+    retentionPolicy: string;
+    provenance: Array<{
+        field: string;
+        value: string;
+        source: string;
+    }>;
+};
+export declare function createGovernanceSnapshot(snapshot: GovernanceSnapshot): GovernanceSnapshot;

package/dist/vendor/adapters/contracts/src/governance.js

@@ -0,0 +1,11 @@
+export function createGovernanceSnapshot(snapshot) {
+    return {
+        ...snapshot,
+        allowedAdapters: [...snapshot.allowedAdapters],
+        allowedModels: [...snapshot.allowedModels],
+        verifierRules: [...snapshot.verifierRules],
+        provenance: snapshot.provenance.map((entry) => ({
+            ...entry
+        }))
+    };
+}

package/dist/vendor/adapters/contracts/src/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/adapters/contracts/src/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)
+    };
+}