martin-loop 0.1.4 → 1.3.0

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;
+}

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

@@ -0,0 +1,97 @@
+import { getTracer } from "../otel/tracer.js";
+export class McpServerRegistry {
+    servers = new Map();
+    constructor(initialServers = []) {
+        for (const server of initialServers) {
+            this.register(server);
+        }
+    }
+    register(server) {
+        if (!server.id || !server.url) {
+            throw new Error(`Invalid MCP server configuration for: ${server.name}`);
+        }
+        this.servers.set(server.id, server);
+    }
+    unregister(serverId) {
+        return this.servers.delete(serverId);
+    }
+    getServer(serverId) {
+        return this.servers.get(serverId);
+    }
+    listServers() {
+        return Array.from(this.servers.values());
+    }
+    evaluateToolPolicy(attempt) {
+        const tracer = getTracer();
+        const span = tracer.startSpan("martin.gateway_policy", {
+            "tool.name": attempt.toolName,
+            "server.id": attempt.serverId,
+            "context.loop": attempt.context.loopId
+        });
+        const finish = (decision) => {
+            tracer.endSpan(span, decision.action === "deny" ? "ERROR" : "OK");
+            return decision;
+        };
+        const server = this.getServer(attempt.serverId);
+        if (!server) {
+            return finish({
+                action: "deny",
+                reason: `Server ID '${attempt.serverId}' not registered.`
+            });
+        }
+        if (server.trustTier === "untrusted" &&
+            attempt.context.executionProfile === "ci_safe") {
+            return finish({
+                action: "deny",
+                reason: "Untrusted MCP servers are disabled under ci_safe profile."
+            });
+        }
+        // Direct blocklist
+        if (this.matchesPattern(attempt.toolName, server.blockedTools)) {
+            return finish({
+                action: "deny",
+                reason: `Tool '${attempt.toolName}' is blocked by server policy.`
+            });
+        }
+        // Allowlist
+        if (server.allowedTools.length > 0 &&
+            !this.matchesPattern(attempt.toolName, server.allowedTools)) {
+            return finish({
+                action: "deny",
+                reason: `Tool '${attempt.toolName}' is not in the server allowlist.`
+            });
+        }
+        // Dangerous patterns require dry-run ("simulate") if not strongly verified
+        if (server.trustTier !== "system") {
+            const stringifiedArgs = JSON.stringify(attempt.args);
+            if (stringifiedArgs.includes("rm -rf") ||
+                stringifiedArgs.includes("drop table")) {
+                return finish({
+                    action: "simulate",
+                    mockResponse: {
+                        success: true,
+                        stdout: "",
+                        stderr: "DRY-RUN: Command intercepted and skipped."
+                    }
+                });
+            }
+        }
+        return finish({ action: "allow" });
+    }
+    matchesPattern(tool, patterns) {
+        for (const p of patterns) {
+            if (p === "*")
+                return true;
+            if (p.endsWith("*")) {
+                const prefix = p.slice(0, -1);
+                if (tool.startsWith(prefix))
+                    return true;
+            }
+            else if (p === tool) {
+                return true;
+            }
+        }
+        return false;
+    }
+}
+//# sourceMappingURL=registry.js.map

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

@@ -0,0 +1,31 @@
+import type { McpServerConfig } from "./registry.js";
+import type { McpTokenVault } from "./vault.js";
+export interface JsonRpcRequest {
+    jsonrpc: "2.0";
+    id: string | number;
+    method: string;
+    params?: unknown;
+}
+export interface JsonRpcResponse<T = unknown> {
+    jsonrpc: "2.0";
+    id: string | number;
+    result?: T;
+    error?: {
+        code: number;
+        message: string;
+        data?: unknown;
+    };
+}
+export declare class McpTransportError extends Error {
+    readonly status?: number | undefined;
+    readonly data?: unknown | undefined;
+    constructor(message: string, status?: number | undefined, data?: unknown | undefined);
+}
+export declare class McpHttpTransport {
+    private readonly vault?;
+    constructor(vault?: McpTokenVault | undefined);
+    /**
+     * Dispatches a raw JSON-RPC 2.0 request to an external MCP HTTP server.
+     */
+    executeCommand<T = unknown>(server: McpServerConfig, method: string, params: Record<string, unknown>, requestId: string): Promise<T>;
+}

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

