input-kanban 0.0.7 → 0.0.8

package/PROJECT_GUIDE.md

@@ -51,9 +51,9 @@ The npm CLI entry is:
 bin/input-kanban.js
 ```
 
-It parses CLI options, sets environment variables before importing backend modules, and starts the HTTP server.
+It parses CLI options and sets environment variables before importing backend modules. Without a subcommand, or with `serve`, it starts the HTTP server. With `submit`, it creates a run directly in the shared runs directory and can optionally run an auto loop.
 
-Supported options:
+Supported serve options:
 
 ```text
 --host <host>
@@ -61,10 +61,62 @@ Supported options:
 --repo <path>
 --runs-dir <path>
 --codex-bin <path>
+--runner <headless|tmux>
 --open
 --no-open
 ```
 
+Supported status options:
+
+```text
+[runId]
+--runs-dir <path>
+--watch
+--poll-ms <ms>
+```
+
+`input-kanban status` refreshes and prints a run summary. If no `runId` is provided, it uses the latest run from the shared runs directory. `--watch` keeps polling until the run reaches a terminal state.
+
+Supported result options:
+
+```text
+[runId]
+--runs-dir <path>
+--copy
+```
+
+`input-kanban result [runId]` prints the final judge result. It prefers `judge/verdict.json` and falls back to `judge/last_message.md`. If no `runId` is provided, it uses the latest run. `--copy` sends the result to the system clipboard.
+
+Supported stop options:
+
+```text
+<runId>
+--runs-dir <path>
+--reason <text>
+```
+
+`input-kanban stop <runId>` calls the same orchestrator stop path as the Web dashboard. Stop requires an explicit run id. The backend first asks the active runner to stop known processes and then falls back to killing live stored PIDs, so Web and CLI processes can stop each other's headless workers.
+
+Supported submit options:
+
+```text
+--repo <path>
+--label <label>
+--task <text>
+--task-file <path|->
+--max-parallel <n>
+--worker-sandbox <read-only|workspace-write|danger-full-access>
+--runner <headless|tmux>
+--runs-dir <path>
+--auto
+--no-auto
+--detach / -d
+--watch
+--poll-ms <ms>
+```
+
+`input-kanban submit` creates a run and starts the planner. Task content can come from `--task <text>` or `--task-file <path|->`; omitting `--repo` uses the current working directory as the target Git work tree. Omitting `--label` derives the run label from the first non-empty task line. Auto mode is the default for submit: it keeps polling the run, dispatches batches when the plan is ready, and starts the final judge once all batches complete. `--no-auto` keeps submit to create + plan only. `-d` / `--detach` starts a background supervisor process for the auto loop and lets the submitting terminal return immediately. The submit output includes `input-kanban status <runId> --watch` for terminal-side observation. Because it writes to the same runs directory as the Web server, CLI-created runs are visible in the 8787 dashboard when both processes use the same `--runs-dir`.
+
 Default behavior:
 
 - default repo: current working directory when `input-kanban` is launched; run creation validates that the selected repo is inside a Git work tree;

package/README.en.md

@@ -43,6 +43,46 @@ If you do not want to `cd` into the target repository first, pass it explicitly:
 input-kanban --repo /path/to/your/repo
 ```
 
+## CLI Auto Execution
+
+To submit a task from the terminal and let it advance automatically, use `submit`. Task content supports two input modes:
+
+```bash
+input-kanban submit --task-file task.md --label "Fix login issue"
+input-kanban submit --task "Fix the login issue and add regression tests" --label "Fix login issue"
+```
+
+`submit` creates a run, starts planning, dispatches all batches, and starts the final judge after all workers finish by default. The default repo is the current directory. If `--label` is omitted, the run label is generated from the task text. It uses the same runs directory, so CLI-created runs are visible in the Web dashboard on port 8787 as long as the dashboard uses the same `--runs-dir`.
+
+To return immediately and let a background supervisor continue the auto loop, pass `-d` / `--detach`:
+
+```bash
+input-kanban submit --task-file task.md -d
+```
+
+To create the run and start planning without dispatching or judging, pass `--no-auto`.
+
+Common examples:
+
+```bash
+input-kanban submit --task "Fix login issue"
+input-kanban submit --task-file task.md --max-parallel 2 --worker-sandbox workspace-write
+input-kanban submit --runs-dir ~/.input-kanban/runs --runner tmux -d
+```
+
+Check and stop:
+
+```bash
+input-kanban status
+input-kanban status --watch
+input-kanban status <runId> --watch
+input-kanban result
+input-kanban result <runId> --copy
+input-kanban stop <runId>
+```
+
+Without a `runId`, `status` and `result` use the latest run by default. `result --copy` copies the final judge result. Stopping requires an explicit `runId` to avoid stopping the wrong run.
+
 ## Common Startup Options
 
 ```bash
@@ -76,7 +116,7 @@ After run-level tmux metadata is available, the dashboard shows `Copy tmux attac
 1. Click `New Run`.
 2. Enter a label, target repository, worker sandbox, and task description.
 3. Click `Create Run`.
-4. Click `Plan` to let the Codex planner generate batches and workers.
+4. The dashboard automatically starts `Plan` so the Codex planner can generate batches and workers.
 5. Click `Dispatch` to run workers by batch barrier and concurrency limits.
 6. Inspect execution logs, final messages, error logs, and artifacts.
 7. After all batches complete, click `Final Judge`.

package/README.md

