input-kanban 0.0.2 → 0.0.4

package/src/orchestrator.js

@@ -1,26 +1,35 @@
-import { spawn } from 'node:child_process';
 import fs from 'node:fs';
 import fsp from 'node:fs/promises';
 import path from 'node:path';
 import {
-  CODEX_BIN, DEFAULT_REPO, RUNS_DIR, ensureDir, nowIso, makeRunId, readJson,
+  DEFAULT_REPO, RUNS_DIR, ensureDir, nowIso, makeRunId, readJson,
   writeJsonAtomic, fileInfo, readTextMaybe, extractFirstJsonObject, listRunDirs,
-  pathForRun, roleDir, safeIdPart
+  pathForRun, roleDir, safeIdPart, RUNNER
 } from './utils.js';
 import { matchThreadToMarkers } from './appServerClient.js';
+import { formatCodexEventsJsonl } from './eventFormatter.js';
+import { defaultRunner } from './runners/index.js';
 
-const runningChildren = new Map(); // key: `${runId}:${taskId}` -> child
+const runner = defaultRunner;
+const VALID_SANDBOXES = new Set(['read-only', 'workspace-write', 'danger-full-access']);
+
+function normalizeSandbox(value, fallback = 'workspace-write') {
+  const sandbox = String(value || '').trim();
+  if (VALID_SANDBOXES.has(sandbox)) return sandbox;
+  return fallback;
+}
 
 function statePath(runDir) { return path.join(runDir, 'run_state.json'); }
 function planPath(runDir) { return path.join(runDir, 'plan.json'); }
 
-export async function createRun({ label = 'task', taskText = '', repo = DEFAULT_REPO, maxParallel = 3 } = {}) {
+export async function createRun({ label = 'task', taskText = '', repo = DEFAULT_REPO, maxParallel = 3, workerSandbox = 'workspace-write' } = {}) {
   const runId = makeRunId(label);
   const runDir = pathForRun(runId);
   await ensureDir(runDir);
   await fsp.writeFile(path.join(runDir, 'task.md'), taskText || '');
   const state = {
-    runId, label, repo: path.resolve(repo), maxParallel: Number(maxParallel) || 3,
+    runId, label, repo: path.resolve(repo), maxParallel: Number(maxParallel) || 3, workerSandbox: normalizeSandbox(workerSandbox),
+    runner: RUNNER,
     status: 'created', createdAt: nowIso(), updatedAt: nowIso(),
     planner: { status: 'pending' }, batches: [], tasks: [], judge: { status: 'pending' }
   };
@@ -74,7 +83,7 @@ Preferred schema with blocking batches:
           "id": "T-01",
           "name": "short name",
           "prompt": "complete worker prompt",
-          "sandbox": "workspace-write",
+          "sandbox": "${state.workerSandbox || 'workspace-write'}",
           "expectedArtifacts": []
         }
       ]
@@ -90,7 +99,7 @@ Backward-compatible schema also accepted:
       "id": "T-01",
       "name": "short name",
       "prompt": "complete worker prompt",
-      "sandbox": "workspace-write",
+      "sandbox": "${state.workerSandbox || 'workspace-write'}",
       "expectedArtifacts": []
     }
   ]
@@ -101,6 +110,7 @@ Rules:
 - Use batch maxParallel to express whether tasks in the same batch may run concurrently or serially.
 - Keep tasks scoped and independently executable.
 - Include exact output/artifact expectations in each worker prompt.
+- Default worker sandbox for this run is ${state.workerSandbox || 'workspace-write'}; use that sandbox unless a task has a specific safety reason to be stricter.
 - If the input already contains task sections, preserve their ids when practical.
 
 User task:
