@martinloop/mcp 0.3.4 → 0.3.6

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

@@ -2,10 +2,10 @@ import { type ApprovalPolicy, type CostProvenance, type ExecutionProfile, type F
 import { classifyFailure, computeEvidenceVector, evaluatePatchDecision, evaluateCostGovernor, evaluateBudgetPreflight, inferExit, nextPolicyPhase, policyPhaseToLifecycleState, scorePatchDecision, selectRecoveryRecipe, type ExitDecision } from "./policy.js";
 import { evaluateChangeApprovalLeash, evaluateFilesystemLeash, evaluateSecretLeash, redactSecretsFromText, resolveExecutionProfile, evaluateVerificationLeash } from "./leash.js";
 import { buildRepoGroundingIndex, loadOrBuildRepoGroundingIndex, queryRepoGroundingIndex, scanPatchForGroundingViolations } from "./grounding.js";
-import { captureRollbackBoundary, restoreRollbackBoundary } from "./rollback.js";
+import { captureRollbackBoundary, listAttemptChangedFilesSinceBoundary, restoreRollbackBoundary } from "./rollback.js";
 import { type RunStore } from "./persistence/index.js";
-export type { ApprovalPolicy, BudgetPreflightEstimate, BudgetSettlement, CostProvenance, EvidenceVector, ExecutionProfile, FailureClass, InterventionType, PatchDecision, PatchDecisionArtifact, PatchDecisionReasonCode, PatchScore, MutationMode, RollbackBoundaryArtifact, RollbackBoundaryStrategy, RollbackFileSnapshot, RollbackOutcomeArtifact, RollbackOutcomeStatus, PolicyPhase } from "../contracts/index.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 type { ApprovalPolicy, BudgetPreflightEstimate, BudgetSettlement, CostProvenance, EvidenceVector, ExecutionProfile, FailureClass, InterventionType, PatchDecision, PatchDecisionArtifact, PatchDecisionReasonCode, PatchScore, MutationMode, RollbackBoundaryArtifact, RollbackBoundaryStrategy, RollbackFileSnapshot, RollbackOutcomeArtifact, RollbackOutcomeStatus, PolicyPhase, CallStage, AgentRole, FirstDelta, RoutingEconomics } from "../contracts/index.js";
+export { classifyFailure, computeEvidenceVector, evaluatePatchDecision, evaluateCostGovernor, evaluateBudgetPreflight, inferExit, nextPolicyPhase, policyPhaseToLifecycleState, scorePatchDecision, selectRecoveryRecipe, evaluateVerificationLeash, evaluateFilesystemLeash, evaluateChangeApprovalLeash, evaluateSecretLeash, resolveExecutionProfile, redactSecretsFromText, buildRepoGroundingIndex, loadOrBuildRepoGroundingIndex, queryRepoGroundingIndex, scanPatchForGroundingViolations, captureRollbackBoundary, listAttemptChangedFilesSinceBoundary, restoreRollbackBoundary };
 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";
@@ -14,6 +14,12 @@ export { createLocalIdentityAuthority, hasIdentityScope, issueIdentityToken, ver
 export type { LocalIdentityAuthority } from "./identity.js";
 export { compileExecutionPolicy } from "./policy-compiler.js";
 export { assessTrajectory, decideCircuitBreak } from "./trajectory.js";
+export { classifyRoute, evaluatePreworkBurnPolicy, resolveModelForTier, selectBestEngine } from "./routing.js";
+export type { RouteDecision, RouteClassificationInput, AvailableEngine } from "./routing.js";
+export { validateTestIntegrity, snapshotTestFiles, identifyNewTests, findTestFiles, isTestFile, extractImports, hasTrivialAssertionsOnly, importsPreExistingCode } from "./test-integrity.js";
+export type { TestIntegrityReport, TestIntegrityFinding } from "./test-integrity.js";
+export { analyzeRepoStyle, buildPromptDirectives } from "./repo-analyzer.js";
+export type { RepoStyleProfile } from "./repo-analyzer.js";
 export { runContextIntegrityPrecheck } from "./context-integrity.js";
 export type { ContextIntegrityPrecheck, ContextIntegrityVerdict } from "./context-integrity.js";
 export { compilePromptPacket } from "./compiler.js";
@@ -22,6 +28,10 @@ export { createFileRunStore, makeLedgerEvent, readAllLoopRecords, readLatestLoop
 export type { AttemptArtifacts, LedgerEvent, LedgerEventKind, LoopAttemptRecord, LoopRunRecord, ReceiptIntegrityChainEntry, RunContract, RunStore, StoredReceiptIntegrityMaterial } from "./persistence/index.js";
 export { compileAndPersistContext } from "./persistence/index.js";
 export type { CompileResult } from "./persistence/index.js";
+export { appendMemory, readMemoryEntries, getPreference, buildMemorySummary, recordPreference, recordConsent } from "./persistence/memory-store.js";
+export type { MemoryEntry, MemoryKind, MemorySummary } from "./persistence/memory-store.js";
+export { appendTraceEntry, readTraceEntries, aggregateTraces, getHistoricalDirectSuccessRate } from "./persistence/trace-store.js";
+export type { TraceEntry, TraceAggregation } from "./persistence/trace-store.js";
 export interface MartinAdapterRequest {
     loopId: string;
     attemptId: string;

package/dist/vendor/core/index.js

@@ -1,18 +1,23 @@
-import { spawnSync } from "node:child_process";
 import { appendLoopEvent, createLoopRecord } from "../contracts/index.js";
 import { classifyFailure, computeEvidenceVector, evaluatePatchDecision, evaluateCostGovernor, evaluateBudgetPreflight, inferExit, nextPolicyPhase, policyPhaseToLifecycleState, scorePatchDecision, selectRecoveryRecipe } from "./policy.js";
 import { evaluateChangeApprovalLeash, evaluateFilesystemLeash, evaluateSecretLeash, redactSecretsFromText, resolveExecutionProfile, evaluateVerificationLeash } from "./leash.js";
 import { buildRepoGroundingIndex, loadOrBuildRepoGroundingIndex, queryRepoGroundingIndex, scanPatchForGroundingViolations } from "./grounding.js";
-import { captureRollbackBoundary, restoreRollbackBoundary } from "./rollback.js";
+import { captureRollbackBoundary, listAttemptChangedFilesSinceBoundary, 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 { classifyFailure, computeEvidenceVector, evaluatePatchDecision, evaluateCostGovernor, evaluateBudgetPreflight, inferExit, nextPolicyPhase, policyPhaseToLifecycleState, scorePatchDecision, selectRecoveryRecipe, evaluateVerificationLeash, evaluateFilesystemLeash, evaluateChangeApprovalLeash, evaluateSecretLeash, resolveExecutionProfile, redactSecretsFromText, buildRepoGroundingIndex, loadOrBuildRepoGroundingIndex, queryRepoGroundingIndex, scanPatchForGroundingViolations, captureRollbackBoundary, listAttemptChangedFilesSinceBoundary, 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";
+// ─── Routing economics ─────────────────────────────────────────────────────
+export { classifyRoute, evaluatePreworkBurnPolicy, resolveModelForTier, selectBestEngine } from "./routing.js";
+// ─── Test Integrity Validation ──────────────────────────────────────────────
+export { validateTestIntegrity, snapshotTestFiles, identifyNewTests, findTestFiles, isTestFile, extractImports, hasTrivialAssertionsOnly, importsPreExistingCode } from "./test-integrity.js";
+// ─── Repo Style Analyzer ────────────────────────────────────────────────────
+export { analyzeRepoStyle, buildPromptDirectives } from "./repo-analyzer.js";
 // ─── Context Integrity Pre-gate ──────────────────────────────────────────────
 export { runContextIntegrityPrecheck } from "./context-integrity.js";
 // ─── Prompt packet compiler ──────────────────────────────────────────────────
@@ -20,6 +25,10 @@ export { compilePromptPacket } from "./compiler.js";
 // ─── Persistence (RunStore, LedgerEvent, FileRunStore) ──────────────────────
 export { createFileRunStore, makeLedgerEvent, readAllLoopRecords, readLatestLoopRecord, readLatestLoopRecordFromFile, readLoopRecordsFromFile, resolveRunsRoot, resolveReceiptIntegrityPath, verifyReceiptIntegrityFromFiles, writeReceiptIntegrityMaterial } from "./persistence/index.js";
 export { compileAndPersistContext } from "./persistence/index.js";
+// ─── MartinLoop Memory Store ────────────────────────────────────────────────
+export { appendMemory, readMemoryEntries, getPreference, buildMemorySummary, recordPreference, recordConsent } from "./persistence/memory-store.js";
+// ─── Trace Intelligence Store ───────────────────────────────────────────────
+export { appendTraceEntry, readTraceEntries, aggregateTraces, getHistoricalDirectSuccessRate } from "./persistence/trace-store.js";
 /**
  * Admission gate — must pass before any attempt is executed.
  * Evaluates budget headroom, oscillation, and repetitive failure patterns.
@@ -263,6 +272,13 @@ export async function runMartin(input) {
     // Explicit PolicyPhase state machine — starts at GATHER, advances per attempt
     let currentPhase = "GATHER";
     let phaseRetryCount = 0;
+    // Routing economics: track first meaningful workspace delta
+    const runStartMs = Date.now();
+    let firstDeltaDetected = false;
+    let firstDeltaTimestampMs;
+    let firstDeltaFilePath;
+    let firstDeltaChangeType;
+    let preDeltaCostUsd = 0;
     while (loop.attempts.length < loop.budget.maxIterations) {
         const distilled = distillContext(loop, {
             maxRecentAttempts: useCompressedContext ? 1 : (input.maxRecentAttempts ?? 3)
@@ -647,8 +663,22 @@ export async function runMartin(input) {
             }));
         }
         const changedFiles = tracksWorkspaceMutations
-            ? resolveChangedFiles(result, request.context.repoRoot)
+            ? resolveChangedFiles(result, request.context.repoRoot, rollbackBoundary)
             : [];
+        // Routing economics: detect first meaningful workspace delta
+        if (!firstDeltaDetected && changedFiles.length > 0) {
+            const meaningfulFile = changedFiles.find((f) => !isMartinLoopMetadata(f));
+            if (meaningfulFile) {
+                firstDeltaDetected = true;
+                firstDeltaTimestampMs = Date.now();
+                firstDeltaFilePath = meaningfulFile;
+                firstDeltaChangeType = "modify";
+                preDeltaCostUsd = roundUsd(loop.cost.actualUsd - getUsageUsd(result.usage));
+            }
+        }
+        if (!firstDeltaDetected) {
+            preDeltaCostUsd = loop.cost.actualUsd;
+        }
         // Evidence is only reliable when the adapter explicitly reported files OR git actually
         // returned a non-empty list. A repoRoot alone is insufficient — git may fail (e.g. not
         // a git repo) and silently return [], which would falsely trigger no_code_change.
@@ -987,7 +1017,7 @@ export async function runMartin(input) {
             }
         }
         if (patchDecision && patchDecision.decision !== "KEEP" && !failure) {
-            failure = classifyPatchDecisionFailure(patchDecision);
+            failure = classifyPatchDecisionFailure(patchDecision, result);
             loop = applyPatchFailureToLoop(loop, {
                 attemptId,
                 summary: patchDecision.summary,
@@ -1071,7 +1101,8 @@ export async function runMartin(input) {
                     payload: createRunExitPayload(decision)
                 }));
             }
-            const finalizedLoop = finalizeLoop(loop, decision, now(), idFactory);
+            const routingInput = { runStartMs, firstDeltaDetected, firstDeltaTimestampMs, firstDeltaFilePath, firstDeltaChangeType, preDeltaCostUsd };
+            const finalizedLoop = finalizeLoop(loop, decision, now(), idFactory, routingInput);
             await persistLoopRecordIfSupported(input.store, finalizedLoop);
             return {
                 loop: finalizedLoop,
@@ -1092,7 +1123,8 @@ export async function runMartin(input) {
             payload: createRunExitPayload(decision)
         }));
     }
-    const finalizedLoop = finalizeLoop(loop, decision, now(), idFactory);
+    const routingInput = { runStartMs, firstDeltaDetected, firstDeltaTimestampMs, firstDeltaFilePath, firstDeltaChangeType, preDeltaCostUsd };
+    const finalizedLoop = finalizeLoop(loop, decision, now(), idFactory, routingInput);
     await persistLoopRecordIfSupported(input.store, finalizedLoop);
     return {
         loop: finalizedLoop,
@@ -1142,19 +1174,78 @@ function safetyLeashReasonCode(decision, safetySurface) {
             return `${safetySurface}_safety_block`;
     }
 }
-function finalizeLoop(loop, decision, timestamp, idFactory) {
+function finalizeLoop(loop, decision, timestamp, idFactory, routingEconomicsInput) {
     const finalized = appendLoopEvent(loop, {
         type: "run.completed",
         lifecycleState: decision.lifecycleState,
         payload: createRunExitPayload(decision)
     }, { now: timestamp, idFactory });
+    const routingEconomics = routingEconomicsInput
+        ? buildRoutingEconomics(finalized, routingEconomicsInput, decision)
+        : undefined;
     return {
         ...finalized,
         status: decision.status,
         lifecycleState: decision.lifecycleState,
-        updatedAt: timestamp
+        updatedAt: timestamp,
+        ...(routingEconomics ? { routingEconomics } : {})
+    };
+}
+function buildRoutingEconomics(loop, input, decision) {
+    const totalCost = loop.cost.actualUsd;
+    const preworkCost = roundUsd(Math.max(input.preDeltaCostUsd, 0));
+    const executionCost = roundUsd(Math.max(totalCost - preworkCost, 0));
+    const preworkBurnPct = totalCost > 0 ? Math.round((preworkCost / totalCost) * 100) : 0;
+    const timeToFirstDeltaMs = input.firstDeltaTimestampMs
+        ? input.firstDeltaTimestampMs - input.runStartMs
+        : undefined;
+    const accepted = decision.lifecycleState === "completed";
+    // Route recommendation based on prework burn
+    let routeRecommendation;
+    let routeRecommendationReason;
+    if (preworkBurnPct > 50) {
+        routeRecommendation = "direct_worker";
+        routeRecommendationReason = `${String(preworkBurnPct)}% of spend was pre-work coordination. Use direct execution for similar tasks.`;
+    }
+    else if (preworkBurnPct > 30) {
+        routeRecommendation = "direct_worker";
+        routeRecommendationReason = `${String(preworkBurnPct)}% pre-work burn is high. Consider direct execution.`;
+    }
+    else {
+        routeRecommendation = "same_route";
+        routeRecommendationReason = `Pre-work burn at ${String(preworkBurnPct)}% is within acceptable range.`;
+    }
+    return {
+        preworkCostUsd: preworkCost,
+        executionCostUsd: executionCost,
+        verificationCostUsd: 0,
+        retryCostUsd: 0,
+        totalCostUsd: totalCost,
+        preworkBurnPct,
+        timeToFirstDeltaMs,
+        firstDelta: {
+            detected: input.firstDeltaDetected,
+            ...(input.firstDeltaTimestampMs ? { timestampMs: input.firstDeltaTimestampMs } : {}),
+            ...(input.firstDeltaFilePath ? { filePath: input.firstDeltaFilePath } : {}),
+            ...(input.firstDeltaChangeType ? { changeType: input.firstDeltaChangeType } : {}),
+            ...(timeToFirstDeltaMs !== undefined ? { timeToFirstDeltaMs } : {})
+        },
+        ...(accepted ? { costPerAcceptedChange: totalCost } : {}),
+        routeRecommendation,
+        routeRecommendationReason
     };
 }
+const MARTINLOOP_METADATA_PATTERNS = [
+    /^PROGRESS\.md$/u,
+    /^\.martin\//u,
+    /\.lock$/u,
+    /^node_modules\//u,
+    /^\.git\//u,
+    /^\.cache\//u,
+];
+function isMartinLoopMetadata(filePath) {
+    return MARTINLOOP_METADATA_PATTERNS.some((p) => p.test(filePath));
+}
 async function persistLoopRecordIfSupported(store, loop) {
     await store?.writeLoopRecord?.(loop.loopId, loop);
 }
@@ -1190,29 +1281,11 @@ function mergeCostProvenance(previous, current) {
     }
     return COST_PROVENANCE_RANK[current] < COST_PROVENANCE_RANK[previous] ? current : previous;
 }
-function resolveChangedFiles(result, repoRoot) {
+function resolveChangedFiles(result, repoRoot, rollbackBoundary) {
     if (result.execution?.changedFiles !== undefined) {
         return result.execution.changedFiles;
     }
-    if (!repoRoot) {
-        return [];
-    }
-    try {
-        const diff = spawnSync("git", ["diff", "--name-only", "HEAD", "--", "."], {
-            cwd: repoRoot,
-            encoding: "utf8"
-        });
-        if (diff.status !== 0 || typeof diff.stdout !== "string") {
-            return [];
-        }
-        return diff.stdout
-            .split(/\r?\n/u)
-            .map((entry) => entry.trim())
-            .filter(Boolean);
-    }
-    catch {
-        return [];
-    }
+    return listAttemptChangedFilesSinceBoundary({ repoRoot, boundary: rollbackBoundary });
 }
 function buildPatchDiff(result, changedFiles) {
     // Use structured diff stats to build a minimal diff header if no raw diff is available
@@ -1338,7 +1411,19 @@ function toPatchDecisionArtifact(decision) {
         reasonCodes: decision.reasonCodes
     };
 }
-function classifyPatchDecisionFailure(decision) {
+const SANDBOX_WRITE_BLOCKED_PATTERNS = [
+    /createprocessasuserw failed:\s*\d+/iu,
+    /windows sandbox: runner error/iu,
+    /writing is blocked by read-only sandbox/iu,
+    /read-only filesystem sandbox/iu,
+    /approval is disabled/iu
+];
+function detectSandboxWriteBlocked(result) {
+    const sources = [result.summary, result.failure?.message]
+        .filter((value) => typeof value === "string" && value.trim().length > 0);
+    return sources.some((source) => SANDBOX_WRITE_BLOCKED_PATTERNS.some((pattern) => pattern.test(source)));
+}
+function classifyPatchDecisionFailure(decision, result) {
     if (decision.reasonCodes.includes("grounding_failure")) {
         return {
             failureClass: "repo_grounding_failure",
@@ -1380,6 +1465,14 @@ function classifyPatchDecisionFailure(decision) {
             recommendedIntervention: "escalate_human"
         };
     }
+    if (result && detectSandboxWriteBlocked(result)) {
+        return {
+            failureClass: "sandbox_write_blocked",
+            rationale: "The adapter reported a completed patch but the workspace-write sandbox blocked the underlying file write, so no trustworthy code change landed on disk.",
+            retryable: true,
+            recommendedIntervention: "switch_adapter"
+        };
+    }
     return {
         failureClass: "no_progress",
         rationale: "Patch truth discarded the attempt because it did not produce a trustworthy code change.",

package/dist/vendor/core/persistence/memory-store.d.ts

@@ -0,0 +1,63 @@
+/**
+ * MartinLoop Memory Store
+ *
+ * Append-only, never-overwriting persistent memory. Records user consent
+ * signals, preferences, behavioral patterns, and learning outcomes so
+ * MartinLoop gets smarter with every session.
+ *
+ * Design principles:
+ * - Append-only JSONL — entries are never deleted or overwritten
+ * - Structured by kind — each memory entry has a type and a key
+ * - Source-aware — distinguishes explicit user input from inferred patterns
+ * - Confidence-scored — inferred memories degrade gracefully
+ *
+ * Storage: <runsRoot>/_martin/memory.jsonl
+ */
+export type MemoryKind = "consent" | "preference" | "pattern" | "feedback" | "budget" | "model";
+export interface MemoryEntry {
+    /** ISO-8601 timestamp */
+    timestamp: string;
+    /** What kind of memory this is */
+    kind: MemoryKind;
+    /** Dot-notated key, e.g. "model.direct.claude", "budget.auth.usd", "gate.bypassed" */
+    key: string;
+    /** The memory payload */
+    value: unknown;
+    /** Did the user say it explicitly, or did Martin observe it? */
+    source: "explicit" | "inferred";
+    /** Confidence score 0-1 — inferred memories should be < 0.8 */
+    confidence: number;
+}
+export interface MemorySummary {
+    totalEntries: number;
+    byKind: Partial<Record<MemoryKind, MemoryEntry[]>>;
+    recentPreferences: MemoryEntry[];
+    recentConsents: MemoryEntry[];
+    recentFeedback: MemoryEntry[];
+}
+/**
+ * Append a memory entry. Never overwrites — always appends.
+ */
+export declare function appendMemory(runsRoot: string, entry: MemoryEntry): Promise<void>;
+/**
+ * Read all memory entries in order (oldest first).
+ */
+export declare function readMemoryEntries(runsRoot: string): Promise<MemoryEntry[]>;
+/**
+ * Get the most recent memory entry for a specific key.
+ * Returns undefined if no entry exists for that key.
+ */
+export declare function getPreference(runsRoot: string, key: string): Promise<MemoryEntry | undefined>;
+/**
+ * Build a summary of memory entries for MCP resource and MartinLoop context injection.
+ * Returns the top 20 most recent entries per kind.
+ */
+export declare function buildMemorySummary(entries: MemoryEntry[]): MemorySummary;
+/**
+ * Record a preference from user input.
+ */
+export declare function recordPreference(runsRoot: string, key: string, value: unknown, source?: "explicit" | "inferred"): Promise<void>;
+/**
+ * Record a consent signal (user approved or denied a governance action).
+ */
+export declare function recordConsent(runsRoot: string, action: string, approved: boolean, context?: Record<string, unknown>): Promise<void>;

package/dist/vendor/core/persistence/memory-store.js

@@ -0,0 +1,115 @@
+/**
+ * MartinLoop Memory Store
+ *
+ * Append-only, never-overwriting persistent memory. Records user consent
+ * signals, preferences, behavioral patterns, and learning outcomes so
+ * MartinLoop gets smarter with every session.
+ *
+ * Design principles:
+ * - Append-only JSONL — entries are never deleted or overwritten
+ * - Structured by kind — each memory entry has a type and a key
+ * - Source-aware — distinguishes explicit user input from inferred patterns
+ * - Confidence-scored — inferred memories degrade gracefully
+ *
+ * Storage: <runsRoot>/_martin/memory.jsonl
+ */
+import { appendFile, mkdir, readFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+const MEMORY_DIRECTORY = "_martin";
+const MEMORY_FILENAME = "memory.jsonl";
+function resolveMemoryPath(runsRoot) {
+    return join(resolve(runsRoot), MEMORY_DIRECTORY, MEMORY_FILENAME);
+}
+/**
+ * Append a memory entry. Never overwrites — always appends.
+ */
+export async function appendMemory(runsRoot, entry) {
+    const memPath = resolveMemoryPath(runsRoot);
+    await mkdir(join(resolve(runsRoot), MEMORY_DIRECTORY), { recursive: true });
+    await appendFile(memPath, JSON.stringify(entry) + "\n", "utf8");
+}
+/**
+ * Read all memory entries in order (oldest first).
+ */
+export async function readMemoryEntries(runsRoot) {
+    const memPath = resolveMemoryPath(runsRoot);
+    try {
+        const raw = await readFile(memPath, "utf8");
+        return raw
+            .split("\n")
+            .filter((line) => line.trim().length > 0)
+            .map((line) => {
+            try {
+                return JSON.parse(line);
+            }
+            catch {
+                return null;
+            }
+        })
+            .filter((e) => e !== null);
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Get the most recent memory entry for a specific key.
+ * Returns undefined if no entry exists for that key.
+ */
+export async function getPreference(runsRoot, key) {
+    const entries = await readMemoryEntries(runsRoot);
+    // Return the most recent entry for this key (last in file)
+    const matches = entries.filter((e) => e.key === key);
+    return matches[matches.length - 1];
+}
+/**
+ * Build a summary of memory entries for MCP resource and MartinLoop context injection.
+ * Returns the top 20 most recent entries per kind.
+ */
+export function buildMemorySummary(entries) {
+    const byKind = {};
+    for (const entry of entries) {
+        if (!byKind[entry.kind]) {
+            byKind[entry.kind] = [];
+        }
+        byKind[entry.kind].push(entry);
+    }
+    // Keep only the 20 most recent per kind
+    for (const kind of Object.keys(byKind)) {
+        byKind[kind] = byKind[kind].slice(-20);
+    }
+    const recent = entries.slice(-50);
+    return {
+        totalEntries: entries.length,
+        byKind,
+        recentPreferences: recent.filter((e) => e.kind === "preference"),
+        recentConsents: recent.filter((e) => e.kind === "consent"),
+        recentFeedback: recent.filter((e) => e.kind === "feedback")
+    };
+}
+/**
+ * Record a preference from user input.
+ */
+export async function recordPreference(runsRoot, key, value, source = "explicit") {
+    await appendMemory(runsRoot, {
+        timestamp: new Date().toISOString(),
+        kind: "preference",
+        key,
+        value,
+        source,
+        confidence: source === "explicit" ? 1.0 : 0.6
+    });
+}
+/**
+ * Record a consent signal (user approved or denied a governance action).
+ */
+export async function recordConsent(runsRoot, action, approved, context) {
+    await appendMemory(runsRoot, {
+        timestamp: new Date().toISOString(),
+        kind: "consent",
+        key: `consent.${action}`,
+        value: { approved, context },
+        source: "explicit",
+        confidence: 1.0
+    });
+}

package/dist/vendor/core/persistence/store.js

@@ -4,6 +4,7 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 import { writeReceiptIntegrityMaterial } from "./integrity.js";
 // ─── FileRunStore implementation ─────────────────────────────────────────────
+const RUN_INDEX_FILENAME = "run-index.ndjson";
 export function resolveRunsRoot(env = process.env) {
     return env["MARTIN_RUNS_DIR"]?.trim() ??
         join(homedir(), ".martin", "runs");
@@ -84,6 +85,7 @@ export function createFileRunStore(options = {}) {
             const dir = runDir(runsRoot, runId);
             await mkdir(dir, { recursive: true });
             await writeJsonFile(join(dir, "loop-record.json"), loop);
+            await appendRunIndexRecord(runsRoot, loop);
             const ledgerRaw = await readFile(join(dir, "ledger.jsonl"), "utf8").catch(() => "");
             const ledgerEntries = ledgerRaw
                 .split(/\r?\n/u)
@@ -110,3 +112,14 @@ export function createFileRunStore(options = {}) {
 async function writeJsonFile(path, value) {
     await writeFile(path, `${JSON.stringify(value, null, 2)}\n`, "utf8");
 }
+async function appendRunIndexRecord(runsRoot, loop) {
+    const line = JSON.stringify({
+        loopId: loop.loopId,
+        workspaceId: loop.workspaceId,
+        projectId: loop.projectId,
+        status: loop.status,
+        lifecycleState: loop.lifecycleState,
+        updatedAt: loop.updatedAt
+    });
+    await appendFile(join(runsRoot, RUN_INDEX_FILENAME), `${line}\n`, "utf8");
+}

package/dist/vendor/core/persistence/trace-store.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Append-Only Trace Store
+ *
+ * Aggregates run data over time to build institutional memory. Every governed
+ * run's routing decision, cost, failure class, and outcome is appended to a
+ * local JSONL trace file. Data is NEVER overwritten — only appended.
+ *
+ * The trace store feeds:
+ * - classifyRoute() with historicalDirectSuccessRate from real past runs
+ * - Cost prediction models with actual spend data
+ * - Failure pattern detection across runs
+ * - Team analytics and optimization recommendations
+ *
+ * Storage: `<runsRoot>/_martin/trace-log.jsonl` (one JSON object per line)
+ */
+export interface TraceEntry {
+    /** ISO-8601 timestamp */
+    timestamp: string;
+    /** Unique loop identifier */
+    loopId: string;
+    /** The objective that was governed */
+    objective: string;
+    /** Which engine executed the run */
+    engine: string;
+    /** Route selected by classifyRoute */
+    selectedRoute: "direct" | "manager" | "consensus";
+    /** Route classifier confidence (0-1) */
+    routeConfidence: number;
+    /** Budget allocated (USD) */
+    budgetUsd: number;
+    /** Actual spend (USD) */
+    actualCostUsd: number;
+    /** Pre-work burn percentage */
+    preWorkBurnPct: number;
+    /** Number of attempts */
+    attempts: number;
+    /** Final loop status */
+    status: string;
+    /** Final lifecycle state */
+    lifecycleState: string;
+    /** Failure class of last attempt (if failed) */
+    failureClass?: string;
+    /** Whether verification passed */
+    verificationPassed: boolean;
+    /** Number of files changed */
+    filesChanged: number;
+    /** Working directory (hashed for privacy) */
+    workspaceHash: string;
+}
+export interface TraceAggregation {
+    totalRuns: number;
+    directRuns: number;
+    managerRuns: number;
+    consensusRuns: number;
+    directSuccessRate: number;
+    managerSuccessRate: number;
+    averageCostUsd: number;
+    averagePreWorkBurnPct: number;
+    totalSpendUsd: number;
+    totalSavedUsd: number;
+    topFailureClasses: Array<{
+        failureClass: string;
+        count: number;
+    }>;
+    averageAttemptsPerRun: number;
+    lastUpdated: string;
+}
+/**
+ * Append a trace entry to the local trace store. Never overwrites.
+ */
+export declare function appendTraceEntry(runsRoot: string, entry: TraceEntry): Promise<void>;
+/**
+ * Read all trace entries from the local trace store.
+ */
+export declare function readTraceEntries(runsRoot: string): Promise<TraceEntry[]>;
+/**
+ * Aggregate trace entries into summary statistics.
+ * Used by classifyRoute() to get historicalDirectSuccessRate.
+ */
+export declare function aggregateTraces(entries: TraceEntry[]): TraceAggregation;
+/**
+ * Get the historical direct success rate for use in route classification.
+ * Returns undefined if insufficient data (< 5 runs).
+ */
+export declare function getHistoricalDirectSuccessRate(runsRoot: string): Promise<number | undefined>;