@@ -43,6 +43,46 @@ http://127.0.0.1:8787
 input-kanban --repo /path/to/your/repo
 ```
 
+## CLI 自动执行
+
+如果希望从终端直接提交任务并自动推进，可以使用 `submit`。任务内容支持两种输入方式：
+
+```bash
+input-kanban submit --task-file task.md --label "修复登录问题"
+input-kanban submit --task "修复登录问题，并补充回归测试" --label "修复登录问题"
+```
+
+`submit` 默认会创建任务批次、发起拆分、自动派发所有批次，并在全部完成后自动发起最终验收。默认 repo 是当前目录；如果不传 `--label`，任务批次名称会从任务内容自动生成。它使用同一个 runs 目录，所以只要 8787 Web 看板也使用相同的 `--runs-dir`，CLI 创建的任务会在 Web 界面里可见。
+
+如果希望提交后立即返回，让任务在后台自动执行，可以加 `-d` / `--detach`：
+
+```bash
+input-kanban submit --task-file task.md -d
+```
+
+如果只想创建并拆分，不自动派发和验收，可以加 `--no-auto`。
+
+常用参数：
+
+```bash
+input-kanban submit --task "修复登录问题"
+input-kanban submit --task-file task.md --max-parallel 2 --worker-sandbox workspace-write
+input-kanban submit --runs-dir ~/.input-kanban/runs --runner tmux -d
+```
+
+查看和停止：
+
+```bash
+input-kanban status
+input-kanban status --watch
+input-kanban status <runId> --watch
+input-kanban result
+input-kanban result <runId> --copy
+input-kanban stop <runId>
+```
+
+不传 `runId` 时，`status` 和 `result` 默认查看最近一次任务批次。`result --copy` 会复制最终验收结果；停止任务请显式传入 `runId`，避免误停。
+
 ## 常用启动参数
 
 ```bash
@@ -76,7 +116,7 @@ tmux 模式是可选能力，主要用于在终端里实时查看每个 Codex
 1. 点击 `新建任务批次`。
 2. 输入批次名称、目标仓库、Worker 沙箱和任务说明。
 3. 点击 `创建批次`。
-4. 点击 `拆分任务`，让 Codex planner 生成 batches 和 workers。
+4. 看板会自动发起 `拆分任务`，让 Codex planner 生成 batches 和 workers。
 5. 点击 `派发执行`，按 batch barrier 和并发限制运行 workers。
 6. 查看执行日志、最终回复、错误日志和产物。
 7. 所有 batch 完成后，点击 `汇总验收`。

package/RELEASE_NOTES.md

@@ -1,5 +1,22 @@
 # Release Notes
 
+## v0.0.8
+
+### Highlights
+
+- Add CLI `submit` workflow with two task input modes: `--task-file <markdown>` for Markdown files and `--task <text>` for inline task text.
+- Add CLI auto loop as the default `submit` behavior to create a run, start planning, dispatch batches, and run the final judge while keeping the run visible in the shared Web dashboard.
+- Add CLI `-d` / `--detach` to run the auto loop in a background supervisor, plus `--no-auto` for create-and-plan-only mode.
+- Add CLI `status [runId] [--watch]`, defaulting to the latest run when `runId` is omitted.
+- Add CLI `result [runId] [--copy]` to print or copy the final judge result.
+- Add CLI `stop <runId>` and make backend stop robust across CLI/Web processes by falling back to stored live PIDs.
+- Derive the run label from task text when `--label` / form label is omitted.
+- Add dashboard run-card archive confirmation without modal popups and replace the detail refresh text chips with a one-shot circle animation.
+
+### Verification
+
+- `npm run check` passed with 51 tests.
+
 ## v0.0.7
 
 ### Highlights

package/bin/input-kanban.js

@@ -1,15 +1,38 @@
 #!/usr/bin/env node
+import fsp from 'node:fs/promises';
 import path from 'node:path';
 import { spawn } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
 
 const VALID_RUNNERS = ['headless', 'tmux'];
+const VALID_SANDBOXES = ['read-only', 'workspace-write', 'danger-full-access'];
+const COMMANDS = new Set(['serve', 'submit', 'status', 'result', 'stop', 'auto']);
+const delay = ms => new Promise(resolve => setTimeout(resolve, ms));
+const STATUS_TEXT = {
+  created: '已创建', planning: '拆分中', plan_failed: '拆分失败', plan_empty: '拆分为空', planned: '已拆分',
+  running: '执行中', batch_blocked: '批次阻塞', batches_completed: '批次完成', judging: '验收中', judged: '已验收',
+  judge_failed: '验收失败', stopped: '已停止'
+};
+
+function validateChoice(value, source, choices) {
+  if (choices.includes(value)) return value;
+  throw new Error(`invalid ${source}: ${value}; expected one of: ${choices.join(', ')}`);
+}
 
 function validateRunner(value, source) {
-  if (VALID_RUNNERS.includes(value)) return value;
-  throw new Error(`invalid ${source}: ${value}; expected one of: ${VALID_RUNNERS.join(', ')}`);
+  return validateChoice(value, source, VALID_RUNNERS);
+}
+
+function validateSandbox(value, source) {
+  return validateChoice(value, source, VALID_SANDBOXES);
+}
+
+function splitCommand(argv) {
+  if (argv[0] && COMMANDS.has(argv[0])) return { command: argv[0], rest: argv.slice(1) };
+  return { command: 'serve', rest: argv };
 }
 
