@martinloop/mcp 0.1.4 → 0.2.5

package/dist/tools/tool-support.js

@@ -1,17 +1,30 @@
 import { spawnSync } from "node:child_process";
 import { readdir, stat } from "node:fs/promises";
 import { join } from "node:path";
-import { evaluateCostGovernor, readLatestLoopRecordFromFile, resolveRunsRoot } from "../vendor/core/index.js";
+import { evaluateCostGovernor, resolveRunsRoot } from "../vendor/core/index.js";
+import { readAllLoopRecordsSafely } from "./run-store.js";
+const CLI_CACHE_TTL_MS = 60_000;
+const RUN_STORE_CACHE_TTL_MS = 5_000;
+const cliAvailabilityCache = new Map();
+const runStoreInspectionCache = new Map();
 export function resolveExecutionMode() {
     const liveMode = process.env.MARTIN_LIVE !== "false";
     return {
         liveMode,
-        mode: liveMode ? "live" : "stub"
+        mode: liveMode ? "live" : "stub",
+        detail: liveMode
+            ? "Live CLI execution is enabled."
+            : "Stub mode is active because MARTIN_LIVE=false."
     };
 }
-export function getEngineAvailability(engine) {
+export function detectCliAvailability(command) {
+    const cacheKey = `${process.platform}:${command}`;
+    const cached = cliAvailabilityCache.get(cacheKey);
+    if (cached && cached.expiresAt > Date.now()) {
+        return cached.value;
+    }
     const locator = process.platform === "win32" ? "where.exe" : "which";
-    const result = spawnSync(locator, [engine], {
+    const result = spawnSync(locator, [command], {
         encoding: "utf8",
         stdio: ["ignore", "pipe", "pipe"]
     });
@@ -21,21 +34,168 @@ export function getEngineAvailability(engine) {
             .map((line) => line.trim())
             .find(Boolean)
         : undefined;
-    return result.status === 0
+    const value = result.status === 0
         ? {
+            command,
             available: true,
-            detail: `${engine} is available on PATH.`,
+            locator,
+            detail: `${command} is available on PATH.`,
             ...(resolvedPath ? { resolvedPath } : {})
         }
         : {
+            command,
             available: false,
-            detail: `${engine} is not available on PATH.`
+            locator,
+            detail: `${command} is not available on PATH.`
         };
+    cliAvailabilityCache.set(cacheKey, {
+        expiresAt: Date.now() + CLI_CACHE_TTL_MS,
+        value
+    });
+    return value;
+}
+export function getEngineAvailability(engine) {
+    return detectCliAvailability(engine);
 }
 export function formatUsd(value) {
     return `$${value.toFixed(2)}`;
 }
+export function buildLoopPreview(loop) {
+    const costState = evaluateCostGovernor({
+        budget: loop.budget,
+        cost: {
+            actualUsd: loop.cost.actualUsd,
+            avoidedUsd: loop.cost.avoidedUsd ?? 0,
+            tokensIn: loop.cost.tokensIn,
+            tokensOut: loop.cost.tokensOut
+        },
+        attemptsUsed: loop.attempts.length
+    });
+    const lastAttempt = loop.attempts.at(-1);
+    return {
+        loopId: loop.loopId,
+        title: loop.task?.title ?? loop.loopId,
+        objective: loop.task?.objective ?? "Loop record summary",
+        status: loop.status,
+        lifecycleState: loop.lifecycleState,
+        ...(loop.createdAt ? { createdAt: loop.createdAt } : {}),
+        ...(loop.updatedAt ? { updatedAt: loop.updatedAt } : {}),
+        attempts: loop.attempts.length,
+        costUsd: loop.cost.actualUsd,
+        avoidedUsd: loop.cost.avoidedUsd ?? 0,
+        pressure: costState.pressure,
+        shouldStop: costState.shouldStop,
+        remainingBudgetUsd: costState.remainingBudgetUsd,
+        remainingIterations: costState.remainingIterations,
+        remainingTokens: costState.remainingTokens,
+        ...(lastAttempt ? { lastAttempt: buildAttemptSummary(lastAttempt) } : {})
+    };
+}
+export function buildAttemptSummary(attempt, artifacts) {
+    return {
+        index: attempt.index,
+        ...(attempt.attemptId ? { attemptId: attempt.attemptId } : {}),
+        ...(attempt.adapterId ? { adapterId: attempt.adapterId } : {}),
+        ...(attempt.model ? { model: attempt.model } : {}),
+        ...(attempt.failureClass ? { failureClass: attempt.failureClass } : {}),
+        ...(attempt.intervention ? { intervention: attempt.intervention } : {}),
+        ...(attempt.startedAt ? { startedAt: attempt.startedAt } : {}),
+        ...(attempt.completedAt ? { completedAt: attempt.completedAt } : {}),
+        ...(attempt.summary ? { summary: attempt.summary } : {}),
+        ...(artifacts ? { artifacts } : {})
+    };
+}
+export function buildArtifactSummary(loop) {
+    const artifacts = loop.artifacts ?? [];
+    const kinds = artifacts.reduce((accumulator, artifact) => {
+        accumulator[artifact.kind] = (accumulator[artifact.kind] ?? 0) + 1;
+        return accumulator;
+    }, {});
+    return {
+        totalCount: artifacts.length,
+        kinds,
+        highlights: artifacts.slice(0, 5).map((artifact) => ({
+            artifactId: artifact.artifactId,
+            kind: artifact.kind,
+            label: artifact.label,
+            uri: artifact.uri
+        }))
+    };
+}
+export function buildVerificationSummary(loop, ledgerEvents = []) {
+    const verificationEvents = (loop.events ?? []).filter((event) => event.type === "verification.completed");
+    const verificationLedgerEvents = ledgerEvents.filter((event) => event.kind === "verification.completed");
+    const warnings = [];
+    const ledgerWarnings = getLedgerWarnings(ledgerEvents);
+    warnings.push(...ledgerWarnings);
+    if (verificationEvents.length === 0) {
+        warnings.push(verificationLedgerEvents.length > 0
+            ? "No verification.completed events were found in the loop record; using ledger evidence."
+            : "No verification.completed events were found in the loop record.");
+    }
+    if (verificationLedgerEvents.length === 0 && ledgerWarnings.length === 0) {
+        warnings.push("No verification.completed ledger events were found for this run.");
+    }
+    const selectedEvidence = selectLatestVerificationEvidence(loop, verificationEvents, verificationLedgerEvents);
+    warnings.push(...selectedEvidence.warnings);
+    const latestEvidence = selectedEvidence.evidence;
+    if (!latestEvidence) {
+        return {
+            status: "unavailable",
+            eventCount: verificationEvents.length,
+            ledgerEventCount: verificationLedgerEvents.length,
+            warnings
+        };
+    }
+    return {
+        status: latestEvidence.passed === true
+            ? "passed"
+            : latestEvidence.passed === false
+                ? "failed"
+                : "unavailable",
+        eventCount: verificationEvents.length,
+        ledgerEventCount: verificationLedgerEvents.length,
+        ...(latestEvidence.attemptIndex !== undefined ? { latestAttemptIndex: latestEvidence.attemptIndex } : {}),
+        ...(latestEvidence.timestamp ? { completedAt: latestEvidence.timestamp } : {}),
+        ...(typeof latestEvidence.summary === "string" && latestEvidence.summary.trim().length > 0
+            ? { summary: latestEvidence.summary.trim() }
+            : {}),
+        warnings
+    };
+}
+export function buildEventSummaries(loop, limit = 5) {
+    return (loop.events ?? [])
+        .slice(-limit)
+        .reverse()
+        .map((event) => ({
+        type: event.type,
+        ...(event.timestamp ? { timestamp: event.timestamp } : {}),
+        ...(event.lifecycleState ? { lifecycleState: event.lifecycleState } : {}),
+        payload: event.payload ?? {}
+    }));
+}
+export function buildLoopCollectionSummary(loops) {
+    const previews = loops
+        .map((loop) => buildLoopPreview(loop))
+        .sort((left, right) => {
+        const leftTime = toPreviewTimestamp(left);
+        const rightTime = toPreviewTimestamp(right);
+        return rightTime - leftTime;
+    });
+    const statusBreakdown = countBy(previews, "status");
+    const lifecycleBreakdown = countBy(previews, "lifecycleState");
+    return {
+        ...(previews[0] ? { latestRun: previews[0] } : {}),
+        recentRuns: previews.slice(0, 5),
+        statusBreakdown,
+        lifecycleBreakdown
+    };
+}
 export async function inspectRunsRoot(runsRoot = resolveRunsRoot(process.env)) {
+    const cached = runStoreInspectionCache.get(runsRoot);
+    if (cached && cached.expiresAt > Date.now()) {
+        return cached.value;
+    }
     let exists = false;
     try {
         exists = (await stat(runsRoot)).isDirectory();
@@ -43,68 +203,203 @@ export async function inspectRunsRoot(runsRoot = resolveRunsRoot(process.env)) {
     catch {
         exists = false;
     }
-    if (!exists) {
+    const inspected = await readAllLoopRecordsSafely(runsRoot);
+    const summary = buildLoopCollectionSummary(inspected.loops);
+    const value = {
+        runsRoot,
+        exists,
+        loopCount: inspected.loops.length,
+        latestRun: summary.latestRun,
+        recentRuns: summary.recentRuns,
+        statusBreakdown: summary.statusBreakdown,
+        lifecycleBreakdown: summary.lifecycleBreakdown,
+        warnings: inspected.warnings
+    };
+    runStoreInspectionCache.set(runsRoot, {
+        expiresAt: Date.now() + RUN_STORE_CACHE_TTL_MS,
+        value
+    });
+    return value;
+}
+export function buildRunRecordPaths(runsRoot, loopId) {
+    const runDirectory = join(runsRoot, loopId);
+    return {
+        runsRoot,
+        runDirectory,
+        loopRecordPath: join(runDirectory, "loop-record.json"),
+        ledgerPath: join(runDirectory, "ledger.jsonl")
+    };
+}
+export function buildAttemptArtifactDirectory(runsRoot, loopId, attemptIndex) {
+    return join(runsRoot, loopId, "artifacts", `attempt-${String(attemptIndex).padStart(3, "0")}`);
+}
+export async function buildAttemptArtifactsReference(runsRoot, loopId, attemptIndex) {
+    const directory = buildAttemptArtifactDirectory(runsRoot, loopId, attemptIndex);
+    try {
+        const entries = await readdir(directory, { withFileTypes: true });
         return {
-            exists: false,
-            loopCount: 0,
-            warnings: []
+            directory,
+            available: true,
+            files: entries.filter((entry) => entry.isFile()).map((entry) => entry.name).sort()
         };
     }
+    catch {
+        return {
+            directory,
+            available: false,
+            files: []
+        };
+    }
+}
+export function buildCostSnapshot(cost) {
+    return {
+        actualUsd: cost.actualUsd,
+        avoidedUsd: cost.avoidedUsd ?? 0,
+        tokensIn: cost.tokensIn,
+        tokensOut: cost.tokensOut
+    };
+}
+export function buildBudgetSnapshot(budget) {
+    return {
+        maxUsd: budget.maxUsd,
+        softLimitUsd: budget.softLimitUsd,
+        maxIterations: budget.maxIterations,
+        maxTokens: budget.maxTokens
+    };
+}
+export function buildSuggestedResourceUris(loopId) {
+    return [
+        "martin://server/health",
+        "martin://runs/recent",
+        "martin://runs/triage",
+        `martin://runs/${loopId}`,
+        `martin://runs/${loopId}/verification`,
+        "martin://guides/mcp-usage",
+        "martin://guides/publish-readiness"
+    ];
+}
+export function buildSuggestedPromptNames() {
+    return [
+        "martin_governed_coding_kickoff",
+        "martin_debug_failed_run",
+        "martin_publish_readiness_review",
+        "martin_triage_run_store"
+    ];
+}
+function countBy(values, key) {
+    return values.reduce((accumulator, value) => {
+        const bucket = String(value[key]);
+        accumulator[bucket] = (accumulator[bucket] ?? 0) + 1;
+        return accumulator;
+    }, {});
+}
+function toPreviewTimestamp(loop) {
+    const value = loop.updatedAt ?? loop.createdAt;
+    return value ? new Date(value).getTime() : 0;
+}
+function selectLatestVerificationEvidence(loop, verificationEvents, verificationLedgerEvents) {
     const warnings = [];
-    const loops = [];
-    const entries = await readdir(runsRoot, { withFileTypes: true });
-    for (const entry of entries) {
-        if (!entry.isDirectory()) {
-            continue;
-        }
-        const loopRecordPath = join(runsRoot, entry.name, "loop-record.json");
-        try {
-            const loop = await readLatestLoopRecordFromFile(loopRecordPath);
-            if (!loop) {
-                continue;
-            }
-            const costState = evaluateCostGovernor({
-                budget: loop.budget,
-                cost: {
-                    actualUsd: loop.cost.actualUsd,
-                    avoidedUsd: loop.cost.avoidedUsd ?? 0,
-                    tokensIn: loop.cost.tokensIn,
-                    tokensOut: loop.cost.tokensOut
-                },
-                attemptsUsed: loop.attempts.length
-            });
-            loops.push({
-                loopId: loop.loopId,
-                title: loop.task?.title ?? loop.loopId,
-                objective: loop.task?.objective ?? "Loop record summary",
-                status: loop.status,
-                lifecycleState: loop.lifecycleState,
-                ...(loop.createdAt ? { createdAt: loop.createdAt } : {}),
-                ...(loop.updatedAt ? { updatedAt: loop.updatedAt } : {}),
-                attempts: loop.attempts.length,
-                costUsd: loop.cost.actualUsd,
-                avoidedUsd: loop.cost.avoidedUsd ?? 0,
-                pressure: costState.pressure,
-                shouldStop: costState.shouldStop,
-                remainingBudgetUsd: costState.remainingBudgetUsd,
-                remainingIterations: costState.remainingIterations,
-                remainingTokens: costState.remainingTokens
-            });
-        }
-        catch {
-            warnings.push(`Skipped unreadable loop record for '${entry.name}'.`);
-        }
+    const futureEvidenceCount = [
+        ...verificationEvents.map((event) => event.timestamp),
+        ...verificationLedgerEvents.map((event) => event.timestamp)
+    ].filter(isFutureVerificationTimestamp).length;
+    if (futureEvidenceCount > 0) {
+        warnings.push(`Ignored ${futureEvidenceCount} future-dated verification evidence item(s) that cannot be trusted yet.`);
+    }
+    const evidence = [
+        ...verificationEvents.map((event) => normalizeLoopVerificationEvidence(loop, event)),
+        ...verificationLedgerEvents.map((event) => normalizeLedgerVerificationEvidence(loop, event))
+    ].filter((candidate) => candidate !== undefined);
+    if (evidence.length === 0) {
+        return { warnings };
+    }
+    evidence.sort((left, right) => new Date(right.timestamp).getTime() - new Date(left.timestamp).getTime());
+    const latest = evidence[0];
+    if (!latest) {
+        return { warnings };
+    }
+    const latestAttemptEvidence = evidence.filter((candidate) => latest.attemptId
+        ? candidate.attemptId === latest.attemptId
+        : latest.attemptIndex !== undefined
+            ? candidate.attemptIndex === latest.attemptIndex
+            : false);
+    const distinctStatuses = new Set(latestAttemptEvidence
+        .map((candidate) => candidate.passed)
+        .filter((candidate) => typeof candidate === "boolean"));
+    if (distinctStatuses.size > 1) {
+        warnings.push("Verification evidence conflicts for the latest attempt; reporting status as unavailable.");
+        return { warnings };
     }
-    loops.sort((left, right) => {
-        const leftTime = Date.parse(left.updatedAt ?? left.createdAt ?? "");
-        const rightTime = Date.parse(right.updatedAt ?? right.createdAt ?? "");
-        return (Number.isFinite(rightTime) ? rightTime : 0) - (Number.isFinite(leftTime) ? leftTime : 0);
-    });
     return {
-        exists: true,
-        loopCount: loops.length,
-        ...(loops[0] ? { latestRun: loops[0] } : {}),
+        evidence: latest,
         warnings
     };
 }
-//# sourceMappingURL=tool-support.js.map
+function normalizeLoopVerificationEvidence(loop, event) {
+    if (!isTrustedVerificationTimestamp(event.timestamp)) {
+        return undefined;
+    }
+    const payload = isRecord(event.payload) ? event.payload : undefined;
+    const attemptId = typeof payload?.["attemptId"] === "string" ? payload["attemptId"] : undefined;
+    const attemptIndex = typeof payload?.["attemptIndex"] === "number" && Number.isInteger(payload["attemptIndex"])
+        ? payload["attemptIndex"]
+        : undefined;
+    const matchedAttempt = attemptId
+        ? loop.attempts.find((attempt) => attempt.attemptId === attemptId)
+        : attemptIndex !== undefined
+            ? loop.attempts.find((attempt) => attempt.index === attemptIndex)
+            : undefined;
+    if (!matchedAttempt) {
+        return undefined;
+    }
+    return {
+        timestamp: event.timestamp,
+        ...(matchedAttempt.attemptId ? { attemptId: matchedAttempt.attemptId } : {}),
+        attemptIndex: matchedAttempt.index,
+        ...(typeof payload?.["passed"] === "boolean" ? { passed: payload["passed"] } : {}),
+        ...(typeof payload?.["summary"] === "string" ? { summary: payload["summary"] } : {})
+    };
+}
+function normalizeLedgerVerificationEvidence(loop, event) {
+    if (!isTrustedVerificationTimestamp(event.timestamp)) {
+        return undefined;
+    }
+    if (event.attemptIndex === undefined || !Number.isInteger(event.attemptIndex)) {
+        return undefined;
+    }
+    const payload = isRecord(event.payload) ? event.payload : undefined;
+    const matchedAttempt = loop.attempts.find((attempt) => attempt.index === event.attemptIndex);
+    if (!matchedAttempt) {
+        return undefined;
+    }
+    return {
+        timestamp: event.timestamp,
+        ...(matchedAttempt?.attemptId ? { attemptId: matchedAttempt.attemptId } : {}),
+        attemptIndex: event.attemptIndex,
+        ...(typeof payload?.["passed"] === "boolean" ? { passed: payload["passed"] } : {}),
+        ...(typeof payload?.["summary"] === "string" ? { summary: payload["summary"] } : {})
+    };
+}
+function isTrustedVerificationTimestamp(value) {
+    const timestamp = new Date(value).getTime();
+    if (!Number.isFinite(timestamp)) {
+        return false;
+    }
+    return timestamp <= Date.now() + 5 * 60_000;
+}
+function isFutureVerificationTimestamp(value) {
+    const timestamp = new Date(value).getTime();
+    if (!Number.isFinite(timestamp)) {
+        return false;
+    }
+    return timestamp > Date.now() + 5 * 60_000;
+}
+function getLedgerWarnings(ledgerEvents) {
+    const diagnostics = ledgerEvents;
+    return Array.isArray(diagnostics.warnings)
+        ? diagnostics.warnings.filter((warning) => typeof warning === "string")
+        : [];
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}

package/dist/tools/triage-runs.d.ts

@@ -0,0 +1,33 @@
+import { type LoopPreview, type VerificationSummary } from "./tool-support.js";
+import { type LoopListInput } from "./run-store.js";
+export interface MartinTriageRunsInput extends LoopListInput {
+    includeHealthy?: boolean;
+}
+export interface MartinRunTriageFinding {
+    severity: "critical" | "high" | "medium" | "low";
+    summary: string;
+    reasonCodes: string[];
+    loop: LoopPreview;
+    verification: VerificationSummary;
+    suggestedResources: string[];
+    suggestedPrompts: string[];
+}
+export interface MartinTriageRunsOutput {
+    source: string;
+    runsRoot: string;
+    filters: {
+        limit: number;
+        includeHealthy: boolean;
+        status?: string;
+        lifecycleState?: string;
+        adapterId?: string;
+        model?: string;
+        updatedAfter?: string;
+    };
+    evaluatedRuns: number;
+    findingCount: number;
+    severityBreakdown: Record<string, number>;
+    findings: MartinRunTriageFinding[];
+    warnings: string[];
+}
+export declare function martinTriageRunsTool(input: MartinTriageRunsInput): Promise<MartinTriageRunsOutput>;

package/dist/tools/triage-runs.js

@@ -0,0 +1,138 @@
+import path from "node:path";
+import { buildLoopPreview, buildSuggestedPromptNames, buildSuggestedResourceUris, buildVerificationSummary } from "./tool-support.js";
+import { listLoopRecords, readLedgerEvents } from "./run-store.js";
+import { resolveSafeLoopRecordPath } from "../server-validation.js";
+const SEVERITY_RANK = {
+    critical: 4,
+    high: 3,
+    medium: 2,
+    low: 1
+};
+export async function martinTriageRunsTool(input) {
+    const listed = await listLoopRecords(input);
+    const warnings = [...listed.warnings];
+    const findings = await Promise.all(listed.loops.map(async (loop) => {
+        try {
+            const preview = buildLoopPreview(loop);
+            let ledgerEvents = [];
+            const canonicalLoopRecordPath = resolveSafeLoopRecordPath(loop.loopId, listed.runsRoot);
+            ledgerEvents = await readLedgerEvents({
+                source: listed.source,
+                sourceKind: "runs_root",
+                runsRoot: listed.runsRoot,
+                loop,
+                warnings: [],
+                canonicalRunDirectory: path.dirname(canonicalLoopRecordPath),
+                canonicalLoopRecordPath
+            });
+            const verification = buildVerificationSummary(loop, ledgerEvents);
+            return buildTriageFinding(preview, verification);
+        }
+        catch {
+            warnings.push(`Skipped triage for '${loop.loopId}' because its run record or verification evidence is unreadable.`);
+            return null;
+        }
+    }));
+    const filteredFindings = findings
+        .filter((finding) => finding !== null)
+        .filter((finding) => input.includeHealthy || finding.reasonCodes[0] !== "healthy")
+        .sort(compareFindings);
+    return {
+        source: listed.source,
+        runsRoot: listed.runsRoot,
+        filters: {
+            limit: input.limit ?? 20,
+            includeHealthy: input.includeHealthy ?? false,
+            ...(input.status ? { status: input.status } : {}),
+            ...(input.lifecycleState ? { lifecycleState: input.lifecycleState } : {}),
+            ...(input.adapterId ? { adapterId: input.adapterId } : {}),
+            ...(input.model ? { model: input.model } : {}),
+            ...(input.updatedAfter ? { updatedAfter: input.updatedAfter } : {})
+        },
+        evaluatedRuns: listed.loops.length,
+        findingCount: filteredFindings.length,
+        severityBreakdown: filteredFindings.reduce((accumulator, finding) => {
+            accumulator[finding.severity] = (accumulator[finding.severity] ?? 0) + 1;
+            return accumulator;
+        }, {}),
+        findings: filteredFindings,
+        warnings
+    };
+}
+function buildTriageFinding(loop, verification) {
+    const reasonCodes = [];
+    let severity = "low";
+    if (verification.status === "failed") {
+        reasonCodes.push("verification_failed");
+        severity = maxSeverity(severity, "critical");
+    }
+    if (loop.pressure === "hard_limit" || loop.shouldStop) {
+        reasonCodes.push("budget_hard_limit");
+        severity = maxSeverity(severity, "critical");
+    }
+    if (loop.status === "failed") {
+        reasonCodes.push("status_failed");
+        severity = maxSeverity(severity, "high");
+    }
+    if (loop.lifecycleState === "diminishing_returns") {
+        reasonCodes.push("diminishing_returns");
+        severity = maxSeverity(severity, "high");
+    }
+    if (verification.status === "unavailable" && loop.attempts > 0) {
+        reasonCodes.push("verification_unavailable");
+        severity = maxSeverity(severity, "medium");
+    }
+    if (loop.pressure === "soft_limit") {
+        reasonCodes.push("budget_soft_limit");
+        severity = maxSeverity(severity, "medium");
+    }
+    if (loop.status === "exited") {
+        reasonCodes.push("status_exited");
+        severity = maxSeverity(severity, "medium");
+    }
+    if (reasonCodes.length === 0) {
+        reasonCodes.push("healthy");
+    }
+    return {
+        severity,
+        summary: summarizeFinding(loop, verification, severity, reasonCodes),
+        reasonCodes,
+        loop,
+        verification,
+        suggestedResources: buildSuggestedResourceUris(loop.loopId),
+        suggestedPrompts: buildSuggestedPromptNames()
+    };
+}
+function summarizeFinding(loop, verification, severity, reasonCodes) {
+    if (reasonCodes.includes("verification_failed")) {
+        return `Severity ${severity}: ${loop.loopId} failed verification after ${loop.attempts} attempt(s).`;
+    }
+    if (reasonCodes.includes("budget_hard_limit")) {
+        return `Severity ${severity}: ${loop.loopId} exhausted its budget envelope with pressure ${loop.pressure}.`;
+    }
+    if (reasonCodes.includes("status_failed")) {
+        return `Severity ${severity}: ${loop.loopId} is currently failed/${loop.lifecycleState}.`;
+    }
+    if (reasonCodes.includes("verification_unavailable")) {
+        return `Severity ${severity}: ${loop.loopId} has ${loop.attempts} attempt(s) but verification is unavailable.`;
+    }
+    if (reasonCodes.includes("budget_soft_limit")) {
+        return `Severity ${severity}: ${loop.loopId} is at soft-limit pressure with ${loop.remainingBudgetUsd.toFixed(2)} USD remaining.`;
+    }
+    if (reasonCodes.includes("status_exited")) {
+        return `Severity ${severity}: ${loop.loopId} exited without a clean verification result.`;
+    }
+    return `Severity ${severity}: ${loop.loopId} is healthy with verification status ${verification.status}.`;
+}
+function maxSeverity(left, right) {
+    return SEVERITY_RANK[left] >= SEVERITY_RANK[right] ? left : right;
+}
+function compareFindings(left, right) {
+    const severityDelta = SEVERITY_RANK[right.severity] - SEVERITY_RANK[left.severity];
+    if (severityDelta !== 0) {
+        return severityDelta;
+    }
+    const leftTimestamp = new Date(left.loop.updatedAt ?? left.loop.createdAt ?? 0).getTime();
+    const rightTimestamp = new Date(right.loop.updatedAt ?? right.loop.createdAt ?? 0).getTime();
+    return rightTimestamp - leftTimestamp;
+}

package/dist/vendor/adapters/claude-cli.js

@@ -583,4 +583,3 @@ async function checkNoDiff(repoRoot) {
     const result = await runSubprocess("git", ["diff", "--name-only", "HEAD"], { cwd: repoRoot, timeoutMs: 5000 });
     return result.exitCode === 0 && result.stdout.trim().length === 0;
 }
-//# sourceMappingURL=claude-cli.js.map

package/dist/vendor/adapters/cli-bridge.js

@@ -250,4 +250,3 @@ function truncate(text, maxLength) {
     }
     return `...${text.slice(-(maxLength - 3))}`;
 }
-//# sourceMappingURL=cli-bridge.js.map

package/dist/vendor/adapters/direct-provider.js

@@ -38,4 +38,3 @@ export function createDirectProviderAdapter(options) {
         }
     };
 }
-//# sourceMappingURL=direct-provider.js.map

package/dist/vendor/adapters/index.js

@@ -3,4 +3,3 @@ export { createStubDirectProviderAdapter } from "./stub-direct-provider.js";
 export { createStubAgentCliAdapter } from "./stub-agent-cli.js";
 export { createAgentCliAdapter, createClaudeCliAdapter, createCodexCliAdapter } from "./claude-cli.js";
 export { createVerifierOnlyAdapter } from "./verifier-only.js";
-//# sourceMappingURL=index.js.map

package/dist/vendor/adapters/runtime-support.js

@@ -49,4 +49,3 @@ export function normalizeStructuredErrors(errors) {
 function roundUsd(value) {
     return Math.round(value * 1_000_000) / 1_000_000;
 }
-//# sourceMappingURL=runtime-support.js.map

package/dist/vendor/adapters/stub-agent-cli.js

@@ -38,4 +38,3 @@ export function createStubAgentCliAdapter(options) {
         }
     };
 }
-//# sourceMappingURL=stub-agent-cli.js.map

package/dist/vendor/adapters/stub-direct-provider.js

@@ -7,4 +7,3 @@ export function createStubDirectProviderAdapter(options) {
         responder: options.responder
     });
 }
-//# sourceMappingURL=stub-direct-provider.js.map