@juspay/neurolink 9.52.0 → 9.53.0

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

package/dist/lib/autoresearch/stateStore.js

@@ -0,0 +1,164 @@
+/**
+ * Research state persistence — file-backed JSON store.
+ */
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync, } from "node:fs";
+import path from "node:path";
+import { logger } from "../utils/logger.js";
+import { AutoresearchError } from "./errors.js";
+export class ResearchStateStore {
+    filePath;
+    constructor(repoPath, statePath) {
+        this.filePath = path.join(repoPath, statePath);
+    }
+    async load() {
+        if (!existsSync(this.filePath)) {
+            return null;
+        }
+        try {
+            const raw = readFileSync(this.filePath, "utf-8");
+            const parsed = JSON.parse(raw);
+            // Validate required fields
+            const requiredFields = [
+                "branch",
+                "currentPhase",
+                "runCount",
+                "keepCount",
+                "tag",
+                "startedAt",
+                "updatedAt",
+            ];
+            for (const field of requiredFields) {
+                if (!(field in parsed)) {
+                    throw AutoresearchError.create("STATE_CORRUPT", `State file missing required field: ${field}`);
+                }
+            }
+            if (!Number.isInteger(parsed.runCount) ||
+                parsed.runCount < 0 ||
+                !Number.isInteger(parsed.keepCount) ||
+                parsed.keepCount < 0) {
+                throw AutoresearchError.create("STATE_CORRUPT", `State file has invalid numeric fields: runCount=${parsed.runCount}, keepCount=${parsed.keepCount}`);
+            }
+            const validPhases = [
+                "bootstrap",
+                "baseline",
+                "propose",
+                "edit",
+                "commit",
+                "run",
+                "evaluate",
+                "record",
+                "accept_or_revert",
+            ];
+            if (!validPhases.includes(parsed.currentPhase)) {
+                throw AutoresearchError.create("STATE_CORRUPT", `State file has invalid currentPhase: ${parsed.currentPhase}`);
+            }
+            if (isNaN(Date.parse(parsed.startedAt)) ||
+                isNaN(Date.parse(parsed.updatedAt))) {
+                throw AutoresearchError.create("STATE_CORRUPT", "State file has invalid timestamp fields");
+            }
+            return parsed;
+        }
+        catch (error) {
+            // Don't double-wrap our own validation errors
+            if (error instanceof Error && error.message.includes("AUTORESEARCH")) {
+                throw error;
+            }
+            throw AutoresearchError.create("STATE_CORRUPT", `Failed to parse state file: ${this.filePath}`, {
+                cause: error instanceof Error ? error : undefined,
+            });
+        }
+    }
+    async save(state) {
+        const dir = path.dirname(this.filePath);
+        if (!existsSync(dir)) {
+            mkdirSync(dir, { recursive: true });
+        }
+        // Strip rawTail from lastSummary before persisting (it's arbitrary stdout/stderr,
+        // kept in run.log; storing it in state.json risks leaking sensitive output)
+        const stateToPersist = { ...state };
+        if (stateToPersist.lastSummary?.rawTail) {
+            stateToPersist.lastSummary = {
+                ...stateToPersist.lastSummary,
+                rawTail: "[see run.log]",
+            };
+        }
+        // Atomic write: write to temp file, then rename
+        const tmpPath = `${this.filePath}.tmp`;
+        try {
+            writeFileSync(tmpPath, JSON.stringify(stateToPersist, null, 2), "utf-8");
+            renameSync(tmpPath, this.filePath);
+            logger.debug("[Autoresearch] State saved", {
+                phase: state.currentPhase,
+                runCount: state.runCount,
+            });
+        }
+        catch (error) {
+            throw AutoresearchError.create("STATE_CORRUPT", `Failed to write state file: ${this.filePath}`, {
+                cause: error instanceof Error ? error : undefined,
+            });
+        }
+    }
+    async initialize(tag, branch) {
+        const now = new Date().toISOString();
+        const state = {
+            branch,
+            acceptedCommit: null,
+            baselineMetric: null,
+            bestMetric: null,
+            candidateCommit: null,
+            runCount: 0,
+            keepCount: 0,
+            lastStatus: null,
+            currentPhase: "bootstrap",
+            tag,
+            startedAt: now,
+            updatedAt: now,
+        };
+        await this.save(state);
+        logger.info("[Autoresearch] State initialized", { tag, branch });
+        return state;
+    }
+    async update(patch) {
+        const current = await this.load();
+        if (!current) {
+            throw AutoresearchError.create("STATE_NOT_FOUND", "Cannot update: no state file found");
+        }
+        // Validate patch fields before merging
+        const VALID_PHASES = [
+            "bootstrap",
+            "baseline",
+            "propose",
+            "edit",
+            "commit",
+            "run",
+            "evaluate",
+            "record",
+            "accept_or_revert",
+        ];
+        if (patch.runCount !== undefined &&
+            (!Number.isInteger(patch.runCount) || patch.runCount < 0)) {
+            throw AutoresearchError.create("STATE_CORRUPT", `Invalid runCount: ${patch.runCount}`);
+        }
+        if (patch.keepCount !== undefined &&
+            (!Number.isInteger(patch.keepCount) || patch.keepCount < 0)) {
+            throw AutoresearchError.create("STATE_CORRUPT", `Invalid keepCount: ${patch.keepCount}`);
+        }
+        if (patch.currentPhase !== undefined &&
+            !VALID_PHASES.includes(patch.currentPhase)) {
+            throw AutoresearchError.create("STATE_CORRUPT", `Invalid currentPhase: ${patch.currentPhase}`);
+        }
+        if (patch.bestMetric !== undefined &&
+            patch.bestMetric !== null &&
+            !Number.isFinite(patch.bestMetric)) {
+            throw AutoresearchError.create("STATE_CORRUPT", `Invalid bestMetric: ${patch.bestMetric}`);
+        }
+        const updated = {
+            ...current,
+            ...patch,
+            updatedAt: new Date().toISOString(),
+        };
+        await this.save(updated);
+        return updated;
+    }
+}
+//# sourceMappingURL=stateStore.js.map

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