-function parseArgs(argv) {
+function parseServeArgs(argv) {
   const args = { host: '127.0.0.1', port: undefined, repo: undefined, runsDir: undefined, codexBin: undefined, runner: undefined, open: false, help: false };
   for (let i = 0; i < argv.length; i++) {
     const arg = argv[i];
@@ -28,22 +51,240 @@ function parseArgs(argv) {
   return args;
 }
 
+function parseStatusArgs(argv) {
+  const args = { host: '127.0.0.1', port: 8787, runsDir: undefined, runId: undefined, watch: false, pollMs: 3000, help: false };
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    const next = () => argv[++i];
+    if (arg === '--help' || arg === '-h') args.help = true;
+    else if (arg === '--host') args.host = next();
+    else if (arg === '--port' || arg === '-p') args.port = Number(next());
+    else if (arg === '--runs-dir') args.runsDir = next();
+    else if (arg === '--watch') args.watch = true;
+    else if (arg === '--poll-ms') args.pollMs = Number(next());
+    else if (!arg.startsWith('-') && !args.runId) args.runId = arg;
+    else throw new Error(`unknown status argument: ${arg}`);
+  }
+  return args;
+}
+
+function parseResultArgs(argv) {
+  const args = { runsDir: undefined, runId: undefined, copy: false, help: false };
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    const next = () => argv[++i];
+    if (arg === '--help' || arg === '-h') args.help = true;
+    else if (arg === '--runs-dir') args.runsDir = next();
+    else if (arg === '--copy') args.copy = true;
+    else if (!arg.startsWith('-') && !args.runId) args.runId = arg;
+    else throw new Error(`unknown result argument: ${arg}`);
+  }
+  return args;
+}
+
+function parseStopArgs(argv) {
+  const args = { runsDir: undefined, runId: undefined, reason: 'stopped from CLI', help: false };
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    const next = () => argv[++i];
+    if (arg === '--help' || arg === '-h') args.help = true;
+    else if (arg === '--runs-dir') args.runsDir = next();
+    else if (arg === '--reason') args.reason = next();
+    else if (!arg.startsWith('-') && !args.runId) args.runId = arg;
+    else throw new Error(`unknown stop argument: ${arg}`);
+  }
+  return args;
+}
+
+function parseAutoArgs(argv) {
+  const args = { host: '127.0.0.1', port: 8787, runsDir: undefined, codexBin: undefined, runner: undefined, runId: undefined, pollMs: 3000, help: false };
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    const next = () => argv[++i];
+    if (arg === '--help' || arg === '-h') args.help = true;
+    else if (arg === '--host') args.host = next();
+    else if (arg === '--port' || arg === '-p') args.port = Number(next());
+    else if (arg === '--runs-dir') args.runsDir = next();
+    else if (arg === '--codex-bin') args.codexBin = next();
+    else if (arg === '--runner') args.runner = validateRunner(next(), '--runner');
+    else if (arg === '--poll-ms') args.pollMs = Number(next());
+    else if (!arg.startsWith('-') && !args.runId) args.runId = arg;
+    else throw new Error(`unknown auto argument: ${arg}`);
+  }
+  return args;
+}
+
+function parseSubmitArgs(argv) {
+  const args = {
+    host: '127.0.0.1', port: 8787, repo: undefined, runsDir: undefined, codexBin: undefined,
+    runner: undefined, label: undefined, taskText: undefined, taskFile: undefined, maxParallel: 3,
+    workerSandbox: 'workspace-write', auto: true, detach: false, watch: true, pollMs: 3000, help: false
+  };
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    const next = () => argv[++i];
+    if (arg === '--help' || arg === '-h') args.help = true;
+    else if (arg === '--host') args.host = next();
+    else if (arg === '--port' || arg === '-p') args.port = Number(next());
+    else if (arg === '--repo' || arg === '-r') args.repo = next();
+    else if (arg === '--runs-dir') args.runsDir = next();
+    else if (arg === '--codex-bin') args.codexBin = next();
+    else if (arg === '--runner') args.runner = validateRunner(next(), '--runner');
+    else if (arg === '--label' || arg === '-l') args.label = next();
+    else if (arg === '--task') args.taskText = next();
+    else if (arg === '--task-file') args.taskFile = next();
+    else if (arg === '--max-parallel') args.maxParallel = Number(next());
+    else if (arg === '--worker-sandbox') args.workerSandbox = validateSandbox(next(), '--worker-sandbox');
+    else if (arg === '--auto') { args.auto = true; args.watch = true; }
+    else if (arg === '--no-auto') { args.auto = false; args.watch = false; }
+    else if (arg === '--detach' || arg === '-d') args.detach = true;
+    else if (arg === '--watch') args.watch = true;
+    else if (arg === '--poll-ms') args.pollMs = Number(next());
+    else throw new Error(`unknown submit argument: ${arg}`);
+  }
+  return args;
+}
+
+function applyRuntimeEnv(args) {
+  if (args.port) process.env.PORT = String(args.port);
+  if (args.host) process.env.HOST = args.host;
+  if (args.repo) process.env.KANBAN_DEFAULT_REPO = path.resolve(args.repo);
+  else if (!process.env.KANBAN_DEFAULT_REPO) process.env.KANBAN_DEFAULT_REPO = process.cwd();
+  if (args.runsDir) process.env.KANBAN_RUNS_DIR = path.resolve(args.runsDir);
+  if (args.codexBin) process.env.KANBAN_CODEX_BIN = args.codexBin;
+  if (args.runner) process.env.KANBAN_RUNNER = args.runner;
+}
+
 function printHelp() {
   console.log(`input-kanban
 
 Usage:
   input-kanban [options]
+  input-kanban serve [options]
+  input-kanban submit [options]
+  input-kanban status [runId] [options]
+  input-kanban result [runId] [options]
+  input-kanban stop <runId> [options]
+
+Serve options:
+  --host <host>              Host to bind, default 127.0.0.1
+  -p, --port <port>          Port to bind, default 8787
+  -r, --repo <path>          Default target repository, default current directory
+  --runs-dir <path>          Runtime runs directory, default ~/.input-kanban/runs
+  --codex-bin <path>         Codex CLI executable, default codex
+  --runner <mode>            Runner mode: headless or tmux, default headless
+  --open                     Open browser after starting
+  --no-open                  Do not open browser, default
+
+Status options:
+  --runs-dir <path>          Runtime runs directory shared with the Web UI
+  --watch                    Keep printing status until the run reaches a terminal state
+  --poll-ms <ms>             Watch poll interval, default 3000
+
+Result options:
+  --runs-dir <path>          Runtime runs directory shared with the Web UI
+  --copy                     Copy final result to clipboard
+
+Stop options:
+  --runs-dir <path>          Runtime runs directory shared with the Web UI
+  --reason <text>            Stop reason stored in run state
+
+Submit options:
+  -r, --repo <path>          Target Git work tree, default current directory
+  -l, --label <label>        Task batch name, default generated from task text
+  --task <text>              Task description text
+  --task-file <path>         Read task description from file, use - for stdin
+  --max-parallel <n>         Default max parallel workers, default 3
+  --worker-sandbox <mode>    read-only, workspace-write, or danger-full-access
+  --runner <mode>            Runner mode: headless or tmux
+  --runs-dir <path>          Runtime runs directory shared with the Web UI
+  --auto                     Plan, dispatch all batches, judge, and watch, default for submit
+  --no-auto                  Only create the run and start planning
+  -d, --detach               Run the default auto loop in a background supervisor
+  --watch                    Watch status after starting the planner
+  --poll-ms <ms>             Watch poll interval, default 3000
+  -h, --help                 Show help
+`);
+}
+
+function printSubmitHelp() {
+  console.log(`input-kanban submit
+
+Usage:
+  input-kanban submit --repo <path> --task-file task.md
+  input-kanban submit --repo <path> --task "fix the bug" --label "bugfix"
+  input-kanban submit --task-file task.md -d
 
 Options:
-  --host <host>          Host to bind, default 127.0.0.1
-  -p, --port <port>      Port to bind, default 8787
-  -r, --repo <path>      Default target repository, default current directory
-  --runs-dir <path>      Runtime runs directory, default ~/.input-kanban/runs
-  --codex-bin <path>     Codex CLI executable, default codex
-  --runner <mode>        Runner mode: headless or tmux, default headless
-  --open                 Open browser after starting
-  --no-open              Do not open browser, default
-  -h, --help             Show help
+  -r, --repo <path>          Target Git work tree, default current directory
+  -l, --label <label>        Task batch name, default generated from task text
+  --task <text>              Task description text
+  --task-file <path>         Read task description from file, use - for stdin
+  --max-parallel <n>         Default max parallel workers, default 3
+  --worker-sandbox <mode>    read-only, workspace-write, or danger-full-access
+  --runner <mode>            Runner mode: headless or tmux
+  --runs-dir <path>          Runtime runs directory shared with the Web UI
+  --auto                     Plan, dispatch all batches, judge, and watch, default for submit
+  --no-auto                  Only create the run and start planning
+  -d, --detach               Run the default auto loop in a background supervisor
+  --watch                    Watch status after starting the planner
+  --poll-ms <ms>             Watch poll interval, default 3000
+`);
+}
+
+function printStatusHelp() {
+  console.log(`input-kanban status
+
+Usage:
+  input-kanban status
+  input-kanban status <runId>
+  input-kanban status --watch
+  input-kanban status <runId> --watch
+
+Options:
+  --runs-dir <path>          Runtime runs directory shared with the Web UI
+  --watch                    Keep printing status until the run reaches a terminal state
+  --poll-ms <ms>             Watch poll interval, default 3000
+`);
+}
+
+function printResultHelp() {
+  console.log(`input-kanban result
+
+Usage:
+  input-kanban result
+  input-kanban result <runId>
+  input-kanban result <runId> --copy
+
+Options:
+  --runs-dir <path>          Runtime runs directory shared with the Web UI
+  --copy                     Copy final result to clipboard
+`);
+}
+
+function printStopHelp() {
+  console.log(`input-kanban stop
+
+Usage:
+  input-kanban stop <runId>
+
+Options:
+  --runs-dir <path>          Runtime runs directory shared with the Web UI
+  --reason <text>            Stop reason stored in run state
+`);
+}
+
+function printAutoHelp() {
+  console.log(`input-kanban auto
+
+Usage:
+  input-kanban auto <runId>
+
+Options:
+  --runs-dir <path>          Runtime runs directory shared with the Web UI
+  --codex-bin <path>         Codex CLI executable, default codex
+  --runner <mode>            Runner mode: headless or tmux
+  --poll-ms <ms>             Watch poll interval, default 3000
 `);
 }
 
