@juspay/neurolink 9.51.4 → 9.53.0

package/dist/lib/autoresearch/phasePolicy.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Phase-based tool access policy for the autoresearch experiment loop.
+ */
+import type { ExperimentPhase, PhaseToolPolicy } from "../types/autoresearchTypes.js";
+export declare function getPhaseToolPolicy(phase: ExperimentPhase): PhaseToolPolicy;
+/**
+ * Returns all research tool names across all phases.
+ */
+export declare function getAllResearchToolNames(): string[];

package/dist/lib/autoresearch/phasePolicy.js

@@ -0,0 +1,70 @@
+/**
+ * Phase-based tool access policy for the autoresearch experiment loop.
+ */
+const PHASE_POLICIES = {
+    bootstrap: {
+        activeTools: [
+            "research_get_context",
+            "research_read_file",
+            "research_checkpoint",
+        ],
+        forcedTool: "research_get_context",
+    },
+    baseline: {
+        activeTools: [
+            "research_run_experiment",
+            "research_parse_log",
+            "research_record",
+            "research_accept",
+            "research_checkpoint",
+        ],
+        forcedTool: "research_run_experiment",
+    },
+    propose: {
+        activeTools: ["research_get_context", "research_read_file"],
+        forcedTool: "research_get_context",
+    },
+    edit: {
+        activeTools: [
+            "research_read_file",
+            "research_write_candidate",
+            "research_diff",
+        ],
+    },
+    commit: {
+        activeTools: ["research_commit_candidate"],
+        forcedTool: "research_commit_candidate",
+    },
+    run: {
+        activeTools: ["research_run_experiment"],
+        forcedTool: "research_run_experiment",
+    },
+    evaluate: {
+        activeTools: ["research_parse_log", "research_inspect_failure"],
+        forcedTool: "research_parse_log",
+    },
+    record: {
+        activeTools: ["research_record", "research_checkpoint"],
+        forcedTool: "research_record",
+    },
+    accept_or_revert: {
+        activeTools: ["research_accept", "research_revert", "research_checkpoint"],
+    },
+};
+export function getPhaseToolPolicy(phase) {
+    const p = PHASE_POLICIES[phase];
+    return { activeTools: [...p.activeTools], forcedTool: p.forcedTool };
+}
+/**
+ * Returns all research tool names across all phases.
+ */
+export function getAllResearchToolNames() {
+    const names = new Set();
+    for (const policy of Object.values(PHASE_POLICIES)) {
+        for (const tool of policy.activeTools) {
+            names.add(tool);
+        }
+    }
+    return [...names];
+}
+//# sourceMappingURL=phasePolicy.js.map

package/dist/lib/autoresearch/promptCompiler.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Prompt compilation for the autoresearch worker.
+ *
+ * Reads program.md and combines it with current state and recent
+ * results to build the system prompt and per-cycle prompt.
+ */
+import type { ResearchConfig, ResearchState, ExperimentRecord } from "../types/autoresearchTypes.js";
+export declare class PromptCompiler {
+    private config;
+    constructor(config: ResearchConfig);
+    /** Reads program.md and builds the system prompt */
+    buildSystemPrompt(): Promise<string>;
+    /** Builds the per-cycle prompt with current state + recent results */
+    buildCyclePrompt(state: ResearchState, recentResults: ExperimentRecord[]): Promise<string>;
+}

package/dist/lib/autoresearch/promptCompiler.js

