@stanco323/oh-my-claude-code 4.10.3

package/dist/autoresearch/runtime.js

@@ -0,0 +1,1103 @@
+import { execFileSync, spawnSync } from 'child_process';
+import { existsSync } from 'fs';
+import { mkdir, readFile, symlink, writeFile } from 'fs/promises';
+import { dirname, join, resolve } from 'path';
+import { readModeState, writeModeState, } from '../lib/mode-state-io.js';
+import { parseEvaluatorResult, } from './contracts.js';
+const AUTORESEARCH_RESULTS_HEADER = 'iteration\tcommit\tpass\tscore\tstatus\tdescription\n';
+const AUTORESEARCH_WORKTREE_EXCLUDES = ['results.tsv', 'run.log', 'node_modules', '.omc/'];
+// Exclusive modes that cannot run concurrently with autoresearch
+const EXCLUSIVE_MODES = ['ralph', 'ultrawork', 'autopilot', 'autoresearch'];
+function nowIso() {
+    return new Date().toISOString();
+}
+export function buildAutoresearchRunTag(date = new Date()) {
+    const iso = date.toISOString();
+    return iso
+        .replace(/[-:]/g, '')
+        .replace(/\.\d{3}Z$/, 'Z')
+        .replace('T', 'T');
+}
+function buildRunId(missionSlug, runTag) {
+    return `${missionSlug}-${runTag.toLowerCase()}`;
+}
+function activeRunStateFile(projectRoot) {
+    return join(projectRoot, '.omc', 'state', 'autoresearch-state.json');
+}
+function trimContent(value, max = 4000) {
+    const trimmed = value.trim();
+    return trimmed.length <= max ? trimmed : `${trimmed.slice(0, max)}\n...`;
+}
+function readGit(repoPath, args) {
+    try {
+        return execFileSync('git', args, {
+            cwd: repoPath,
+            encoding: 'utf-8',
+            stdio: ['ignore', 'pipe', 'pipe'],
+        }).trim();
+    }
+    catch (error) {
+        const err = error;
+        const stderr = typeof err.stderr === 'string'
+            ? err.stderr.trim()
+            : err.stderr instanceof Buffer
+                ? err.stderr.toString('utf-8').trim()
+                : '';
+        throw new Error(stderr || `git ${args.join(' ')} failed`);
+    }
+}
+function tryResolveGitCommit(worktreePath, ref) {
+    const result = spawnSync('git', ['rev-parse', '--verify', `${ref}^{commit}`], {
+        cwd: worktreePath,
+        encoding: 'utf-8',
+    });
+    if (result.status !== 0)
+        return null;
+    const resolved = (result.stdout || '').trim();
+    return resolved || null;
+}
+async function writeGitInfoExclude(worktreePath, pattern) {
+    const excludePath = readGit(worktreePath, ['rev-parse', '--git-path', 'info/exclude']);
+    const existing = existsSync(excludePath)
+        ? await readFile(excludePath, 'utf-8')
+        : '';
+    const lines = new Set(existing.split(/\r?\n/).filter(Boolean));
+    if (lines.has(pattern))
+        return;
+    const next = `${existing}${existing.endsWith('\n') || existing.length === 0 ? '' : '\n'}${pattern}\n`;
+    await ensureParentDir(excludePath);
+    await writeFile(excludePath, next, 'utf-8');
+}
+async function ensureRuntimeExcludes(worktreePath) {
+    for (const file of AUTORESEARCH_WORKTREE_EXCLUDES) {
+        await writeGitInfoExclude(worktreePath, file);
+    }
+}
+async function ensureAutoresearchWorktreeDependencies(repoRoot, worktreePath) {
+    const sourceNodeModules = join(repoRoot, 'node_modules');
+    const targetNodeModules = join(worktreePath, 'node_modules');
+    if (!existsSync(sourceNodeModules) || existsSync(targetNodeModules)) {
+        return;
+    }
+    await symlink(sourceNodeModules, targetNodeModules, process.platform === 'win32' ? 'junction' : 'dir');
+}
+function readGitShortHead(worktreePath) {
+    return readGit(worktreePath, ['rev-parse', '--short=7', 'HEAD']);
+}
+function readGitFullHead(worktreePath) {
+    return readGit(worktreePath, ['rev-parse', 'HEAD']);
+}
+function requireGitSuccess(worktreePath, args) {
+    const result = spawnSync('git', args, {
+        cwd: worktreePath,
+        encoding: 'utf-8',
+    });
+    if (result.status === 0)
+        return;
+    throw new Error((result.stderr || '').trim() || `git ${args.join(' ')} failed`);
+}
+function gitStatusLines(worktreePath) {
+    const result = spawnSync('git', ['status', '--porcelain', '--untracked-files=all'], {
+        cwd: worktreePath,
+        encoding: 'utf-8',
+    });
+    if (result.status !== 0) {
+        throw new Error((result.stderr || '').trim() || `git status failed for ${worktreePath}`);
+    }
+    return (result.stdout || '')
+        .split(/\r?\n/)
+        .map((line) => line.trimEnd())
+        .filter(Boolean);
+}
+function normalizeGitStatusPath(path) {
+    return path.startsWith('\"') && path.endsWith('\"')
+        ? path.slice(1, -1).replace(/\\\"/g, '\"')
+        : path;
+}
+function isAllowedRuntimeDirtyPath(path) {
+    return AUTORESEARCH_WORKTREE_EXCLUDES.some((exclude) => exclude.endsWith('/')
+        ? path.startsWith(exclude) || path === exclude.slice(0, -1)
+        : path === exclude);
+}
+function allowedBootstrapDirtyPaths(worktreePath, allowedDirtyPaths = []) {
+    const normalizedWorktreePath = resolve(worktreePath);
+    return new Set(allowedDirtyPaths
+        .map((path) => {
+        const normalizedPath = resolve(path);
+        return normalizedPath.startsWith(`${normalizedWorktreePath}/`)
+            ? normalizedPath.slice(normalizedWorktreePath.length + 1)
+            : null;
+    })
+        .filter((path) => Boolean(path)));
+}
+function isAllowedRuntimeDirtyLine(line, allowedBootstrapPaths) {
+    const trimmed = line.trim();
+    if (trimmed.length < 4)
+        return false;
+    const path = normalizeGitStatusPath(trimmed.slice(3).trim());
+    if (!trimmed.startsWith('?? '))
+        return false;
+    return isAllowedRuntimeDirtyPath(path) || allowedBootstrapPaths.has(path);
+}
+export function assertResetSafeWorktree(worktreePath, allowedDirtyPaths = []) {
+    const lines = gitStatusLines(worktreePath);
+    const allowedBootstrapPaths = allowedBootstrapDirtyPaths(worktreePath, allowedDirtyPaths);
+    const blocking = lines.filter((line) => !isAllowedRuntimeDirtyLine(line, allowedBootstrapPaths));
+    if (blocking.length === 0)
+        return;
+    throw new Error(`autoresearch_reset_requires_clean_worktree:${worktreePath}:${blocking.join(' | ')}`);
+}
+async function ensureParentDir(filePath) {
+    await mkdir(dirname(filePath), { recursive: true });
+}
+async function writeJsonFile(filePath, value) {
+    await ensureParentDir(filePath);
+    await writeFile(filePath, `${JSON.stringify(value, null, 2)}\n`, 'utf-8');
+}
+async function readJsonFile(filePath) {
+    return JSON.parse(await readFile(filePath, 'utf-8'));
+}
+async function readActiveRunState(projectRoot) {
+    const file = activeRunStateFile(projectRoot);
+    if (!existsSync(file))
+        return null;
+    return readJsonFile(file);
+}
+async function writeActiveRunState(projectRoot, value) {
+    await writeJsonFile(activeRunStateFile(projectRoot), value);
+}
+async function assertAutoresearchLockAvailable(projectRoot) {
+    const state = await readActiveRunState(projectRoot);
+    if (state?.active && state.run_id) {
+        throw new Error(`autoresearch_active_run_exists:${state.run_id}`);
+    }
+}
+/**
+ * Assert no exclusive mode is already active (ralph, ultrawork, autopilot).
+ * Mirrors OMX assertModeStartAllowed semantics using OMC mode-state-io.
+ */
+export async function assertModeStartAllowed(mode, projectRoot) {
+    for (const other of EXCLUSIVE_MODES) {
+        if (other === mode)
+            continue;
+        const state = readModeState(other, projectRoot);
+        if (state && state.active) {
+            throw new Error(`Cannot start ${mode}: ${other} is already active`);
+        }
+    }
+}
+async function activateAutoresearchRun(manifest) {
+    await writeActiveRunState(manifest.repo_root, {
+        schema_version: 1,
+        active: true,
+        run_id: manifest.run_id,
+        mission_slug: manifest.mission_slug,
+        repo_root: manifest.repo_root,
+        worktree_path: manifest.worktree_path,
+        status: manifest.status,
+        updated_at: nowIso(),
+    });
+}
+async function deactivateAutoresearchRun(manifest) {
+    const previous = await readActiveRunState(manifest.repo_root);
+    await writeActiveRunState(manifest.repo_root, {
+        schema_version: 1,
+        active: false,
+        run_id: previous?.run_id ?? manifest.run_id,
+        mission_slug: previous?.mission_slug ?? manifest.mission_slug,
+        repo_root: manifest.repo_root,
+        worktree_path: previous?.worktree_path ?? manifest.worktree_path,
+        status: manifest.status,
+        updated_at: nowIso(),
+        completed_at: nowIso(),
+    });
+}
+/**
+ * Start autoresearch mode state using OMC's writeModeState.
+ */
+function startAutoresearchMode(taskDescription, projectRoot) {
+    writeModeState('autoresearch', {
+        active: true,
+        mode: 'autoresearch',
+        iteration: 0,
+        max_iterations: 1,
+        current_phase: 'starting',
+        task_description: taskDescription,
+        started_at: nowIso(),
+    }, projectRoot);
+}
+/**
+ * Update autoresearch mode state (merge semantics).
+ */
+function updateAutoresearchMode(updates, projectRoot) {
+    const current = readModeState('autoresearch', projectRoot);
+    if (!current)
+        return;
+    writeModeState('autoresearch', { ...current, ...updates }, projectRoot);
+}
+/**
+ * Cancel autoresearch mode state.
+ */
+function cancelAutoresearchMode(projectRoot) {
+    const state = readModeState('autoresearch', projectRoot);
+    if (state && state.active) {
+        writeModeState('autoresearch', {
+            ...state,
+            active: false,
+            current_phase: 'cancelled',
+            completed_at: nowIso(),
+        }, projectRoot);
+    }
+}
+function resultPassValue(value) {
+    return value === undefined ? '' : String(value);
+}
+function resultScoreValue(value) {
+    return typeof value === 'number' ? String(value) : '';
+}
+async function initializeAutoresearchResultsFile(resultsFile) {
+    if (existsSync(resultsFile))
+        return;
+    await ensureParentDir(resultsFile);
+    await writeFile(resultsFile, AUTORESEARCH_RESULTS_HEADER, 'utf-8');
+}
+async function appendAutoresearchResultsRow(resultsFile, row) {
+    const existing = existsSync(resultsFile)
+        ? await readFile(resultsFile, 'utf-8')
+        : AUTORESEARCH_RESULTS_HEADER;
+    await writeFile(resultsFile, `${existing}${row.iteration}\t${row.commit}\t${resultPassValue(row.pass)}\t${resultScoreValue(row.score)}\t${row.status}\t${row.description}\n`, 'utf-8');
+}
+async function appendAutoresearchLedgerEntry(ledgerFile, entry) {
+    const parsed = existsSync(ledgerFile)
+        ? await readJsonFile(ledgerFile)
+        : { schema_version: 1, entries: [] };
+    const entries = Array.isArray(parsed.entries) ? parsed.entries : [];
+    entries.push(entry);
+    await writeJsonFile(ledgerFile, {
+        schema_version: typeof parsed.schema_version === 'number' ? parsed.schema_version : 1,
+        run_id: parsed.run_id,
+        created_at: parsed.created_at || nowIso(),
+        updated_at: nowIso(),
+        entries,
+    });
+}
+async function readAutoresearchLedgerEntries(ledgerFile) {
+    if (!existsSync(ledgerFile))
+        return [];
+    const parsed = await readJsonFile(ledgerFile);
+    return Array.isArray(parsed.entries) ? parsed.entries : [];
+}
+export async function countTrailingAutoresearchNoops(ledgerFile) {
+    const entries = await readAutoresearchLedgerEntries(ledgerFile);
+    let count = 0;
+    for (let index = entries.length - 1; index >= 0; index -= 1) {
+        const entry = entries[index];
+        if (!entry || entry.kind !== 'iteration' || entry.decision !== 'noop')
+            break;
+        count += 1;
+    }
+    return count;
+}
+function formatAutoresearchInstructionSummary(entries, maxEntries = 3) {
+    return entries
+        .slice(-maxEntries)
+        .map((entry) => ({
+        iteration: entry.iteration,
+        decision: entry.decision,
+        reason: trimContent(entry.decision_reason, 160),
+        kept_commit: entry.kept_commit,
+        candidate_commit: entry.candidate_commit,
+        evaluator_status: entry.evaluator?.status ?? null,
+        evaluator_score: typeof entry.evaluator?.score === 'number' ? entry.evaluator.score : null,
+        description: trimContent(entry.description, 120),
+    }));
+}
+async function buildAutoresearchInstructionContext(manifest) {
+    const entries = await readAutoresearchLedgerEntries(manifest.ledger_file);
+    const previous = entries.at(-1);
+    return {
+        previousIterationOutcome: previous
+            ? `${previous.decision}:${trimContent(previous.decision_reason, 160)}`
+            : null,
+        recentLedgerSummary: formatAutoresearchInstructionSummary(entries),
+    };
+}
+export async function runAutoresearchEvaluator(contract, worktreePath, ledgerFile, latestEvaluatorFile) {
+    const ran_at = nowIso();
+    const result = spawnSync(contract.sandbox.evaluator.command, {
+        cwd: worktreePath,
+        encoding: 'utf-8',
+        shell: true,
+        maxBuffer: 1024 * 1024,
+    });
+    const stdout = result.stdout?.trim() || '';
+    const stderr = result.stderr?.trim() || '';
+    let record;
+    if (result.error || result.status !== 0) {
+        record = {
+            command: contract.sandbox.evaluator.command,
+            ran_at,
+            status: 'error',
+            exit_code: result.status,
+            stdout,
+            stderr: result.error ? [stderr, result.error.message].filter(Boolean).join('\n') : stderr,
+        };
+    }
+    else {
+        try {
+            const parsed = parseEvaluatorResult(stdout);
+            record = {
+                command: contract.sandbox.evaluator.command,
+                ran_at,
+                status: parsed.pass ? 'pass' : 'fail',
+                pass: parsed.pass,
+                ...(parsed.score !== undefined ? { score: parsed.score } : {}),
+                exit_code: result.status,
+                stdout,
+                stderr,
+            };
+        }
+        catch (error) {
+            record = {
+                command: contract.sandbox.evaluator.command,
+                ran_at,
+                status: 'error',
+                exit_code: result.status,
+                stdout,
+                stderr,
+                parse_error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    if (latestEvaluatorFile) {
+        await writeJsonFile(latestEvaluatorFile, record);
+    }
+    if (ledgerFile) {
+        await appendAutoresearchLedgerEntry(ledgerFile, {
+            iteration: -1,
+            kind: 'iteration',
+            decision: record.status === 'error' ? 'error' : record.status === 'pass' ? 'keep' : 'discard',
+            decision_reason: 'raw evaluator record',
+            candidate_status: 'candidate',
+            base_commit: readGitShortHead(worktreePath),
+            candidate_commit: null,
+            kept_commit: readGitShortHead(worktreePath),
+            keep_policy: contract.sandbox.evaluator.keep_policy ?? 'score_improvement',
+            evaluator: record,
+            created_at: nowIso(),
+            notes: ['raw evaluator invocation'],
+            description: 'raw evaluator record',
+        });
+    }
+    return record;
+}
+function comparableScore(previousScore, nextScore) {
+    return typeof previousScore === 'number' && typeof nextScore === 'number';
+}
+export function decideAutoresearchOutcome(manifest, candidate, evaluation) {
+    if (candidate.status === 'abort') {
+        return {
+            decision: 'abort',
+            decisionReason: 'candidate requested abort',
+            keep: false,
+            evaluator: null,
+            notes: ['run stopped by candidate artifact'],
+        };
+    }
+    if (candidate.status === 'noop') {
+        return {
+            decision: 'noop',
+            decisionReason: 'candidate reported noop',
+            keep: false,
+            evaluator: null,
+            notes: ['no code change was proposed'],
+        };
+    }
+    if (candidate.status === 'interrupted') {
+        return {
+            decision: 'interrupted',
+            decisionReason: 'candidate session was interrupted',
+            keep: false,
+            evaluator: null,
+            notes: ['supervisor should inspect worktree cleanliness before continuing'],
+        };
+    }
+    if (!evaluation || evaluation.status === 'error') {
+        return {
+            decision: 'discard',
+            decisionReason: 'evaluator error',
+            keep: false,
+            evaluator: evaluation,
+            notes: ['candidate discarded because evaluator errored or crashed'],
+        };
+    }
+    if (!evaluation.pass) {
+        return {
+            decision: 'discard',
+            decisionReason: 'evaluator reported failure',
+            keep: false,
+            evaluator: evaluation,
+            notes: ['candidate discarded because evaluator pass=false'],
+        };
+    }
+    if (manifest.keep_policy === 'pass_only') {
+        return {
+            decision: 'keep',
+            decisionReason: 'pass_only keep policy accepted evaluator pass=true',
+            keep: true,
+            evaluator: evaluation,
+            notes: ['candidate kept because sandbox opted into pass_only policy'],
+        };
+    }
+    if (!comparableScore(manifest.last_kept_score, evaluation.score)) {
+        return {
+            decision: 'ambiguous',
+            decisionReason: 'evaluator pass without comparable score',
+            keep: false,
+            evaluator: evaluation,
+            notes: ['candidate discarded because score_improvement policy requires comparable numeric scores'],
+        };
+    }
+    if (evaluation.score > manifest.last_kept_score) {
+        return {
+            decision: 'keep',
+            decisionReason: 'score improved over last kept score',
+            keep: true,
+            evaluator: evaluation,
+            notes: ['candidate kept because evaluator score increased'],
+        };
+    }
+    return {
+        decision: 'discard',
+        decisionReason: 'score did not improve',
+        keep: false,
+        evaluator: evaluation,
+        notes: ['candidate discarded because evaluator score was not better than the kept baseline'],
+    };
+}
+export function buildAutoresearchInstructions(contract, context) {
+    return [
+        '# OMC Autoresearch Supervisor Instructions',
+        '',
+        `Run ID: ${context.runId}`,
+        `Mission directory: ${contract.missionDir}`,
+        `Mission file: ${contract.missionFile}`,
+        `Sandbox file: ${contract.sandboxFile}`,
+        `Mission slug: ${contract.missionSlug}`,
+        `Iteration: ${context.iteration}`,
+        `Baseline commit: ${context.baselineCommit}`,
+        `Last kept commit: ${context.lastKeptCommit}`,
+        `Last kept score: ${typeof context.lastKeptScore === 'number' ? context.lastKeptScore : 'n/a'}`,
+        `Results file: ${context.resultsFile}`,
+        `Candidate artifact: ${context.candidateFile}`,
+        `Keep policy: ${context.keepPolicy}`,
+        '',
+        'Iteration state snapshot:',
+        '```json',
+        JSON.stringify({
+            iteration: context.iteration,
+            baseline_commit: context.baselineCommit,
+            last_kept_commit: context.lastKeptCommit,
+            last_kept_score: context.lastKeptScore ?? null,
+            previous_iteration_outcome: context.previousIterationOutcome ?? 'none yet',
+            recent_ledger_summary: context.recentLedgerSummary ?? [],
+            keep_policy: context.keepPolicy,
+        }, null, 2),
+        '```',
+        '',
+        'Operate as a thin autoresearch experiment worker for exactly one experiment cycle.',
+        'Do not loop forever inside this session. Make at most one candidate commit, then write the candidate artifact JSON and exit.',
+        '',
+        'Candidate artifact contract:',
+        '- Write JSON to the exact candidate artifact path above.',
+        '- status: candidate | noop | abort | interrupted',
+        '- candidate_commit: string | null',
+        '- base_commit: current base commit before your edits',
+        '- for status=candidate, candidate_commit must resolve in git and match the worktree HEAD commit when you exit',
+        '- base_commit must still match the last kept commit provided above',
+        '- description: short one-line summary',
+        '- notes: array of short strings',
+        '- created_at: ISO timestamp',
+        '',
+        'Supervisor semantics after you exit:',
+        '- status=candidate => evaluator runs, then supervisor keeps or discards and may reset the worktree',
+        '- status=noop => supervisor logs a noop iteration and relaunches',
+        '- status=abort => supervisor stops the run',
+        '- status=interrupted => supervisor inspects worktree safety before deciding how to proceed',
+        '',
+        'Evaluator contract:',
+        `- command: ${contract.sandbox.evaluator.command}`,
+        '- format: json',
+        '- required output field: pass (boolean)',
+        '- optional output field: score (number)',
+        '',
+        'Mission content:',
+        '```md',
+        trimContent(contract.missionContent),
+        '```',
+        '',
+        'Sandbox policy:',
+        '```md',
+        trimContent(contract.sandbox.body || contract.sandboxContent),
+        '```',
+    ].join('\n');
+}
+export async function materializeAutoresearchMissionToWorktree(contract, worktreePath) {
+    const missionDir = join(worktreePath, contract.missionRelativeDir);
+    const missionFile = join(missionDir, 'mission.md');
+    const sandboxFile = join(missionDir, 'sandbox.md');
+    await mkdir(missionDir, { recursive: true });
+    await writeFile(missionFile, contract.missionContent, 'utf-8');
+    await writeFile(sandboxFile, contract.sandboxContent, 'utf-8');
+    return {
+        ...contract,
+        missionDir,
+        missionFile,
+        sandboxFile,
+    };
+}
+export async function loadAutoresearchRunManifest(projectRoot, runId) {
+    const manifestFile = join(projectRoot, '.omc', 'logs', 'autoresearch', runId, 'manifest.json');
+    if (!existsSync(manifestFile)) {
+        throw new Error(`autoresearch_resume_manifest_missing:${runId}`);
+    }
+    return readJsonFile(manifestFile);
+}
+async function writeRunManifest(manifest) {
+    manifest.updated_at = nowIso();
+    await writeJsonFile(manifest.manifest_file, manifest);
+}
+async function writeInstructionsFile(contract, manifest) {
+    const instructionContext = await buildAutoresearchInstructionContext(manifest);
+    await writeFile(manifest.instructions_file, `${buildAutoresearchInstructions(contract, {
+        runId: manifest.run_id,
+        iteration: manifest.iteration + 1,
+        baselineCommit: manifest.baseline_commit,
+        lastKeptCommit: manifest.last_kept_commit,
+        lastKeptScore: manifest.last_kept_score,
+        resultsFile: manifest.results_file,
+        candidateFile: manifest.candidate_file,
+        keepPolicy: manifest.keep_policy,
+        previousIterationOutcome: instructionContext.previousIterationOutcome,
+        recentLedgerSummary: instructionContext.recentLedgerSummary,
+    })}\n`, 'utf-8');
+}
+async function seedBaseline(contract, manifest) {
+    const evaluation = await runAutoresearchEvaluator(contract, manifest.worktree_path);
+    await writeJsonFile(manifest.latest_evaluator_file, evaluation);
+    await appendAutoresearchResultsRow(manifest.results_file, {
+        iteration: 0,
+        commit: readGitShortHead(manifest.worktree_path),
+        pass: evaluation.pass,
+        score: evaluation.score,
+        status: evaluation.status === 'error' ? 'error' : 'baseline',
+        description: 'initial baseline evaluation',
+    });
+    await appendAutoresearchLedgerEntry(manifest.ledger_file, {
+        iteration: 0,
+        kind: 'baseline',
+        decision: evaluation.status === 'error' ? 'error' : 'baseline',
+        decision_reason: evaluation.status === 'error' ? 'baseline evaluator error' : 'baseline established',
+        candidate_status: 'baseline',
+        base_commit: manifest.baseline_commit,
+        candidate_commit: null,
+        kept_commit: manifest.last_kept_commit,
+        keep_policy: manifest.keep_policy,
+        evaluator: evaluation,
+        created_at: nowIso(),
+        notes: ['baseline row is always recorded'],
+        description: 'initial baseline evaluation',
+    });
+    manifest.last_kept_score = evaluation.pass && typeof evaluation.score === 'number' ? evaluation.score : null;
+    await writeRunManifest(manifest);
+    await writeInstructionsFile(contract, manifest);
+    return evaluation;
+}
+export async function prepareAutoresearchRuntime(contract, projectRoot, worktreePath, options = {}) {
+    await assertAutoresearchLockAvailable(projectRoot);
+    await ensureRuntimeExcludes(worktreePath);
+    await ensureAutoresearchWorktreeDependencies(projectRoot, worktreePath);
+    assertResetSafeWorktree(worktreePath, [contract.missionFile, contract.sandboxFile]);
+    const runTag = options.runTag || buildAutoresearchRunTag();
+    const runId = buildRunId(contract.missionSlug, runTag);
+    const baselineCommit = readGitShortHead(worktreePath);
+    const branchName = readGit(worktreePath, ['symbolic-ref', '--quiet', '--short', 'HEAD']);
+    const runDir = join(projectRoot, '.omc', 'logs', 'autoresearch', runId);
+    const stateFile = activeRunStateFile(projectRoot);
+    const instructionsFile = join(runDir, 'bootstrap-instructions.md');
+    const manifestFile = join(runDir, 'manifest.json');
+    const ledgerFile = join(runDir, 'iteration-ledger.json');
+    const latestEvaluatorFile = join(runDir, 'latest-evaluator-result.json');
+    const candidateFile = join(runDir, 'candidate.json');
+    const resultsFile = join(worktreePath, 'results.tsv');
+    const taskDescription = `autoresearch ${contract.missionRelativeDir} (${runId})`;
+    const keepPolicy = contract.sandbox.evaluator.keep_policy ?? 'score_improvement';
+    await mkdir(runDir, { recursive: true });
+    await initializeAutoresearchResultsFile(resultsFile);
+    await writeJsonFile(candidateFile, {
+        status: 'noop',
+        candidate_commit: null,
+        base_commit: baselineCommit,
+        description: 'not-yet-written',
+        notes: ['candidate artifact will be overwritten by the launched session'],
+        created_at: nowIso(),
+    });
+    const manifest = {
+        schema_version: 1,
+        run_id: runId,
+        run_tag: runTag,
+        mission_dir: contract.missionDir,
+        mission_file: contract.missionFile,
+        sandbox_file: contract.sandboxFile,
+        repo_root: projectRoot,
+        worktree_path: worktreePath,
+        mission_slug: contract.missionSlug,
+        branch_name: branchName,
+        baseline_commit: baselineCommit,
+        last_kept_commit: readGitFullHead(worktreePath),
+        last_kept_score: null,
+        latest_candidate_commit: null,
+        results_file: resultsFile,
+        instructions_file: instructionsFile,
+        manifest_file: manifestFile,
+        ledger_file: ledgerFile,
+        latest_evaluator_file: latestEvaluatorFile,
+        candidate_file: candidateFile,
+        evaluator: contract.sandbox.evaluator,
+        keep_policy: keepPolicy,
+        status: 'running',
+        stop_reason: null,
+        iteration: 0,
+        created_at: nowIso(),
+        updated_at: nowIso(),
+        completed_at: null,
+    };
+    await writeInstructionsFile(contract, manifest);
+    await writeRunManifest(manifest);
+    await writeJsonFile(ledgerFile, {
+        schema_version: 1,
+        run_id: runId,
+        created_at: nowIso(),
+        updated_at: nowIso(),
+        entries: [],
+    });
+    await writeJsonFile(latestEvaluatorFile, {
+        run_id: runId,
+        status: 'not-yet-run',
+        updated_at: nowIso(),
+    });
+    const existingModeState = readModeState('autoresearch', projectRoot);
+    if (existingModeState?.active) {
+        throw new Error(`autoresearch_active_mode_exists:${String(existingModeState.run_id || 'unknown')}`);
+    }
+    startAutoresearchMode(taskDescription, projectRoot);
+    await activateAutoresearchRun(manifest);
+    updateAutoresearchMode({
+        current_phase: 'evaluating-baseline',
+        run_id: runId,
+        run_tag: runTag,
+        mission_dir: contract.missionDir,
+        mission_file: contract.missionFile,
+        sandbox_file: contract.sandboxFile,
+        mission_slug: contract.missionSlug,
+        repo_root: projectRoot,
+        worktree_path: worktreePath,
+        baseline_commit: baselineCommit,
+        last_kept_commit: manifest.last_kept_commit,
+        results_file: resultsFile,
+        manifest_path: manifestFile,
+        iteration_ledger_path: ledgerFile,
+        latest_evaluator_result_path: latestEvaluatorFile,
+        bootstrap_instructions_path: instructionsFile,
+        candidate_path: candidateFile,
+        keep_policy: keepPolicy,
+        state_file: stateFile,
+    }, projectRoot);
+    const evaluation = await seedBaseline(contract, manifest);
+    updateAutoresearchMode({
+        current_phase: 'running',
+        latest_evaluator_status: evaluation.status,
+        latest_evaluator_pass: evaluation.pass,
+        latest_evaluator_score: evaluation.score,
+        latest_evaluator_ran_at: evaluation.ran_at,
+        last_kept_commit: manifest.last_kept_commit,
+        last_kept_score: manifest.last_kept_score,
+    }, projectRoot);
+    return {
+        runId,
+        runTag,
+        runDir,
+        instructionsFile,
+        manifestFile,
+        ledgerFile,
+        latestEvaluatorFile,
+        resultsFile,
+        stateFile,
+        candidateFile,
+        repoRoot: projectRoot,
+        worktreePath,
+        taskDescription,
+    };
+}
+export async function resumeAutoresearchRuntime(projectRoot, runId) {
+    await assertAutoresearchLockAvailable(projectRoot);
+    const manifest = await loadAutoresearchRunManifest(projectRoot, runId);
+    if (manifest.status !== 'running') {
+        throw new Error(`autoresearch_resume_terminal_run:${runId}`);
+    }
+    if (!existsSync(manifest.worktree_path)) {
+        throw new Error(`autoresearch_resume_missing_worktree:${manifest.worktree_path}`);
+    }
+    await ensureRuntimeExcludes(manifest.worktree_path);
+    await ensureAutoresearchWorktreeDependencies(projectRoot, manifest.worktree_path);
+    assertResetSafeWorktree(manifest.worktree_path, [manifest.mission_file, manifest.sandbox_file]);
+    startAutoresearchMode(`autoresearch resume ${runId}`, projectRoot);
+    await activateAutoresearchRun(manifest);
+    updateAutoresearchMode({
+        current_phase: 'running',
+        run_id: manifest.run_id,
+        run_tag: manifest.run_tag,
+        mission_dir: manifest.mission_dir,
+        mission_file: manifest.mission_file,
+        sandbox_file: manifest.sandbox_file,
+        mission_slug: manifest.mission_slug,
+        repo_root: manifest.repo_root,
+        worktree_path: manifest.worktree_path,
+        baseline_commit: manifest.baseline_commit,
+        last_kept_commit: manifest.last_kept_commit,
+        last_kept_score: manifest.last_kept_score,
+        results_file: manifest.results_file,
+        manifest_path: manifest.manifest_file,
+        iteration_ledger_path: manifest.ledger_file,
+        latest_evaluator_result_path: manifest.latest_evaluator_file,
+        bootstrap_instructions_path: manifest.instructions_file,
+        candidate_path: manifest.candidate_file,
+        keep_policy: manifest.keep_policy,
+        state_file: activeRunStateFile(projectRoot),
+    }, projectRoot);
+    return {
+        runId: manifest.run_id,
+        runTag: manifest.run_tag,
+        runDir: dirname(manifest.manifest_file),
+        instructionsFile: manifest.instructions_file,
+        manifestFile: manifest.manifest_file,
+        ledgerFile: manifest.ledger_file,
+        latestEvaluatorFile: manifest.latest_evaluator_file,
+        resultsFile: manifest.results_file,
+        stateFile: activeRunStateFile(projectRoot),
+        candidateFile: manifest.candidate_file,
+        repoRoot: manifest.repo_root,
+        worktreePath: manifest.worktree_path,
+        taskDescription: `autoresearch resume ${runId}`,
+    };
+}
+export function parseAutoresearchCandidateArtifact(raw) {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw new Error('autoresearch candidate artifact must be valid JSON');
+    }
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new Error('autoresearch candidate artifact must be a JSON object');
+    }
+    const record = parsed;
+    const status = record.status;
+    if (status !== 'candidate' && status !== 'noop' && status !== 'abort' && status !== 'interrupted') {
+        throw new Error('autoresearch candidate artifact status must be candidate|noop|abort|interrupted');
+    }
+    if (record.candidate_commit !== null && typeof record.candidate_commit !== 'string') {
+        throw new Error('autoresearch candidate artifact candidate_commit must be string|null');
+    }
+    if (typeof record.base_commit !== 'string' || !record.base_commit.trim()) {
+        throw new Error('autoresearch candidate artifact base_commit is required');
+    }
+    if (typeof record.description !== 'string') {
+        throw new Error('autoresearch candidate artifact description is required');
+    }
+    if (!Array.isArray(record.notes) || record.notes.some((note) => typeof note !== 'string')) {
+        throw new Error('autoresearch candidate artifact notes must be a string array');
+    }
+    if (typeof record.created_at !== 'string' || !record.created_at.trim()) {
+        throw new Error('autoresearch candidate artifact created_at is required');
+    }
+    return {
+        status,
+        candidate_commit: record.candidate_commit,
+        base_commit: record.base_commit,
+        description: record.description,
+        notes: record.notes,
+        created_at: record.created_at,
+    };
+}
+async function readCandidateArtifact(candidateFile) {
+    if (!existsSync(candidateFile)) {
+        throw new Error(`autoresearch_candidate_missing:${candidateFile}`);
+    }
+    return parseAutoresearchCandidateArtifact(await readFile(candidateFile, 'utf-8'));
+}
+async function finalizeRun(manifest, projectRoot, updates) {
+    manifest.status = updates.status;
+    manifest.stop_reason = updates.stopReason;
+    manifest.completed_at = nowIso();
+    await writeRunManifest(manifest);
+    updateAutoresearchMode({
+        active: false,
+        current_phase: updates.status,
+        completed_at: manifest.completed_at,
+        stop_reason: updates.stopReason,
+    }, projectRoot);
+    await deactivateAutoresearchRun(manifest);
+}
+function resetToLastKeptCommit(manifest) {
+    assertResetSafeWorktree(manifest.worktree_path, [manifest.mission_file, manifest.sandbox_file]);
+    requireGitSuccess(manifest.worktree_path, ['reset', '--hard', manifest.last_kept_commit]);
+}
+function validateAutoresearchCandidate(manifest, candidate) {
+    const resolvedBaseCommit = tryResolveGitCommit(manifest.worktree_path, candidate.base_commit);
+    if (!resolvedBaseCommit) {
+        return {
+            reason: `candidate base_commit does not resolve in git: ${candidate.base_commit}`,
+        };
+    }
+    if (resolvedBaseCommit !== manifest.last_kept_commit) {
+        return {
+            reason: `candidate base_commit ${resolvedBaseCommit} does not match last kept commit ${manifest.last_kept_commit}`,
+        };
+    }
+    if (candidate.status !== 'candidate') {
+        return {
+            candidate: {
+                ...candidate,
+                base_commit: resolvedBaseCommit,
+            },
+        };
+    }
+    if (!candidate.candidate_commit) {
+        return {
+            reason: 'candidate status requires a non-null candidate_commit',
+        };
+    }
+    const resolvedCandidateCommit = tryResolveGitCommit(manifest.worktree_path, candidate.candidate_commit);
+    if (!resolvedCandidateCommit) {
+        return {
+            reason: `candidate_commit does not resolve in git: ${candidate.candidate_commit}`,
+        };
+    }
+    const headCommit = readGitFullHead(manifest.worktree_path);
+    if (resolvedCandidateCommit !== headCommit) {
+        return {
+            reason: `candidate_commit ${resolvedCandidateCommit} does not match worktree HEAD ${headCommit}`,
+        };
+    }
+    return {
+        candidate: {
+            ...candidate,
+            base_commit: resolvedBaseCommit,
+            candidate_commit: resolvedCandidateCommit,
+        },
+    };
+}
+async function failAutoresearchIteration(manifest, projectRoot, reason, candidate) {
+    const headCommit = (() => {
+        try {
+            return readGitShortHead(manifest.worktree_path);
+        }
+        catch {
+            return manifest.baseline_commit;
+        }
+    })();
+    await appendAutoresearchResultsRow(manifest.results_file, {
+        iteration: manifest.iteration,
+        commit: headCommit,
+        status: 'error',
+        description: candidate?.description || 'candidate validation failed',
+    });
+    await appendAutoresearchLedgerEntry(manifest.ledger_file, {
+        iteration: manifest.iteration,
+        kind: 'iteration',
+        decision: 'error',
+        decision_reason: reason,
+        candidate_status: candidate?.status ?? 'candidate',
+        base_commit: candidate?.base_commit ?? manifest.last_kept_commit,
+        candidate_commit: candidate?.candidate_commit ?? null,
+        kept_commit: manifest.last_kept_commit,
+        keep_policy: manifest.keep_policy,
+        evaluator: null,
+        created_at: nowIso(),
+        notes: [...(candidate?.notes ?? []), `validation_error:${reason}`],
+        description: candidate?.description || 'candidate validation failed',
+    });
+    await finalizeRun(manifest, projectRoot, { status: 'failed', stopReason: reason });
+    return 'error';
+}
+export async function processAutoresearchCandidate(contract, manifest, projectRoot) {
+    manifest.iteration += 1;
+    let candidate;
+    try {
+        candidate = await readCandidateArtifact(manifest.candidate_file);
+    }
+    catch (error) {
+        return failAutoresearchIteration(manifest, projectRoot, error instanceof Error ? error.message : String(error));
+    }
+    const validation = validateAutoresearchCandidate(manifest, candidate);
+    if ('reason' in validation) {
+        return failAutoresearchIteration(manifest, projectRoot, validation.reason, candidate);
+    }
+    candidate = validation.candidate;
+    manifest.latest_candidate_commit = candidate.candidate_commit;
+    if (candidate.status === 'abort') {
+        await appendAutoresearchResultsRow(manifest.results_file, {
+            iteration: manifest.iteration,
+            commit: readGitShortHead(manifest.worktree_path),
+            status: 'abort',
+            description: candidate.description,
+        });
+        await appendAutoresearchLedgerEntry(manifest.ledger_file, {
+            iteration: manifest.iteration,
+            kind: 'iteration',
+            decision: 'abort',
+            decision_reason: 'candidate requested abort',
+            candidate_status: candidate.status,
+            base_commit: candidate.base_commit,
+            candidate_commit: candidate.candidate_commit,
+            kept_commit: manifest.last_kept_commit,
+            keep_policy: manifest.keep_policy,
+            evaluator: null,
+            created_at: nowIso(),
+            notes: candidate.notes,
+            description: candidate.description,
+        });
+        await finalizeRun(manifest, projectRoot, { status: 'stopped', stopReason: 'candidate abort' });
+        return 'abort';
+    }
+    if (candidate.status === 'interrupted') {
+        try {
+            assertResetSafeWorktree(manifest.worktree_path, [manifest.mission_file, manifest.sandbox_file]);
+        }
+        catch {
+            await finalizeRun(manifest, projectRoot, { status: 'failed', stopReason: 'interrupted dirty worktree requires operator intervention' });
+            return 'error';
+        }
+        await appendAutoresearchResultsRow(manifest.results_file, {
+            iteration: manifest.iteration,
+            commit: readGitShortHead(manifest.worktree_path),
+            status: 'interrupted',
+            description: candidate.description,
+        });
+        await appendAutoresearchLedgerEntry(manifest.ledger_file, {
+            iteration: manifest.iteration,
+            kind: 'iteration',
+            decision: 'interrupted',
+            decision_reason: 'candidate session interrupted cleanly',
+            candidate_status: candidate.status,
+            base_commit: candidate.base_commit,
+            candidate_commit: candidate.candidate_commit,
+            kept_commit: manifest.last_kept_commit,
+            keep_policy: manifest.keep_policy,
+            evaluator: null,
+            created_at: nowIso(),
+            notes: candidate.notes,
+            description: candidate.description,
+        });
+        await writeRunManifest(manifest);
+        await writeInstructionsFile(contract, manifest);
+        return 'interrupted';
+    }
+    if (candidate.status === 'noop') {
+        await appendAutoresearchResultsRow(manifest.results_file, {
+            iteration: manifest.iteration,
+            commit: readGitShortHead(manifest.worktree_path),
+            status: 'noop',
+            description: candidate.description,
+        });
+        await appendAutoresearchLedgerEntry(manifest.ledger_file, {
+            iteration: manifest.iteration,
+            kind: 'iteration',
+            decision: 'noop',
+            decision_reason: 'candidate reported noop',
+            candidate_status: candidate.status,
+            base_commit: candidate.base_commit,
+            candidate_commit: candidate.candidate_commit,
+            kept_commit: manifest.last_kept_commit,
+            keep_policy: manifest.keep_policy,
+            evaluator: null,
+            created_at: nowIso(),
+            notes: candidate.notes,
+            description: candidate.description,
+        });
+        await writeRunManifest(manifest);
+        await writeInstructionsFile(contract, manifest);
+        return 'noop';
+    }
+    const evaluation = await runAutoresearchEvaluator(contract, manifest.worktree_path);
+    await writeJsonFile(manifest.latest_evaluator_file, evaluation);
+    const decision = decideAutoresearchOutcome(manifest, candidate, evaluation);
+    if (decision.keep) {
+        manifest.last_kept_commit = readGitFullHead(manifest.worktree_path);
+        manifest.last_kept_score = typeof evaluation.score === 'number' ? evaluation.score : manifest.last_kept_score;
+    }
+    else {
+        resetToLastKeptCommit(manifest);
+    }
+    await appendAutoresearchResultsRow(manifest.results_file, {
+        iteration: manifest.iteration,
+        commit: readGitShortHead(manifest.worktree_path),
+        pass: evaluation.pass,
+        score: evaluation.score,
+        status: decision.decision,
+        description: candidate.description,
+    });
+    await appendAutoresearchLedgerEntry(manifest.ledger_file, {
+        iteration: manifest.iteration,
+        kind: 'iteration',
+        decision: decision.decision,
+        decision_reason: decision.decisionReason,
+        candidate_status: candidate.status,
+        base_commit: candidate.base_commit,
+        candidate_commit: candidate.candidate_commit,
+        kept_commit: manifest.last_kept_commit,
+        keep_policy: manifest.keep_policy,
+        evaluator: evaluation,
+        created_at: nowIso(),
+        notes: [...candidate.notes, ...decision.notes],
+        description: candidate.description,
+    });
+    await writeRunManifest(manifest);
+    await writeInstructionsFile(contract, manifest);
+    updateAutoresearchMode({
+        current_phase: 'running',
+        iteration: manifest.iteration,
+        last_kept_commit: manifest.last_kept_commit,
+        last_kept_score: manifest.last_kept_score,
+        latest_evaluator_status: evaluation.status,
+        latest_evaluator_pass: evaluation.pass,
+        latest_evaluator_score: evaluation.score,
+        latest_evaluator_ran_at: evaluation.ran_at,
+    }, projectRoot);
+    return decision.decision;
+}
+export async function finalizeAutoresearchRunState(projectRoot, runId, updates) {
+    const manifest = await loadAutoresearchRunManifest(projectRoot, runId);
+    if (manifest.status !== 'running') {
+        return;
+    }
+    await finalizeRun(manifest, projectRoot, updates);
+}
+export async function stopAutoresearchRuntime(projectRoot) {
+    const state = readModeState('autoresearch', projectRoot);
+    if (!state?.active) {
+        return;
+    }
+    const runId = typeof state.run_id === 'string' ? state.run_id : null;
+    if (runId) {
+        await finalizeAutoresearchRunState(projectRoot, runId, {
+            status: 'stopped',
+            stopReason: 'operator stop',
+        });
+        return;
+    }
+    cancelAutoresearchMode(projectRoot);
+}
+//# sourceMappingURL=runtime.js.map