martin-loop 0.1.5 → 1.3.0

package/dist/vendor/cli/ui/summary-card.js

@@ -0,0 +1,102 @@
+/**
+ * summary-card.ts
+ *
+ * Renders a human-readable run summary card to stdout after every martin run.
+ * Respects --json flag and MARTIN_NO_SUMMARY env var.
+ * Width: 56 chars to fit any terminal >= 60 cols.
+ */
+const CARD_WIDTH = 56;
+const INNER_WIDTH = CARD_WIDTH - 4; // 2 border chars + 2 padding spaces
+export function shouldRenderSummaryCard(args) {
+    if (process.env.MARTIN_NO_SUMMARY === "1")
+        return false;
+    if (args.includes("--json"))
+        return false;
+    // Only render when stdout is a TTY or when explicitly forced
+    if (!process.stdout.isTTY && process.env.MARTIN_FORCE_SUMMARY !== "1")
+        return false;
+    return true;
+}
+export function renderSummaryCard(input) {
+    const lines = [];
+    const top = `╔${"═".repeat(CARD_WIDTH - 2)}╗`;
+    const bottom = `╚${"═".repeat(CARD_WIDTH - 2)}╝`;
+    const divider = `╠${"═".repeat(CARD_WIDTH - 2)}╣`;
+    const title = input.succeeded
+        ? "Martin Loop — Run Complete"
+        : "Martin Loop — Run Failed";
+    lines.push(top);
+    lines.push(row(title));
+    lines.push(divider);
+    if (input.succeeded) {
+        const attemptLabel = input.attemptCount === 1
+            ? "1 attempt"
+            : `attempt ${input.attemptCount} of ${input.maxAttempts}`;
+        lines.push(row(`Outcome     SUCCEEDED (${attemptLabel})`));
+        lines.push(row(`Objective   ${truncate(input.objective, INNER_WIDTH - 12)}`));
+        if (input.grade) {
+            const grounding = input.groundingScore !== undefined
+                ? `  (grounding: ${input.groundingScore.toFixed(2)})`
+                : "";
+            lines.push(row(`Patch grade ${input.grade}${grounding}`));
+        }
+        if (input.modelName) {
+            const probe = input.probeTier ? ` (probe: ${input.probeTier})` : "";
+            lines.push(row(`Model       ${truncate(input.modelName + probe, INNER_WIDTH - 12)}`));
+        }
+        const probeNote = input.probeCostUsd !== undefined
+            ? `  (probe $${input.probeCostUsd.toFixed(2)} + attempts $${(input.costUsd - input.probeCostUsd).toFixed(2)})`
+            : "";
+        lines.push(row(`Cost        $${input.costUsd.toFixed(2)}${probeNote}`));
+        if (input.routerSelectedModel !== undefined) {
+            const routerCostStr = input.routerCostPer1kTcs !== undefined
+                ? ` · $${input.routerCostPer1kTcs.toFixed(4)}/1kTcs`
+                : "";
+            const tierStr = input.routerTrustTier ? ` [${input.routerTrustTier}]` : "";
+            lines.push(row(`Route       ${truncate(input.routerSelectedModel + routerCostStr + tierStr, INNER_WIDTH - 12)}`));
+        }
+        if (input.blastRadius !== undefined) {
+            lines.push(row(`Blast radius  ${input.blastRadius}/100`));
+        }
+        lines.push(row(`Duration    ${formatDuration(input.durationMs)}`));
+    }
+    else {
+        lines.push(row(`Outcome     FAILED after ${input.attemptCount} attempt${input.attemptCount !== 1 ? "s" : ""}`));
+        lines.push(row(`Objective   ${truncate(input.objective, INNER_WIDTH - 12)}`));
+        if (input.lastBlockReason) {
+            lines.push(row(`Last block  ${truncate(input.lastBlockReason, INNER_WIDTH - 12)}`));
+        }
+        lines.push(row(`Cost        $${input.costUsd.toFixed(2)} (all attempts charged)`));
+        const rollbackStr = input.rollbackComplete === false
+            ? "incomplete — check workspace"
+            : "complete — workspace restored";
+        lines.push(row(`Rollback    ${rollbackStr}`));
+    }
+    lines.push(divider);
+    lines.push(row(`Audit trail → ~/.martin/runs/${truncate(input.loopId, INNER_WIDTH - 22)}`));
+    if (!input.succeeded) {
+        lines.push(row(`Tip:  martin explain ${truncate(input.loopId, INNER_WIDTH - 22)}`));
+    }
+    lines.push(bottom);
+    return lines.join("\n");
+}
+function row(content) {
+    const remaining = CARD_WIDTH - 4 - content.length;
+    const padding = remaining > 0 ? " ".repeat(remaining) : "";
+    return `║ ${content}${padding} ║`;
+}
+function truncate(str, maxLen) {
+    if (str.length <= maxLen)
+        return str;
+    return `${str.slice(0, maxLen - 3)}...`;
+}
+function formatDuration(ms) {
+    if (ms < 1000)
+        return `${ms}ms`;
+    if (ms < 60_000)
+        return `${(ms / 1000).toFixed(1)}s`;
+    const mins = Math.floor(ms / 60_000);
+    const secs = Math.round((ms % 60_000) / 1000);
+    return `${mins}m ${secs}s`;
+}
+//# sourceMappingURL=summary-card.js.map