@@ -0,0 +1,121 @@
+/**
+ * Prompt compilation for the autoresearch worker.
+ *
+ * Reads program.md and combines it with current state and recent
+ * results to build the system prompt and per-cycle prompt.
+ */
+import { readFileSync, statSync } from "node:fs";
+import path from "node:path";
+import { logger } from "../utils/logger.js";
+import { getPhaseToolPolicy } from "./phasePolicy.js";
+export class PromptCompiler {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    /** Reads program.md and builds the system prompt */
+    async buildSystemPrompt() {
+        const MAX_PROGRAM_BYTES = 1_048_576; // 1 MB
+        let programContent = "";
+        try {
+            const programPath = path.join(this.config.repoPath, this.config.programPath);
+            const stat = statSync(programPath);
+            if (stat.size > MAX_PROGRAM_BYTES) {
+                logger.warn("[Autoresearch] program.md exceeds 1MB, truncating");
+                programContent = readFileSync(programPath, "utf-8").slice(0, MAX_PROGRAM_BYTES);
+            }
+            else {
+                programContent = readFileSync(programPath, "utf-8");
+            }
+        }
+        catch {
+            logger.warn("[Autoresearch] program.md not found, using minimal system prompt");
+        }
+        const toolList = [
+            "research_get_context — Get current research state (branch, metric, recent results)",
+            "research_read_file — Read a file from the repo (must be in allowed paths)",
+            "research_write_candidate — Write to a mutable file (only allowed paths)",
+            "research_diff — Show git diff for mutable files",
+            "research_commit_candidate — Commit staged mutable files",
+            "research_run_experiment — Run the experiment command with timeout",
+            "research_parse_log — Parse the experiment log for metrics",
+            "research_record — Record experiment result (keep/discard/crash/timeout)",
+            "research_accept — Accept candidate (update best metric, advance branch)",
+            "research_revert — Revert to last accepted commit",
+            "research_inspect_failure — Read last 50 lines of run.log for crash diagnosis",
+            "research_checkpoint — Save current state to disk",
+        ];
+        return [
+            "You are an autonomous research agent running experiments in a loop.",
+            "",
+            programContent ? "## Research Program" : "",
+            programContent,
+            "",
+            "## Available Tools",
+            ...toolList.map((t) => `- ${t}`),
+            "",
+            "## Constraints",
+            `- You may ONLY modify these files: ${this.config.mutablePaths.join(", ")}`,
+            `- You must NEVER modify: ${this.config.immutablePaths.join(", ")}`,
+            `- The primary metric is: ${this.config.metric.name} (${this.config.metric.direction} is better)`,
+            `- Experiment timeout: ${Math.round(this.config.timeoutMs / 1000)} seconds`,
+            "",
+            "## Workflow",
+            "1. Call research_get_context to understand current state",
+            "2. Read relevant files to understand the code",
+            "3. Propose and implement a single experiment change",
+            "4. Commit the change",
+            "5. Run the experiment",
+            "6. Parse the results",
+            "7. Record the outcome",
+            "8. Accept (if improved) or revert (if not)",
+            "",
+            "NEVER STOP. Continue proposing experiments indefinitely.",
+            "Prefer simplicity — deleting code is better than adding complexity.",
+        ]
+            .filter(Boolean)
+            .join("\n");
+    }
+    /** Builds the per-cycle prompt with current state + recent results */
+    async buildCyclePrompt(state, recentResults) {
+        const parts = [
+            `## Current Research State`,
+            `- Branch: ${state.branch}`,
+            `- Run count: ${state.runCount}`,
+            `- Keep count: ${state.keepCount}`,
+            `- Best ${this.config.metric.name}: ${state.bestMetric ?? "no baseline yet"}`,
+            `- Last status: ${state.lastStatus ?? "none"}`,
+            `- Current phase: ${state.currentPhase}`,
+            `- Accepted commit: ${state.acceptedCommit ?? "none"}`,
+        ];
+        if (recentResults.length > 0) {
+            parts.push("");
+            parts.push("## Recent Results (last 10)");
+            parts.push(`commit\t${this.config.metric.name}\tstatus\tdescription`);
+            for (const r of recentResults.slice(-10)) {
+                const metricStr = r.metric !== null && Number.isFinite(r.metric)
+                    ? r.metric.toFixed(6)
+                    : "N/A";
+                parts.push(`${r.commit}\t${metricStr}\t${r.status}\t${r.description}`);
+            }
+        }
+        parts.push("");
+        // Phase-aware first action suggestion (avoid biasing accept_or_revert toward accept)
+        const phasePolicy = getPhaseToolPolicy(state.currentPhase);
+        let firstAction;
+        if (phasePolicy.forcedTool) {
+            firstAction = phasePolicy.forcedTool;
+        }
+        else if (state.currentPhase === "accept_or_revert") {
+            // Don't bias toward accept or revert — the deterministic policy decides.
+            // Use checkpoint (neutral) since accept/revert are both in activeTools.
+            firstAction = "research_checkpoint";
+        }
+        else {
+            firstAction = phasePolicy.activeTools[0] || "research_get_context";
+        }
+        parts.push(`Continue the experiment loop. Start by calling ${firstAction}.`);
+        return parts.join("\n");
+    }
+}
+//# sourceMappingURL=promptCompiler.js.map

