martin-loop 0.1.5 → 1.3.0

package/dist/vendor/core/exit-intelligence.js

@@ -0,0 +1,58 @@
+export function inferExit(input) {
+    if (input.lastResult?.status === "completed" && input.lastResult.verification.passed) {
+        return {
+            shouldExit: true,
+            lifecycleState: "completed",
+            reason: input.lastResult.verification.summary
+        };
+    }
+    if (input.costState.shouldStop) {
+        return {
+            shouldExit: true,
+            lifecycleState: "budget_exit",
+            reason: "Budget governor reached a hard limit."
+        };
+    }
+    if (input.lastFailure) {
+        const repeatedFailures = countRecentFailureMatches(input.loop.attempts, input.lastFailure.failureClass);
+        if (input.lastFailure.failureClass === "environment_mismatch" && repeatedFailures >= 2) {
+            return {
+                shouldExit: true,
+                lifecycleState: "human_escalation",
+                reason: "Repeated environment_mismatch failures require a human to repair the runtime."
+            };
+        }
+        if (repeatedFailures >= 2) {
+            return {
+                shouldExit: true,
+                lifecycleState: "diminishing_returns",
+                reason: `Repeated ${input.lastFailure.failureClass} failures suggest diminishing returns.`
+            };
+        }
+    }
+    if (input.lastResult?.status === "stalled" || repeatedSummary(input)) {
+        return {
+            shouldExit: true,
+            lifecycleState: "stuck_exit",
+            reason: "The loop is repeating the same stalled output."
+        };
+    }
+    return {
+        shouldExit: false,
+        lifecycleState: "running",
+        reason: "Another attempt is still justified."
+    };
+}
+function countRecentFailureMatches(attempts, failureClass) {
+    return attempts.slice(-3).filter((attempt) => attempt.failureClass === failureClass).length;
+}
+function repeatedSummary(input) {
+    if (!input.lastResult?.summary) {
+        return false;
+    }
+    const normalized = input.lastResult.summary.trim().toLowerCase();
+    return input.loop.attempts
+        .slice(-2)
+        .filter((attempt) => attempt.summary?.trim().toLowerCase() === normalized).length >= 2;
+}
+//# sourceMappingURL=exit-intelligence.js.map

package/dist/vendor/core/explain/formatter.d.ts

@@ -0,0 +1,42 @@
+/**
+ * formatter.ts — SLICE-25
+ *
+ * Pure artifact-to-explanation formatter. No model calls.
+ * Reads StoredAttemptArtifact structures and produces plain-English Markdown
+ * and structured JSON explaining every gate decision.
+ */
+import type { StoredAttemptArtifact } from "../replay/replay.js";
+export interface ExplainOptions {
+    loopId: string;
+    /** --attempt N — filter to a single attempt index (1-based) */
+    attemptFilter?: number;
+    /** --decision <gate> — filter to only one gate's explanation */
+    decisionFilter?: string;
+    /** --json — request structured JSON output in addition to Markdown */
+    json?: boolean;
+}
+export interface ExplainAttempt {
+    attemptId: string;
+    attemptNumber: number;
+    verdict: string;
+    grade: string;
+    costUsd: number;
+    leashBlocked: boolean;
+    leashPattern?: string;
+    verifierPasses: number;
+    verifierTotal: number;
+    blockReason?: string;
+    warning?: string;
+}
+export interface ExplainJson {
+    loopId: string;
+    objective: string;
+    outcome: string;
+    totalCostUsd: number;
+    attempts: ExplainAttempt[];
+}
+export interface ExplainOutput {
+    markdown: string;
+    json: ExplainJson;
+}
+export declare function formatRunExplanation(artifacts: StoredAttemptArtifact[], options: ExplainOptions): ExplainOutput;

package/dist/vendor/core/explain/formatter.js