@@ -132,24 +142,6 @@ Plan: ${path.join(pathForRun(state.runId), 'plan.json')}
 `;
 }
 
-function spawnCodex({ state, taskId, prompt, sandbox, cwd, outDir }) {
-  const events = path.join(outDir, 'events.jsonl');
-  const stderr = path.join(outDir, 'stderr.log');
-  const last = path.join(outDir, 'last_message.md');
-  fs.writeFileSync(path.join(outDir, 'prompt.md'), prompt);
-  const args = ['exec', '--json', '--sandbox', sandbox, '-C', cwd, '-o', last, prompt];
-  const child = spawn(CODEX_BIN, args, { cwd, stdio: ['ignore', 'pipe', 'pipe'] });
-  child.stdout.pipe(fs.createWriteStream(events, { flags: 'a' }));
-  child.stderr.pipe(fs.createWriteStream(stderr, { flags: 'a' }));
-  const key = `${state.runId}:${taskId}`;
-  runningChildren.set(key, child);
-  child.on('exit', code => {
-    try { fs.writeFileSync(path.join(outDir, 'exit_code'), String(code)); } catch {}
-    runningChildren.delete(key);
-  });
-  return child;
-}
-
 export async function startPlanner(runId) {
   const state = await loadRun(runId);
   if (!state) throw new Error(`run not found: ${runId}`);
@@ -168,11 +160,11 @@ export async function startPlanner(runId) {
   await fsp.rm(planPath(runDir), { force: true });
   const taskText = await fsp.readFile(path.join(runDir, 'task.md'), 'utf8');
   const prompt = defaultPlannerPrompt(state, taskText);
-  const child = spawnCodex({ state, taskId: 'planner', prompt, sandbox: 'read-only', cwd: state.repo, outDir });
+  const child = await runner.startCodexTask({ runId: state.runId, taskId: 'planner', batchId: 'planner', runStatePath: statePath(runDir), prompt, sandbox: 'read-only', cwd: state.repo, outDir });
   state.status = 'planning';
   state.planner = { status: 'running', pid: child.pid, startedAt: nowIso(), dir: outDir, attempt: (state.plannerAttempts?.length || 0) + 1 };
   await saveRun(state);
-  child.on('exit', async code => {
+  child.onExit(async code => {
     const s = await loadRun(runId); if (!s || s.status === 'stopped') return;
     s.planner.exitCode = code; s.planner.endedAt = nowIso(); s.planner.status = code === 0 ? 'completed' : 'failed';
     const planResult = await materializePlan(s);
@@ -185,14 +177,14 @@ export async function startPlanner(runId) {
   return state;
 }
 
-function normalizeTask(t, i, batch) {
+function normalizeTask(t, i, batch, defaultSandbox = 'workspace-write') {
   const id = safeIdPart(t.id || `T-${String(i + 1).padStart(2, '0')}`);
   return {
     id,
     batchId: batch.id,
     name: t.name || t.id || `Task ${i + 1}`,
     prompt: t.prompt || t.instructions || '',
-    sandbox: t.sandbox || 'workspace-write',
+    sandbox: normalizeSandbox(t.sandbox, defaultSandbox),
     expectedArtifacts: Array.isArray(t.expectedArtifacts) ? t.expectedArtifacts : [],
     status: 'pending'
   };
@@ -225,7 +217,7 @@ async function rotatePlannerAttempt(state, runDir) {
   }];
 }
 
-function normalizePlan(plan, defaultMaxParallel) {
+function normalizePlan(plan, defaultMaxParallel, defaultSandbox = 'workspace-write') {
   if (Array.isArray(plan.batches)) {
     const batches = plan.batches.map((b, bi) => {
       const batch = {
@@ -235,14 +227,14 @@ function normalizePlan(plan, defaultMaxParallel) {
         status: 'pending',
         tasks: []
       };
-      batch.tasks = (Array.isArray(b.tasks) ? b.tasks : []).map((t, ti) => normalizeTask(t, ti, batch));
+      batch.tasks = (Array.isArray(b.tasks) ? b.tasks : []).map((t, ti) => normalizeTask(t, ti, batch, defaultSandbox));
       return batch;
     }).filter(b => b.tasks.length);
     return { ...plan, batches, tasks: batches.flatMap(b => b.tasks) };
   }
   if (Array.isArray(plan.tasks)) {
     const batch = { id: 'batch-1', name: '默认批次', maxParallel: Math.max(1, Number(defaultMaxParallel) || 1), status: 'pending', tasks: [] };
-    batch.tasks = plan.tasks.map((t, i) => normalizeTask(t, i, batch));
+    batch.tasks = plan.tasks.map((t, i) => normalizeTask(t, i, batch, defaultSandbox));
     return { ...plan, batches: [batch], tasks: batch.tasks };
   }
   return null;
@@ -258,7 +250,7 @@ async function materializePlan(state) {
     state.tasks = [];
     return { ok: false, empty: false, error: state.planner.planParseError };
   }
-  const normalized = normalizePlan(plan, state.maxParallel);
+  const normalized = normalizePlan(plan, state.maxParallel, state.workerSandbox || 'workspace-write');
   if (!normalized || !Array.isArray(normalized.tasks)) {
     state.planner.planParseError = 'planner JSON did not contain { batches: [...] } or { tasks: [...] }';
     state.batches = [];
@@ -304,7 +296,7 @@ ORCHESTRATOR_BATCH_ID: ${task.batchId || 'batch-1'}
 
 ${task.prompt}
 `;