package/dist/lib/autoresearch/repoPolicy.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Repository policy enforcement for autoresearch.
+ *
+ * Controls which files can be read/written and validates
+ * git operations against the research branch.
+ */
+import type { ResearchConfig } from "../types/autoresearchTypes.js";
+export declare class RepoPolicy {
+    private config;
+    private resolvedMutablePaths;
+    private resolvedImmutablePaths;
+    constructor(config: ResearchConfig);
+    /** Returns true if resolved path is inside repoPath (handles prefix collision) */
+    private isInsideRepo;
+    /** Returns true if path is within mutablePaths and NOT in immutablePaths */
+    isWriteAllowed(filePath: string): boolean;
+    /** Returns true if path is in immutablePaths */
+    isProtected(filePath: string): boolean;
+    /** Returns true if path is readable (mutable, immutable, or program path) */
+    isReadAllowed(filePath: string): boolean;
+    /** Validates staged files are all in mutablePaths and on the right branch */
+    validateCommit(expectedBranch: string): Promise<{
+        valid: boolean;
+        violations: string[];
+    }>;
+    /** Returns list of staged file paths. Throws on git failure. */
+    getStagedFiles(): Promise<string[]>;
+    /** Returns current git branch */
+    getCurrentBranch(): string;
+    /** Returns short commit hash */
+    getHeadCommit(): string;
+}

package/dist/lib/autoresearch/repoPolicy.js

@@ -0,0 +1,129 @@
+/**
+ * Repository policy enforcement for autoresearch.
+ *
+ * Controls which files can be read/written and validates
+ * git operations against the research branch.
+ */
+import { execFileSync } from "node:child_process";
+import path from "node:path";
+import { logger } from "../utils/logger.js";
+export class RepoPolicy {
+    config;
+    resolvedMutablePaths;
+    resolvedImmutablePaths;
+    constructor(config) {
+        this.config = config;
+        this.resolvedMutablePaths = config.mutablePaths.map((p) => path.resolve(config.repoPath, p));
+        this.resolvedImmutablePaths = config.immutablePaths.map((p) => path.resolve(config.repoPath, p));
+    }
+    /** Returns true if resolved path is inside repoPath (handles prefix collision) */
+    isInsideRepo(resolved) {
+        const rel = path.relative(this.config.repoPath, resolved);
+        return !rel.startsWith("..") && !path.isAbsolute(rel);
+    }
+    /** Returns true if path is within mutablePaths and NOT in immutablePaths */
+    isWriteAllowed(filePath) {
+        const resolved = path.resolve(this.config.repoPath, filePath);
+        // Must be inside repoPath
+        if (!this.isInsideRepo(resolved)) {
+            return false;
+        }
+        // Immutable paths always deny, even if they're children of a mutable parent
+        if (this.isProtected(filePath)) {
+            return false;
+        }
+        return this.resolvedMutablePaths.some((mp) => resolved === mp || resolved.startsWith(mp + path.sep));
+    }
+    /** Returns true if path is in immutablePaths */
+    isProtected(filePath) {
+        const resolved = path.resolve(this.config.repoPath, filePath);
+        return this.resolvedImmutablePaths.some((ip) => resolved === ip || resolved.startsWith(ip + path.sep));
+    }
+    /** Returns true if path is readable (mutable, immutable, or program path) */
+    isReadAllowed(filePath) {
+        const resolved = path.resolve(this.config.repoPath, filePath);
+        if (!this.isInsideRepo(resolved)) {
+            return false;
+        }
+        const programResolved = path.resolve(this.config.repoPath, this.config.programPath);
+        return (this.isWriteAllowed(filePath) ||
+            this.isProtected(filePath) ||
+            resolved === programResolved);
+    }
+    /** Validates staged files are all in mutablePaths and on the right branch */
+    async validateCommit(expectedBranch) {
+        const violations = [];
+        const staged = await this.getStagedFiles();
+        for (const file of staged) {
+            const resolved = path.resolve(this.config.repoPath, file);
+            // Block results files
+            if (file === this.config.resultsPath) {
+                violations.push(`Results file staged: ${file}`);
+                continue;
+            }
+            // Block state files
+            const stateDir = path.dirname(this.config.statePath);
+            if (file === this.config.statePath ||
+                (stateDir !== "." && file.startsWith(stateDir + path.sep))) {
+                violations.push(`State file staged: ${file}`);
+                continue;
+            }
+            // Block immutable files (even if under a mutable parent)
+            if (this.resolvedImmutablePaths.some((ip) => resolved === ip || resolved.startsWith(ip + path.sep))) {
+                violations.push(`Immutable file staged: ${file}`);
+                continue;
+            }
+            // Block non-mutable files
+            if (!this.resolvedMutablePaths.some((mp) => resolved === mp || resolved.startsWith(mp + path.sep))) {
+                violations.push(`Non-mutable file staged: ${file}`);
+            }
+        }
+        // Verify branch
+        const currentBranch = this.getCurrentBranch();
+        if (currentBranch !== expectedBranch) {
+            violations.push(`Wrong branch: expected ${expectedBranch}, got ${currentBranch}`);
+        }
+        return { valid: violations.length === 0, violations };
+    }
+    /** Returns list of staged file paths. Throws on git failure. */
+    async getStagedFiles() {
+        const output = execFileSync("git", ["diff", "--cached", "--name-only"], {
+            cwd: this.config.repoPath,
+            encoding: "utf-8",
+        });
+        return output.trim().split("\n").filter(Boolean);
+    }
+    /** Returns current git branch */
+    getCurrentBranch() {
+        try {
+            return execFileSync("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
+                cwd: this.config.repoPath,
+                encoding: "utf-8",
+            }).trim();
+        }
+        catch (err) {
+            logger.warn("[Autoresearch] getCurrentBranch failed", {
+                repoPath: this.config.repoPath,
+                error: err instanceof Error ? err.message : String(err),
+            });
+            return "";
+        }
+    }
+    /** Returns short commit hash */
+    getHeadCommit() {
+        try {
+            return execFileSync("git", ["rev-parse", "--short=7", "HEAD"], {
+                cwd: this.config.repoPath,
+                encoding: "utf-8",
+            }).trim();
+        }
+        catch (err) {
+            logger.warn("[Autoresearch] getHeadCommit failed", {
+                repoPath: this.config.repoPath,
+                error: err instanceof Error ? err.message : String(err),
+            });
+            return "";
+        }
+    }
+}
+//# sourceMappingURL=repoPolicy.js.map