@@ -0,0 +1,171 @@
+/**
+ * formatter.ts — SLICE-25
+ *
+ * Pure artifact-to-explanation formatter. No model calls.
+ * Reads StoredAttemptArtifact structures and produces plain-English Markdown
+ * and structured JSON explaining every gate decision.
+ */
+// ─── Formatter ────────────────────────────────────────────────────────────────
+export function formatRunExplanation(artifacts, options) {
+    const { loopId, attemptFilter, decisionFilter, json: jsonMode } = options;
+    // Build attempt models with safe access for potentially-broken artifacts
+    const allAttempts = artifacts.map((art, idx) => {
+        return buildAttemptModel(art, idx + 1);
+    });
+    // Apply attempt filter (1-based)
+    const filteredAttempts = attemptFilter != null
+        ? allAttempts.filter(a => a.attemptNumber === attemptFilter)
+        : allAttempts;
+    const objective = artifacts[0]?.objective ?? "unknown";
+    const totalCostUsd = allAttempts.reduce((sum, a) => sum + a.costUsd, 0);
+    const lastVerdict = allAttempts[allAttempts.length - 1]?.verdict ?? "UNKNOWN";
+    // Build JSON output
+    const jsonOutput = {
+        loopId,
+        objective,
+        outcome: lastVerdict,
+        totalCostUsd,
+        attempts: filteredAttempts
+    };
+    // Build Markdown output
+    const lines = [];
+    lines.push(`# Run Explanation — ${loopId}`);
+    lines.push("");
+    lines.push(`**Objective:** ${objective}`);
+    lines.push(`**Outcome:** ${lastVerdict}`);
+    lines.push(`**Total Cost:** $${totalCostUsd.toFixed(4)}`);
+    lines.push("");
+    for (const attempt of filteredAttempts) {
+        if (attempt.warning) {
+            lines.push(`> **Warning:** ${attempt.warning}`);
+            lines.push("");
+        }
+        if (decisionFilter) {
+            lines.push(...renderGateSection(attempt, decisionFilter));
+        }
+        else {
+            lines.push(...renderFullAttempt(attempt));
+        }
+        lines.push("");
+    }
+    return {
+        markdown: lines.join("\n"),
+        json: jsonOutput
+    };
+}
+// ─── Internal builders ────────────────────────────────────────────────────────
+function buildAttemptModel(artifact, attemptNumber) {
+    // Safe access — artifact may be partially broken
+    const decisions = artifact.decisions ?? {};
+    const leash = decisions.leash ?? { blocked: false };
+    const proof = decisions.proof;
+    const finalVerdict = decisions.finalVerdict ?? "UNKNOWN";
+    let warning;
+    let grade = "unknown";
+    let verifierPasses = 0;
+    let verifierTotal = 0;
+    let blockReason;
+    if (!proof || typeof proof.grade !== "string") {
+        warning = "invalid or missing proof gate data in artifact";
+    }
+    else {
+        grade = proof.grade;
+    }
+    // Support optional extended fields on artifact (attached by callers)
+    const extended = artifact;
+    const costUsd = typeof extended.costUsd === "number" ? extended.costUsd : 0;
+    if (typeof extended.verifierPasses === "number")
+        verifierPasses = extended.verifierPasses;
+    if (typeof extended.verifierTotal === "number")
+        verifierTotal = extended.verifierTotal;
+    if (typeof extended.blockReason === "string")
+        blockReason = extended.blockReason;
+    return {
+        attemptId: artifact.attemptId,
+        attemptNumber,
+        verdict: finalVerdict,
+        grade,
+        costUsd,
+        leashBlocked: leash.blocked,
+        leashPattern: leash.matchedPattern,
+        verifierPasses,
+        verifierTotal,
+        blockReason,
+        warning
+    };
+}
+function renderFullAttempt(attempt) {
+    const lines = [];
+    lines.push(`## Attempt ${attempt.attemptNumber}`);
+    lines.push("");
+    if (attempt.verdict === "ACCEPTED") {
+        lines.push(`Attempt ${attempt.attemptNumber} — ACCEPTED. Grade: ${attempt.grade}. ` +
+            `Verifier: ${attempt.verifierPasses}/${attempt.verifierTotal} passing. ` +
+            `Cost: $${attempt.costUsd.toFixed(4)}.`);
+    }
+    else if (attempt.leashBlocked) {
+        lines.push(`Attempt ${attempt.attemptNumber} — REJECTED by leash. ` +
+            `Pattern matched: ${attempt.leashPattern ?? "unknown"}. ` +
+            `Cost: $${attempt.costUsd.toFixed(4)}.`);
+    }
+    else if (attempt.grade === "C") {
+        const reason = attempt.blockReason ?? "grade C";
+        lines.push(`Attempt ${attempt.attemptNumber} — REJECTED at patch-proof gate. ` +
+            `Grade: C. Reason: ${reason}. ` +
+            `Cost: $${attempt.costUsd.toFixed(4)}.`);
+    }
+    else {
+        lines.push(`Attempt ${attempt.attemptNumber} — REJECTED. Grade: ${attempt.grade}. ` +
+            `Cost: $${attempt.costUsd.toFixed(4)}.`);
+    }
+    return lines;
+}
+function renderGateSection(attempt, gate) {
+    const lines = [];
+    lines.push(`## Attempt ${attempt.attemptNumber} — ${gate} gate`);
+    lines.push("");
+    switch (gate) {
+        case "leash": {
+            if (attempt.leashBlocked) {
+                lines.push(`Attempt ${attempt.attemptNumber} — REJECTED by leash. ` +
+                    `Pattern matched: ${attempt.leashPattern ?? "unknown"}. ` +
+                    `Cost: $${attempt.costUsd.toFixed(4)}.`);
+            }
+            else {
+                lines.push(`Attempt ${attempt.attemptNumber} — leash gate PASSED (no dangerous patterns detected).`);
+            }
+            break;
+        }
+        case "patch-proof": {
+            if (attempt.grade === "C") {
+                const reason = attempt.blockReason ?? "grade C";
+                lines.push(`Attempt ${attempt.attemptNumber} — REJECTED at patch-proof gate. ` +
+                    `Grade: C. Reason: ${reason}. ` +
+                    `Cost: $${attempt.costUsd.toFixed(4)}.`);
+            }
+            else {
+                lines.push(`Attempt ${attempt.attemptNumber} — patch-proof gate PASSED. ` +
+                    `Grade: ${attempt.grade}. ` +
+                    `Verifier: ${attempt.verifierPasses}/${attempt.verifierTotal} passing.`);
+            }
+            break;
+        }
+        case "grounding": {
+            lines.push(`Attempt ${attempt.attemptNumber} — grounding gate. Verdict: ${attempt.verdict}.`);
+            break;
+        }
+        case "budget": {
+            lines.push(`Attempt ${attempt.attemptNumber} — cost at this attempt: $${attempt.costUsd.toFixed(4)}.`);
+            break;
+        }
+        case "rollback": {
+            lines.push(`Attempt ${attempt.attemptNumber} — rollback gate. Verdict: ${attempt.verdict}.`);
+            break;
+        }
+        default: {
+            lines.push(`Attempt ${attempt.attemptNumber} — gate "${gate}" not recognised. Verdict: ${attempt.verdict}.`);
+        }
+    }
+    return lines;
+}
+//# sourceMappingURL=formatter.js.map

