@martinloop/mcp 0.3.5 → 0.3.7

package/dist/vendor/core/index.js

@@ -13,7 +13,11 @@ export { createLocalIdentityAuthority, hasIdentityScope, issueIdentityToken, ver
 export { compileExecutionPolicy } from "./policy-compiler.js";
 export { assessTrajectory, decideCircuitBreak } from "./trajectory.js";
 // ─── Routing economics ─────────────────────────────────────────────────────
-export { classifyRoute, evaluatePreworkBurnPolicy } from "./routing.js";
+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 ──────────────────────────────────────────────────
@@ -21,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.
@@ -178,7 +186,6 @@ export async function runMartin(input) {
     let currentAdapterIndex = 0;
     let currentAdapter = adapterChain[currentAdapterIndex] ?? input.adapter;
     let useCompressedContext = false;
-    const isVerifyOnly = input.task.mutationMode === "verify_only";
     const executionProfile = resolveExecutionProfile({
         executionProfile: input.task.executionProfile,
         allowedNetworkDomains: input.task.allowedNetworkDomains
@@ -676,93 +683,7 @@ export async function runMartin(input) {
         // a git repo) and silently return [], which would falsely trigger no_code_change.
         const changedFileEvidenceAvailable = result.execution?.changedFiles !== undefined || changedFiles.length > 0;
         const isVerifierOnlyAdapter = executingAdapter.adapterId === "direct:verifier:verify-only";
-        const patchTruthCountsEdits = !isVerifyOnly && !isVerifierOnlyAdapter && changedFileEvidenceAvailable;
-        if (isVerifyOnly && changedFiles.length > 0) {
-            const patchDecision = evaluatePatchDecision({
-                verificationPassed: verification.passed,
-                previousVerifierScore,
-                verifierScore: verification.passed ? 1 : 0,
-                scopeViolationCount: changedFiles.length,
-                changedFileCount: changedFiles.length,
-                diffNovelty: 1,
-                diffStats: result.execution?.diffStats,
-                costUsd: getUsageUsd(result.usage),
-                summary: result.summary
-            });
-            const verifyOnlyExitDecision = {
-                shouldExit: true,
-                lifecycleState: "human_escalation",
-                status: "exited",
-                reason: "Verify-only mode forbids file changes.",
-                failureClass: "safety_leash_blocked",
-                safetySurface: "filesystem",
-                reasonCode: "verify_only_write_attempt"
-            };
-            const rollbackOutcome = await restoreRollbackBoundary({
-                repoRoot: request.context.repoRoot,
-                boundary: rollbackBoundary,
-                restoredAt: attemptCompletedAt,
-                decision: patchDecision.decision
-            });
-            if (input.store) {
-                const verifyOnlyViolation = {
-                    kind: "path_not_allowed",
-                    message: `Verify-only mode forbids changed files: ${changedFiles.join(", ")}`,
-                    file: changedFiles[0]
-                };
-                await input.store.writeAttemptArtifacts(loop.loopId, currentAttemptIndex, {
-                    compiledContext,
-                    leash: createLeashArtifact({
-                        surface: "filesystem",
-                        reason: verifyOnlyExitDecision.reason,
-                        violations: [verifyOnlyViolation]
-                    }, currentAttemptIndex),
-                    patchScore: patchDecision.score,
-                    patchDecision: toPatchDecisionArtifact(patchDecision),
-                    ...(rollbackBoundary ? { rollbackBoundary } : {}),
-                    ...(rollbackOutcome ? { rollbackOutcome } : {})
-                });
-                await input.store.appendLedger(loop.loopId, makeLedgerEvent({
-                    kind: "safety.violations_found",
-                    runId: loop.loopId,
-                    attemptIndex: currentAttemptIndex,
-                    payload: {
-                        surface: "filesystem",
-                        blocked: true,
-                        attemptIndex: currentAttemptIndex,
-                        violations: [
-                            {
-                                kind: "path_not_allowed",
-                                message: verifyOnlyExitDecision.reason,
-                                files: changedFiles
-                            }
-                        ]
-                    }
-                }));
-                await input.store.appendLedger(loop.loopId, makeLedgerEvent({
-                    kind: "attempt.discarded",
-                    runId: loop.loopId,
-                    attemptIndex: currentAttemptIndex,
-                    payload: {
-                        decision: patchDecision.decision,
-                        reason: patchDecision.summary,
-                        reasonCodes: patchDecision.reasonCodes,
-                        score: patchDecision.score.score
-                    }
-                }));
-                await input.store.appendLedger(loop.loopId, makeLedgerEvent({
-                    kind: "run.exited",
-                    runId: loop.loopId,
-                    payload: createRunExitPayload(verifyOnlyExitDecision)
-                }));
-            }
-            const finalizedLoop = finalizeLoop(loop, verifyOnlyExitDecision, now(), idFactory);
-            await persistLoopRecordIfSupported(input.store, finalizedLoop);
-            return {
-                loop: finalizedLoop,
-                decision: verifyOnlyExitDecision
-            };
-        }
+        const patchTruthCountsEdits = !isVerifierOnlyAdapter && changedFileEvidenceAvailable;
         const filesystemDecision = evaluateFilesystemLeash({
             repoRoot: request.context.repoRoot,
             changedFiles,
@@ -1009,7 +930,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,
@@ -1403,7 +1324,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",
@@ -1445,6 +1378,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/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>;

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

@@ -0,0 +1,125 @@
+/**
+ * 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)
+ */
+import { appendFile, mkdir, readFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+const TRACE_DIRECTORY = "_martin";
+const TRACE_FILENAME = "trace-log.jsonl";
+function resolveTracePath(runsRoot) {
+    return join(resolve(runsRoot), TRACE_DIRECTORY, TRACE_FILENAME);
+}
+/**
+ * Append a trace entry to the local trace store. Never overwrites.
+ */
+export async function appendTraceEntry(runsRoot, entry) {
+    const tracePath = resolveTracePath(runsRoot);
+    await mkdir(join(resolve(runsRoot), TRACE_DIRECTORY), { recursive: true });
+    const line = JSON.stringify(entry) + "\n";
+    await appendFile(tracePath, line, "utf8");
+}
+/**
+ * Read all trace entries from the local trace store.
+ */
+export async function readTraceEntries(runsRoot) {
+    const tracePath = resolveTracePath(runsRoot);
+    try {
+        const raw = await readFile(tracePath, "utf8");
+        return raw
+            .split("\n")
+            .filter((line) => line.trim().length > 0)
+            .map((line) => {
+            try {
+                return JSON.parse(line);
+            }
+            catch {
+                return null;
+            }
+        })
+            .filter((entry) => entry !== null);
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Aggregate trace entries into summary statistics.
+ * Used by classifyRoute() to get historicalDirectSuccessRate.
+ */
+export function aggregateTraces(entries) {
+    if (entries.length === 0) {
+        return {
+            totalRuns: 0,
+            directRuns: 0,
+            managerRuns: 0,
+            consensusRuns: 0,
+            directSuccessRate: 0,
+            managerSuccessRate: 0,
+            averageCostUsd: 0,
+            averagePreWorkBurnPct: 0,
+            totalSpendUsd: 0,
+            totalSavedUsd: 0,
+            topFailureClasses: [],
+            averageAttemptsPerRun: 0,
+            lastUpdated: new Date().toISOString()
+        };
+    }
+    const direct = entries.filter((e) => e.selectedRoute === "direct");
+    const manager = entries.filter((e) => e.selectedRoute === "manager");
+    const consensus = entries.filter((e) => e.selectedRoute === "consensus");
+    const directSuccesses = direct.filter((e) => e.status === "completed" && e.verificationPassed);
+    const managerSuccesses = manager.filter((e) => e.status === "completed" && e.verificationPassed);
+    const totalCost = entries.reduce((sum, e) => sum + e.actualCostUsd, 0);
+    const totalBudget = entries.reduce((sum, e) => sum + e.budgetUsd, 0);
+    const totalAttempts = entries.reduce((sum, e) => sum + e.attempts, 0);
+    const totalBurnPct = entries.reduce((sum, e) => sum + e.preWorkBurnPct, 0);
+    // Count failure classes
+    const failureCounts = new Map();
+    for (const entry of entries) {
+        if (entry.failureClass) {
+            failureCounts.set(entry.failureClass, (failureCounts.get(entry.failureClass) ?? 0) + 1);
+        }
+    }
+    const topFailureClasses = [...failureCounts.entries()]
+        .map(([failureClass, count]) => ({ failureClass, count }))
+        .sort((a, b) => b.count - a.count)
+        .slice(0, 10);
+    return {
+        totalRuns: entries.length,
+        directRuns: direct.length,
+        managerRuns: manager.length,
+        consensusRuns: consensus.length,
+        directSuccessRate: direct.length > 0 ? directSuccesses.length / direct.length : 0,
+        managerSuccessRate: manager.length > 0 ? managerSuccesses.length / manager.length : 0,
+        averageCostUsd: Math.round((totalCost / entries.length) * 100) / 100,
+        averagePreWorkBurnPct: Math.round(totalBurnPct / entries.length),
+        totalSpendUsd: Math.round(totalCost * 100) / 100,
+        totalSavedUsd: Math.round((totalBudget - totalCost) * 100) / 100,
+        topFailureClasses,
+        averageAttemptsPerRun: Math.round((totalAttempts / entries.length) * 10) / 10,
+        lastUpdated: entries[entries.length - 1]?.timestamp ?? new Date().toISOString()
+    };
+}
+/**
+ * Get the historical direct success rate for use in route classification.
+ * Returns undefined if insufficient data (< 5 runs).
+ */
+export async function getHistoricalDirectSuccessRate(runsRoot) {
+    const entries = await readTraceEntries(runsRoot);
+    const directRuns = entries.filter((e) => e.selectedRoute === "direct");
+    if (directRuns.length < 5)
+        return undefined;
+    const successes = directRuns.filter((e) => e.status === "completed" && e.verificationPassed);
+    return successes.length / directRuns.length;
+}

package/dist/vendor/core/repo-analyzer.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Repo Style Analyzer
+ *
+ * Scans a repository to detect coding conventions, patterns, and style
+ * so that governed agent runs produce code matching the existing codebase.
+ *
+ * Detects:
+ * - Naming conventions (camelCase, snake_case, PascalCase, kebab-case)
+ * - Test framework (Vitest, Jest, Mocha, node:test)
+ * - Package manager (pnpm, npm, yarn, bun)
+ * - Module system (ESM, CJS, mixed)
+ * - File organization pattern (feature folders, type folders, flat)
+ * - TypeScript strictness level
+ * - Comment density
+ * - Formatting (tabs vs spaces, semicolons, quotes)
+ */
+export interface RepoStyleProfile {
+    /** Detected package manager */
+    packageManager: "pnpm" | "npm" | "yarn" | "bun" | "unknown";
+    /** Detected module system */
+    moduleSystem: "esm" | "cjs" | "mixed" | "unknown";
+    /** Detected test framework */
+    testFramework: "vitest" | "jest" | "mocha" | "node-test" | "unknown";
+    /** Primary language */
+    language: "typescript" | "javascript" | "mixed";
+    /** TypeScript strict mode enabled */
+    typescriptStrict: boolean;
+    /** Dominant naming convention for files */
+    fileNaming: "kebab-case" | "camelCase" | "PascalCase" | "snake_case" | "mixed";
+    /** Dominant naming convention for variables/functions */
+    codeNaming: "camelCase" | "snake_case" | "mixed";
+    /** Uses semicolons */
+    semicolons: boolean;
+    /** Single vs double quotes */
+    quotes: "single" | "double" | "mixed";
+    /** Indentation style */
+    indentation: "tabs" | "2-spaces" | "4-spaces" | "mixed";
+    /** Average lines per file (source files) */
+    avgLinesPerFile: number;
+    /** File organization pattern */
+    organization: "feature-folders" | "type-folders" | "flat" | "mixed";
+    /** Raw signals for prompt injection */
+    promptDirectives: string[];
+}
+/**
+ * Analyze a repository and return a style profile.
+ */
+export declare function analyzeRepoStyle(rootDir: string): RepoStyleProfile;
+/**
+ * Build prompt directives from the style profile.
+ * These get injected into the agent's prompt to match repo conventions.
+ */
+export declare function buildPromptDirectives(profile: RepoStyleProfile): string[];