input-kanban 0.0.6 → 0.0.8

package/src/orchestrator.js

@@ -15,6 +15,8 @@ import { defaultRunner } from './runners/index.js';
 const execFileAsync = promisify(execFile);
 const runner = defaultRunner;
 const VALID_SANDBOXES = new Set(['read-only', 'workspace-write', 'danger-full-access']);
+const MISSING_RUNNER_GRACE_MS = 10000;
+const MAX_DERIVED_LABEL_DISPLAY_WIDTH = 40;
 
 function normalizeSandbox(value, fallback = 'workspace-write') {
   const sandbox = String(value || '').trim();
@@ -25,12 +27,81 @@ function normalizeSandbox(value, fallback = 'workspace-write') {
 function statePath(runDir) { return path.join(runDir, 'run_state.json'); }
 function planPath(runDir) { return path.join(runDir, 'plan.json'); }
 
+function shouldMarkRunnerUnknown(target) {
+  const missingSince = Date.parse(target.missingRunnerAt || '');
+  if (!Number.isFinite(missingSince)) {
+    target.missingRunnerAt = nowIso();
+    return false;
+  }
+  return Date.now() - missingSince >= MISSING_RUNNER_GRACE_MS;
+}
+
+function clearMissingRunner(target) {
+  delete target.missingRunnerAt;
+}
+
+function isPidAlive(pid) {
+  const value = Number(pid);
+  if (!Number.isFinite(value) || value <= 0) return false;
+  try {
+    process.kill(value, 0);
+    return true;
+  } catch (error) {
+    return error?.code === 'EPERM';
+  }
+}
+
+function hasLiveRunnerProcess(state, id, target) {
+  return runner.hasRunning(state.runId, id) || isPidAlive(target?.pid);
+}
+
+function stopPid(pid, signal = 'SIGTERM') {
+  const value = Number(pid);
+  if (!Number.isFinite(value) || value <= 0) return false;
+  try {
+    process.kill(value, signal);
+    if (signal !== 'SIGKILL') setTimeout(() => { if (isPidAlive(value)) stopPid(value, 'SIGKILL'); }, 1000).unref?.();
+    return true;
+  } catch (error) {
+    return error?.code === 'ESRCH';
+  }
+}
+
 function userInputError(message) {
   const error = new Error(message);
   error.statusCode = 400;
   return error;
 }
 
+function charDisplayWidth(char) {
+  return char.codePointAt(0) > 0x2e80 ? 2 : 1;
+}
+
+function truncateDisplayWidth(text, maxWidth) {
+  let width = 0;
+  let result = '';
+  for (const char of text) {
+    const nextWidth = width + charDisplayWidth(char);
+    if (nextWidth > maxWidth) return `${result.trimEnd()}…`;
+    result += char;
+    width = nextWidth;
+  }
+  return result;
+}
+
+function deriveRunLabel(label, taskText) {
+  const explicit = String(label || '').trim();
+  if (explicit) return explicit;
+  const firstLine = String(taskText || '').split(/\r?\n/).map(line => line.trim()).find(Boolean) || 'task';
+  const cleaned = firstLine
+    .replace(/^#{1,6}\s+/, '')
+    .replace(/^[-*+]\s+/, '')
+    .replace(/^\d+[.)、]\s*/, '')
+    .replace(/\s+/g, ' ')
+    .trim();
+  return truncateDisplayWidth(cleaned, MAX_DERIVED_LABEL_DISPLAY_WIDTH) || 'task';
+}
+
 async function assertGitWorkTree(repo) {
   const resolvedRepo = path.resolve(repo || DEFAULT_REPO);
   let stat;
@@ -44,14 +115,15 @@ async function assertGitWorkTree(repo) {
   throw userInputError(`target repository is not a git work tree: ${resolvedRepo}`);
 }
 
-export async function createRun({ label = 'task', taskText = '', repo = DEFAULT_REPO, maxParallel = 3, workerSandbox = 'workspace-write' } = {}) {
+export async function createRun({ label = '', taskText = '', repo = DEFAULT_REPO, maxParallel = 3, workerSandbox = 'workspace-write' } = {}) {
   const resolvedRepo = await assertGitWorkTree(repo);
-  const runId = makeRunId(label);
+  const runLabel = deriveRunLabel(label, taskText);
+  const runId = makeRunId(runLabel);
   const runDir = pathForRun(runId);
   await ensureDir(runDir);
   await fsp.writeFile(path.join(runDir, 'task.md'), taskText || '');
   const state = {
-    runId, label, repo: resolvedRepo, maxParallel: Number(maxParallel) || 3, workerSandbox: normalizeSandbox(workerSandbox),
+    runId, label: runLabel, repo: resolvedRepo, maxParallel: Number(maxParallel) || 3, workerSandbox: normalizeSandbox(workerSandbox),
     runner: RUNNER,
     status: 'created', createdAt: nowIso(), updatedAt: nowIso(),
     planner: { status: 'pending' }, batches: [], tasks: [], judge: { status: 'pending' }
@@ -200,7 +272,17 @@ export async function startPlanner(runId) {
   return state;
 }
 
-function normalizeTask(t, i, batch, defaultSandbox = 'workspace-write') {
+function normalizeExpectedArtifacts(value, runId, taskId) {
+  const artifacts = Array.isArray(value) ? value : [];
+  return artifacts.map(item => String(item || '').trim()).filter(Boolean).map(item => {
+    if (path.isAbsolute(item)) return item;
+    const normalized = item.replace(/^\.\//, '');
+    if (normalized.includes(runId)) return normalized;
+    return path.posix.join('.orchestrator', runId, taskId, normalized);
+  });
+}
+
+function normalizeTask(t, i, batch, defaultSandbox = 'workspace-write', runId = '') {
   const id = safeIdPart(t.id || `T-${String(i + 1).padStart(2, '0')}`);
   return {
     id,
@@ -208,7 +290,7 @@ function normalizeTask(t, i, batch, defaultSandbox = 'workspace-write') {
     name: t.name || t.id || `Task ${i + 1}`,
     prompt: t.prompt || t.instructions || '',
     sandbox: normalizeSandbox(t.sandbox, defaultSandbox),
-    expectedArtifacts: Array.isArray(t.expectedArtifacts) ? t.expectedArtifacts : [],
+    expectedArtifacts: normalizeExpectedArtifacts(t.expectedArtifacts, runId, id),
     status: 'pending'
   };
 }
@@ -240,7 +322,7 @@ async function rotatePlannerAttempt(state, runDir) {
   }];
 }
 
-function normalizePlan(plan, defaultMaxParallel, defaultSandbox = 'workspace-write') {
+function normalizePlan(plan, defaultMaxParallel, defaultSandbox = 'workspace-write', runId = '') {
   if (Array.isArray(plan.batches)) {
     const batches = plan.batches.map((b, bi) => {
       const batch = {
@@ -250,14 +332,14 @@ function normalizePlan(plan, defaultMaxParallel, defaultSandbox = 'workspace-wri
         status: 'pending',
         tasks: []
       };
-      batch.tasks = (Array.isArray(b.tasks) ? b.tasks : []).map((t, ti) => normalizeTask(t, ti, batch, defaultSandbox));
+      batch.tasks = (Array.isArray(b.tasks) ? b.tasks : []).map((t, ti) => normalizeTask(t, ti, batch, defaultSandbox, runId));
       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, defaultSandbox));
+    batch.tasks = plan.tasks.map((t, i) => normalizeTask(t, i, batch, defaultSandbox, runId));
     return { ...plan, batches: [batch], tasks: batch.tasks };
   }
   return null;
@@ -273,7 +355,7 @@ async function materializePlan(state) {
     state.tasks = [];
     return { ok: false, empty: false, error: state.planner.planParseError };
   }
-  const normalized = normalizePlan(plan, state.maxParallel, state.workerSandbox || 'workspace-write');
+  const normalized = normalizePlan(plan, state.maxParallel, state.workerSandbox || 'workspace-write', state.runId);
   if (!normalized || !Array.isArray(normalized.tasks)) {
     state.planner.planParseError = 'planner JSON did not contain { batches: [...] } or { tasks: [...] }';
     state.batches = [];
@@ -310,6 +392,28 @@ export async function dispatchRun(runId) {
   return state;
 }
 
+function artifactPathForState(state, rel) {
+  return path.isAbsolute(rel) ? rel : path.join(state.repo, rel);
+}
+
+function workerArtifactInstructions(state, task) {
+  const artifacts = task.expectedArtifacts || [];
+  if (!artifacts.length) return '';
+  const lines = artifacts.map(rel => `- ${artifactPathForState(state, rel)}`);
+  return `\n\nRequired output artifacts:\nWrite the following artifact path(s) exactly. Create parent directories if needed.\n${lines.join('\n')}`;
+}
+
+function upstreamArtifactInstructions(state, task) {
+  const currentBatchIndex = (state.batches || []).findIndex(batch => batch.id === task.batchId);
+  if (currentBatchIndex <= 0) return '';
+  const previousTaskIds = new Set((state.batches || []).slice(0, currentBatchIndex).flatMap(batch => (batch.tasks || []).map(item => item.id)));
+  const lines = (state.tasks || [])
+    .filter(item => previousTaskIds.has(item.id))
+    .flatMap(item => (item.expectedArtifacts || []).map(rel => `- ${item.id}: ${artifactPathForState(state, rel)}`));
+  if (!lines.length) return '';
+  return `\n\nAvailable upstream artifacts from completed earlier batches:\n${lines.join('\n')}\nUse only artifacts from this run id: ${state.runId}.`;
+}
+
 async function startWorkerInState(state, task) {
   const runDir = pathForRun(state.runId);
   const outDir = roleDir(runDir, 'worker', task.id);
@@ -317,7 +421,7 @@ async function startWorkerInState(state, task) {
   const fullPrompt = `${marker(state.runId, task.id, 'worker')}
 ORCHESTRATOR_BATCH_ID: ${task.batchId || 'batch-1'}
 
-${task.prompt}
+${task.prompt}${workerArtifactInstructions(state, task)}${upstreamArtifactInstructions(state, task)}
 `;
   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 });
@@ -328,11 +432,28 @@ export async function stopRun(runId, { reason = 'stopped by user' } = {}) {
   if (!state) throw new Error(`run not found: ${runId}`);
   const stoppedAt = nowIso();
   await runner.stopRun(runId);
+  const stoppedPids = new Set();
+  const stopTargetPid = target => {
+    const pid = Number(target?.pid);
+    if (Number.isFinite(pid) && pid > 0 && !stoppedPids.has(pid)) {
+      stoppedPids.add(pid);
+      stopPid(pid);
+    }
+  };
   for (const roleState of [state.planner, state.judge]) {
-    if (roleState?.status === 'running') Object.assign(roleState, { status: 'stopped', stoppedAt, endedAt: stoppedAt });
+    if (roleState?.status === 'running') {
+      stopTargetPid(roleState);
+      Object.assign(roleState, { status: 'stopped', stoppedAt, endedAt: stoppedAt });
+    }
   }
   for (const task of state.tasks || []) {
-    if (task.status === 'running') Object.assign(task, { status: 'stopped', stoppedAt, endedAt: stoppedAt });
+    if (task.status === 'running') {
+      stopTargetPid(task);
+      Object.assign(task, { status: 'stopped', stoppedAt, endedAt: stoppedAt });
+    }
+  }
+  for (const batch of state.batches || []) {
+    for (const task of batch.tasks || []) if (task.status === 'running') stopTargetPid(task);
   }
   for (const batch of state.batches || []) {
     if ((batch.tasks || []).some(t => t.status === 'stopped')) batch.status = 'stopped';
@@ -356,7 +477,18 @@ export async function archiveRun(runId, { reason = 'archived by user' } = {}) {
   return state;
 }
 
-export async function markTaskCompleted(runId, taskId, { reason = 'manual success confirmed by user' } = {}) {
+export async function renameRun(runId, { label = '' } = {}) {
+  const state = await loadRun(runId);
+  if (!state) throw new Error(`run not found: ${runId}`);
+  const nextLabel = String(label || '').trim();
+  if (!nextLabel) throw userInputError('run label cannot be empty');
+  state.label = nextLabel;
+  state.renamedAt = nowIso();
+  await saveRun(state);
+  return state;
+}
+
+export async function markTaskCompleted(runId, taskId, { reason = 'manual success confirmed by user', resultText = '' } = {}) {
   const state = await loadRun(runId);
   if (!state) throw new Error(`run not found: ${runId}`);
   const task = (state.tasks || []).find(t => t.id === taskId);
@@ -366,6 +498,8 @@ export async function markTaskCompleted(runId, taskId, { reason = 'manual succes
   const outDir = roleDir(runDir, 'worker', task.id);
   await ensureDir(outDir);
   if (task.status !== 'completed') {
+    const manualResult = String(resultText || '').trim();
+    if (manualResult) await fsp.writeFile(path.join(outDir, 'manual_result.md'), manualResult);
     const override = {
       type: 'manual_task_completed',
       runId,
@@ -375,6 +509,9 @@ export async function markTaskCompleted(runId, taskId, { reason = 'manual succes
       previousStatus: task.status,
       previousExitCode: task.exitCode ?? null,
       reason,
+      hasManualResult: !!manualResult,
+      manualResultFile: manualResult ? 'manual_result.md' : null,
+      manualResultPreview: manualResult ? manualResult.slice(0, 500) : '',
       markedAt: nowIso()
     };
     await writeJsonAtomic(path.join(outDir, 'manual_completion.json'), override);
@@ -479,9 +616,16 @@ async function refreshRole(state, roleState, dir) {
   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';
+    clearMissingRunner(roleState);
+    if (['running', 'unknown'].includes(roleState.status)) roleState.status = roleState.exitCode === 0 ? 'completed' : 'failed';
+  }
+  else if (['running', 'unknown'].includes(roleState.status) && hasLiveRunnerProcess(state, key, roleState)) {
+    roleState.status = 'running';
+    clearMissingRunner(roleState);
   }
-  else if (roleState.status === 'running' && !runner.hasRunning(state.runId, key)) roleState.status = 'unknown';
+  else if (roleState.status === 'running' && !hasLiveRunnerProcess(state, key, roleState)) {
+    if (shouldMarkRunnerUnknown(roleState)) roleState.status = 'unknown';
+  } else if (roleState.status === 'running') clearMissingRunner(roleState);
   roleState.files = await standardFiles(dir);
   await attachTmuxMetadata(roleState, dir);
 }
@@ -494,8 +638,14 @@ async function refreshTask(state, task) {
   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' && !runner.hasRunning(state.runId, task.id)) task.status = 'unknown';
+    clearMissingRunner(task);
+    if (['pending', 'running', 'unknown'].includes(task.status)) task.status = task.exitCode === 0 ? 'completed' : 'failed';
+  } else if (['running', 'unknown'].includes(task.status) && hasLiveRunnerProcess(state, task.id, task)) {
+    task.status = 'running';
+    clearMissingRunner(task);
+  } else if (task.status === 'running' && !hasLiveRunnerProcess(state, task.id, task)) {
+    if (shouldMarkRunnerUnknown(task)) task.status = 'unknown';
+  } else if (task.status === 'running') clearMissingRunner(task);
   task.files = await standardFiles(dir);
   await attachTmuxMetadata(task, dir);
   delete task.attentionHint;
@@ -579,11 +729,13 @@ async function standardFiles(dir) {
   return {
     prompt: await fileInfo(path.join(dir, 'prompt.md')),
     events: await fileInfo(path.join(dir, 'events.jsonl')),
+    timedEvents: await fileInfo(path.join(dir, 'events_timed.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')),
     runScript: await fileInfo(path.join(dir, 'run.sh')),
-    tmux: await fileInfo(path.join(dir, 'tmux.json'))
+    tmux: await fileInfo(path.join(dir, 'tmux.json')),
+    manualResult: await fileInfo(path.join(dir, 'manual_result.md'))
   };
 }
 
@@ -674,6 +826,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),
+      manualResult: await readTextMaybe(path.join(dir, 'manual_result.md'), 200000),
       tmux: task.tmux || null,
       stderrTail: await readTextMaybe(path.join(dir, 'stderr.log'), 20000)
     });
@@ -738,9 +891,22 @@ async function enrichFromAppServer(state, appClient) {
   }
 }
 
+function runDurationEndOfState(s) {
+  const terminalStatuses = new Set(['judged', 'judge_failed', 'batch_blocked', 'plan_failed', 'plan_empty', 'stopped']);
+  if (!terminalStatuses.has(s.status)) return null;
+  const times = [
+    s.stoppedAt,
+    s.stopInfo?.stoppedAt,
+    s.judge?.endedAt,
+    s.planner?.endedAt,
+    ...(s.tasks || []).flatMap(task => [task.endedAt, task.completedAt, task.stoppedAt])
+  ].map(value => Date.parse(value || '')).filter(Number.isFinite);
+  return times.length ? new Date(Math.max(...times)).toISOString() : s.updatedAt;
+}
+
 function summaryOfRun(s) {
   const tasks = s.tasks || [];
-  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 })) };
+  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, durationEnd: runDurationEndOfState(s), 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 })) };
 }
 
 export async function readRunTaskText(runId) {
@@ -749,7 +915,7 @@ export async function readRunTaskText(runId) {
 
 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','run.sh','tmux.json']);
+  const allowed = new Set(['prompt.md','events.jsonl','events_timed.jsonl','events.pretty','stderr.log','last_message.md','exit_code','result.json','evidence.json','verdict.json','judge_input.json','manual_completion.json','manual_result.md','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

@@ -7,17 +7,48 @@ function processKey(runId, taskId) {
   return `${runId}:${taskId}`;
 }
 
+function captureEventsWithTimestamps(stream, eventsFile, timedEventsFile) {
+  const events = fs.createWriteStream(eventsFile, { flags: 'a' });
+  const timedEvents = fs.createWriteStream(timedEventsFile, { flags: 'a' });
+  let buffer = '';
+  const writeLine = line => {
+    events.write(`${line}\n`);
+    const receivedAt = new Date().toISOString();
+    try {
+      timedEvents.write(`${JSON.stringify({ receivedAt, event: JSON.parse(line) })}\n`);
+    } catch {
+      timedEvents.write(`${JSON.stringify({ receivedAt, rawLine: line })}\n`);
+    }
+  };
+  stream.setEncoding('utf8');
+  stream.on('data', chunk => {
+    buffer += chunk;
+    let newlineIndex;
+    while ((newlineIndex = buffer.indexOf('\n')) >= 0) {
+      const line = buffer.slice(0, newlineIndex).replace(/\r$/, '');
+      buffer = buffer.slice(newlineIndex + 1);
+      if (line) writeLine(line);
+    }
+  });
+  stream.on('end', () => {
+    if (buffer) writeLine(buffer.replace(/\r$/, ''));
+    events.end();
+    timedEvents.end();
+  });
+}
+
 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 timedEvents = path.join(outDir, 'events_timed.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' }));
+    captureEventsWithTimestamps(child.stdout, events, timedEvents);
     child.stderr.pipe(fs.createWriteStream(stderr, { flags: 'a' }));
     const key = processKey(runId, taskId);
     runningProcesses.set(key, child);

package/src/runners/tmuxRunner.js

@@ -46,6 +46,7 @@ function shellQuote(value) {
 
 const BIN_DIR = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../bin');
 const FORMATTER_BIN = path.join(BIN_DIR, 'input-kanban-format-events.js');
+const TIMESTAMP_BIN = path.join(BIN_DIR, 'input-kanban-timestamp-events.js');
 const OVERVIEW_BIN = path.join(BIN_DIR, 'input-kanban-tmux-overview.js');
 
 function buildOverviewCommand(runStatePath) {
@@ -54,7 +55,7 @@ function buildOverviewCommand(runStatePath) {
   return `while true; do clear; node ${quotedOverviewBin} ${quotedStatePath}; sleep 2; done`;
 }
 
-function buildRunScript({ codexBin, formatterBin = FORMATTER_BIN, sandbox, cwd, outDir, runId, taskId, role }) {
+function buildRunScript({ codexBin, formatterBin = FORMATTER_BIN, timestampBin = TIMESTAMP_BIN, sandbox, cwd, outDir, runId, taskId, role }) {
   return `#!/usr/bin/env bash
 set -u
 
@@ -67,15 +68,17 @@ TASK_ID=${shellQuote(taskId)}
 ROLE=${shellQuote(role)}
 PROMPT_FILE="$OUT_DIR/prompt.md"
 EVENTS="$OUT_DIR/events.jsonl"
+TIMED_EVENTS="$OUT_DIR/events_timed.jsonl"
 STDERR_LOG="$OUT_DIR/stderr.log"
 FORMATTER_BIN=${shellQuote(formatterBin)}
+TIMESTAMP_BIN=${shellQuote(timestampBin)}
 LAST_MESSAGE="$OUT_DIR/last_message.md"
 EXIT_CODE="$OUT_DIR/exit_code"
 
 cd "$CWD"
 rm -f "$EXIT_CODE"
-touch "$EVENTS" "$STDERR_LOG"
-"$CODEX_BIN" exec --json --sandbox "$SANDBOX" -C "$CWD" -o "$LAST_MESSAGE" "$(<"$PROMPT_FILE")" > >(tee -a "$EVENTS" | node "$FORMATTER_BIN") 2> >(tee -a "$STDERR_LOG" >&2)
+touch "$EVENTS" "$TIMED_EVENTS" "$STDERR_LOG"
+"$CODEX_BIN" exec --json --sandbox "$SANDBOX" -C "$CWD" -o "$LAST_MESSAGE" "$(<"$PROMPT_FILE")" > >(node "$TIMESTAMP_BIN" "$EVENTS" "$TIMED_EVENTS" | node "$FORMATTER_BIN") 2> >(tee -a "$STDERR_LOG" >&2)
 code=$?
 printf '%s' "$code" > "$EXIT_CODE"
 printf '\\nInput Kanban tmux task completed.\\n'

package/src/server.js

@@ -4,7 +4,7 @@ import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { CodexAppServerClient } from './appServerClient.js';
 import { APP_ROOT, DEFAULT_REPO, RUNNER, RUNS_DIR } from './utils.js';
-import { createRun, listRuns, startPlanner, dispatchRun, startJudge, refreshRun, readRunFile, readRunTaskText, markTaskCompleted, stopRun, archiveRun } from './orchestrator.js';
+import { createRun, listRuns, startPlanner, dispatchRun, startJudge, refreshRun, readRunFile, readRunTaskText, markTaskCompleted, stopRun, archiveRun, renameRun } from './orchestrator.js';
 
 const PUBLIC_DIR = path.join(APP_ROOT, 'public');
 
@@ -66,6 +66,10 @@ async function handleApi(req, res, url, appClient) {
         const body = await readBody(req);
         return send(res, 200, await archiveRun(runId, body));
       }
+      if (parts.length === 4 && parts[3] === 'label' && req.method === 'PATCH') {
+        const body = await readBody(req);
+        return send(res, 200, await renameRun(runId, body));
+      }
       if (parts.length === 4 && parts[3] === 'task-text' && req.method === 'GET') return send(res, 200, await readRunTaskText(runId), 'text/plain');
       if (parts.length === 6 && parts[3] === 'tasks' && parts[5] === 'file' && req.method === 'GET') {
         const text = await readRunFile(runId, parts[4], url.searchParams.get('name') || 'last_message.md');