package/dist/vendor/core/explain/timeline.d.ts

@@ -0,0 +1,29 @@
+import type { LoopEvent, LoopLifecycleState } from "../../contracts/index.js";
+import type { LedgerEvent } from "../persistence/ledger.js";
+export interface RunTimelineEntry {
+    timestamp: string;
+    source: "loop" | "ledger";
+    label: string;
+    detail: string;
+    severity: "info" | "ok" | "warn";
+    attemptIndex?: number;
+}
+export interface RunTimelineJson {
+    loopId: string;
+    objective: string;
+    lifecycleState?: LoopLifecycleState;
+    entries: RunTimelineEntry[];
+}
+export interface RunTimelineOutput {
+    markdown: string;
+    html: string;
+    json: RunTimelineJson;
+}
+export interface FormatRunTimelineInput {
+    loopId: string;
+    objective: string;
+    lifecycleState?: LoopLifecycleState;
+    events?: LoopEvent[];
+    ledgerEvents?: LedgerEvent[];
+}
+export declare function formatRunTimeline(input: FormatRunTimelineInput): RunTimelineOutput;

package/dist/vendor/core/explain/timeline.js

@@ -0,0 +1,213 @@
+export function formatRunTimeline(input) {
+    const entries = buildRunTimelineEntries(input);
+    const json = {
+        loopId: input.loopId,
+        objective: input.objective,
+        ...(input.lifecycleState ? { lifecycleState: input.lifecycleState } : {}),
+        entries
+    };
+    return {
+        markdown: renderTimelineMarkdown(json),
+        html: renderTimelineHtml(json),
+        json
+    };
+}
+function buildRunTimelineEntries(input) {
+    const loopEntries = (input.events ?? []).map(mapLoopEvent);
+    const ledgerEntries = (input.ledgerEvents ?? []).map(mapLedgerEvent);
+    return [...loopEntries, ...ledgerEntries].sort((left, right) => left.timestamp.localeCompare(right.timestamp));
+}
+function mapLoopEvent(event) {
+    switch (event.type) {
+        case "run.started":
+            return {
+                timestamp: event.timestamp,
+                source: "loop",
+                label: "Run started",
+                detail: stringifyPayload(event.payload),
+                severity: "info"
+            };
+        case "attempt.started":
+            return {
+                timestamp: event.timestamp,
+                source: "loop",
+                label: "Attempt started",
+                detail: stringifyPayload(event.payload),
+                severity: "info"
+            };
+        case "attempt.completed":
+            return {
+                timestamp: event.timestamp,
+                source: "loop",
+                label: "Attempt completed",
+                detail: stringifyPayload(event.payload),
+                severity: "ok"
+            };
+        case "pattern.detected":
+            return {
+                timestamp: event.timestamp,
+                source: "loop",
+                label: "Pattern detected",
+                detail: stringifyPayload(event.payload),
+                severity: "warn"
+            };
+        case "failure.classified":
+            return {
+                timestamp: event.timestamp,
+                source: "loop",
+                label: "Failure classified",
+                detail: stringifyPayload(event.payload),
+                severity: "warn"
+            };
+        case "intervention.selected":
+            return {
+                timestamp: event.timestamp,
+                source: "loop",
+                label: "Intervention selected",
+                detail: stringifyPayload(event.payload),
+                severity: "info"
+            };
+        case "verification.completed":
+            return {
+                timestamp: event.timestamp,
+                source: "loop",
+                label: "Verification completed",
+                detail: stringifyPayload(event.payload),
+                severity: "ok"
+            };
+        case "budget.updated":
+            return {
+                timestamp: event.timestamp,
+                source: "loop",
+                label: "Budget updated",
+                detail: stringifyPayload(event.payload),
+                severity: "info"
+            };
+        case "run.completed":
+            return {
+                timestamp: event.timestamp,
+                source: "loop",
+                label: "Run completed",
+                detail: stringifyPayload(event.payload),
+                severity: "ok"
+            };
+    }
+}
+function mapLedgerEvent(event) {
+    const labelMap = {
+        "contract.created": "Contract created",
+        "attempt.admitted": "Attempt admitted",
+        "attempt.rejected": "Attempt rejected",
+        "prompt.compiled": "Prompt compiled",
+        "patch.generated": "Patch generated",
+        "verification.completed": "Verification completed",
+        "grounding.violations_found": "Grounding violation",
+        "safety.violations_found": "Safety violation",
+        "budget.settled": "Budget settled",
+        "attempt.kept": "Attempt kept",
+        "attempt.discarded": "Attempt discarded",
+        "run.exited": "Run exited"
+    };
+    const severity = event.kind === "attempt.rejected" ||
+        event.kind === "grounding.violations_found" ||
+        event.kind === "safety.violations_found" ||
+        event.kind === "attempt.discarded" ||
+        event.kind === "run.exited"
+        ? "warn"
+        : event.kind === "attempt.kept" || event.kind === "verification.completed"
+            ? "ok"
+            : "info";
+    return {
+        timestamp: event.timestamp,
+        source: "ledger",
+        label: labelMap[event.kind],
+        detail: stringifyPayload(event.payload),
+        severity,
+        ...(event.attemptIndex !== undefined ? { attemptIndex: event.attemptIndex } : {})
+    };
+}
+function renderTimelineMarkdown(timeline) {
+    const lines = [
+        `# Run Timeline — ${timeline.loopId}`,
+        "",
+        `**Objective:** ${timeline.objective}`,
+        ...(timeline.lifecycleState ? [`**Lifecycle:** ${timeline.lifecycleState}`, ""] : [""]),
+        "| Time | Source | Event | Detail |",
+        "| --- | --- | --- | --- |",
+        ...timeline.entries.map((entry) => {
+            const detail = entry.detail.replace(/\|/g, "\\|");
+            return `| ${entry.timestamp} | ${entry.source} | ${entry.label} | ${detail} |`;
+        })
+    ];
+    return lines.join("\n");
+}
+function renderTimelineHtml(timeline) {
+    const rows = timeline.entries
+        .map((entry) => {
+        const badgeClass = `badge-${entry.severity}`;
+        return [
+            "<tr>",
+            `<td>${escapeHtml(entry.timestamp)}</td>`,
+            `<td><span class="source-chip">${escapeHtml(entry.source)}</span></td>`,
+            `<td><span class="badge ${badgeClass}">${escapeHtml(entry.label)}</span></td>`,
+            `<td>${escapeHtml(entry.detail)}</td>`,
+            "</tr>"
+        ].join("");
+    })
+        .join("\n");
+    return [
+        "<!DOCTYPE html>",
+        '<html lang="en">',
+        "<head>",
+        '<meta charset="UTF-8" />',
+        '<meta name="viewport" content="width=device-width, initial-scale=1.0" />',
+        `<title>Run Timeline — ${escapeHtml(timeline.loopId)}</title>`,
+        "<style>",
+        "body{margin:0;background:#f8f5ed;color:#18181b;font-family:'General Sans',-apple-system,BlinkMacSystemFont,sans-serif;padding:40px;}",
+        "h1{font-family:'Fraunces',Georgia,serif;font-size:42px;line-height:1.05;margin:0 0 12px;}",
+        "p.meta{color:#5c6170;margin:0 0 28px;font-size:16px;}",
+        ".wrap{max-width:1100px;margin:0 auto;}",
+        "table{width:100%;border-collapse:collapse;background:#fff;border:1px solid #e6e0d4;border-radius:18px;overflow:hidden;box-shadow:0 18px 50px rgba(17,17,17,.06);}",
+        "th,td{padding:14px 16px;border-bottom:1px solid #eee8dc;text-align:left;vertical-align:top;font-size:14px;}",
+        "th{font-size:12px;letter-spacing:.08em;text-transform:uppercase;color:#6b7280;background:#fcfbf7;}",
+        ".badge,.source-chip{display:inline-flex;align-items:center;border-radius:999px;padding:4px 10px;font-size:12px;font-weight:700;}",
+        ".badge-info{background:#ece8ff;color:#4f46e5;}.badge-ok{background:#dcfce7;color:#166534;}.badge-warn{background:#fef3c7;color:#92400e;}",
+        ".source-chip{background:#f3f4f6;color:#4b5563;}",
+        "</style>",
+        "</head>",
+        "<body>",
+        '<div class="wrap">',
+        `<h1>Run timeline</h1>`,
+        `<p class="meta"><strong>Loop:</strong> ${escapeHtml(timeline.loopId)}<br/><strong>Objective:</strong> ${escapeHtml(timeline.objective)}${timeline.lifecycleState ? `<br/><strong>Lifecycle:</strong> ${escapeHtml(timeline.lifecycleState)}` : ""}</p>`,
+        "<table>",
+        "<thead><tr><th>Time</th><th>Source</th><th>Event</th><th>Detail</th></tr></thead>",
+        `<tbody>${rows}</tbody>`,
+        "</table>",
+        "</div>",
+        "</body>",
+        "</html>"
+    ].join("");
+}
+function stringifyPayload(payload) {
+    const flattened = Object.entries(payload)
+        .map(([key, value]) => `${key}=${formatValue(value)}`)
+        .join("; ");
+    return flattened || "no additional payload";
+}
+function formatValue(value) {
+    if (Array.isArray(value)) {
+        return value.join(", ");
+    }
+    if (value && typeof value === "object") {
+        return JSON.stringify(value);
+    }
+    return String(value);
+}
+function escapeHtml(value) {
+    return value
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;");
+}
+//# sourceMappingURL=timeline.js.map