@@ -0,0 +1,82 @@
+export class McpTransportError extends Error {
+    status;
+    data;
+    constructor(message, status, data) {
+        super(message);
+        this.status = status;
+        this.data = data;
+        this.name = "McpTransportError";
+    }
+}
+export class McpHttpTransport {
+    vault;
+    constructor(vault) {
+        this.vault = vault;
+    }
+    /**
+     * Dispatches a raw JSON-RPC 2.0 request to an external MCP HTTP server.
+     */
+    async executeCommand(server, method, params, requestId) {
+        const payload = {
+            jsonrpc: "2.0",
+            id: requestId,
+            method,
+            params
+        };
+        const headers = new Headers({
+            "Content-Type": "application/json",
+            "User-Agent": "Martin-Loop-Gateway/0.1.0"
+        });
+        if (server.headers) {
+            for (const [key, value] of Object.entries(server.headers)) {
+                headers.set(key, value);
+            }
+        }
+        if (this.vault) {
+            const dynamicHeaders = await this.vault.resolveHeaders(server.id);
+            for (const [key, value] of Object.entries(dynamicHeaders)) {
+                headers.set(key, value);
+            }
+        }
+        try {
+            // 30s timeout so the loop doesn't hang indefinitely on a bad server
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), 30000);
+            const response = await fetch(server.url, {
+                method: "POST",
+                headers,
+                body: JSON.stringify(payload),
+                signal: controller.signal
+            });
+            clearTimeout(timeout);
+            if (!response.ok) {
+                throw new McpTransportError(`HTTP Error ${response.status}: Failed to reach MCP Server '${server.id}'`, response.status);
+            }
+            const rawJson = await response.text();
+            let rpcResponse;
+            try {
+                rpcResponse = JSON.parse(rawJson);
+            }
+            catch {
+                throw new McpTransportError(`Invalid JSON received from MCP Server '${server.id}'`);
+            }
+            if (rpcResponse.error) {
+                throw new McpTransportError(`MCP Server Internal Error: ${rpcResponse.error.message}`, undefined, rpcResponse.error.data);
+            }
+            // JSON-RPC 2.0 requires `result` to exist on success
+            if (rpcResponse.result === undefined) {
+                throw new McpTransportError(`Malformed JSON-RPC response from '${server.id}': Missing result.`);
+            }
+            return rpcResponse.result;
+        }
+        catch (e) {
+            if (e instanceof McpTransportError) {
+                throw e;
+            }
+            const err = e;
+            const errMessage = err.name === "AbortError" ? "Request Timeout" : err.message;
+            throw new McpTransportError(`Network error dispatching to MCP Server '${server.id}': ${errMessage}`);
+        }
+    }
+}
+//# sourceMappingURL=transport.js.map

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

@@ -0,0 +1,19 @@
+export interface McpTokenVault {
+    /**
+     * Resolves authentication headers for a given server dynamically.
+     * Can be implemented via OAuth, Secret Managers, or static config.
+     */
+    resolveHeaders(serverId: string): Promise<Record<string, string>>;
+}
+export declare class StaticTokenVault implements McpTokenVault {
+    private readonly staticHeaders;
+    constructor(staticHeaders: Map<string, Record<string, string>>);
+    resolveHeaders(serverId: string): Promise<Record<string, string>>;
+}
+export declare class OAuthProxyVault implements McpTokenVault {
+    private readonly oauthTokenEndpoint;
+    private readonly clientId;
+    private readonly clientSecret;
+    constructor(oauthTokenEndpoint: string, clientId: string, clientSecret: string);
+    resolveHeaders(serverId: string): Promise<Record<string, string>>;
+}

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

@@ -0,0 +1,29 @@
+export class StaticTokenVault {
+    staticHeaders;
+    constructor(staticHeaders) {
+        this.staticHeaders = staticHeaders;
+    }
+    async resolveHeaders(serverId) {
+        return this.staticHeaders.get(serverId) ?? {};
+    }
+}
+export class OAuthProxyVault {
+    oauthTokenEndpoint;
+    clientId;
+    clientSecret;
+    constructor(oauthTokenEndpoint, clientId, clientSecret) {
+        this.oauthTokenEndpoint = oauthTokenEndpoint;
+        this.clientId = clientId;
+        this.clientSecret = clientSecret;
+    }
+    async resolveHeaders(serverId) {
+        // Basic dynamic OAuth token fetch simulation for multi-tenant isolation
+        // Without actually making real un-mocked requests that could crash tests
+        const token = Buffer.from(`${this.clientId}:${this.clientSecret}-${serverId}`).toString("base64");
+        return {
+            Authorization: `Bearer ${token}`,
+            "X-Martin-Scope": "dynamic-vault"
+        };
+    }
+}
+//# sourceMappingURL=vault.js.map

package/dist/vendor/core/graph/adapters.d.ts

@@ -0,0 +1,43 @@
+import type { RepoHotspot } from "./hotspots.js";
+export interface MartinGraphAdapter {
+    queryRegressions(targetFiles: string[], objective: string): Promise<RepoHotspot[]>;
+    ingestRun(record: unknown): Promise<void>;
+}
+/**
+ * Abstract interface to ensure the system can hot-swap external graph engines
+ * (like Neo4j) without rewriting the core calculation logic when workspace scale grows.
+ */
+export declare abstract class AbstractGraphStore implements MartinGraphAdapter {
+    abstract queryRegressions(targetFiles: string[], objective: string): Promise<RepoHotspot[]>;
+    abstract ingestRun(record: unknown): Promise<void>;
+}
+export declare class JsonAdjacencyGraphAdapter extends AbstractGraphStore {
+    private readonly adjacencyFilePath;
+    constructor(adjacencyFilePath: string);
+    queryRegressions(targetFiles: string[], _objective: string): Promise<RepoHotspot[]>;
+    ingestRun(_record: unknown): Promise<void>;
+}
+/**
+ * GitBlameGraphAdapter
+ *
+ * Derives repository hotspots from live git history — no static JSON file required.
+ *
+ * For each target file, runs `git log --oneline --follow -- <file>` to count
+ * how many commits have touched it. Files with a commit count >= the configured
+ * threshold are returned as hotspots. The regression count is the git commit count,
+ * which is a reliable, repo-native signal of churn / instability.
+ *
+ * Fail-open: any git error (not a repo, file not tracked, git not installed) returns
+ * an empty result for that file — never throws.
+ */
+export declare class GitBlameGraphAdapter extends AbstractGraphStore {
+    private readonly repoRoot;
+    /** Files with >= this many commits are classified as hotspots. Default: 5 */
+    private readonly commitThreshold;
+    constructor(repoRoot: string, 
+    /** Files with >= this many commits are classified as hotspots. Default: 5 */
+    commitThreshold?: number);
+    queryRegressions(targetFiles: string[], _objective: string): Promise<RepoHotspot[]>;
+    ingestRun(_record: unknown): Promise<void>;
+    private countCommits;
+}