-  const child = spawnCodex({ state, taskId: task.id, prompt: fullPrompt, sandbox: task.sandbox || 'workspace-write', cwd: state.repo, outDir });
+  const child = await runner.startCodexTask({ runId: state.runId, taskId: task.id, batchId: task.batchId || 'batch-1', runStatePath: statePath(runDir), prompt: fullPrompt, sandbox: task.sandbox || state.workerSandbox || 'workspace-write', cwd: state.repo, outDir });
   Object.assign(task, { status: 'running', pid: child.pid, startedAt: nowIso(), dir: outDir });
 }
 
@@ -312,12 +304,7 @@ export async function stopRun(runId, { reason = 'stopped by user' } = {}) {
   const state = await loadRun(runId);
   if (!state) throw new Error(`run not found: ${runId}`);
   const stoppedAt = nowIso();
-  for (const [key, child] of runningChildren.entries()) {
-    if (key.startsWith(`${runId}:`)) {
-      try { child.kill('TERM'); } catch {}
-      runningChildren.delete(key);
-    }
-  }
+  await runner.stopRun(runId);
   for (const roleState of [state.planner, state.judge]) {
     if (roleState?.status === 'running') Object.assign(roleState, { status: 'stopped', stoppedAt, endedAt: stoppedAt });
   }
@@ -400,11 +387,11 @@ export async function startJudge(runId) {
   const judgeInput = await buildJudgeInput(state);
   await writeJsonAtomic(judgeInputPath, judgeInput);
   const prompt = defaultJudgePrompt(state, judgeInputPath);
-  const child = spawnCodex({ state, taskId: 'judge', prompt, sandbox: 'read-only', cwd: state.repo, outDir });
+  const child = await runner.startCodexTask({ runId: state.runId, taskId: 'judge', batchId: 'judge', runStatePath: statePath(pathForRun(runId)), prompt, sandbox: 'read-only', cwd: state.repo, outDir });
   state.judge = { status: 'running', pid: child.pid, startedAt: nowIso(), dir: outDir };
   state.status = 'judging';
   await saveRun(state);
-  child.on('exit', async code => {
+  child.onExit(async code => {
     const s = await loadRun(runId); if (!s || s.status === 'stopped') return;
     s.judge.exitCode = code; s.judge.endedAt = nowIso(); s.judge.status = code === 0 ? 'completed' : 'failed';
     const text = await readTextMaybe(path.join(outDir, 'last_message.md'), 1000000);
@@ -423,9 +410,13 @@ export async function refreshRun(runId, appClient = null) {
 async function loadAndRefreshRun(runId, appClient = null, { light = false } = {}) {
   const state = await loadRun(runId);
   if (!state) return null;
+  state.runner = state.runner || RUNNER;
   await refreshRole(state, state.planner, roleDir(pathForRun(runId), 'planner'));
+  await recoverCompletedPlanner(state);
   for (const task of state.tasks || []) await refreshTask(state, task);
   await refreshRole(state, state.judge, roleDir(pathForRun(runId), 'judge'));
+  await recoverCompletedJudge(state);
+  aggregateRunTmuxMetadata(state);
   recomputeRunStatus(state);
   await scheduleMoreWorkers(state);
   recomputeRunStatus(state);
@@ -434,19 +425,42 @@ async function loadAndRefreshRun(runId, appClient = null, { light = false } = {}
   return state;
 }
 
+async function recoverCompletedPlanner(state) {
+  if (state.planner?.status !== 'completed' || state.tasks?.length || state.batches?.length) return;
+  const planResult = await materializePlan(state);
+  if (planResult.ok) state.status = 'planned';
+  else if (planResult.empty) state.status = 'plan_empty';
+  else state.status = 'plan_failed';
+}
+
+async function recoverCompletedJudge(state) {
+  if (!['completed', 'failed'].includes(state.judge?.status)) return;
+  if (state.judge.status === 'completed' && !state.judge.verdict) {
+    const outDir = roleDir(pathForRun(state.runId), 'judge');
+    const text = await readTextMaybe(path.join(outDir, 'last_message.md'), 1000000);
+    const verdict = extractFirstJsonObject(text);
+    if (verdict) {
+      state.judge.verdict = verdict;
+      await writeJsonAtomic(path.join(outDir, 'verdict.json'), verdict);
+    }
+  }
+  state.status = state.judge.status === 'completed' ? 'judged' : 'judge_failed';
+}
+
 async function refreshRole(state, roleState, dir) {
   if (!roleState) return;
   const exitPath = path.join(dir, 'exit_code');
   const exit = await readTextMaybe(exitPath, 1000);
   const exitInfo = await fileInfo(exitPath);
-  const key = `${state.runId}:${roleState === state.judge ? 'judge' : 'planner'}`;
+  const key = roleState === state.judge ? 'judge' : 'planner';
   if (exit !== '') {
     roleState.exitCode = Number(exit.trim());
     if (!roleState.endedAt && exitInfo.exists) roleState.endedAt = exitInfo.mtime;
     if (roleState.status === 'running') roleState.status = roleState.exitCode === 0 ? 'completed' : 'failed';
   }
-  else if (roleState.status === 'running' && !runningChildren.has(key)) roleState.status = 'unknown';
+  else if (roleState.status === 'running' && !runner.hasRunning(state.runId, key)) roleState.status = 'unknown';
   roleState.files = await standardFiles(dir);
+  await attachTmuxMetadata(roleState, dir);
 }
 
 async function refreshTask(state, task) {
@@ -454,13 +468,14 @@ async function refreshTask(state, task) {
   const exitPath = path.join(dir, 'exit_code');
   const exit = await readTextMaybe(exitPath, 1000);
   const exitInfo = await fileInfo(exitPath);
-  const key = `${state.runId}:${task.id}`;
   if (exit !== '') {
     task.exitCode = Number(exit.trim());
     if (!task.endedAt && exitInfo.exists) task.endedAt = exitInfo.mtime;
     if (task.status === 'running') task.status = task.exitCode === 0 ? 'completed' : 'failed';
-  } else if (task.status === 'running' && !runningChildren.has(key)) task.status = 'unknown';
+  } else if (task.status === 'running' && !runner.hasRunning(state.runId, task.id)) task.status = 'unknown';
   task.files = await standardFiles(dir);
+  await attachTmuxMetadata(task, dir);
+  delete task.attentionHint;
   task.artifacts = [];
   for (const rel of task.expectedArtifacts || []) task.artifacts.push({ path: rel, ...(await fileInfo(path.isAbsolute(rel) ? rel : path.join(state.repo, rel))) });
   const batch = (state.batches || []).find(b => b.id === task.batchId);
@@ -470,13 +485,82 @@ async function refreshTask(state, task) {
   }
 }
 
+async function attachTmuxMetadata(target, dir) {
+  const raw = await readJson(path.join(dir, 'tmux.json'), null);
+  if (!raw || raw.runner !== 'tmux') {
+    delete target.tmux;
+    return;
+  }
+  if (raw.ready !== true) {
+    target.tmux = {
+      runner: 'tmux',
+      ready: false,
+      status: raw.status || 'pending',
+      sessionName: raw.sessionName || '',
+      windowName: raw.windowName || '',
+      target: raw.target || '',
+      runScript: raw.runScript || '',
+      startedAt: raw.startedAt || '',
+      error: raw.error || ''
+    };
+    return;
+  }
+  const selectWindowCommand = raw.selectWindowCommand || raw.selectCommand || '';
+  target.tmux = {
+    runner: 'tmux',
+    ready: true,
+    status: raw.status || 'ready',
+    sessionName: raw.sessionName || '',
+    windowName: raw.windowName || '',
+    target: raw.target || '',
+    attachCommand: raw.attachCommand || '',
+    selectWindowCommand,
+    runScript: raw.runScript || '',
+    startedAt: raw.startedAt || '',
+    readyAt: raw.readyAt || ''
+  };
+}
+
+function aggregateRunTmuxMetadata(state) {
+  const roles = [state.planner, ...(state.tasks || []), state.judge].filter(Boolean);
+  const entries = roles.map(role => role.tmux).filter(tmux => tmux?.runner === 'tmux');
+  const readyEntries = entries.filter(tmux => tmux.ready === true);
+  if (!entries.length) {
+    if ((state.runner || RUNNER) === 'tmux') {
+      state.tmux = {
+        runner: 'tmux',
+        hasTmuxSession: false
+      };
+    } else {
+      delete state.tmux;
+    }
+    return;
+  }
+  const withSession = readyEntries.find(tmux => tmux.sessionName || tmux.target || tmux.windowName);
+  if (!withSession) {
+    state.tmux = {
+      runner: 'tmux',
+      hasTmuxSession: false
+    };
+    return;
+  }
+  state.tmux = {
+    runner: 'tmux',
+    hasTmuxSession: true,
+    tmuxSessionName: withSession.sessionName || ''
+  };
+  if (withSession.attachCommand) state.tmux.tmuxAttachCommand = withSession.attachCommand;
+}
+
 async function standardFiles(dir) {
   return {
     prompt: await fileInfo(path.join(dir, 'prompt.md')),
     events: await fileInfo(path.join(dir, 'events.jsonl')),
     stderr: await fileInfo(path.join(dir, 'stderr.log')),
     lastMessage: await fileInfo(path.join(dir, 'last_message.md')),
-    exitCode: await fileInfo(path.join(dir, 'exit_code'))
+    exitCode: await fileInfo(path.join(dir, 'exit_code')),
+    runScript: await fileInfo(path.join(dir, 'run.sh')),
+    tmux: await fileInfo(path.join(dir, 'tmux.json'))
   };
 }
 
@@ -567,6 +651,7 @@ async function buildJudgeInput(state) {
       resultJson: await readJson(path.join(dir, 'result.json'), null),
       evidenceJson: await readJson(path.join(dir, 'evidence.json'), null),
       manualCompletion: task.manualCompletion || await readJson(path.join(dir, 'manual_completion.json'), null),
+      tmux: task.tmux || null,
       stderrTail: await readTextMaybe(path.join(dir, 'stderr.log'), 20000)
     });
   }
@@ -579,9 +664,11 @@ async function buildJudgeInput(state) {
       label: state.label,
       repo: state.repo,
       status: state.status,
+      runner: state.runner || RUNNER,
       createdAt: state.createdAt,
       updatedAt: state.updatedAt,
-      maxParallel: state.maxParallel
+      maxParallel: state.maxParallel,
+      workerSandbox: state.workerSandbox || 'workspace-write'
     },
     taskText,
     plan,
@@ -597,6 +684,7 @@ async function buildJudgeInput(state) {
       exitCode: state.planner?.exitCode ?? null,
       planParseError: state.planner?.planParseError,
       planEmpty: !!state.planner?.planEmpty,
+      tmux: state.planner?.tmux || null,
       lastMessage: await readTextMaybe(path.join(roleDir(runDir, 'planner'), 'last_message.md'), 200000)
     },
     tasks
@@ -629,96 +717,16 @@ async function enrichFromAppServer(state, appClient) {
 
 function summaryOfRun(s) {
   const tasks = s.tasks || [];
-  return { runId: s.runId, label: s.label, repo: s.repo, status: s.status, archived: !!s.archived, createdAt: s.createdAt, updatedAt: s.updatedAt, total: tasks.length, completed: tasks.filter(t => t.status === 'completed').length, failed: tasks.filter(t => ['failed','unknown'].includes(t.status)).length, running: tasks.filter(t => t.status === 'running').length, batches: (s.batches || []).map(b => ({ id: b.id, name: b.name, status: b.status, total: b.tasks?.length || 0, completed: (b.tasks || []).filter(t => t.status === 'completed').length })) };
-}
-
-function formatCodexEventsJsonl(text) {
-  if (!text.trim()) return '暂无事件日志。';
-  const lines = text.split(/\r?\n/).filter(Boolean);
-  return lines.map((line, index) => {
-    const seq = String(index + 1).padStart(3, '0');
-    let event;
-    try { event = JSON.parse(line); }
-    catch { return `[${seq}] 无法解析事件\n${line}`; }
-    return formatCodexEvent(seq, event);
-  }).join('\n\n');
-}
-
-function formatCodexEvent(seq, event) {
-  switch (event.type) {
-    case 'thread.started':
-      return `[${seq}] Codex 会话开始\n  会话ID: ${event.thread_id || '-'}`;
-    case 'turn.started':
-      return `[${seq}] 回合开始`;
-    case 'turn.completed':
-      return `[${seq}] 回合完成\n${formatKnownFields(event, ['status', 'error', 'usage'])}`.trimEnd();
-    case 'item.started':
-      return formatCodexItem(seq, '开始', event.item);
-    case 'item.completed':
-      return formatCodexItem(seq, '完成', event.item);
-    case 'error':
-      return `[${seq}] 错误\n${formatJson(event)}`;
-    default:
-      return `[${seq}] ${event.type || '未知事件'}\n${formatJson(event)}`;
-  }
+  return { runId: s.runId, label: s.label, repo: s.repo, status: s.status, runner: s.runner || RUNNER, workerSandbox: s.workerSandbox || 'workspace-write', archived: !!s.archived, createdAt: s.createdAt, updatedAt: s.updatedAt, total: tasks.length, completed: tasks.filter(t => t.status === 'completed').length, failed: tasks.filter(t => ['failed','unknown'].includes(t.status)).length, running: tasks.filter(t => t.status === 'running').length, batches: (s.batches || []).map(b => ({ id: b.id, name: b.name, status: b.status, total: b.tasks?.length || 0, completed: (b.tasks || []).filter(t => t.status === 'completed').length })) };
 }
 
-function formatCodexItem(seq, action, item = {}) {
-  const type = item.type || 'unknown';
-  const title = `[${seq}] ${action}: ${displayItemType(type)}`;
-  if (type === 'command_execution') {
-    const parts = [title];
-    if (item.command) parts.push(`  命令: ${item.command}`);
-    if (item.status) parts.push(`  状态: ${item.status}`);
-    if (item.exit_code !== undefined && item.exit_code !== null) parts.push(`  退出码: ${item.exit_code}`);
-    if (item.aggregated_output) parts.push(`  输出:\n${indentText(truncateText(item.aggregated_output))}`);
-    return parts.join('\n');
-  }
-  if (type === 'agent_message' || type === 'agentMessage') {
-    const text = item.text || item.message || item.content || '';
-    return text ? `${title}\n  内容:\n${indentText(truncateText(String(text)))}` : title;
-  }
-  if (type === 'reasoning') {
-    const summary = item.summary || item.content || '';
-    return summary ? `${title}\n  摘要:\n${indentText(truncateText(Array.isArray(summary) ? summary.join('\n') : String(summary)))}` : title;
-  }
-  if (type === 'file_change' || type === 'fileChange') {
-    return `${title}\n${formatKnownFields(item, ['status', 'path', 'changes'])}`.trimEnd();
-  }
-  return `${title}\n${formatJson(item)}`;
-}
-
-function displayItemType(type) {
-  return {
-    command_execution: '命令执行',
-    agent_message: '模型回复',
-    agentMessage: '模型回复',
-    reasoning: '推理',
-    file_change: '文件变更',
-    fileChange: '文件变更',
-    mcp_tool_call: 'MCP 工具调用',
-    mcpToolCall: 'MCP 工具调用'
-  }[type] || type;
-}
-
-function formatKnownFields(obj, fields) {
-  return fields
-    .filter(field => obj[field] !== undefined && obj[field] !== null)
-    .map(field => `  ${field}: ${typeof obj[field] === 'string' ? obj[field] : JSON.stringify(obj[field], null, 2)}`)
-    .join('\n');
-}
-
-function formatJson(value) { return indentText(JSON.stringify(value, null, 2)); }
-function indentText(text) { return String(text).split('\n').map(line => `  ${line}`).join('\n'); }
-function truncateText(text, max = 12000) { return text.length > max ? `${text.slice(0, max)}\n...<已截断 ${text.length - max} 字符>` : text; }
-
 export async function readRunTaskText(runId) {
   return await readTextMaybe(path.join(pathForRun(runId), 'task.md'), 1000000);
 }
 
 export async function readRunFile(runId, taskId, name) {
   const runDir = pathForRun(runId);
-  const allowed = new Set(['prompt.md','events.jsonl','events.pretty','stderr.log','last_message.md','exit_code','result.json','evidence.json','verdict.json','judge_input.json','manual_completion.json']);
+  const allowed = new Set(['prompt.md','events.jsonl','events.pretty','stderr.log','last_message.md','exit_code','result.json','evidence.json','verdict.json','judge_input.json','manual_completion.json','run.sh','tmux.json']);
   if (!allowed.has(name)) throw new Error('file not allowed');
   let dir;
   if (taskId === 'planner') dir = roleDir(runDir, 'planner');

package/src/runners/headlessRunner.js

@@ -0,0 +1,51 @@
+import { spawn } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { CODEX_BIN } from '../utils.js';
+
+function processKey(runId, taskId) {
+  return `${runId}:${taskId}`;
+}
+
+export function createHeadlessRunner({ codexBin = CODEX_BIN } = {}) {
+  const runningProcesses = new Map();
+
+  function startCodexTask({ runId, taskId, prompt, sandbox, cwd, outDir }) {
+    const events = path.join(outDir, 'events.jsonl');
+    const stderr = path.join(outDir, 'stderr.log');
+    const last = path.join(outDir, 'last_message.md');
+    fs.writeFileSync(path.join(outDir, 'prompt.md'), prompt);
+    const args = ['exec', '--json', '--sandbox', sandbox, '-C', cwd, '-o', last, prompt];
+    const child = spawn(codexBin, args, { cwd, stdio: ['ignore', 'pipe', 'pipe'] });
+    child.stdout.pipe(fs.createWriteStream(events, { flags: 'a' }));
+    child.stderr.pipe(fs.createWriteStream(stderr, { flags: 'a' }));
+    const key = processKey(runId, taskId);
+    runningProcesses.set(key, child);
+    child.on('exit', code => {
+      try { fs.writeFileSync(path.join(outDir, 'exit_code'), String(code)); } catch {}
+      runningProcesses.delete(key);
+    });
+    return {
+      pid: child.pid,
+      onExit(listener) { child.on('exit', listener); },
+      stop(signal = 'TERM') { child.kill(signal); }
+    };
+  }
+
+  function stopRun(runId, signal = 'TERM') {
+    for (const [key, child] of runningProcesses.entries()) {
+      if (key.startsWith(`${runId}:`)) {
+        try { child.kill(signal); } catch {}
+        runningProcesses.delete(key);
+      }
+    }
+  }
+
+  function hasRunning(runId, taskId) {
+    return runningProcesses.has(processKey(runId, taskId));
+  }
+
+  return { kind: 'headless', startCodexTask, stopRun, hasRunning };
+}
+
+export const headlessRunner = createHeadlessRunner();

package/src/runners/index.js

@@ -0,0 +1,13 @@
+import { headlessRunner } from './headlessRunner.js';
+import { createTmuxRunner } from './tmuxRunner.js';
+import { RUNNER } from '../utils.js';
+
+export { createHeadlessRunner, headlessRunner } from './headlessRunner.js';
+export { createTmuxRunner } from './tmuxRunner.js';
+
+export function createDefaultRunner(runnerMode = RUNNER) {
+  if (runnerMode === 'tmux') return createTmuxRunner();
+  return headlessRunner;
+}
+
+export const defaultRunner = createDefaultRunner();