package/dist/vendor/core/failure-taxonomy.d.ts

@@ -0,0 +1,2 @@
+import type { FailureAssessment, FailureClassificationInput } from "./types.js";
+export declare function classifyFailure(input: FailureClassificationInput): FailureAssessment;

package/dist/vendor/core/failure-taxonomy.js

@@ -0,0 +1,76 @@
+export function classifyFailure(input) {
+    const failureClass = detectFailureClass(input);
+    const repeatedCount = countRecentMatches(input.attempts, failureClass);
+    const retryable = failureClass !== "environment_mismatch";
+    const recommendedIntervention = chooseIntervention(failureClass, repeatedCount);
+    return {
+        failureClass,
+        retryable,
+        recommendedIntervention,
+        rationale: buildRationale(failureClass, input, repeatedCount, recommendedIntervention)
+    };
+}
+function detectFailureClass(input) {
+    const hint = input.result.failure?.classHint;
+    if (hint) {
+        return hint;
+    }
+    const haystack = [
+        input.result.summary,
+        input.result.verification.summary,
+        input.result.failure?.message
+    ]
+        .filter((value) => typeof value === "string")
+        .join(" ")
+        .toLowerCase();
+    if (containsAny(haystack, ["enoent", "command not found", "missing from path", "permission denied"])) {
+        return "environment_mismatch";
+    }
+    if (containsAny(haystack, ["syntax", "parse", "eslint", "ts1"])) {
+        return "syntax_error";
+    }
+    if (containsAny(haystack, ["budget", "token", "limit", "cost"])) {
+        return "budget_pressure";
+    }
+    if (containsAny(haystack, ["scope", "too broad", "expanded"])) {
+        return "scope_creep";
+    }
+    if (containsAny(haystack, ["hallucin", "invented", "made up"])) {
+        return "hallucination";
+    }
+    if (!input.result.verification.passed) {
+        return "verification_failure";
+    }
+    return "logic_error";
+}
+function chooseIntervention(failureClass, repeatedCount) {
+    if (failureClass === "environment_mismatch") {
+        return repeatedCount >= 2 ? "switch_adapter" : "escalate_human";
+    }
+    if (failureClass === "budget_pressure") {
+        return "compress_context";
+    }
+    if (failureClass === "scope_creep") {
+        return "tighten_task";
+    }
+    if (failureClass === "verification_failure" || failureClass === "syntax_error") {
+        return "run_verifier";
+    }
+    if (repeatedCount >= 2) {
+        return "change_model";
+    }
+    return "change_model";
+}
+function buildRationale(failureClass, input, repeatedCount, intervention) {
+    const evidence = input.result.failure?.message ?? input.result.verification.summary;
+    const repetitionNote = repeatedCount >= 2 ? ` The same failure appeared in ${repeatedCount} recent attempts.` : "";
+    return `${failureClass} inferred from "${evidence}". Recommended intervention: ${intervention}.${repetitionNote}`;
+}
+function countRecentMatches(attempts, failureClass) {
+    const recent = attempts.slice(-3).filter((attempt) => attempt.failureClass === failureClass);
+    return recent.length;
+}
+function containsAny(value, needles) {
+    return needles.some((needle) => value.includes(needle));
+}
+//# sourceMappingURL=failure-taxonomy.js.map

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