package/dist/lib/autoresearch/resultRecorder.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Experiment result recording — TSV + optional JSONL.
+ */
+import type { ExperimentRecord, ExperimentStats, ResearchConfig } from "../types/autoresearchTypes.js";
+export declare class ResultRecorder {
+    private config;
+    private tsvPath;
+    private jsonlPath;
+    constructor(config: ResearchConfig);
+    /** Creates results.tsv with header if it doesn't exist */
+    ensureResultsFile(): Promise<void>;
+    /** Appends one TSV row to results.tsv */
+    appendTsv(record: ExperimentRecord): Promise<void>;
+    /** Appends one JSON line to runs.jsonl */
+    appendJsonl(record: ExperimentRecord): Promise<void>;
+    /** Reads all records from results.tsv */
+    readAll(): Promise<ExperimentRecord[]>;
+    /** Returns summary stats */
+    getStats(): Promise<ExperimentStats>;
+}

package/dist/lib/autoresearch/resultRecorder.js

@@ -0,0 +1,131 @@
+/**
+ * Experiment result recording — TSV + optional JSONL.
+ */
+import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync, } from "node:fs";
+import path from "node:path";
+import { logger } from "../utils/logger.js";
+import { AutoresearchError } from "./errors.js";
+export class ResultRecorder {
+    config;
+    tsvPath;
+    jsonlPath;
+    constructor(config) {
+        this.config = config;
+        this.tsvPath = path.join(config.repoPath, config.resultsPath);
+        this.jsonlPath = path.join(config.repoPath, ".autoresearch", "runs.jsonl");
+    }
+    /** Creates results.tsv with header if it doesn't exist */
+    async ensureResultsFile() {
+        if (!existsSync(this.tsvPath)) {
+            try {
+                // Ensure parent directory exists (handles custom resultsPath like "artifacts/results.tsv")
+                const dir = path.dirname(this.tsvPath);
+                if (!existsSync(dir)) {
+                    mkdirSync(dir, { recursive: true });
+                }
+                // Use the actual metric name in header
+                const header = `commit\t${this.config.metric.name}\tmemory_gb\tstatus\tdescription`;
+                writeFileSync(this.tsvPath, header + "\n", "utf-8");
+                logger.info("[Autoresearch] Created results file", {
+                    path: this.tsvPath,
+                });
+            }
+            catch (error) {
+                throw AutoresearchError.create("RESULTS_WRITE_FAILED", `Failed to create results file: ${this.tsvPath}`, {
+                    cause: error instanceof Error ? error : undefined,
+                });
+            }
+        }
+    }
+    /** Appends one TSV row to results.tsv */
+    async appendTsv(record) {
+        await this.ensureResultsFile();
+        const metricStr = record.metric !== null ? record.metric.toFixed(6) : "N/A";
+        const memoryStr = record.memoryGb !== null ? record.memoryGb.toFixed(1) : "N/A";
+        const safeDescription = record.description.replace(/[\t\n\r]/g, " ").trim();
+        const line = `${record.commit}\t${metricStr}\t${memoryStr}\t${record.status}\t${safeDescription}`;
+        try {
+            appendFileSync(this.tsvPath, line + "\n", "utf-8");
+            logger.debug("[Autoresearch] Appended TSV record", {
+                commit: record.commit,
+                status: record.status,
+            });
+        }
+        catch (error) {
+            throw AutoresearchError.create("RESULTS_WRITE_FAILED", `Failed to append to results file`, {
+                cause: error instanceof Error ? error : undefined,
+            });
+        }
+    }
+    /** Appends one JSON line to runs.jsonl */
+    async appendJsonl(record) {
+        try {
+            const dir = path.dirname(this.jsonlPath);
+            if (!existsSync(dir)) {
+                mkdirSync(dir, { recursive: true });
+            }
+            appendFileSync(this.jsonlPath, JSON.stringify(record) + "\n", "utf-8");
+        }
+        catch (error) {
+            // JSONL is optional — log warning but don't throw
+            logger.warn("[Autoresearch] Failed to append JSONL audit entry", {
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    /** Reads all records from results.tsv */
+    async readAll() {
+        if (!existsSync(this.tsvPath)) {
+            return [];
+        }
+        try {
+            const content = readFileSync(this.tsvPath, "utf-8");
+            const lines = content.trim().split("\n");
+            if (lines.length <= 1) {
+                return [];
+            } // Header only
+            return lines.slice(1).map((line) => {
+                const [commit, metricStr, memoryStr, status, ...descParts] = line.split("\t");
+                return {
+                    commit: commit || "",
+                    metric: metricStr && metricStr !== "N/A" ? parseFloat(metricStr) : null,
+                    memoryGb: memoryStr && memoryStr !== "N/A" ? parseFloat(memoryStr) : null,
+                    status: (status || "crash"),
+                    description: descParts.join("\t"),
+                    timestamp: new Date().toISOString(), // Not stored in TSV, use current
+                };
+            });
+        }
+        catch {
+            return [];
+        }
+    }
+    /** Returns summary stats */
+    async getStats() {
+        const records = await this.readAll();
+        const keeps = records.filter((r) => r.status === "keep");
+        const bestKeep = keeps.reduce((best, r) => {
+            if (r.metric === null) {
+                return best;
+            }
+            if (best === null || best.metric === null) {
+                return r;
+            }
+            if (this.config.metric.direction === "lower") {
+                return r.metric < best.metric ? r : best;
+            }
+            return r.metric > best.metric ? r : best;
+        }, null);
+        return {
+            total: records.length,
+            keepCount: keeps.length,
+            discardCount: records.filter((r) => r.status === "discard").length,
+            crashCount: records.filter((r) => r.status === "crash").length,
+            timeoutCount: records.filter((r) => r.status === "timeout").length,
+            keepRate: records.length > 0 ? keeps.length / records.length : 0,
+            bestMetric: bestKeep?.metric ?? null,
+            bestCommit: bestKeep?.commit ?? null,
+        };
+    }
+}
+//# sourceMappingURL=resultRecorder.js.map

package/dist/lib/autoresearch/runner.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Experiment runner — spawn, timeout, capture.
+ */
+import type { ExperimentSummary, ResearchConfig } from "../types/autoresearchTypes.js";
+export declare class ExperimentRunner {
+    private config;
+    constructor(config: ResearchConfig);
+    /** Runs the experiment with hard timeout, returns summary */
+    run(): Promise<ExperimentSummary>;
+}

package/dist/lib/autoresearch/runner.js

@@ -0,0 +1,103 @@
+/**
+ * Experiment runner — spawn, timeout, capture.
+ */
+import { spawn } from "node:child_process";
+import { writeFileSync } from "node:fs";
+import path from "node:path";
+import { logger } from "../utils/logger.js";
+import { parseExperimentSummary } from "./summaryParser.js";
+export class ExperimentRunner {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    /** Runs the experiment with hard timeout, returns summary */
+    async run() {
+        const logPath = path.join(this.config.repoPath, this.config.logPath);
+        // Redact potential inline env vars or tokens before logging
+        const redactedCmd = this.config.runCommand
+            .replace(/[A-Z_]+=\S+\s/g, (m) => m.split("=")[0] + "=*** ")
+            .replace(/--(?:token|key|secret|password)\s+\S+/gi, (m) => m.split(/\s+/)[0] + " ***");
+        logger.info("[Autoresearch] Starting experiment", {
+            command: redactedCmd,
+            timeoutMs: this.config.timeoutMs,
+        });
+        // eslint-disable-next-line no-useless-assignment -- catch block assigns on spawn failure
+        let logContent = "";
+        let timedOut = false;
+        let exitCode = 0;
+        try {
+            logContent = await new Promise((resolve, reject) => {
+                let output = "";
+                const proc = spawn(this.config.runCommand, {
+                    shell: true,
+                    cwd: this.config.repoPath,
+                    stdio: ["ignore", "pipe", "pipe"],
+                });
+                // Capture stdout and stderr
+                proc.stdout?.on("data", (chunk) => {
+                    output += chunk.toString();
+                });
+                proc.stderr?.on("data", (chunk) => {
+                    output += chunk.toString();
+                });
+                // Hard timeout
+                const timer = setTimeout(() => {
+                    timedOut = true;
+                    try {
+                        proc.kill("SIGKILL");
+                    }
+                    catch {
+                        // Process may have already exited
+                    }
+                }, this.config.timeoutMs);
+                proc.on("close", (code, signal) => {
+                    clearTimeout(timer);
+                    // Signal-terminated (SIGKILL, SIGSEGV, etc.) = crash unless we timed it out
+                    if (signal && !timedOut) {
+                        exitCode = 1;
+                    }
+                    else {
+                        exitCode = code ?? 0;
+                    }
+                    logger.debug("[Autoresearch] Experiment process exited", {
+                        code,
+                        signal,
+                        exitCode,
+                        timedOut,
+                    });
+                    resolve(output);
+                });
+                proc.on("error", (error) => {
+                    clearTimeout(timer);
+                    reject(error);
+                });
+            });
+        }
+        catch (error) {
+            // Spawn failure — treat as crash with non-zero exit code
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            logContent = `SPAWN ERROR: ${errorMsg}\nFAIL`;
+            exitCode = 1;
+            logger.error("[Autoresearch] Experiment spawn failed", {
+                error: errorMsg,
+            });
+        }
+        // Write log to file
+        try {
+            writeFileSync(logPath, logContent, "utf-8");
+        }
+        catch (writeError) {
+            logger.warn("[Autoresearch] Failed to write run.log", {
+                error: writeError instanceof Error ? writeError.message : String(writeError),
+            });
+        }
+        // Parse summary with exit code and timeout info
+        const summary = parseExperimentSummary(logContent, this.config.metric, this.config.memoryMetric, {
+            timedOut,
+            exitCode,
+        });
+        return summary;
+    }
+}
+//# sourceMappingURL=runner.js.map

package/dist/lib/autoresearch/stateStore.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Research state persistence — file-backed JSON store.
+ */
+import type { ResearchState } from "../types/autoresearchTypes.js";
+export declare class ResearchStateStore {
+    private filePath;
+    constructor(repoPath: string, statePath: string);
+    load(): Promise<ResearchState | null>;
+    save(state: ResearchState): Promise<void>;
+    initialize(tag: string, branch: string): Promise<ResearchState>;
+    update(patch: Partial<ResearchState>): Promise<ResearchState>;
+}