@martinloop/mcp 0.3.2 → 0.3.4

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

@@ -0,0 +1,371 @@
+import { readdir, readFile } from "node:fs/promises";
+import { extname, join, posix, relative, resolve } from "node:path";
+import { cloneContextGraphSnapshot } from "../contracts/index.js";
+const TEXT_EXTENSIONS = new Set([
+    ".ts",
+    ".tsx",
+    ".js",
+    ".jsx",
+    ".mjs",
+    ".cjs",
+    ".json",
+    ".md",
+    ".yaml",
+    ".yml",
+    ".txt",
+    ".py",
+    ".go",
+    ".rs",
+    ".java",
+    ".sh"
+]);
+const IGNORED_DIRS = new Set([
+    ".git",
+    "node_modules",
+    "dist",
+    "build",
+    ".next",
+    ".turbo",
+    "coverage",
+    ".pnpm-store",
+    ".npm-cache"
+]);
+export async function buildContextGraphSnapshot(repoRoot, options = {}) {
+    const normalizedRoot = resolve(repoRoot);
+    const maxFiles = options.maxFiles ?? 600;
+    const maxFileBytes = options.maxFileBytes ?? 96_000;
+    const nodes = [];
+    const state = { count: 0, truncated: false };
+    await walkContextGraph(normalizedRoot, normalizedRoot, nodes, state, { maxFiles, maxFileBytes });
+    const edges = buildContextGraphEdges(nodes);
+    return cloneContextGraphSnapshot({
+        schemaVersion: "martin.context-graph.v1",
+        repoRoot: normalizedRoot,
+        createdAt: new Date().toISOString(),
+        nodeCount: nodes.length,
+        edgeCount: edges.length,
+        truncated: state.truncated,
+        nodes,
+        edges
+    });
+}
+export function queryContextGraph(snapshot, query) {
+    const terms = normalizeQueryTerms(query);
+    const pathPrefix = query.pathPrefix?.replace(/\\/gu, "/").replace(/^\.\/+/u, "");
+    const limit = query.limit ?? 8;
+    return snapshot.nodes
+        .filter((node) => {
+        if (query.kinds && !query.kinds.includes(node.kind)) {
+            return false;
+        }
+        if (pathPrefix && !node.path.startsWith(pathPrefix)) {
+            return false;
+        }
+        return true;
+    })
+        .map((node) => scoreContextNode(node, terms))
+        .filter((hit) => hit !== undefined)
+        .sort((left, right) => right.score - left.score || left.path.localeCompare(right.path))
+        .slice(0, limit);
+}
+async function walkContextGraph(repoRoot, currentDir, nodes, state, options) {
+    if (state.count >= options.maxFiles) {
+        state.truncated = true;
+        return;
+    }
+    const entries = await readdir(currentDir, { withFileTypes: true });
+    for (const entry of entries) {
+        if (state.count >= options.maxFiles) {
+            state.truncated = true;
+            break;
+        }
+        const absPath = join(currentDir, entry.name);
+        if (entry.isDirectory()) {
+            if (!IGNORED_DIRS.has(entry.name)) {
+                await walkContextGraph(repoRoot, absPath, nodes, state, options);
+            }
+            continue;
+        }
+        if (!entry.isFile()) {
+            continue;
+        }
+        const extension = extname(entry.name).toLowerCase();
+        if (!TEXT_EXTENSIONS.has(extension)) {
+            continue;
+        }
+        const content = await readFile(absPath, "utf8").catch(() => undefined);
+        if (!content || content.length > options.maxFileBytes) {
+            continue;
+        }
+        const relPath = relative(repoRoot, absPath).replace(/\\/gu, "/");
+        nodes.push(createContextNode(relPath, content));
+        state.count += 1;
+    }
+}
+function createContextNode(path, content) {
+    const kind = classifyContextNodeKind(path);
+    return {
+        nodeId: path,
+        path,
+        kind,
+        ...(inferLanguage(path) ? { language: inferLanguage(path) } : {}),
+        sizeBytes: Buffer.byteLength(content, "utf8"),
+        headings: extractHeadings(path, content),
+        symbols: extractSymbols(content),
+        keywords: extractKeywords(path, content),
+        imports: extractImports(path, content)
+    };
+}
+function buildContextGraphEdges(nodes) {
+    const paths = new Set(nodes.map((node) => node.path));
+    const edges = [];
+    for (const node of nodes) {
+        for (const importTarget of node.imports) {
+            const resolvedTarget = resolveContextImport(node.path, importTarget, paths);
+            if (resolvedTarget) {
+                edges.push({
+                    fromNodeId: node.nodeId,
+                    toNodeId: resolvedTarget,
+                    kind: "imports"
+                });
+            }
+        }
+        if (node.kind === "document") {
+            const documentTargets = node.keywords
+                .map((keyword) => nodes.find((candidate) => candidate.path !== node.path && candidate.path.includes(keyword)))
+                .filter((candidate) => candidate !== undefined)
+                .slice(0, 3);
+            for (const target of documentTargets) {
+                edges.push({
+                    fromNodeId: node.nodeId,
+                    toNodeId: target.nodeId,
+                    kind: "documents"
+                });
+            }
+        }
+    }
+    return dedupeEdges(edges);
+}
+function scoreContextNode(node, terms) {
+    if (terms.length === 0) {
+        return {
+            nodeId: node.nodeId,
+            path: node.path,
+            kind: node.kind,
+            score: 1,
+            matchedTerms: [],
+            reasons: ["default_match"]
+        };
+    }
+    let score = 0;
+    const matchedTerms = new Set();
+    const reasons = new Set();
+    for (const term of terms) {
+        if (node.path.toLowerCase().includes(term)) {
+            score += 6;
+            matchedTerms.add(term);
+            reasons.add("path");
+        }
+        if (node.keywords.includes(term)) {
+            score += 3;
+            matchedTerms.add(term);
+            reasons.add("keyword");
+        }
+        if (node.symbols.some((symbol) => symbol.toLowerCase().includes(term))) {
+            score += 5;
+            matchedTerms.add(term);
+            reasons.add("symbol");
+        }
+        if (node.headings.some((heading) => heading.toLowerCase().includes(term))) {
+            score += 4;
+            matchedTerms.add(term);
+            reasons.add("heading");
+        }
+        if (node.imports.some((importPath) => importPath.toLowerCase().includes(term))) {
+            score += 2;
+            matchedTerms.add(term);
+            reasons.add("import");
+        }
+    }
+    if (score === 0) {
+        return undefined;
+    }
+    return {
+        nodeId: node.nodeId,
+        path: node.path,
+        kind: node.kind,
+        score,
+        matchedTerms: [...matchedTerms],
+        reasons: [...reasons]
+    };
+}
+function normalizeQueryTerms(query) {
+    const rawTerms = [
+        ...(query.text ? tokenize(query.text) : []),
+        ...((query.terms ?? []).flatMap((term) => tokenize(term)))
+    ];
+    return [...new Set(rawTerms)];
+}
+function classifyContextNodeKind(path) {
+    const extension = extname(path).toLowerCase();
+    if (path.endsWith("package.json") || path.endsWith("tsconfig.json")) {
+        return "manifest";
+    }
+    if (extension === ".md" || extension === ".txt") {
+        return "document";
+    }
+    if (extension === ".sh") {
+        return "script";
+    }
+    if (extension === ".json" || extension === ".yaml" || extension === ".yml") {
+        return "config";
+    }
+    return "source_file";
+}
+function inferLanguage(path) {
+    const extension = extname(path).toLowerCase();
+    switch (extension) {
+        case ".ts":
+        case ".tsx":
+            return "typescript";
+        case ".js":
+        case ".jsx":
+        case ".mjs":
+        case ".cjs":
+            return "javascript";
+        case ".md":
+            return "markdown";
+        case ".json":
+            return "json";
+        case ".yaml":
+        case ".yml":
+            return "yaml";
+        case ".py":
+            return "python";
+        case ".sh":
+            return "shell";
+        default:
+            return undefined;
+    }
+}
+function extractHeadings(path, content) {
+    if (extname(path).toLowerCase() !== ".md") {
+        return [];
+    }
+    return content
+        .split(/\r?\n/gu)
+        .map((line) => line.trim())
+        .filter((line) => line.startsWith("#"))
+        .map((line) => line.replace(/^#+\s*/u, "").trim())
+        .filter(Boolean)
+        .slice(0, 12);
+}
+function extractSymbols(content) {
+    const out = new Set();
+    const patterns = [
+        /export\s+(?:async\s+)?function\s+([A-Za-z0-9_]+)/gu,
+        /export\s+class\s+([A-Za-z0-9_]+)/gu,
+        /export\s+const\s+([A-Za-z0-9_]+)/gu,
+        /function\s+([A-Za-z0-9_]+)/gu,
+        /class\s+([A-Za-z0-9_]+)/gu,
+        /interface\s+([A-Za-z0-9_]+)/gu,
+        /type\s+([A-Za-z0-9_]+)/gu
+    ];
+    for (const pattern of patterns) {
+        for (const match of content.matchAll(pattern)) {
+            if (match[1]) {
+                out.add(match[1]);
+            }
+        }
+    }
+    return [...out].slice(0, 16);
+}
+function extractKeywords(path, content) {
+    const out = new Set();
+    for (const part of path.split(/[\/._-]+/u)) {
+        if (part.length >= 3) {
+            out.add(part.toLowerCase());
+        }
+    }
+    for (const token of tokenize(content.split(/\r?\n/gu).slice(0, 16).join(" "))) {
+        out.add(token);
+    }
+    return [...out].slice(0, 24);
+}
+function extractImports(path, content) {
+    if (![".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"].includes(extname(path).toLowerCase())) {
+        return [];
+    }
+    const imports = new Set();
+    const patterns = [
+        /from\s+["']([^"']+)["']/gu,
+        /require\(\s*["']([^"']+)["']\s*\)/gu,
+        /import\(\s*["']([^"']+)["']\s*\)/gu
+    ];
+    for (const pattern of patterns) {
+        for (const match of content.matchAll(pattern)) {
+            const candidate = match[1]?.trim();
+            if (candidate) {
+                imports.add(candidate);
+            }
+        }
+    }
+    return [...imports].slice(0, 24);
+}
+function resolveContextImport(fromPath, importPath, paths) {
+    if (!importPath.startsWith(".")) {
+        return undefined;
+    }
+    const fromDirectory = fromPath.includes("/") ? fromPath.slice(0, fromPath.lastIndexOf("/")) : "";
+    const base = posix.normalize(posix.join(fromDirectory, importPath)).replace(/^\.\//u, "");
+    const extensionlessBase = extname(base) ? base.slice(0, -extname(base).length) : base;
+    const candidates = [
+        base,
+        extensionlessBase,
+        `${extensionlessBase}.ts`,
+        `${extensionlessBase}.tsx`,
+        `${extensionlessBase}.js`,
+        `${extensionlessBase}.jsx`,
+        `${extensionlessBase}.md`,
+        `${base}.ts`,
+        `${base}.tsx`,
+        `${base}.js`,
+        `${base}.jsx`,
+        `${base}.md`,
+        `${base}/index.ts`,
+        `${base}/index.tsx`,
+        `${base}/index.js`
+    ];
+    return candidates.find((candidate) => paths.has(candidate));
+}
+function dedupeEdges(edges) {
+    const seen = new Set();
+    return edges.filter((edge) => {
+        const key = `${edge.kind}:${edge.fromNodeId}:${edge.toNodeId}`;
+        if (seen.has(key)) {
+            return false;
+        }
+        seen.add(key);
+        return true;
+    });
+}
+function tokenize(input) {
+    const normalized = input.replace(/([a-z0-9])([A-Z])/gu, "$1 $2").toLowerCase();
+    const stopWords = new Set([
+        "the",
+        "and",
+        "for",
+        "with",
+        "from",
+        "that",
+        "this",
+        "into",
+        "only",
+        "keep",
+        "make",
+        "loop",
+        "then",
+        "when"
+    ]);
+    return [...new Set(normalized.match(/[a-z0-9_]{3,}/gu) ?? [])].filter((term) => !stopWords.has(term));
+}

package/dist/vendor/core/context-integrity.js

@@ -21,7 +21,7 @@ const POISON_PATTERNS = [
  */
 const IDENTITY_REDEFINITION_PATTERNS = [
     /\byou(?:'re|\s+are)\s+now\s+(?:a|an|the)\b(?!\s+(?:martin\s+loop|ai\s+coding\s+agent))/i,
-    /\byou(?:'re|\s+are)\s+no\s+longer\s+(?!.*\b(?:martin\s+loop|an?\s+ai)\b)/i,
+    /\byou(?:'re|\s+are)\s+no\s+longer\s+(?!(?:martin\s+loop|an?\s+ai)\b)/i,
     /\bforget\s+(?:that\s+)?you(?:'re|\s+are)\s+martin\s+loop\b/i,
     /\b(?:pretend|imagine)\s+(?:that\s+)?you(?:'re|\s+are)\b/i,
     /\bact\s+as\s+(?:if\s+you(?:'re|\s+are)\s+)?(?:a|an)\s+(?:different|new|unrestricted|jailbroken)\b/i,

package/dist/vendor/core/grounding.js

@@ -13,7 +13,7 @@ const IGNORED_DIRS = new Set([
 const MAX_FILE_BYTES = 64_000;
 const MAX_FILES = 500;
 export function resolveGroundingRoot(env = process.env) {
-    return env["MARTIN_GROUNDING_DIR"]?.trim() ??
+    return env["MARTIN_GROUNDING_DIR"]?.trim() ||
         join(homedir(), ".martin", "grounding");
 }
 export async function loadOrBuildRepoGroundingIndex(repoRoot) {

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

@@ -0,0 +1,20 @@
+import { type IdentityAttestation, type IdentityClaims, type IdentityToken } from "../contracts/index.js";
+export interface LocalIdentityAuthority {
+    keyId: string;
+    algorithm: "ed25519";
+    privateKeyPem: string;
+    publicKeyPem: string;
+}
+export declare function createLocalIdentityAuthority(input?: {
+    keyId?: string;
+}): LocalIdentityAuthority;
+export declare function issueIdentityToken(input: {
+    authority: Pick<LocalIdentityAuthority, "keyId" | "algorithm" | "privateKeyPem">;
+    claims: IdentityClaims;
+}): IdentityToken;
+export declare function verifyIdentityToken(input: {
+    token: IdentityToken;
+    publicKeyPem: string;
+    now?: string;
+}): IdentityAttestation;
+export declare function hasIdentityScope(token: IdentityToken, requiredScope: string): boolean;

package/dist/vendor/core/identity.js

@@ -0,0 +1,86 @@
+import { createPrivateKey, createPublicKey, generateKeyPairSync, sign, verify } from "node:crypto";
+import { cloneIdentityAttestation, cloneIdentityClaims, cloneIdentityToken } from "../contracts/index.js";
+export function createLocalIdentityAuthority(input = {}) {
+    const { privateKey, publicKey } = generateKeyPairSync("ed25519");
+    return {
+        keyId: input.keyId ?? `martin-local-${Date.now().toString(36)}`,
+        algorithm: "ed25519",
+        privateKeyPem: privateKey.export({ format: "pem", type: "pkcs8" }).toString(),
+        publicKeyPem: publicKey.export({ format: "pem", type: "spki" }).toString()
+    };
+}
+export function issueIdentityToken(input) {
+    const claims = cloneIdentityClaims(input.claims);
+    const signer = createPrivateKey(input.authority.privateKeyPem);
+    const payload = serializeIdentityClaims(claims);
+    const signature = sign(null, payload, signer).toString("base64");
+    return cloneIdentityToken({
+        schemaVersion: "martin.identity.v1",
+        algorithm: input.authority.algorithm,
+        keyId: input.authority.keyId,
+        claims,
+        signature
+    });
+}
+export function verifyIdentityToken(input) {
+    const token = cloneIdentityToken(input.token);
+    const verifier = createPublicKey(input.publicKeyPem);
+    const payload = serializeIdentityClaims(token.claims);
+    const verifiedAt = input.now ?? new Date().toISOString();
+    if (token.schemaVersion !== "martin.identity.v1") {
+        return cloneIdentityAttestation({
+            valid: false,
+            verifiedAt,
+            reason: `Unsupported identity schema version '${token.schemaVersion}'.`,
+            token
+        });
+    }
+    const signatureValid = verify(null, payload, verifier, Buffer.from(token.signature, "base64"));
+    if (!signatureValid) {
+        return cloneIdentityAttestation({
+            valid: false,
+            verifiedAt,
+            reason: "Identity signature verification failed.",
+            token
+        });
+    }
+    const expiresAt = token.claims.expiresAt ? Date.parse(token.claims.expiresAt) : undefined;
+    if (expiresAt !== undefined && Number.isFinite(expiresAt) && expiresAt <= Date.parse(verifiedAt)) {
+        return cloneIdentityAttestation({
+            valid: false,
+            verifiedAt,
+            reason: "Identity token is expired.",
+            token
+        });
+    }
+    return cloneIdentityAttestation({
+        valid: true,
+        verifiedAt,
+        reason: `Identity token for role '${token.claims.role}' verified successfully.`,
+        token
+    });
+}
+export function hasIdentityScope(token, requiredScope) {
+    const required = requiredScope.trim().toLowerCase();
+    if (required.length === 0) {
+        return false;
+    }
+    return token.claims.scopes.some((scope) => scope.trim().toLowerCase() === required);
+}
+function serializeIdentityClaims(claims) {
+    return Buffer.from(JSON.stringify(claims, sortKeys), "utf8");
+}
+function sortKeys(_, value) {
+    if (Array.isArray(value)) {
+        return value;
+    }
+    if (value && typeof value === "object") {
+        return Object.keys(value)
+            .sort()
+            .reduce((sorted, key) => {
+            sorted[key] = value[key];
+            return sorted;
+        }, {});
+    }
+    return value;
+}

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

@@ -9,6 +9,11 @@ export { classifyFailure, computeEvidenceVector, evaluatePatchDecision, evaluate
 export type { BudgetPreflightDecision, BudgetPreflightInput, CostGovernorState, EvidenceVectorInput, EvaluatedPatchDecision, ExitDecision, FailureAssessment, PatchDecisionInput, RecoveryDecision, RecoveryRecipe } from "./policy.js";
 export type { ResolvedExecutionProfile, SafetyLeashDecision, SafetyViolation } from "./leash.js";
 export type { GroundingScanResult, GroundingViolation, GroundingViolationKind, RepoGroundingHit, RepoGroundingIndex } from "./grounding.js";
+export { buildContextGraphSnapshot, queryContextGraph } from "./context-graph.js";
+export { createLocalIdentityAuthority, hasIdentityScope, issueIdentityToken, verifyIdentityToken } from "./identity.js";
+export type { LocalIdentityAuthority } from "./identity.js";
+export { compileExecutionPolicy } from "./policy-compiler.js";
+export { assessTrajectory, decideCircuitBreak } from "./trajectory.js";
 export { runContextIntegrityPrecheck } from "./context-integrity.js";
 export type { ContextIntegrityPrecheck, ContextIntegrityVerdict } from "./context-integrity.js";
 export { compilePromptPacket } from "./compiler.js";
@@ -132,6 +137,8 @@ export interface AttemptPolicyDecision {
     allowed: boolean;
     reason: string;
     recommendedIntervention?: InterventionType;
+    trajectoryAssessment?: import("../contracts/index.js").TrajectoryAssessment;
+    circuitBreakDecision?: import("../contracts/index.js").CircuitBreakDecision;
 }
 /**
  * Admission gate — must pass before any attempt is executed.

package/dist/vendor/core/index.js

@@ -7,7 +7,12 @@ import { captureRollbackBoundary, restoreRollbackBoundary } from "./rollback.js"
 import { compilePromptPacket } from "./compiler.js";
 import { makeLedgerEvent, resolveRunsRoot, runDir } from "./persistence/index.js";
 import { runContextIntegrityPrecheck } from "./context-integrity.js";
+import { decideCircuitBreak } from "./trajectory.js";
 export { classifyFailure, computeEvidenceVector, evaluatePatchDecision, evaluateCostGovernor, evaluateBudgetPreflight, inferExit, nextPolicyPhase, policyPhaseToLifecycleState, scorePatchDecision, selectRecoveryRecipe, evaluateVerificationLeash, evaluateFilesystemLeash, evaluateChangeApprovalLeash, evaluateSecretLeash, resolveExecutionProfile, redactSecretsFromText, buildRepoGroundingIndex, loadOrBuildRepoGroundingIndex, queryRepoGroundingIndex, scanPatchForGroundingViolations, captureRollbackBoundary, restoreRollbackBoundary };
+export { buildContextGraphSnapshot, queryContextGraph } from "./context-graph.js";
+export { createLocalIdentityAuthority, hasIdentityScope, issueIdentityToken, verifyIdentityToken } from "./identity.js";
+export { compileExecutionPolicy } from "./policy-compiler.js";
+export { assessTrajectory, decideCircuitBreak } from "./trajectory.js";
 // ─── Context Integrity Pre-gate ──────────────────────────────────────────────
 export { runContextIntegrityPrecheck } from "./context-integrity.js";
 // ─── Prompt packet compiler ──────────────────────────────────────────────────
@@ -22,12 +27,35 @@ export { compileAndPersistContext } from "./persistence/index.js";
  */
 export function evaluateAttemptPolicy(input) {
     const { request, projectedUsd } = input;
+    const trajectoryAttempts = request.previousAttempts.map((attempt) => ({
+        index: attempt.index,
+        summary: attempt.summary,
+        failureClass: attempt.failureClass
+    }));
+    const circuitBreakDecision = decideCircuitBreak({
+        objective: request.context.objective,
+        verificationPlan: request.context.verificationPlan,
+        attempts: trajectoryAttempts,
+        remainingIterations: request.context.remainingIterations
+    });
+    const trajectoryAssessment = circuitBreakDecision.assessment;
+    if (circuitBreakDecision.shouldStop) {
+        return {
+            allowed: false,
+            reason: circuitBreakDecision.reason,
+            recommendedIntervention: circuitBreakDecision.recommendedIntervention,
+            trajectoryAssessment,
+            circuitBreakDecision
+        };
+    }
     // Budget gate: reject if projected cost exceeds remaining
     if (projectedUsd > request.context.remainingBudgetUsd) {
         return {
             allowed: false,
             reason: `Projected cost $${projectedUsd} exceeds remaining budget $${request.context.remainingBudgetUsd}.`,
-            recommendedIntervention: "stop_loop"
+            recommendedIntervention: "stop_loop",
+            trajectoryAssessment,
+            circuitBreakDecision
         };
     }
     // Iteration gate
@@ -35,7 +63,9 @@ export function evaluateAttemptPolicy(input) {
         return {
             allowed: false,
             reason: "No remaining iterations in the budget.",
-            recommendedIntervention: "stop_loop"
+            recommendedIntervention: "stop_loop",
+            trajectoryAssessment,
+            circuitBreakDecision
         };
     }
     // Oscillation detection: A/B/A pattern in failure classes
@@ -49,7 +79,9 @@ export function evaluateAttemptPolicy(input) {
             return {
                 allowed: false,
                 reason: "Oscillating failure pattern detected. Escalating to human.",
-                recommendedIntervention: "escalate_human"
+                recommendedIntervention: "escalate_human",
+                trajectoryAssessment,
+                circuitBreakDecision
             };
         }
     }
@@ -70,14 +102,18 @@ export function evaluateAttemptPolicy(input) {
                 return {
                     allowed: false,
                     reason: "Materially repetitive attempts detected. Escalating to human.",
-                    recommendedIntervention: "escalate_human"
+                    recommendedIntervention: "escalate_human",
+                    trajectoryAssessment,
+                    circuitBreakDecision
                 };
             }
         }
     }
     return {
         allowed: true,
-        reason: "Attempt admitted."
+        reason: "Attempt admitted.",
+        trajectoryAssessment,
+        circuitBreakDecision
     };
 }
 export function distillContext(loop, options = {}) {
@@ -278,7 +314,7 @@ export async function runMartin(input) {
         // re-enters subsequent prompts, matching the documented "tool output / test output" scope.
         const priorVerifierOutput = loop.events
             .filter((event) => event.type === "verification.completed")
-            .flatMap((event) => event.payload.steps ?? [])
+            .flatMap((event) => event.payload?.steps ?? [])
             .map((step) => step.detail)
             .filter((detail) => Boolean(detail))
             .join("\n---\n");
@@ -453,7 +489,8 @@ export async function runMartin(input) {
             ...(failure?.failureClass ? { failureClass: failure.failureClass } : {}),
             ...(failure?.recommendedIntervention
                 ? { intervention: failure.recommendedIntervention }
-                : {})
+                : {}),
+            ...(failure?.diagnosticHint ? { diagnosticHint: failure.diagnosticHint } : {})
         };
         loop = {
             ...loop,
@@ -468,7 +505,7 @@ export async function runMartin(input) {
                         estimatedUsd: roundUsd((loop.cost.estimatedUsd ?? loop.cost.actualUsd) + result.usage.estimatedUsd)
                     }
                     : {}),
-                provenance: getUsageProvenance(result.usage),
+                provenance: mergeCostProvenance(loop.cost.provenance, getUsageProvenance(result.usage)),
                 ...(result.usage.providerSettlement
                     ? { providerSettlement: result.usage.providerSettlement }
                     : {})
@@ -552,7 +589,7 @@ export async function runMartin(input) {
                 actualUsd: loop.cost.actualUsd,
                 remainingBudgetUsd: costState.remainingBudgetUsd,
                 pressure: costState.pressure,
-                provenance: getUsageProvenance(result.usage)
+                provenance: loop.cost.provenance
             }
         }, { now: now(), idFactory });
         if (input.store) {
@@ -1136,6 +1173,23 @@ function getUsageProvenance(usage) {
     }
     return "actual";
 }
+const COST_PROVENANCE_RANK = {
+    unavailable: 0,
+    estimated: 1,
+    actual: 2
+};
+/**
+ * Aggregates cost provenance across attempts. The cumulative loop provenance
+ * can only be as trustworthy as its weakest attempt: if any attempt's cost was
+ * estimated or unavailable, the cumulative total must reflect that, even if a
+ * later attempt reports an authoritative actual cost.
+ */
+function mergeCostProvenance(previous, current) {
+    if (previous === undefined) {
+        return current;
+    }
+    return COST_PROVENANCE_RANK[current] < COST_PROVENANCE_RANK[previous] ? current : previous;
+}
 function resolveChangedFiles(result, repoRoot) {
     if (result.execution?.changedFiles !== undefined) {
         return result.execution.changedFiles;

package/dist/vendor/core/leash.js

@@ -39,7 +39,7 @@ const BLOCKED_PATTERNS = [
  */
 function commandContainsDestructiveRemoval(command) {
     const normalized = command.replace(/\$\{?IFS\}?/giu, " ").toLowerCase();
-    const rmInvocation = /(?:^|[\s;&|`(])(?:\/(?:usr\/(?:local\/)?)?s?bin\/)?rm\s+([^\n;|`]+)/giu;
+    const rmInvocation = /(?:^|[\s;&|`(])(?:[^\s;&|`(]+\/)?rm\s+([^\n;|`]+)/giu;
     let match;
     while ((match = rmInvocation.exec(normalized)) !== null) {
         const args = match[1] ?? "";

package/dist/vendor/core/persistence/integrity.d.ts

@@ -21,6 +21,7 @@ export interface StoredReceiptIntegrityMaterial {
     chain: ReceiptIntegrityChainEntry[];
     signatureHmacSha256: string;
 }
+export declare function resolveReceiptIntegrityRoot(env?: NodeJS.ProcessEnv): string;
 export declare function writeReceiptIntegrityMaterial(input: {
     runId: string;
     runsRoot: string;