@@ -0,0 +1,10 @@
+export * from "./registry.js";
+export * from "./transport.js";
+export * from "./vault.js";
+import { McpServerRegistry, type McpServerConfig } from "./registry.js";
+import { McpHttpTransport } from "./transport.js";
+import type { McpTokenVault } from "./vault.js";
+export declare function createGateway(servers: McpServerConfig[], vault?: McpTokenVault): {
+    registry: McpServerRegistry;
+    transport: McpHttpTransport;
+};

package/dist/vendor/core/gateway/index.js

@@ -0,0 +1,12 @@
+export * from "./registry.js";
+export * from "./transport.js";
+export * from "./vault.js";
+import { McpServerRegistry } from "./registry.js";
+import { McpHttpTransport } from "./transport.js";
+export function createGateway(servers, vault) {
+    return {
+        registry: new McpServerRegistry(servers),
+        transport: new McpHttpTransport(vault)
+    };
+}
+//# sourceMappingURL=index.js.map

package/dist/vendor/core/gateway/registry.d.ts

@@ -0,0 +1,40 @@
+export interface McpServerConfig {
+    id: string;
+    name: string;
+    url: string;
+    headers?: Record<string, string>;
+    trustTier: "system" | "verified" | "untrusted";
+    allowedTools: string[];
+    blockedTools: string[];
+}
+export type ToolPolicyDecision = {
+    action: "allow";
+} | {
+    action: "deny";
+    reason: string;
+} | {
+    action: "simulate";
+    mockResponse: unknown;
+} | {
+    action: "review";
+    reason: string;
+};
+export interface ToolExecutionAttempt {
+    serverId: string;
+    toolName: string;
+    args: Record<string, unknown>;
+    context: {
+        loopId: string;
+        executionProfile?: string;
+    };
+}
+export declare class McpServerRegistry {
+    private readonly servers;
+    constructor(initialServers?: McpServerConfig[]);
+    register(server: McpServerConfig): void;
+    unregister(serverId: string): boolean;
+    getServer(serverId: string): McpServerConfig | undefined;
+    listServers(): McpServerConfig[];
+    evaluateToolPolicy(attempt: ToolExecutionAttempt): ToolPolicyDecision;
+    private matchesPattern;
+}