@@ -0,0 +1,16 @@
+/**
+ * Deterministic experiment log parser.
+ *
+ * Extracts metrics from run.log output. Never throws — returns
+ * crashed/timedOut summary on parse failure.
+ */
+import type { ExperimentSummary, MetricConfig, MemoryMetricConfig } from "../types/autoresearchTypes.js";
+/**
+ * Parse experiment output into a structured summary.
+ *
+ * This function is deterministic and pure — no side effects, no throws.
+ */
+export declare function parseExperimentSummary(logContent: string, metricConfig: MetricConfig, memoryConfig?: MemoryMetricConfig, options?: {
+    timedOut?: boolean;
+    exitCode?: number;
+}): ExperimentSummary;

package/dist/lib/autoresearch/summaryParser.js

@@ -0,0 +1,95 @@
+/**
+ * Deterministic experiment log parser.
+ *
+ * Extracts metrics from run.log output. Never throws — returns
+ * crashed/timedOut summary on parse failure.
+ */
+/**
+ * Parse experiment output into a structured summary.
+ *
+ * This function is deterministic and pure — no side effects, no throws.
+ */
+export function parseExperimentSummary(logContent, metricConfig, memoryConfig, options) {
+    const lines = logContent.split("\n");
+    const tailLines = lines.slice(-50);
+    const rawTail = tailLines.join("\n");
+    // Check for crash indicators (only if not already determined by exit code)
+    let crashed = options?.exitCode !== undefined &&
+        options.exitCode !== 0 &&
+        !options?.timedOut;
+    if (!crashed) {
+        const lastMeaningfulLine = [...lines]
+            .reverse()
+            .find((l) => l.trim().length > 0)
+            ?.trim() ?? "";
+        crashed =
+            lastMeaningfulLine === "FAIL" ||
+                lastMeaningfulLine.toLowerCase().includes("traceback") ||
+                lastMeaningfulLine.toLowerCase().includes("error:");
+    }
+    // Parse primary metric
+    let metric = null;
+    try {
+        const regex = new RegExp(metricConfig.pattern, "m");
+        const match = regex.exec(logContent);
+        if (match && match[1]) {
+            const parsed = parseFloat(match[1]);
+            if (!isNaN(parsed) && isFinite(parsed)) {
+                metric = parsed;
+            }
+        }
+    }
+    catch {
+        // Invalid regex — treat as parse failure
+    }
+    // Parse memory metric
+    let memoryValue = null;
+    if (memoryConfig) {
+        try {
+            const regex = new RegExp(memoryConfig.pattern, "m");
+            const match = regex.exec(logContent);
+            if (match && match[1]) {
+                const parsed = parseFloat(match[1]);
+                if (!isNaN(parsed) && isFinite(parsed)) {
+                    memoryValue = parsed;
+                    // Convert MB to GB if the name suggests MB.
+                    // Uses binary divisor (1024 = MiB→GiB). For decimal MB→GB use 1000.
+                    // The 1024 convention matches GPU monitoring tools (nvidia-smi, etc.).
+                    const MIB_TO_GIB_DIVISOR = 1024;
+                    if (memoryConfig.name.toLowerCase().includes("mb")) {
+                        memoryValue =
+                            Math.round((memoryValue / MIB_TO_GIB_DIVISOR) * 100) / 100;
+                    }
+                }
+            }
+        }
+        catch {
+            // Invalid regex — treat as parse failure
+        }
+    }
+    // Parse training time
+    let trainingSeconds = null;
+    try {
+        const timeRegex = /^training_seconds:\s+([\d.]+)/m;
+        const match = timeRegex.exec(logContent);
+        if (match && match[1]) {
+            trainingSeconds = parseFloat(match[1]);
+        }
+    }
+    catch {
+        // Ignore
+    }
+    // Only treat as timeout if explicitly signaled by the runner — don't infer from missing metric
+    const timedOut = options?.timedOut ?? false;
+    // Missing metric without explicit timeout is a crash (regex failure, spawn error, etc.)
+    const finalCrashed = crashed || (metric === null && !timedOut);
+    return {
+        crashed: finalCrashed,
+        timedOut,
+        metric,
+        memoryValue,
+        trainingSeconds,
+        rawTail,
+    };
+}
+//# sourceMappingURL=summaryParser.js.map