@@ -54,17 +295,124 @@ function openBrowser(url) {
   child.unref();
 }
 
-try {
-  const args = parseArgs(process.argv.slice(2));
-  if (args.help) { printHelp(); process.exit(0); }
-  if (args.port) process.env.PORT = String(args.port);
-  if (args.host) process.env.HOST = args.host;
-  if (args.repo) process.env.KANBAN_DEFAULT_REPO = path.resolve(args.repo);
-  else if (!process.env.KANBAN_DEFAULT_REPO) process.env.KANBAN_DEFAULT_REPO = process.cwd();
-  if (args.runsDir) process.env.KANBAN_RUNS_DIR = path.resolve(args.runsDir);
-  if (args.codexBin) process.env.KANBAN_CODEX_BIN = args.codexBin;
-  if (args.runner) process.env.KANBAN_RUNNER = args.runner;
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) chunks.push(Buffer.from(chunk));
+  return Buffer.concat(chunks).toString('utf8');
+}
+
+async function readTaskText(args) {
+  if (args.taskText !== undefined) return args.taskText;
+  if (args.taskFile === '-') return await readStdin();
+  if (args.taskFile) return await fsp.readFile(path.resolve(args.taskFile), 'utf8');
+  throw new Error('submit requires --task or --task-file');
+}
+
+function webUrl(args, runId = '') {
+  return `http://${args.host || '127.0.0.1'}:${Number(args.port || 8787)}${runId ? `  (runId: ${runId})` : ''}`;
+}
+
+function displayStatus(status) {
+  const text = STATUS_TEXT[status] || status || '-';
+  return status && text !== status ? `${text}(${status})` : text;
+}
+
+function countByStatus(state) {
+  const tasks = state.tasks || [];
+  return {
+    total: tasks.length,
+    completed: tasks.filter(task => task.status === 'completed').length,
+    running: tasks.filter(task => task.status === 'running').length,
+    failed: tasks.filter(task => ['failed', 'unknown'].includes(task.status)).length
+  };
+}
+
+function currentBatchText(state) {
+  const batch = (state.batches || []).find(item => item.status !== 'completed');
+  if (!batch) return '-';
+  const tasks = batch.tasks || [];
+  const completed = tasks.filter(task => task.status === 'completed').length;
+  return `${batch.name || batch.id}(${batch.id}) ${displayStatus(batch.status)} ${completed}/${tasks.length}`;
+}
+
+function statusLine(state) {
+  const counts = countByStatus(state);
+  return `${state.label || state.runId}｜${state.runId}｜状态 ${displayStatus(state.status)}｜进度 ${counts.completed}/${counts.total}｜执行中 ${counts.running}｜失败 ${counts.failed}`;
+}
+
+function printRunStatus(state) {
+  const counts = countByStatus(state);
+  console.log(`任务批次: ${state.label || '-'}`);
+  console.log(`Run ID: ${state.runId}`);
+  console.log(`状态: ${displayStatus(state.status)}`);
+  console.log(`仓库: ${state.repo || '-'}`);
+  console.log(`当前批次: ${currentBatchText(state)}`);
+  console.log(`进度: ${counts.completed}/${counts.total} ｜执行中 ${counts.running} ｜失败 ${counts.failed}`);
+  if (state.judge?.status && state.judge.status !== 'pending') console.log(`验收: ${displayStatus(state.judge.status)}`);
+}
+
+function isTerminal(state) {
+  return ['judged', 'judge_failed', 'batch_blocked', 'plan_failed', 'plan_empty', 'stopped'].includes(state.status);
+}
+
+function isFailureTerminal(state) {
+  return ['judge_failed', 'batch_blocked', 'plan_failed', 'plan_empty', 'stopped'].includes(state.status);
+}
+
+function hasRecoverableUnknownTask(state) {
+  return (state.tasks || []).some(task => task.status === 'unknown' && (task.exitCode === undefined || task.exitCode === 0));
+}
+
+async function confirmFailureTerminal(runId, state, refreshRun, pollMs) {
+  let confirmed = state;
+  const deadline = Date.now() + 30000;
+  while (confirmed?.status === 'batch_blocked' && hasRecoverableUnknownTask(confirmed) && Date.now() < deadline) {
+    await delay(Math.max(500, Number(pollMs) || 3000));
+    confirmed = await refreshRun(runId);
+    if (!confirmed || !isTerminal(confirmed) || confirmed.status !== state.status) return { confirmed: false, state: confirmed };
+  }
+  return { confirmed: true, state: confirmed };
+}
+
+async function watchRun(runId, { auto = false, pollMs = 3000 } = {}) {
+  const { dispatchRun, refreshRun, startJudge } = await import('../src/orchestrator.js');
+  let lastStatus = '';
+  let judgeStarted = false;
+  while (true) {
+    const state = await refreshRun(runId);
+    if (!state) throw new Error(`run not found: ${runId}`);
+    const line = statusLine(state);
+    if (line !== lastStatus) {
+      console.log(`[${new Date().toLocaleTimeString()}] ${line}`);
+      lastStatus = line;
+    }
+
+    if (auto && state.status === 'planned') {
+      console.log('自动派发任务...');
+      await dispatchRun(runId);
+    } else if (auto && state.status === 'batches_completed' && state.judge?.status !== 'running' && !judgeStarted) {
+      console.log('自动发起最终验收...');
+      judgeStarted = true;
+      await startJudge(runId);
+    }
+
+    if (isTerminal(state)) {
+      if (isFailureTerminal(state)) {
+        const result = await confirmFailureTerminal(runId, state, refreshRun, pollMs);
+        if (!result.confirmed) {
+          lastStatus = '';
+          continue;
+        }
+        return result.state || state;
+      }
+      return state;
+    }
+    await delay(Math.max(500, Number(pollMs) || 3000));
+  }
+}
 