package/dist/vendor/contracts/audit.d.ts

@@ -0,0 +1,46 @@
+export interface AuditManifestEntry {
+    path: string;
+    sha256: string;
+    sizeBytes: number;
+}
+export interface AuditManifest {
+    runId: string;
+    generatedAt: string;
+    generatedBy: string;
+    files: AuditManifestEntry[];
+    manifestVersion: "h3.v1";
+    tamperEvident: boolean;
+}
+export interface AuditPackFile {
+    path: string;
+    content: string;
+}
+export interface AuditPackInput {
+    runId: string;
+    generatedBy: string;
+    generatedAt: string;
+    files: AuditPackFile[];
+}
+export interface GenerateAuditPackFromRunDirectoryOptions {
+    runId: string;
+    runDir: string;
+    outputDir: string;
+    generatedBy?: string;
+    generatedAt?: string;
+    truthFacts?: unknown[];
+    treatyTimeline?: unknown[];
+}
+export interface AuditPackGenerationResult {
+    packPath: string;
+    manifest: AuditManifest;
+}
+export interface AuditPackVerificationResult {
+    ok: boolean;
+    manifest: AuditManifest;
+    checkedFiles: AuditManifestEntry[];
+    failures: string[];
+}
+export declare function generateAuditPackFromRunDirectory(options: GenerateAuditPackFromRunDirectoryOptions): Promise<AuditPackGenerationResult>;
+export declare function writeAuditPack(packPath: string, input: AuditPackInput): Promise<AuditPackGenerationResult>;
+export declare function verifyAuditPack(packPath: string): Promise<AuditPackVerificationResult>;
+export declare function stableStringify(value: unknown): string;

package/dist/vendor/contracts/audit.js

