@infinitedusky/indusk-mcp 1.16.1 → 1.18.0

package/dist/bin/commands/eval.js

@@ -212,7 +212,7 @@ export async function evalBaseline(projectRoot, opts) {
     }
     // Run the smart evaluator against the baseline
     console.info("Running smart evaluator against baseline...");
-    const { runJudgeSync } = await import("../../lib/eval/judge-runner.js");
+    const { runEvaluatorSync } = await import("../../lib/eval/evaluator-runner.js");
     let changeId;
     try {
         changeId = execSync("jj log -r @ --no-graph -T change_id", {
@@ -223,7 +223,7 @@ export async function evalBaseline(projectRoot, opts) {
     catch {
         changeId = "baseline-unknown";
     }
-    const evalResult = await runJudgeSync({
+    const evalResult = await runEvaluatorSync({
         projectRoot: worktreePath,
         changeId,
         transcriptPath: "(baseline — no transcript)",

package/dist/bin/commands/extensions.js

@@ -374,7 +374,7 @@ export async function extensionsUpdate(projectRoot, names) {
             continue;
         try {
             if (!ext.manifest._source) {
-                if (names && names.includes(name)) {
+                if (names?.includes(name)) {
                     console.info(`  ${name}: built-in extension — updated via package update, not extensions update`);
                 }
                 continue;
@@ -633,7 +633,10 @@ function printMcpInstructions(name, manifest) {
     const needsAuth = server.headers && Object.keys(server.headers).length > 0;
     // Remove first, then add — ensures clean state
     try {
-        execSync(`claude mcp remove -s project ${name}`, { timeout: 10000, stdio: ["ignore", "pipe", "pipe"] });
+        execSync(`claude mcp remove -s project ${name}`, {
+            timeout: 10000,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
     }
     catch {
         // not registered yet, fine

package/dist/bin/commands/init-docs.js

@@ -24,7 +24,7 @@ export async function initDocs(projectRoot) {
         mkdirSync(join(docsDir, dir), { recursive: true });
     }
     // package.json
-    writeFileSync(join(docsDir, "package.json"), JSON.stringify({
+    writeFileSync(join(docsDir, "package.json"), `${JSON.stringify({
         name: `${projectName}-docs`,
         version: "0.1.0",
         private: true,
@@ -42,7 +42,7 @@ export async function initDocs(projectRoot) {
             "vitepress-plugin-mermaid": "^2.0.10",
             vue: "^3.4.15",
         },
-    }, null, "\t") + "\n");
+    }, null, "\t")}\n`);
     // .vitepress/config.ts
     writeFileSync(join(docsDir, "src/.vitepress/config.ts"), `import { defineConfig } from "vitepress";
 import llmstxt from "vitepress-plugin-llms";

package/dist/lib/eval/evaluator-runner.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Evaluator runner — spawns a background `claude --print` process that evaluates
+ * a commit and writes results to the eval log.
+ *
+ * The evaluator is a detached child process so the calling hook can exit immediately.
+ * Results appear asynchronously in `.indusk/eval/results.log`.
+ */
+import type { EvalErrorEntry, EvalScorecard } from "./types.js";
+export interface EvaluatorRunOptions {
+    projectRoot: string;
+    changeId: string;
+    transcriptPath: string;
+    mode: "eval" | "baseline";
+    evalEndpoint?: string;
+}
+/**
+ * Run the evaluator as a detached background process.
+ *
+ * Spawns `claude --print` with the evaluator prompt and allowed tools whitelist.
+ * Collects stdout, parses the scorecard JSON, and appends to the eval log.
+ * If anything fails, logs an error entry instead of silently dropping.
+ */
+export declare function runEvaluatorBackground(opts: EvaluatorRunOptions): void;
+/**
+ * Run the evaluator synchronously (for testing and manual invocation).
+ * Returns the scorecard or error entry.
+ */
+export declare function runEvaluatorSync(opts: EvaluatorRunOptions): Promise<EvalScorecard | EvalErrorEntry>;

package/dist/lib/eval/evaluator-runner.js

@@ -0,0 +1,266 @@
+/**
+ * Evaluator runner — spawns a background `claude --print` process that evaluates
+ * a commit and writes results to the eval log.
+ *
+ * The evaluator is a detached child process so the calling hook can exit immediately.
+ * Results appear asynchronously in `.indusk/eval/results.log`.
+ */
+import { spawn } from "node:child_process";
+import { join } from "node:path";
+import { getProjectGroupId } from "../config.js";
+import { ingestScorecard } from "./findings.js";
+import { EvalLogWriter } from "./log-writer.js";
+import { initEvalOtel, shutdownEvalOtel, withSpan } from "./otel.js";
+import { buildEvaluatorPrompt } from "./prompt-builder.js";
+import { V1_RUBRIC } from "./rubric.js";
+function getEvalLogPath(projectRoot) {
+    return join(projectRoot, ".indusk", "eval", "results.log");
+}
+async function postTelemetry(endpoint, scorecard) {
+    try {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 5000);
+        await fetch(endpoint, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(scorecard),
+            signal: controller.signal,
+        });
+        clearTimeout(timeout);
+    }
+    catch {
+        // fire-and-forget — silently ignore errors
+    }
+}
+/**
+ * Run the evaluator as a detached background process.
+ *
+ * Spawns `claude --print` with the evaluator prompt and allowed tools whitelist.
+ * Collects stdout, parses the scorecard JSON, and appends to the eval log.
+ * If anything fails, logs an error entry instead of silently dropping.
+ */
+export function runEvaluatorBackground(opts) {
+    const projectGroup = getProjectGroupId(opts.projectRoot);
+    const prompt = buildEvaluatorPrompt({
+        rubric: V1_RUBRIC,
+        changeId: opts.changeId,
+        transcriptPath: opts.transcriptPath,
+        mode: opts.mode,
+        projectGroup,
+    });
+    const allowedTools = [
+        "Read",
+        "Grep",
+        "Glob",
+        "Bash(jj:*)",
+        "Bash(git:*)",
+        "mcp__graphiti__*",
+        "mcp__indusk__*",
+        "mcp__codegraphcontext__*",
+    ];
+    const args = [
+        "--print",
+        "--output-format",
+        "json",
+        "--model",
+        "opus",
+        "--permission-mode",
+        "acceptEdits",
+        "--allowed-tools",
+        allowedTools.join(","),
+    ];
+    // Not detached — the eval-trigger hook already spawns this in a separate
+    // node process. Detaching + unref causes the close handler to never fire.
+    const child = spawn("claude", args, {
+        cwd: opts.projectRoot,
+        stdio: ["pipe", "pipe", "pipe"],
+        env: { ...process.env },
+    });
+    // Pipe the prompt via stdin (too large for CLI arg)
+    child.stdin?.write(prompt);
+    child.stdin?.end();
+    let stdout = "";
+    let stderr = "";
+    child.stdout?.on("data", (chunk) => {
+        stdout += chunk.toString();
+    });
+    child.stderr?.on("data", (chunk) => {
+        stderr += chunk.toString();
+    });
+    child.on("close", async (code) => {
+        const logWriter = new EvalLogWriter(getEvalLogPath(opts.projectRoot));
+        try {
+            if (code !== 0) {
+                throw new Error(`claude exited with code ${code}: ${stderr.slice(0, 500)}`);
+            }
+            // --output-format json wraps the result; extract the text content and usage
+            let scorecardText = stdout;
+            let usage;
+            try {
+                const jsonOutput = JSON.parse(stdout);
+                scorecardText = jsonOutput.result ?? jsonOutput.text ?? jsonOutput.content ?? stdout;
+                // Capture usage data from claude --print output
+                if (jsonOutput.total_cost_usd !== undefined || jsonOutput.usage) {
+                    const u = jsonOutput.usage ?? {};
+                    usage = {
+                        costUsd: jsonOutput.total_cost_usd ?? 0,
+                        inputTokens: u.input_tokens ?? 0,
+                        outputTokens: u.output_tokens ?? 0,
+                        cacheCreationTokens: u.cache_creation_input_tokens ?? 0,
+                        cacheReadTokens: u.cache_read_input_tokens ?? 0,
+                        durationMs: jsonOutput.duration_ms ?? 0,
+                    };
+                }
+            }
+            catch {
+                // stdout might be raw JSON scorecard already
+            }
+            // Extract JSON from possible markdown code fences
+            const jsonMatch = scorecardText.match(/```(?:json)?\s*\n?([\s\S]*?)\n?```/);
+            if (jsonMatch?.[1]) {
+                scorecardText = jsonMatch[1];
+            }
+            const scorecard = JSON.parse(scorecardText.trim());
+            if (usage)
+                scorecard.usage = usage;
+            scorecard.telemetryPosted = false;
+            if (opts.evalEndpoint) {
+                await postTelemetry(opts.evalEndpoint, scorecard);
+                scorecard.telemetryPosted = true;
+            }
+            await logWriter.append(scorecard);
+            ingestScorecard(opts.projectRoot, scorecard);
+        }
+        catch (err) {
+            const errorEntry = {
+                version: 1,
+                timestamp: new Date().toISOString(),
+                mode: opts.mode,
+                changeId: opts.changeId,
+                error: true,
+                message: err instanceof Error ? err.message : String(err),
+            };
+            await logWriter.append(errorEntry);
+        }
+    });
+}
+/**
+ * Run the evaluator synchronously (for testing and manual invocation).
+ * Returns the scorecard or error entry.
+ */
+export async function runEvaluatorSync(opts) {
+    const tracer = initEvalOtel(opts.projectRoot);
+    const source = process.env.INDUSK_EVAL_SOURCE ?? "commit";
+    const projectGroup = getProjectGroupId(opts.projectRoot);
+    const result = await withSpan(tracer, "eval.run", {
+        changeId: opts.changeId,
+        source,
+        mode: opts.mode,
+        projectGroup,
+        entrypoint: "runEvaluatorSync",
+    }, () => runEvaluatorSyncInner(opts, projectGroup));
+    await shutdownEvalOtel();
+    return result;
+}
+async function runEvaluatorSyncInner(opts, projectGroup) {
+    const prompt = buildEvaluatorPrompt({
+        rubric: V1_RUBRIC,
+        changeId: opts.changeId,
+        transcriptPath: opts.transcriptPath,
+        mode: opts.mode,
+        projectGroup,
+    });
+    const allowedTools = [
+        "Read",
+        "Grep",
+        "Glob",
+        "Bash(jj:*)",
+        "Bash(git:*)",
+        "mcp__graphiti__*",
+        "mcp__indusk__*",
+        "mcp__codegraphcontext__*",
+    ];
+    const args = [
+        "--print",
+        "--output-format",
+        "json",
+        "--model",
+        "opus",
+        "--permission-mode",
+        "acceptEdits",
+        "--allowed-tools",
+        allowedTools.join(","),
+    ];
+    return new Promise((resolve) => {
+        const child = spawn("claude", args, {
+            cwd: opts.projectRoot,
+            stdio: ["pipe", "pipe", "pipe"],
+            env: { ...process.env },
+        });
+        child.stdin?.write(prompt);
+        child.stdin?.end();
+        let stdout = "";
+        let stderr = "";
+        child.stdout?.on("data", (chunk) => {
+            stdout += chunk.toString();
+        });
+        child.stderr?.on("data", (chunk) => {
+            stderr += chunk.toString();
+        });
+        child.on("close", async (code) => {
+            const logWriter = new EvalLogWriter(getEvalLogPath(opts.projectRoot));
+            try {
+                if (code !== 0) {
+                    throw new Error(`claude exited with code ${code}: ${stderr.slice(0, 500)}`);
+                }
+                let scorecardText = stdout;
+                let syncUsage;
+                try {
+                    const jsonOutput = JSON.parse(stdout);
+                    scorecardText = jsonOutput.result ?? jsonOutput.text ?? jsonOutput.content ?? stdout;
+                    if (jsonOutput.total_cost_usd !== undefined || jsonOutput.usage) {
+                        const u = jsonOutput.usage ?? {};
+                        syncUsage = {
+                            costUsd: jsonOutput.total_cost_usd ?? 0,
+                            inputTokens: u.input_tokens ?? 0,
+                            outputTokens: u.output_tokens ?? 0,
+                            cacheCreationTokens: u.cache_creation_input_tokens ?? 0,
+                            cacheReadTokens: u.cache_read_input_tokens ?? 0,
+                            durationMs: jsonOutput.duration_ms ?? 0,
+                        };
+                    }
+                }
+                catch {
+                    // raw JSON
+                }
+                const jsonMatch = scorecardText.match(/```(?:json)?\s*\n?([\s\S]*?)\n?```/);
+                if (jsonMatch?.[1]) {
+                    scorecardText = jsonMatch[1];
+                }
+                const scorecard = JSON.parse(scorecardText.trim());
+                if (syncUsage)
+                    scorecard.usage = syncUsage;
+                scorecard.telemetryPosted = false;
+                if (opts.evalEndpoint) {
+                    await postTelemetry(opts.evalEndpoint, scorecard);
+                    scorecard.telemetryPosted = true;
+                }
+                await logWriter.append(scorecard);
+                ingestScorecard(opts.projectRoot, scorecard);
+                resolve(scorecard);
+            }
+            catch (err) {
+                const errorEntry = {
+                    version: 1,
+                    timestamp: new Date().toISOString(),
+                    mode: opts.mode,
+                    changeId: opts.changeId,
+                    error: true,
+                    message: err instanceof Error ? err.message : String(err),
+                };
+                await logWriter.append(errorEntry);
+                resolve(errorEntry);
+            }
+        });
+    });
+}

package/dist/lib/eval/otel.d.ts

@@ -0,0 +1,61 @@
+/**
+ * OpenTelemetry tracing for the eval agent (evaluator).
+ *
+ * Opt-in via `eval.otel.enabled: true` in `.indusk/config.json` OR
+ * `INDUSK_EVAL_OTEL=1` env var. Exports to `OTEL_EXPORTER_OTLP_ENDPOINT`
+ * (Dash0 or any OTLP HTTP receiver).
+ *
+ * Default OFF — zero cost in normal operation (no SDK init, no network).
+ *
+ * Graceful degradation: when enabled but endpoint missing, log a warning
+ * to `.indusk/eval/system.log` and return a no-op tracer. When SDK init
+ * throws, same behavior. The evaluator never fails because of OTel.
+ */
+import { type Attributes, type Span, type Tracer } from "@opentelemetry/api";
+export interface EvalOtelConfig {
+    enabled: boolean;
+    endpoint: string | null;
+    dataset: string;
+}
+/**
+ * Pure predicate — reads `.indusk/config.json` `eval.otel.{enabled,dataset}` and
+ * the `INDUSK_EVAL_OTEL` / `INDUSK_EVAL_OTEL_DATASET` / `OTEL_EXPORTER_OTLP_ENDPOINT`
+ * env vars. Does not init anything or touch the network.
+ *
+ * Resolution:
+ * - `enabled`: `INDUSK_EVAL_OTEL=1` (truthy) wins, else config `eval.otel.enabled`, else false.
+ * - `endpoint`: `OTEL_EXPORTER_OTLP_ENDPOINT` (null if unset).
+ * - `dataset`: `INDUSK_EVAL_OTEL_DATASET` env var wins, else config `eval.otel.dataset`,
+ *   else `"agent"` default. Sent as the `Dash0-Dataset` header on every OTLP export.
+ */
+export declare function isEvalOtelEnabled(projectRoot: string): EvalOtelConfig;
+/**
+ * Initialize OTel tracing for the evaluator if enabled + endpoint set.
+ * Returns a Tracer — real when enabled, no-op when not.
+ *
+ * The no-op path costs nothing: no provider registered, no network, the
+ * returned tracer's `startSpan` / `startActiveSpan` produce no-op spans.
+ *
+ * Safe to call multiple times — subsequent calls return the same tracer.
+ */
+export declare function initEvalOtel(projectRoot: string): Tracer;
+/**
+ * Run `fn` inside an active span. Closes the span in `finally`. On thrown
+ * error, records the exception on the span and sets status to ERROR, then
+ * re-throws so callers can still handle it.
+ *
+ * Use this for every lifecycle step in the evaluator so spans close even
+ * when Claude exits non-zero or a downstream step throws.
+ */
+export declare function withSpan<T>(tracer: Tracer, name: string, attrs: Attributes | undefined, fn: (span: Span) => Promise<T> | T): Promise<T>;
+/**
+ * Flush and shut down the active provider. Call this before `process.exit()`
+ * in detached processes so batched spans are not lost. No-op if no provider
+ * is active.
+ */
+export declare function shutdownEvalOtel(): Promise<void>;
+/**
+ * Test hook: reset the module's state AND the global OTel API so each test
+ * starts fresh. Not part of the public API.
+ */
+export declare function __resetEvalOtelForTests(): void;

package/dist/lib/eval/otel.js

@@ -0,0 +1,177 @@
+/**
+ * OpenTelemetry tracing for the eval agent (evaluator).
+ *
+ * Opt-in via `eval.otel.enabled: true` in `.indusk/config.json` OR
+ * `INDUSK_EVAL_OTEL=1` env var. Exports to `OTEL_EXPORTER_OTLP_ENDPOINT`
+ * (Dash0 or any OTLP HTTP receiver).
+ *
+ * Default OFF — zero cost in normal operation (no SDK init, no network).
+ *
+ * Graceful degradation: when enabled but endpoint missing, log a warning
+ * to `.indusk/eval/system.log` and return a no-op tracer. When SDK init
+ * throws, same behavior. The evaluator never fails because of OTel.
+ */
+import { appendFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { SpanStatusCode, trace } from "@opentelemetry/api";
+import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
+import { resourceFromAttributes } from "@opentelemetry/resources";
+import { BatchSpanProcessor } from "@opentelemetry/sdk-trace-base";
+import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
+import { ATTR_SERVICE_NAME } from "@opentelemetry/semantic-conventions";
+const TRACER_NAME = "@infinitedusky/indusk-mcp/eval";
+const SERVICE_NAME = "indusk-eval-agent";
+function syslog(projectRoot, msg) {
+    try {
+        const logDir = resolve(projectRoot, ".indusk", "eval");
+        mkdirSync(logDir, { recursive: true });
+        appendFileSync(resolve(logDir, "system.log"), `${new Date().toISOString()} ${msg}\n`);
+    }
+    catch {
+        // logging should never break anything
+    }
+}
+const DEFAULT_DATASET = "agent";
+/**
+ * Pure predicate — reads `.indusk/config.json` `eval.otel.{enabled,dataset}` and
+ * the `INDUSK_EVAL_OTEL` / `INDUSK_EVAL_OTEL_DATASET` / `OTEL_EXPORTER_OTLP_ENDPOINT`
+ * env vars. Does not init anything or touch the network.
+ *
+ * Resolution:
+ * - `enabled`: `INDUSK_EVAL_OTEL=1` (truthy) wins, else config `eval.otel.enabled`, else false.
+ * - `endpoint`: `OTEL_EXPORTER_OTLP_ENDPOINT` (null if unset).
+ * - `dataset`: `INDUSK_EVAL_OTEL_DATASET` env var wins, else config `eval.otel.dataset`,
+ *   else `"agent"` default. Sent as the `Dash0-Dataset` header on every OTLP export.
+ */
+export function isEvalOtelEnabled(projectRoot) {
+    const envFlag = process.env.INDUSK_EVAL_OTEL;
+    const endpoint = process.env.OTEL_EXPORTER_OTLP_ENDPOINT ?? null;
+    const envDataset = process.env.INDUSK_EVAL_OTEL_DATASET;
+    let configEnabled = false;
+    let configDataset;
+    const configPath = join(projectRoot, ".indusk", "config.json");
+    if (existsSync(configPath)) {
+        try {
+            const config = JSON.parse(readFileSync(configPath, "utf-8"));
+            configEnabled = config?.eval?.otel?.enabled === true;
+            if (typeof config?.eval?.otel?.dataset === "string") {
+                configDataset = config.eval.otel.dataset;
+            }
+        }
+        catch {
+            // malformed config — treat as disabled
+        }
+    }
+    const envForcesEnabled = envFlag !== undefined && envFlag !== "" && envFlag !== "0" && envFlag.toLowerCase() !== "false";
+    const dataset = envDataset && envDataset !== "" ? envDataset : (configDataset ?? DEFAULT_DATASET);
+    return {
+        enabled: envForcesEnabled || configEnabled,
+        endpoint,
+        dataset,
+    };
+}
+let activeProvider = null;
+/**
+ * Initialize OTel tracing for the evaluator if enabled + endpoint set.
+ * Returns a Tracer — real when enabled, no-op when not.
+ *
+ * The no-op path costs nothing: no provider registered, no network, the
+ * returned tracer's `startSpan` / `startActiveSpan` produce no-op spans.
+ *
+ * Safe to call multiple times — subsequent calls return the same tracer.
+ */
+export function initEvalOtel(projectRoot) {
+    const { enabled, endpoint, dataset } = isEvalOtelEnabled(projectRoot);
+    if (!enabled) {
+        return trace.getTracer(TRACER_NAME);
+    }
+    if (!endpoint) {
+        syslog(projectRoot, "eval.otel.enabled but OTEL_EXPORTER_OTLP_ENDPOINT is unset — falling back to no-op tracer");
+        return trace.getTracer(TRACER_NAME);
+    }
+    if (activeProvider) {
+        return trace.getTracer(TRACER_NAME);
+    }
+    try {
+        const exporter = new OTLPTraceExporter({
+            url: endpoint.endsWith("/v1/traces") ? endpoint : `${endpoint.replace(/\/$/, "")}/v1/traces`,
+            // Route agent spans to the Dash0 dataset named `dataset`. Default
+            // is "agent". Env-set headers (OTEL_EXPORTER_OTLP_HEADERS) take
+            // precedence — per the OTel SDK contract — so a user-provided
+            // Dash0-Dataset in env overrides this default.
+            headers: {
+                "Dash0-Dataset": dataset,
+            },
+        });
+        const provider = new NodeTracerProvider({
+            resource: resourceFromAttributes({
+                [ATTR_SERVICE_NAME]: SERVICE_NAME,
+            }),
+            spanProcessors: [new BatchSpanProcessor(exporter)],
+        });
+        provider.register();
+        activeProvider = provider;
+        syslog(projectRoot, `eval.otel initialized — endpoint: ${endpoint}, dataset: ${dataset}`);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        syslog(projectRoot, `eval.otel init failed — falling back to no-op tracer: ${message}`);
+    }
+    return trace.getTracer(TRACER_NAME);
+}
+/**
+ * Run `fn` inside an active span. Closes the span in `finally`. On thrown
+ * error, records the exception on the span and sets status to ERROR, then
+ * re-throws so callers can still handle it.
+ *
+ * Use this for every lifecycle step in the evaluator so spans close even
+ * when Claude exits non-zero or a downstream step throws.
+ */
+export async function withSpan(tracer, name, attrs, fn) {
+    return tracer.startActiveSpan(name, { attributes: attrs ?? {} }, async (span) => {
+        try {
+            return await fn(span);
+        }
+        catch (err) {
+            span.recordException(err instanceof Error ? err : new Error(String(err)));
+            span.setStatus({ code: SpanStatusCode.ERROR });
+            throw err;
+        }
+        finally {
+            span.end();
+        }
+    });
+}
+/**
+ * Flush and shut down the active provider. Call this before `process.exit()`
+ * in detached processes so batched spans are not lost. No-op if no provider
+ * is active.
+ */
+export async function shutdownEvalOtel() {
+    if (!activeProvider)
+        return;
+    try {
+        await activeProvider.forceFlush();
+        await activeProvider.shutdown();
+    }
+    catch {
+        // shutdown is best-effort
+    }
+    finally {
+        activeProvider = null;
+    }
+}
+/**
+ * Test hook: reset the module's state AND the global OTel API so each test
+ * starts fresh. Not part of the public API.
+ */
+export function __resetEvalOtelForTests() {
+    // Tear down any provider left over from a previous test. This un-registers
+    // from the global OTel API, so `trace.getTracer()` falls back to the no-op
+    // tracer until a new provider is registered.
+    if (activeProvider) {
+        void activeProvider.shutdown().catch(() => { });
+    }
+    activeProvider = null;
+    trace.disable();
+}

package/dist/lib/eval/persistent-evaluator.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Persistent evaluator session management.
+ *
+ * First eval spawns a new session with full catchup. Subsequent evals resume
+ * the same session — no catchup cost, just "evaluate this change."
+ *
+ * Session state stored in `.indusk/eval/evaluator-session.json`.
+ */
+import type { EvalErrorEntry, EvalScorecard } from "./types.js";
+/**
+ * Run eval using a persistent session. First call does catchup + eval.
+ * Subsequent calls resume the session with just the new change.
+ */
+export declare function runPersistentEval(opts: {
+    projectRoot: string;
+    changeId: string;
+    transcriptPath: string;
+    mode: "eval" | "baseline";
+    evalEndpoint?: string;
+}): Promise<EvalScorecard | EvalErrorEntry>;