+async function serve(args) {
+  applyRuntimeEnv(args);
   const { startServer } = await import('../src/server.js');
   const instance = await startServer({ host: process.env.HOST, port: Number(process.env.PORT || 8787), log: false });
   console.log('Input Kanban started');
@@ -76,6 +424,168 @@ try {
   const shutdown = () => { instance.stop().finally(() => process.exit(0)); };
   process.on('SIGINT', shutdown);
   process.on('SIGTERM', shutdown);
+}
+
+function detachedAutoArgs(runId, args) {
+  const cliPath = fileURLToPath(import.meta.url);
+  const values = [cliPath, 'auto', runId, '--host', args.host || '127.0.0.1', '--port', String(args.port || 8787), '--poll-ms', String(args.pollMs || 3000)];
+  if (args.runsDir) values.push('--runs-dir', path.resolve(args.runsDir));
+  if (args.codexBin) values.push('--codex-bin', args.codexBin);
+  if (args.runner) values.push('--runner', args.runner);
+  return values;
+}
+
+function startDetachedAuto(runId, args) {
+  const child = spawn(process.execPath, detachedAutoArgs(runId, args), {
+    detached: true,
+    stdio: 'ignore',
+    env: process.env
+  });
+  child.unref();
+  return child.pid;
+}
+
+async function latestRunId() {
+  const { listRuns } = await import('../src/orchestrator.js');
+  const runs = await listRuns();
+  if (!runs.length) throw new Error('没有找到任务批次');
+  return runs[0].runId;
+}
+
+async function status(args) {
+  applyRuntimeEnv(args);
+  const runId = args.runId || await latestRunId();
+  if (args.watch) {
+    await watchRun(runId, { auto: false, pollMs: args.pollMs });
+    return;
+  }
+  const { refreshRun } = await import('../src/orchestrator.js');
+  const state = await refreshRun(runId);
+  if (!state) throw new Error(`run not found: ${runId}`);
+  printRunStatus(state);
+}
+
+async function readFinalResult(runId) {
+  const { loadRun, readRunFile } = await import('../src/orchestrator.js');
+  const state = await loadRun(runId);
+  if (!state) throw new Error(`run not found: ${runId}`);
+  try { return await readRunFile(runId, 'judge', 'verdict.json'); }
+  catch {}
+  try { return await readRunFile(runId, 'judge', 'last_message.md'); }
+  catch {}
+  throw new Error(`最终结果尚未生成：当前状态 ${displayStatus(state.status)}`);
+}
+
+function clipboardCommands() {
+  if (process.platform === 'darwin') return [['pbcopy', []]];
+  if (process.platform === 'win32') return [['clip', []]];
+  return [['wl-copy', []], ['xclip', ['-selection', 'clipboard']], ['xsel', ['--clipboard', '--input']]];
+}
+
+async function copyToClipboard(text) {
+  let lastError = null;
+  for (const [command, args] of clipboardCommands()) {
+    try {
+      await new Promise((resolve, reject) => {
+        const child = spawn(command, args, { stdio: ['pipe', 'ignore', 'ignore'] });
+        child.on('error', reject);
+        child.on('exit', code => code === 0 ? resolve() : reject(new Error(`${command} exited with ${code}`)));
+        child.stdin.end(text);
+      });
+      return;
+    } catch (error) {
+      lastError = error;
+    }
+  }
+  throw new Error(`无法复制到剪贴板：${lastError?.message || '未找到可用剪贴板命令'}`);
+}
+
+async function result(args) {
+  applyRuntimeEnv(args);
+  const runId = args.runId || await latestRunId();
+  const text = await readFinalResult(runId);
+  if (args.copy) {
+    await copyToClipboard(text);
+    console.log(`已复制最终结果: ${runId}`);
+    return;
+  }
+  console.log(text);
+}
+
+async function stop(args) {
+  applyRuntimeEnv(args);
+  if (!args.runId) throw new Error('stop requires a runId');
+  const { stopRun } = await import('../src/orchestrator.js');
+  const state = await stopRun(args.runId, { reason: args.reason });
+  console.log(`已停止任务批次: ${state.runId}`);
+}
+
+async function autoRun(args) {
+  applyRuntimeEnv(args);
+  if (!args.runId) throw new Error('auto requires a runId');
+  const { loadRun, startPlanner } = await import('../src/orchestrator.js');
+  const state = await loadRun(args.runId);
+  if (!state) throw new Error(`run not found: ${args.runId}`);
+  if (state.status === 'created') await startPlanner(args.runId);
+  const finalState = await watchRun(args.runId, { auto: true, pollMs: args.pollMs });
+  if (isFailureTerminal(finalState)) process.exitCode = 1;
+}
+
+async function submit(args) {
+  if (args.detach && !args.auto) throw new Error('--detach requires auto mode; remove --no-auto');
+  applyRuntimeEnv(args);
+  const taskText = await readTaskText(args);
+  const { createRun, startPlanner } = await import('../src/orchestrator.js');
+  const state = await createRun({
+    label: args.label,
+    taskText,
+    repo: process.env.KANBAN_DEFAULT_REPO,
+    maxParallel: args.maxParallel,
+    workerSandbox: args.workerSandbox
+  });
+  console.log(`已创建任务批次: ${state.runId}`);
+  console.log(`看板地址: ${webUrl(args, state.runId)}`);
+  console.log(`终端查看: input-kanban status ${state.runId} --watch`);
+  if (args.detach) {
+    const pid = startDetachedAuto(state.runId, args);
+    console.log(`后台执行中: supervisor pid ${pid}`);
+    return;
+  }
+  console.log('发起任务拆分...');
+  await startPlanner(state.runId);
+  if (!args.watch && !args.auto) return;
+  const finalState = await watchRun(state.runId, { auto: args.auto, pollMs: args.pollMs });
+  console.log(`最终状态: ${finalState.status}`);
+  if (isFailureTerminal(finalState)) process.exitCode = 1;
+}
+
+try {
+  const { command, rest } = splitCommand(process.argv.slice(2));
+  if (command === 'serve') {
+    const args = parseServeArgs(rest);
+    if (args.help) { printHelp(); process.exit(0); }
+    await serve(args);
+  } else if (command === 'submit') {
+    const args = parseSubmitArgs(rest);
+    if (args.help) { printSubmitHelp(); process.exit(0); }
+    await submit(args);
+  } else if (command === 'status') {
+    const args = parseStatusArgs(rest);
+    if (args.help) { printStatusHelp(); process.exit(0); }
+    await status(args);
+  } else if (command === 'result') {
+    const args = parseResultArgs(rest);
+    if (args.help) { printResultHelp(); process.exit(0); }
+    await result(args);
+  } else if (command === 'stop') {
+    const args = parseStopArgs(rest);
+    if (args.help) { printStopHelp(); process.exit(0); }
+    await stop(args);
+  } else if (command === 'auto') {
+    const args = parseAutoArgs(rest);
+    if (args.help) { printAutoHelp(); process.exit(0); }
+    await autoRun(args);
+  }
 } catch (error) {
   console.error(error.message || String(error));
   process.exit(1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "input-kanban",
-  "version": "0.0.7",
+  "version": "0.0.8",
   "type": "module",
   "bin": {
     "input-kanban": "bin/input-kanban.js"
@@ -9,7 +9,6 @@
     "start": "node bin/input-kanban.js",
     "check": "node --check bin/input-kanban.js && node --check bin/input-kanban-format-events.js && node --check bin/input-kanban-timestamp-events.js && node --check bin/input-kanban-tmux-overview.js && node --check src/server.js && node --check src/orchestrator.js && node --check src/appServerClient.js && node --check src/utils.js && node --check src/eventFormatter.js && node --check src/runners/index.js && node --check src/runners/headlessRunner.js && node --check src/runners/tmuxRunner.js && node --check src/runners/tmuxUtils.js && node --check src/tmux.js && node --test"
   },
-  "dependencies": {},
   "description": "A local Codex orchestration kanban dashboard",
   "files": [
     "bin",

package/public/index.html

@@ -84,11 +84,17 @@
     .meta-value { min-width: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
     .meta-chip.long .meta-value { max-width: min(680px, 72vw); }
     .meta-chip .copy-btn { margin-left: 2px; }
+    .refresh-pulse-chip { width: 30px; height: 30px; display: inline-flex; align-items: center; justify-content: center; border: 1px solid var(--line); border-radius: 999px; background: #020617; }
+    .refresh-pulse-dot { width: 12px; height: 12px; border: 2px solid #60a5fa; border-top-color: transparent; border-radius: 999px; opacity: .62; }
+    .refresh-pulse-chip.pulse .refresh-pulse-dot { animation: refresh-spin .8s ease-out; }
+    @keyframes refresh-spin { 0% { transform: rotate(0deg) scale(.75); opacity: 1; } 70% { transform: rotate(300deg) scale(1.18); opacity: 1; } 100% { transform: rotate(360deg) scale(1); opacity: .62; } }
     .log-panel { margin-top: 16px; }
     .file-tabs button { font-size: 13px; }
     .copy-btn { padding: 2px 6px; margin: 0 0 0 6px; border-radius: 6px; font-size: 12px; line-height: 1.2; background: var(--gray); vertical-align: middle; }
     .rename-btn { opacity: 0; pointer-events: none; transition: opacity .15s ease; }
     .run-card:hover .rename-btn, .run-card:focus-within .rename-btn, .build-title:hover .rename-btn, .build-title:focus-within .rename-btn, .rename-btn:focus { opacity: 1; pointer-events: auto; }
+    .run-card-title-actions { display: inline-flex; align-items: center; gap: 3px; }
+    .archive-confirm-btn { min-width: 46px; padding: 4px 10px; border-color: rgba(248,113,113,.85); background: var(--red) !important; color: white; font-weight: 900; }
     .icon-svg { width: 14px; height: 14px; display: block; }
     .session-cell { word-break: break-all; }
     .row-actions { display: flex; align-items: center; justify-content: flex-end; gap: 6px; }
@@ -198,6 +204,7 @@ let selectedRun = null;
 let selectedTask = null;
 let selectedFileName = null;
 let manualCompleteTaskId = null;
+let pendingArchiveRunId = null;
 let currentState = null;
 let lastAutoRefreshAt = null;
 let runListVisibleCount = 10;
@@ -226,6 +233,7 @@ function userFacingErrorMessage(error) {
   if (/planner already running/i.test(detail)) return '任务拆分正在进行中，请稍后查看结果。';
   if (/judge already running/i.test(detail)) return '验收正在进行中，请稍后查看结果。';
   if (/already running/i.test(detail)) return '任务正在进行中，请稍后查看结果。';
+  if (/cannot archive.*running/i.test(detail)) return '任务仍在执行中，请先停止后再归档。';
   return error?.message || String(error);
 }
 const statusText = {
@@ -279,6 +287,9 @@ function metaChip(label, value, { title = value, danger = false, long = false, e
 function editIcon() {
   return '<svg class="icon-svg" viewBox="0 0 24 24" focusable="false" aria-hidden="true"><path d="M4 16.5V20h3.5L18.1 9.4l-3.5-3.5L4 16.5Z" fill="currentColor"/><path d="m16 4.5 3.5 3.5" stroke="currentColor" stroke-width="2" stroke-linecap="round"/></svg>';
 }
+function archiveIcon() {
+  return '<svg class="icon-svg" viewBox="0 0 24 24" focusable="false" aria-hidden="true"><path d="M4 5h16v4H4V5Z" fill="currentColor"/><path d="M6 10h12v9H6v-9Z" fill="currentColor" opacity=".72"/><path d="M9 13h6" stroke="#020617" stroke-width="2" stroke-linecap="round"/></svg>';
+}
 function isTmuxMode() { return currentState?.runner === 'tmux'; }
 function taskById(id) {
   if (!currentState) return null;
@@ -350,8 +361,8 @@ async function refreshRuns() {
 function renderRunList() {
   const visibleRuns = latestRuns.slice(0, runListVisibleCount);
   const cards = visibleRuns.map(r => `
-    <div class="run-card ${selectedRun === r.runId ? 'active' : ''}" onclick="selectRun('${r.runId}')">
-      <div class="run-card-title"><span class="run-card-name-wrap"><span class="run-card-name" title="${esc(r.label)}">${esc(r.label)}</span><button class="secondary copy-btn rename-btn" title="修改任务批次名称" onclick="renameRunLabel(event, '${r.runId}')">${editIcon()}</button></span><span>${pill(r.status)}</span></div>
+    <div class="run-card ${selectedRun === r.runId ? 'active' : ''}" onclick="selectRun('${r.runId}')" onmouseleave="clearArchiveConfirm('${r.runId}')">
+      <div class="run-card-title"><span class="run-card-name-wrap"><span class="run-card-name" title="${esc(r.label)}">${esc(r.label)}</span><span class="run-card-title-actions"><button class="secondary copy-btn rename-btn" title="修改任务批次名称" onclick="renameRunLabel(event, '${r.runId}')">${editIcon()}</button><button class="secondary copy-btn rename-btn ${pendingArchiveRunId === r.runId ? 'archive-confirm-btn' : ''}" title="${pendingArchiveRunId === r.runId ? '再次点击确认归档' : '归档任务批次（运行中请先停止）'}" onclick="archiveRunFromCard(event, '${r.runId}')">${pendingArchiveRunId === r.runId ? '确认' : archiveIcon()}</button></span></span><span>${pill(r.status)}</span></div>
       <div class="run-card-meta">
         ${metaChip('仓库', basenamePath(r.repo), { title: r.repo, long: true, extra: `<button class="secondary copy-btn" title="复制仓库地址" onclick="copyRunRepoPath(event, '${r.runId}')">⧉</button>` })}
         ${metaChip('创建', formatDateTime(r.createdAt))}
@@ -377,6 +388,7 @@ async function refreshSelected({auto=false} = {}) {
   statusByRunId.set(selectedRun, currentState);
   if (auto) lastAutoRefreshAt = new Date();
   document.getElementById('selected').innerHTML = renderSelectedHeader();
+  if (auto) requestAnimationFrame(triggerRefreshPulse);
   updateAutoRefreshHint();
   updateRunNotice();
   await loadTaskDescription();
@@ -407,14 +419,24 @@ function renderSelectedHeader() {
       chips.push(metaChip('终端', 'tmux 现场尚未生成'));
     }
   }
-  chips.push(metaChip('刷新', `每 ${AUTO_REFRESH_MS / 1000} 秒`));
-  chips.push(metaChip('上次', lastAutoRefreshAt ? lastAutoRefreshAt.toLocaleTimeString() : '尚未触发'));
+  chips.push(refreshPulseChip());
   return `<div class="build-title"><span>${esc(currentState.label)}</span><button class="secondary copy-btn rename-btn" title="修改任务批次名称" onclick="renameRunLabel(event, currentState.runId)">${editIcon()}</button>${pill(currentState.status)}</div><div class="build-meta">${chips.join('')}</div>`;
 }
 async function loadTaskDescription() {
   if (!selectedRun) { document.getElementById('taskDescription').textContent = '未选择任务批次'; return; }
   document.getElementById('taskDescription').textContent = await api(`/api/runs/${selectedRun}/task-text`);
 }
+function refreshPulseChip() {
+  const last = lastAutoRefreshAt ? lastAutoRefreshAt.toLocaleTimeString() : '尚未触发';
+  return `<span id="refreshPulse" class="refresh-pulse-chip" title="自动刷新：每 ${AUTO_REFRESH_MS / 1000} 秒；上次 ${esc(last)}"><span class="refresh-pulse-dot"></span></span>`;
+}
+function triggerRefreshPulse() {
+  const el = document.getElementById('refreshPulse');
+  if (!el) return;
+  el.classList.remove('pulse');
+  void el.offsetWidth;
+  el.classList.add('pulse');
+}
 function updateRunNotice() {
   const el = document.getElementById('runNotice');
   if (!el) return;
@@ -800,21 +822,46 @@ async function stopSelectedRun() {
   });
   await refreshSelected();
 }
+function clearArchiveConfirm(runId) {
+  if (pendingArchiveRunId !== runId) return;
+  pendingArchiveRunId = null;
+  renderRunList();
+}
+async function archiveRunFromCard(event, runId) {
+  event.stopPropagation();
+  if (pendingArchiveRunId !== runId) {
+    pendingArchiveRunId = runId;
+    renderRunList();
+    return;
+  }
+  pendingArchiveRunId = null;
+  await archiveRunById(runId, { confirmFirst: false });
+}
+async function archiveRunById(runId, { confirmFirst = true } = {}) {
+  if (!runId) return;
+  if (confirmFirst) {
+    const ok = confirm('确认归档当前任务批次？\n\n归档后会从默认任务批次列表隐藏。若仍有任务运行，请先停止。');
+    if (!ok) return;
+  }
+  await runAction(async () => {
+    await api(`/api/runs/${runId}/archive`, {
+      method: 'POST',
+      body: JSON.stringify({ reason: 'archived from dashboard' })
+    });
+    if (selectedRun === runId) {
+      selectedRun = null; selectedTask = null; selectedFileName = null; currentState = null;
+      document.getElementById('selected').textContent = '未选择任务批次';
+      document.getElementById('taskDescription').textContent = '未选择任务批次';
+      document.getElementById('tasks').innerHTML = '';
+      clearFileView();
+      updateAutoRefreshHint();
+    }
+    await refreshRuns();
+  });
+}
 async function archiveSelectedRun() {
   if (!selectedRun) return;
-  const ok = confirm('确认归档当前任务批次？\n\n归档后会从默认任务批次列表隐藏。若仍有任务运行，请先停止。');
-  if (!ok) return;
-  await api(`/api/runs/${selectedRun}/archive`, {
-    method: 'POST',
-    body: JSON.stringify({ reason: 'archived from dashboard' })
-  });
-  selectedRun = null; selectedTask = null; selectedFileName = null; currentState = null;
-  document.getElementById('selected').textContent = '未选择任务批次';
-  document.getElementById('taskDescription').textContent = '未选择任务批次';
-  document.getElementById('tasks').innerHTML = '';
-  clearFileView();
-  updateAutoRefreshHint();
-  await refreshRuns();
+  await archiveRunById(selectedRun);
 }
 async function markTaskCompleted(event, taskId) {
   event.stopPropagation();

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';
@@ -495,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);
 }
@@ -510,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;