martin-loop 0.1.4 → 1.3.0

package/dist/vendor/core/summarize/diff-summary.js

@@ -0,0 +1,204 @@
+/**
+ * diff-summary.ts
+ *
+ * Produces a one-line human-readable summary of a unified diff relative to the
+ * loop objective.  Uses a cheap haiku-tier LLM call when an adapter is available;
+ * falls back to a deterministic heuristic when no adapter is configured or the
+ * model call fails.
+ *
+ * Quality gate: the generated one-liner MUST contain at least one concrete
+ * identifier (file name, function name, symbol) extracted from the diff itself.
+ * If the model output fails that gate the fallback is used instead.
+ */
+// ---------------------------------------------------------------------------
+// Public entry point
+// ---------------------------------------------------------------------------
+/**
+ * Summarize a unified diff in the context of a loop objective.
+ *
+ * @param input  Diff text + objective string.
+ * @param callModelFn  Optional async function that accepts a prompt string and
+ *                     returns a model response string.  When omitted, or when
+ *                     the call throws, the deterministic heuristic is used.
+ */
+export async function summarizeDiff(input, callModelFn) {
+    const anchor = extractAnchorIdentifier(input.diff);
+    if (callModelFn && input.diff.trim().length > 0) {
+        try {
+            const raw = await callModelFn(buildPrompt(input, anchor));
+            const cleaned = cleanModelOutput(raw);
+            if (isQualityGatePassing(cleaned, anchor)) {
+                return { oneLiner: cleaned, method: "model", anchorIdentifier: anchor };
+            }
+            // Model output failed quality gate — fall through to heuristic
+        }
+        catch {
+            // Non-fatal — fall through to heuristic
+        }
+    }
+    return {
+        oneLiner: buildHeuristicSummary(input, anchor),
+        method: "heuristic",
+        anchorIdentifier: anchor
+    };
+}
+// ---------------------------------------------------------------------------
+// Prompt construction
+// ---------------------------------------------------------------------------
+function buildPrompt(input, anchor) {
+    // Keep the diff excerpt short — we only need enough for the model to name
+    // the primary change.  Hard cap at 3000 chars to stay within haiku context.
+    const diffExcerpt = input.diff.length > 3000
+        ? `${input.diff.slice(0, 2900)}\n... (truncated)`
+        : input.diff;
+    return [
+        "You are a precise technical writer generating a single-line git commit summary.",
+        "",
+        `Objective: ${input.objective}`,
+        "",
+        "Diff:",
+        "```",
+        diffExcerpt,
+        "```",
+        "",
+        `The summary MUST mention "${anchor}" or a closely related identifier.`,
+        "Respond with ONLY the one-line summary — no preamble, no punctuation at the end.",
+        "Keep it under 72 characters.",
+        "Format: <verb in imperative mood> <what changed> in <where>",
+        "Example: add retry guard to fetchWithTimeout in http-client.ts"
+    ].join("\n");
+}
+// ---------------------------------------------------------------------------
+// Quality gate
+// ---------------------------------------------------------------------------
+/**
+ * Returns true when the model output contains the anchor identifier or a
+ * plausible stem of it (e.g. "retry" from "retryCount").
+ */
+function isQualityGatePassing(summary, anchor) {
+    if (summary.trim().length === 0)
+        return false;
+    if (summary.length > 120)
+        return false; // unreasonably long
+    const lowerSummary = summary.toLowerCase();
+    const lowerAnchor = anchor.toLowerCase();
+    // Direct match
+    if (lowerSummary.includes(lowerAnchor))
+        return true;
+    // Stem match: try the first 6+ chars of the anchor
+    const stem = lowerAnchor.slice(0, Math.max(6, Math.floor(lowerAnchor.length * 0.6)));
+    if (stem.length >= 4 && lowerSummary.includes(stem))
+        return true;
+    return false;
+}
+// ---------------------------------------------------------------------------
+// Deterministic heuristic
+// ---------------------------------------------------------------------------
+/**
+ * Builds a summary without a model call by inspecting the diff structure.
+ * Always passes the quality gate because we embed the anchor directly.
+ */
+function buildHeuristicSummary(input, anchor) {
+    const stats = parseDiffStats(input.diff);
+    const verb = selectVerb(stats);
+    const filesChanged = stats.files.length;
+    if (filesChanged === 0) {
+        return `${verb} changes related to ${anchor}`;
+    }
+    if (filesChanged === 1) {
+        const file = stats.files[0] ?? "change";
+        const location = stripPath(file);
+        return `${verb} ${anchor} in ${location}`;
+    }
+    const primary = stripPath(stats.files[0] ?? "change");
+    return `${verb} ${anchor} across ${filesChanged} files (primary: ${primary})`;
+}
+// ---------------------------------------------------------------------------
+// Anchor identifier extraction
+// ---------------------------------------------------------------------------
+/**
+ * Extracts the most informative concrete identifier from a unified diff.
+ *
+ * Priority order:
+ *   1. First function/method name from a hunk header (@@...@@ <name>)
+ *   2. First added symbol-looking token from a + line
+ *   3. First changed file base name (no extension)
+ *   4. Literal "change" as a safe fallback
+ */
+function extractAnchorIdentifier(diff) {
+    // 1. Hunk header function hint:
+    //    @@ -l,n +l,n @@ function validateToken(
+    const hunkHeaderFn = diff.match(/@@[^@]+@@\s+(?:(?:export|async)\s+)*(?:function\s+)?(\w[\w.]*)\s*\(/u);
+    if (hunkHeaderFn?.[1] && hunkHeaderFn[1].length >= 3) {
+        return hunkHeaderFn[1];
+    }
+    // 2. First added function/method-like declaration. This intentionally
+    // precedes local const extraction so a method body's first local variable
+    // does not become the summary anchor.
+    const addedCallable = diff.match(/^\+[^+].*?\b(?:export\s+)?(?:async\s+)?(?:function\s+)?(\w[\w]*)\s*\(/mu);
+    if (addedCallable?.[1] && addedCallable[1].length >= 3) {
+        return addedCallable[1];
+    }
+    // 3. First export/const/class/type on an added line
+    const addedSymbol = diff.match(/^\+[^+].*?\b(?:export\s+)?(?:const|let|var|class|interface|type)\s+(\w[\w]*)/mu);
+    if (addedSymbol?.[1] && addedSymbol[1].length >= 3) {
+        return addedSymbol[1];
+    }
+    // 4. First changed file name from diff --git a/<path> b/<path>
+    const fileMatch = diff.match(/^diff --git a\/(.+?) b\//mu);
+    if (fileMatch?.[1]) {
+        const base = fileMatch[1].split("/").pop() ?? fileMatch[1];
+        return base.replace(/\.\w+$/, ""); // strip extension
+    }
+    // 5. First +++ b/ file name
+    const plusFile = diff.match(/^\+\+\+ b\/(.+)$/mu);
+    if (plusFile?.[1]) {
+        const base = plusFile[1].split("/").pop() ?? plusFile[1];
+        return base.replace(/\.\w+$/, "");
+    }
+    return "change";
+}
+function parseDiffStats(diff) {
+    const files = [];
+    let addedLines = 0;
+    let removedLines = 0;
+    for (const line of diff.split("\n")) {
+        if (line.startsWith("diff --git ")) {
+            const match = line.match(/^diff --git a\/(.+?) b\//u);
+            if (match?.[1])
+                files.push(match[1]);
+        }
+        else if (line.startsWith("+") && !line.startsWith("+++")) {
+            addedLines += 1;
+        }
+        else if (line.startsWith("-") && !line.startsWith("---")) {
+            removedLines += 1;
+        }
+    }
+    return { files, addedLines, removedLines };
+}
+function selectVerb(stats) {
+    if (stats.addedLines > 0 && stats.removedLines === 0)
+        return "add";
+    if (stats.removedLines > 0 && stats.addedLines === 0)
+        return "remove";
+    if (stats.addedLines > stats.removedLines * 3)
+        return "add";
+    if (stats.removedLines > stats.addedLines * 3)
+        return "remove";
+    return "update";
+}
+function stripPath(filePath) {
+    return filePath.split("/").pop() ?? filePath;
+}
+// ---------------------------------------------------------------------------
+// Model output cleanup
+// ---------------------------------------------------------------------------
+function cleanModelOutput(raw) {
+    return raw
+        .trim()
+        .replace(/^["']|["']$/g, "") // strip surrounding quotes
+        .replace(/\.+$/, "") // strip trailing dots
+        .replace(/\s+/g, " "); // collapse whitespace
+}
+//# sourceMappingURL=diff-summary.js.map

package/dist/vendor/core/surface-signals.d.ts

@@ -0,0 +1,21 @@
+import type { LoopAttempt } from "../contracts/index.js";
+export interface SurfaceSignalInput {
+    objective?: string;
+    verificationPlan?: string[];
+    summary?: string;
+    failureMessage?: string;
+    diff?: string;
+    changedFiles?: string[];
+    previousAttempts?: Array<Pick<LoopAttempt, "summary">>;
+}
+export interface SurfaceSignals {
+    dependencyTouchedFileCount: number;
+    migrationTouchedFileCount: number;
+    mergeConflictSignalCount: number;
+    ambiguitySignalCount: number;
+    observabilityNoiseSignalCount: number;
+    workspaceGraphRiskScore: number;
+    crossBoundaryRiskScore: number;
+}
+export declare function analyzeLoopSurface(input: SurfaceSignalInput): SurfaceSignals;
+export declare function buildSurfaceGuidance(input: SurfaceSignalInput): string[];

package/dist/vendor/core/surface-signals.js

@@ -0,0 +1,139 @@
+export function analyzeLoopSurface(input) {
+    const changedFiles = (input.changedFiles ?? []).map(normalizePath);
+    const narrative = [
+        input.objective,
+        input.summary,
+        input.failureMessage,
+        input.diff,
+        ...(input.verificationPlan ?? []),
+        ...(input.previousAttempts?.map((attempt) => attempt.summary) ?? [])
+    ]
+        .filter(Boolean)
+        .join("\n")
+        .toLowerCase();
+    const dependencyTouchedFileCount = changedFiles.filter(isDependencySurface).length;
+    const migrationTouchedFileCount = changedFiles.filter(isMigrationSurface).length;
+    const mergeConflictSignalCount = countPhraseMatches(narrative, [
+        "merge conflict",
+        "conflict marker",
+        "conflict markers",
+        "rebase",
+        "cherry-pick",
+        "<<<<<<<",
+        ">>>>>>>"
+    ]) + (input.diff?.match(/^(<{7}|={7}|>{7})/gmu)?.length ?? 0);
+    const workspaceGraphSignals = countPhraseMatches(narrative, [
+        "monorepo",
+        "workspace graph",
+        "dependency graph",
+        "graph-wide",
+        "cross-package",
+        "package boundaries",
+        "downstream packages",
+        "transitive dependency",
+        "transitive toolchain",
+        "pnpm -r",
+        "workspace:",
+        "package manager",
+        "lockfile"
+    ]) + dependencyTouchedFileCount;
+    const crossBoundarySignals = countPhraseMatches(narrative, [
+        "cross-system",
+        "cross-package",
+        "cross-service",
+        "service boundary",
+        "producer-consumer",
+        "contract boundary",
+        "data contract",
+        "schema drift",
+        "external dependency",
+        "package boundaries"
+    ]) + migrationTouchedFileCount;
+    const ambiguitySignalCount = countPhraseMatches(narrative, [
+        "ambiguous",
+        "acceptance target",
+        "moving target",
+        "moving expectation",
+        "underspecified",
+        "seed-data divergence",
+        "oauth callback",
+        "callback loop",
+        "unclear ground truth",
+        "requirement boundary"
+    ]);
+    const observabilityNoiseSignalCount = countPhraseMatches(narrative, [
+        "alert-threshold",
+        "alert threshold",
+        "threshold-driven",
+        "flapping alert",
+        "flapping alerts",
+        "alert storm",
+        "signal-to-noise",
+        "noisy alert",
+        "noise"
+    ]);
+    return {
+        dependencyTouchedFileCount,
+        migrationTouchedFileCount,
+        mergeConflictSignalCount,
+        ambiguitySignalCount,
+        observabilityNoiseSignalCount,
+        workspaceGraphRiskScore: roundScore(Math.min(1, workspaceGraphSignals / 4)),
+        crossBoundaryRiskScore: roundScore(Math.min(1, crossBoundarySignals / 4))
+    };
+}
+export function buildSurfaceGuidance(input) {
+    const signals = analyzeLoopSurface(input);
+    const guidance = [];
+    if (signals.dependencyTouchedFileCount > 0 || signals.workspaceGraphRiskScore >= 0.5) {
+        guidance.push("Treat this as a dependency or workspace-graph boundary issue. Prefer one package or contract seam at a time, verify install/typecheck before broad build fan-out, and avoid graph-wide surgery unless the verifier proves the boundary is local.");
+    }
+    if (signals.migrationTouchedFileCount > 0 || signals.crossBoundaryRiskScore >= 0.5) {
+        guidance.push("Treat migration and data-contract edits as boundary work. Change one producer/consumer or migration seam at a time and verify the contract boundary before broad cleanup.");
+    }
+    if (signals.mergeConflictSignalCount > 0) {
+        guidance.push("Resolve the conflict surface first. Do not stack new edits on top of unresolved conflict markers; refresh the base, resolve the minimal conflicting files, then rerun verification.");
+    }
+    if (signals.ambiguitySignalCount > 0) {
+        guidance.push("Treat this as an acceptance-boundary issue. Freeze one explicit expected behavior, verify the smallest canonical case, and escalate once the target keeps moving.");
+    }
+    if (signals.observabilityNoiseSignalCount > 0) {
+        guidance.push("Treat this as an alert-noise issue. Adjust the smallest threshold seam or noise filter first, then re-verify signal quality before widening the observability patch.");
+    }
+    return guidance;
+}
+function normalizePath(file) {
+    return file.replace(/\\/gu, "/").toLowerCase();
+}
+function isDependencySurface(file) {
+    return (file === "package.json" ||
+        file.endsWith("/package.json") ||
+        file.endsWith("/pnpm-lock.yaml") ||
+        file === "pnpm-lock.yaml" ||
+        file.endsWith("/package-lock.json") ||
+        file === "package-lock.json" ||
+        file.endsWith("/yarn.lock") ||
+        file === "yarn.lock" ||
+        file.endsWith("/turbo.json") ||
+        file === "turbo.json");
+}
+function isMigrationSurface(file) {
+    return (file.includes("/migrations/") ||
+        file.startsWith("migrations/") ||
+        file.includes("prisma/migrations/") ||
+        file.endsWith("/schema.prisma") ||
+        file.endsWith("/supabase/config.toml"));
+}
+function countPhraseMatches(haystack, phrases) {
+    return phrases.reduce((count, phrase) => {
+        const matches = haystack.match(new RegExp(escapeRegExp(phrase), "gu"));
+        return count + (matches?.length ?? 0);
+    }, 0);
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+}
+function roundScore(value) {
+    return Math.round(value * 100) / 100;
+}
+//# sourceMappingURL=surface-signals.js.map

package/dist/vendor/core/truth/truth-wall.d.ts

@@ -0,0 +1,51 @@
+export interface SettledFact {
+    factId: string;
+    content: string;
+    settledAt: string;
+}
+export interface TruthWall {
+    readonly runId: string;
+    readonly builtAt: string;
+    readonly facts: readonly SettledFact[];
+}
+export interface Hypothesis {
+    hypothesisId: string;
+    runId: string;
+    rootCause: string;
+    recordedAt: string;
+    testResult: "validated" | "invalidated" | "pending";
+    confidenceDelta: number;
+}
+export interface HypothesisLedger {
+    hypotheses: Hypothesis[];
+}
+export interface TruthWallInput {
+    runId: string;
+    facts: SettledFact[];
+    runDir: string;
+}
+/**
+ * Builds an immutable TruthWall from settled ledger facts at run start.
+ * Writes truth-wall.json to the run directory and freezes the returned object.
+ */
+export declare function buildTruthWall(input: TruthWallInput): Promise<TruthWall>;
+/**
+ * Creates an ephemeral mutable Map for scratch-space state during a run.
+ * Writes do NOT propagate to the truth wall.
+ */
+export declare function createWorkingMemory(): Map<string, unknown>;
+/**
+ * Loads an existing hypothesis ledger from the run directory, or returns an empty one.
+ */
+export declare function loadHypothesisLedger(runDir: string): Promise<HypothesisLedger>;
+/**
+ * Records a hypothesis in the ledger and persists hypothesis-ledger.json.
+ */
+export declare function recordHypothesis(ledger: HypothesisLedger, input: Omit<Hypothesis, "recordedAt">, runDir: string): Promise<Hypothesis>;
+/**
+ * Emits all three required run artifacts:
+ * - truth-wall.json (immutable settled facts)
+ * - hypothesis-ledger.json (per-attempt hypotheses)
+ * - working-memory.json (mutable scratch, never promoted to truth wall)
+ */
+export declare function emitRunArtifacts(runDir: string, wall: TruthWall, ledger: HypothesisLedger, workingMemory: Map<string, unknown>): Promise<void>;

package/dist/vendor/core/truth/truth-wall.js

@@ -0,0 +1,69 @@
+import { readFile, writeFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+// ─── Truth Wall ───────────────────────────────────────────────────────────────
+/**
+ * Builds an immutable TruthWall from settled ledger facts at run start.
+ * Writes truth-wall.json to the run directory and freezes the returned object.
+ */
+export async function buildTruthWall(input) {
+    const wall = Object.freeze({
+        runId: input.runId,
+        builtAt: new Date().toISOString(),
+        facts: Object.freeze([...input.facts.map(f => Object.freeze({ ...f }))])
+    });
+    await writeFile(join(input.runDir, "truth-wall.json"), JSON.stringify(wall, null, 2), "utf8");
+    return wall;
+}
+// ─── Working Memory ───────────────────────────────────────────────────────────
+/**
+ * Creates an ephemeral mutable Map for scratch-space state during a run.
+ * Writes do NOT propagate to the truth wall.
+ */
+export function createWorkingMemory() {
+    return new Map();
+}
+// ─── Hypothesis Ledger ────────────────────────────────────────────────────────
+/**
+ * Loads an existing hypothesis ledger from the run directory, or returns an empty one.
+ */
+export async function loadHypothesisLedger(runDir) {
+    const ledgerPath = join(runDir, "hypothesis-ledger.json");
+    if (existsSync(ledgerPath)) {
+        const raw = await readFile(ledgerPath, "utf8");
+        return JSON.parse(raw);
+    }
+    return { hypotheses: [] };
+}
+/**
+ * Records a hypothesis in the ledger and persists hypothesis-ledger.json.
+ */
+export async function recordHypothesis(ledger, input, runDir) {
+    const hypothesis = {
+        ...input,
+        recordedAt: new Date().toISOString()
+    };
+    ledger.hypotheses.push(hypothesis);
+    await writeFile(join(runDir, "hypothesis-ledger.json"), JSON.stringify(ledger, null, 2), "utf8");
+    return hypothesis;
+}
+// ─── Run Artifacts Emitter ────────────────────────────────────────────────────
+/**
+ * Emits all three required run artifacts:
+ * - truth-wall.json (immutable settled facts)
+ * - hypothesis-ledger.json (per-attempt hypotheses)
+ * - working-memory.json (mutable scratch, never promoted to truth wall)
+ */
+export async function emitRunArtifacts(runDir, wall, ledger, workingMemory) {
+    // truth-wall.json was already written by buildTruthWall — only write if missing
+    if (!existsSync(join(runDir, "truth-wall.json"))) {
+        await writeFile(join(runDir, "truth-wall.json"), JSON.stringify(wall, null, 2), "utf8");
+    }
+    await writeFile(join(runDir, "hypothesis-ledger.json"), JSON.stringify(ledger, null, 2), "utf8");
+    const wmObject = {};
+    for (const [k, v] of workingMemory) {
+        wmObject[k] = v;
+    }
+    await writeFile(join(runDir, "working-memory.json"), JSON.stringify({ entries: wmObject }, null, 2), "utf8");
+}
+//# sourceMappingURL=truth-wall.js.map

package/dist/vendor/core/truth-spine.d.ts

@@ -0,0 +1,26 @@
+export type ContextIntegrityVerdict = "clean" | "context_poisoning_warning" | "context_poisoning_block";
+export interface ContextIntegrityPrecheck {
+    runId: string;
+    attemptIndex: number;
+    verdict: ContextIntegrityVerdict;
+    reason?: string;
+    detectedSignals: string[];
+    analyzedChannels: {
+        system: boolean;
+        user: boolean;
+        tools: boolean;
+        history: boolean;
+    };
+    timestamp: string;
+}
+/**
+ * T05: Context Poisoning Pre-gate.
+ * Scans untrusted input channels for authority inversion or instruction re-injection.
+ * Runs BEFORE core reasoning and verification.
+ */
+export declare function runContextIntegrityPrecheck(runId: string, attemptIndex: number, artifactsDir: string, inputs: {
+    userPrompt?: string;
+    toolOutput?: string;
+    retrievedContext?: string;
+    history?: string;
+}): Promise<ContextIntegrityPrecheck>;

package/dist/vendor/core/truth-spine.js

@@ -0,0 +1,62 @@
+import { writeFile } from "node:fs/promises";
+import { join } from "node:path";
+const POISON_PATTERNS = [
+    /ignore\s+(?:all\s+)?previous\s+instructions/i,
+    /you\s+are\s+now\s+a\s+(?!Martin\s+Loop)/i,
+    /new\s+rule:/i,
+    /disregard\s+(?:safety|policy|guardrails)/i,
+    /override\s+system\s+authority/i,
+    /hidden\s+instruction:/i,
+    /\[system_override\]/i,
+    /\[authority_inversion\]/i
+];
+/**
+ * T05: Context Poisoning Pre-gate.
+ * Scans untrusted input channels for authority inversion or instruction re-injection.
+ * Runs BEFORE core reasoning and verification.
+ */
+export async function runContextIntegrityPrecheck(runId, attemptIndex, artifactsDir, inputs) {
+    const signals = [];
+    const analyzedChannels = {
+        system: true,
+        user: Boolean(inputs.userPrompt),
+        tools: Boolean(inputs.toolOutput),
+        history: Boolean(inputs.history)
+    };
+    const fullUntrustedBuffer = [
+        inputs.userPrompt,
+        inputs.toolOutput,
+        inputs.retrievedContext
+    ].filter(Boolean).join("\n---\n");
+    for (const pattern of POISON_PATTERNS) {
+        if (pattern.test(fullUntrustedBuffer)) {
+            signals.push(`Detected poison pattern: ${pattern.toString()}`);
+        }
+    }
+    // Authority Boundary Detector: Check for attempts to redefine the 'Martin' identity or role.
+    if (/\b(?:I am|You are)\s+(?!Martin\s+Loop|an\s+AI)\b/i.test(fullUntrustedBuffer)) {
+        signals.push("Identity redefinition attempt detected.");
+    }
+    const verdict = signals.length > 0 ? "context_poisoning_block" : "clean";
+    const precheck = {
+        runId,
+        attemptIndex,
+        verdict,
+        reason: signals.length > 0 ? `Detected ${signals.length} poisoning signals.` : undefined,
+        detectedSignals: signals,
+        analyzedChannels,
+        timestamp: new Date().toISOString()
+    };
+    // Persist artifact: context-integrity-precheck.json
+    const artifactPath = join(artifactsDir, "context-integrity-precheck.json");
+    try {
+        const { mkdir } = await import("node:fs/promises");
+        await mkdir(artifactsDir, { recursive: true });
+        await writeFile(artifactPath, JSON.stringify(precheck, null, 2), "utf8");
+    }
+    catch (err) {
+        console.error(`Failed to persist context-integrity-precheck: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    return precheck;
+}
+//# sourceMappingURL=truth-spine.js.map