@@ -0,0 +1,360 @@
+import crypto from "node:crypto";
+import { mkdir, readFile, readdir, stat, writeFile } from "node:fs/promises";
+import { basename, join, relative, resolve } from "node:path";
+const AUDIT_DIRECTORIES = [
+    "patch-proofs",
+    "drift-reports",
+    "truth-facts",
+    "treaty-timeline",
+    "red-findings",
+    "hypothesis-ledger"
+];
+export async function generateAuditPackFromRunDirectory(options) {
+    const runSource = await readRunAuditSource(options.runDir);
+    const generatedAt = options.generatedAt ??
+        (typeof runSource.state?.updatedAt === "string" ? runSource.state.updatedAt : undefined) ??
+        (typeof runSource.contract.createdAt === "string" ? runSource.contract.createdAt : undefined) ??
+        new Date().toISOString();
+    const files = buildAuditPackFiles({
+        runId: options.runId,
+        runSource,
+        truthFacts: options.truthFacts ?? [],
+        treatyTimeline: options.treatyTimeline ?? []
+    });
+    const packPath = join(resolve(options.outputDir), `audit-pack-${options.runId}`);
+    return writeAuditPack(packPath, {
+        runId: options.runId,
+        generatedAt,
+        generatedBy: options.generatedBy ?? "martin",
+        files
+    });
+}
+export async function writeAuditPack(packPath, input) {
+    const normalizedFiles = [...input.files].sort((left, right) => left.path.localeCompare(right.path));
+    const manifest = createAuditManifest(input.runId, input.generatedAt, input.generatedBy, normalizedFiles);
+    await mkdir(packPath, { recursive: true });
+    for (const directory of AUDIT_DIRECTORIES) {
+        await mkdir(join(packPath, directory), { recursive: true });
+    }
+    for (const file of normalizedFiles) {
+        await mkdir(join(packPath, relative(".", file.path).split(/[\\/]/u).slice(0, -1).join("/")), {
+            recursive: true
+        });
+        await writeFile(join(packPath, file.path), file.content, "utf8");
+    }
+    await writeFile(join(packPath, "MANIFEST.json"), `${stableStringify(manifest)}\n`, "utf8");
+    return {
+        packPath,
+        manifest
+    };
+}
+export async function verifyAuditPack(packPath) {
+    const resolvedPackPath = resolve(packPath);
+    const manifest = JSON.parse(await readFile(join(resolvedPackPath, "MANIFEST.json"), "utf8"));
+    const actualFiles = await collectAuditManifestEntries(resolvedPackPath);
+    const manifestFiles = [...manifest.files].sort((left, right) => left.path.localeCompare(right.path));
+    const failures = [];
+    const actualPaths = new Set(actualFiles.map((entry) => entry.path));
+    const manifestPaths = new Set(manifestFiles.map((entry) => entry.path));
+    for (const entry of manifestFiles) {
+        if (!actualPaths.has(entry.path)) {
+            failures.push(`Missing file: ${entry.path}`);
+            continue;
+        }
+        const actual = actualFiles.find((candidate) => candidate.path === entry.path);
+        if (!actual) {
+            failures.push(`Missing file: ${entry.path}`);
+            continue;
+        }
+        if (actual.sha256 !== entry.sha256) {
+            failures.push(`Checksum mismatch: ${entry.path}`);
+        }
+        if (actual.sizeBytes !== entry.sizeBytes) {
+            failures.push(`Size mismatch: ${entry.path}`);
+        }
+    }
+    for (const actual of actualFiles) {
+        if (!manifestPaths.has(actual.path)) {
+            failures.push(`Unexpected file not covered by manifest: ${actual.path}`);
+        }
+    }
+    return {
+        ok: failures.length === 0,
+        manifest,
+        checkedFiles: actualFiles,
+        failures
+    };
+}
+export function stableStringify(value) {
+    return JSON.stringify(sortValue(value), null, 2);
+}
+function createAuditManifest(runId, generatedAt, generatedBy, files) {
+    const entries = files.map((file) => ({
+        path: normalizeAuditPath(file.path),
+        sha256: hashContent(file.content),
+        sizeBytes: Buffer.byteLength(file.content, "utf8")
+    }));
+    return {
+        runId,
+        generatedAt,
+        generatedBy,
+        files: entries,
+        manifestVersion: "h3.v1",
+        tamperEvident: true
+    };
+}
+function buildAuditPackFiles(input) {
+    const { runId, runSource, truthFacts, treatyTimeline } = input;
+    const patchProofs = buildPatchProofs(runSource);
+    const driftReports = buildDriftReports(runSource);
+    const redFindings = buildRedFindings(runSource);
+    const hypothesisLedger = buildHypothesisLedger(runId, runSource);
+    return [
+        {
+            path: "patch-proofs/contract.json",
+            content: `${stableStringify(runSource.contract)}\n`
+        },
+        {
+            path: "patch-proofs/ledger.jsonl",
+            content: runSource.ledgerLines.length > 0 ? `${runSource.ledgerLines.join("\n")}\n` : ""
+        },
+        {
+            path: "patch-proofs/attempts.json",
+            content: `${stableStringify(patchProofs)}\n`
+        },
+        {
+            path: "drift-reports/drift-summary.json",
+            content: `${stableStringify(driftReports)}\n`
+        },
+        {
+            path: "truth-facts/truth-facts.json",
+            content: `${stableStringify({ runId, facts: truthFacts })}\n`
+        },
+        {
+            path: "treaty-timeline/treaty-timeline.json",
+            content: `${stableStringify({ runId, transitions: treatyTimeline })}\n`
+        },
+        {
+            path: "red-findings/red-findings.json",
+            content: `${stableStringify({ runId, findings: redFindings })}\n`
+        },
+        {
+            path: "hypothesis-ledger/hypothesis-ledger.json",
+            content: `${stableStringify(hypothesisLedger)}\n`
+        },
+        ...collectAttemptFiles(runSource.attempts, "patch-proofs", [
+            "diff.patch",
+            "patch-decision.json",
+            "patch-score.json",
+            "final-semantic-verification.json",
+            "attempt-semantic-check.json"
+        ]),
+        ...collectAttemptFiles(runSource.attempts, "drift-reports", [
+            "grounding-scan.json",
+            "scope-surface.json",
+            "leash.json",
+            "rollback-outcome.json",
+            "rollback-boundary.json"
+        ])
+    ];
+}
+function buildPatchProofs(runSource) {
+    return {
+        attemptCount: runSource.attempts.length,
+        attempts: runSource.attempts.map((attempt) => ({
+            attempt: attempt.attemptLabel,
+            files: Object.keys(attempt.files).filter((file) => [
+                "diff.patch",
+                "patch-decision.json",
+                "patch-score.json",
+                "final-semantic-verification.json",
+                "attempt-semantic-check.json"
+            ].includes(file))
+        }))
+    };
+}
+function buildDriftReports(runSource) {
+    return {
+        state: runSource.state,
+        attemptCount: runSource.attempts.length,
+        attempts: runSource.attempts.map((attempt) => {
+            const grounding = parseOptionalJson(attempt.files["grounding-scan.json"]);
+            const leash = parseOptionalJson(attempt.files["leash.json"]);
+            return {
+                attempt: attempt.attemptLabel,
+                hasGroundingScan: attempt.files["grounding-scan.json"] !== undefined,
+                hasScopeSurface: attempt.files["scope-surface.json"] !== undefined,
+                hasLeash: attempt.files["leash.json"] !== undefined,
+                groundingViolations: Array.isArray(grounding?.violations) ? grounding.violations.length : 0,
+                safetyBlocked: typeof leash?.blocked === "boolean" ? leash.blocked : false
+            };
+        })
+    };
+}
+function buildRedFindings(runSource) {
+    const findings = [];
+    for (const event of runSource.ledgerEvents) {
+        const kind = typeof event.kind === "string" ? event.kind : "";
+        if (kind.includes("violation") ||
+            kind.includes("discard") ||
+            kind.includes("escalat") ||
+            kind.includes("blocked")) {
+            findings.push({
+                source: "ledger",
+                kind,
+                payload: typeof event.payload === "object" && event.payload !== null ? event.payload : {}
+            });
+        }
+    }
+    for (const attempt of runSource.attempts) {
+        const grounding = parseOptionalJson(attempt.files["grounding-scan.json"]);
+        if (Array.isArray(grounding?.violations) && grounding.violations.length > 0) {
+            findings.push({
+                source: attempt.attemptLabel,
+                kind: "grounding.violations_found",
+                violations: grounding.violations
+            });
+        }
+    }
+    return findings;
+}
+function buildHypothesisLedger(runId, runSource) {
+    const task = typeof runSource.contract.task === "object" && runSource.contract.task !== null
+        ? runSource.contract.task
+        : null;
+    return {
+        runId,
+        objective: (typeof runSource.contract.objective === "string" ? runSource.contract.objective : undefined) ??
+            (typeof task?.objective === "string" ? task.objective : undefined) ??
+            null,
+        verificationPlan: task?.verificationPlan ?? [],
+        eventKinds: runSource.ledgerEvents
+            .map((event) => (typeof event.kind === "string" ? event.kind : null))
+            .filter((value) => value !== null),
+        attempts: runSource.attempts.map((attempt) => ({
+            attempt: attempt.attemptLabel,
+            hasPatchDecision: attempt.files["patch-decision.json"] !== undefined,
+            hasPatchScore: attempt.files["patch-score.json"] !== undefined,
+            hasGroundingScan: attempt.files["grounding-scan.json"] !== undefined
+        }))
+    };
+}
+function collectAttemptFiles(attempts, section, names) {
+    const files = [];
+    for (const attempt of attempts) {
+        for (const name of names) {
+            const content = attempt.files[name];
+            if (content === undefined) {
+                continue;
+            }
+            files.push({
+                path: `${section}/${attempt.attemptLabel}/${name}`,
+                content: ensureTrailingNewline(content)
+            });
+        }
+    }
+    return files;
+}
+async function readRunAuditSource(runDir) {
+    const resolvedRunDir = resolve(runDir);
+    const contract = JSON.parse(await readFile(join(resolvedRunDir, "contract.json"), "utf8"));
+    const state = await readJsonIfExists(join(resolvedRunDir, "state.json"));
+    const ledgerPath = join(resolvedRunDir, "ledger.jsonl");
+    const ledgerRaw = await readFile(ledgerPath, "utf8").catch(() => "");
+    const ledgerLines = ledgerRaw.split(/\r?\n/u).filter((line) => line.length > 0);
+    const ledgerEvents = ledgerLines.map((line) => JSON.parse(line));
+    const artifactsRoot = join(resolvedRunDir, "artifacts");
+    const attemptEntries = await readdir(artifactsRoot, { withFileTypes: true }).catch(() => []);
+    const attempts = [];
+    for (const entry of attemptEntries.sort((left, right) => left.name.localeCompare(right.name))) {
+        if (!entry.isDirectory()) {
+            continue;
+        }
+        const attemptDir = join(artifactsRoot, entry.name);
+        const fileEntries = await readdir(attemptDir, { withFileTypes: true });
+        const files = {};
+        for (const fileEntry of fileEntries) {
+            if (!fileEntry.isFile()) {
+                continue;
+            }
+            const fileName = fileEntry.name;
+            files[fileName] = await readFile(join(attemptDir, fileName), "utf8");
+        }
+        attempts.push({
+            attemptLabel: entry.name,
+            files
+        });
+    }
+    return {
+        contract,
+        state,
+        ledgerLines,
+        ledgerEvents,
+        attempts
+    };
+}
+async function collectAuditManifestEntries(packPath) {
+    const entries = [];
+    await collectFilesRecursive(packPath, packPath, entries);
+    return entries.sort((left, right) => left.path.localeCompare(right.path));
+}
+async function collectFilesRecursive(root, current, entries) {
+    const fileEntries = await readdir(current, { withFileTypes: true });
+    for (const entry of fileEntries) {
+        const fullPath = join(current, entry.name);
+        if (entry.isDirectory()) {
+            await collectFilesRecursive(root, fullPath, entries);
+            continue;
+        }
+        if (basename(fullPath) === "MANIFEST.json") {
+            continue;
+        }
+        const content = await readFile(fullPath, "utf8");
+        const fileStat = await stat(fullPath);
+        entries.push({
+            path: normalizeAuditPath(relative(root, fullPath)),
+            sha256: hashContent(content),
+            sizeBytes: fileStat.size
+        });
+    }
+}
+async function readJsonIfExists(pathname) {
+    try {
+        return JSON.parse(await readFile(pathname, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+function parseOptionalJson(content) {
+    if (!content) {
+        return null;
+    }
+    try {
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+function hashContent(content) {
+    return crypto.createHash("sha256").update(content).digest("hex");
+}
+function normalizeAuditPath(pathname) {
+    return pathname.replace(/\\/gu, "/");
+}
+function ensureTrailingNewline(content) {
+    return content.endsWith("\n") ? content : `${content}\n`;
+}
+function sortValue(value) {
+    if (Array.isArray(value)) {
+        return value.map((entry) => sortValue(entry));
+    }
+    if (value && typeof value === "object") {
+        return Object.fromEntries(Object.entries(value)
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([key, entry]) => [key, sortValue(entry)]));
+    }
+    return value;
+}
+//# sourceMappingURL=audit.js.map