@task0/cli 0.1.0

package/dist/main.js

@@ -0,0 +1,4385 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// ../../packages/shared/dist/node/yaml.js
+import fs2 from "fs";
+import path2 from "path";
+import yaml2 from "js-yaml";
+function readYaml(filePath) {
+  if (!fs2.existsSync(filePath))
+    return null;
+  const raw = fs2.readFileSync(filePath, "utf-8");
+  return yaml2.load(raw);
+}
+function readContext(taskDir) {
+  const files = fs2.readdirSync(taskDir).filter((f) => f.endsWith(".md"));
+  if (files.length === 0)
+    return void 0;
+  const content = fs2.readFileSync(path2.join(taskDir, files[0]), "utf-8");
+  const stripped = content.replace(/^---[\s\S]*?---\s*/, "");
+  return stripped.trim() || void 0;
+}
+var init_yaml = __esm({
+  "../../packages/shared/dist/node/yaml.js"() {
+    "use strict";
+  }
+});
+
+// ../../packages/shared/dist/object-id.js
+function encodeBase62(n, len) {
+  let s = "";
+  let v = n;
+  for (let i = 0; i < len; i++) {
+    s = BASE62[Number(v % BASE)] + s;
+    v /= BASE;
+  }
+  return s;
+}
+function formatObjectId(type, value) {
+  return `${RESOURCE_PREFIXES[type]}_${value}`;
+}
+function generateObjectId(type) {
+  const bytes = new Uint8Array(4);
+  globalThis.crypto.getRandomValues(bytes);
+  let hex = "";
+  for (const b of bytes)
+    hex += b.toString(16).padStart(2, "0");
+  const value = encodeBase62(BigInt("0x" + hex) % MOD, ID_LEN);
+  return formatObjectId(type, value);
+}
+function isTaskObjectId(id) {
+  return TASK_ID_RE.test(id);
+}
+var RESOURCE_PREFIXES, PREFIX_TO_TYPE, BASE62, ID_LEN, BASE, MOD, TASK_ID_RE, PREFIXES_PATTERN, OBJECT_ID_RE;
+var init_object_id = __esm({
+  "../../packages/shared/dist/object-id.js"() {
+    "use strict";
+    RESOURCE_PREFIXES = {
+      task: "tsk",
+      project: "prj",
+      runtime: "rt",
+      issue: "iss",
+      inbox: "ibx",
+      inbox_note: "note",
+      deck: "deck",
+      kanban: "kb",
+      column: "col",
+      task_source: "src",
+      event: "evt",
+      okr_plan: "okr",
+      objective: "obj",
+      key_result: "kr",
+      milestone: "ms",
+      task_kr_link: "krl",
+      task_comment: "cmt",
+      agent: "agt",
+      daemon: "dmn"
+    };
+    PREFIX_TO_TYPE = Object.fromEntries(Object.entries(RESOURCE_PREFIXES).map(([k, v]) => [v, k]));
+    BASE62 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+    ID_LEN = 5;
+    BASE = 62n;
+    MOD = BASE ** BigInt(ID_LEN);
+    TASK_ID_RE = /^tsk_[A-Za-z0-9]{5,12}$/;
+    PREFIXES_PATTERN = Object.values(RESOURCE_PREFIXES).join("|");
+    OBJECT_ID_RE = new RegExp(`\\b(?:${PREFIXES_PATTERN})_[A-Za-z0-9]{5,12}\\b`, "g");
+  }
+});
+
+// ../../packages/shared/dist/types/task.js
+function isActiveTaskStatus(status) {
+  return ACTIVE_TASK_STATUS_SET.has(status);
+}
+var TASK_STATUS_VALUES, ACTIVE_TASK_STATUSES, ATTENTION_TASK_STATUSES, ACTIVE_TASK_STATUS_SET, ATTENTION_TASK_STATUS_SET;
+var init_task = __esm({
+  "../../packages/shared/dist/types/task.js"() {
+    "use strict";
+    TASK_STATUS_VALUES = [
+      "todo",
+      "triaging",
+      "triaged",
+      "planning",
+      "planned",
+      "refining",
+      "refined",
+      "executing",
+      "blocked",
+      "done",
+      "archived"
+    ];
+    ACTIVE_TASK_STATUSES = [
+      "triaging",
+      "planning",
+      "refining",
+      "executing"
+    ];
+    ATTENTION_TASK_STATUSES = [
+      "blocked"
+    ];
+    ACTIVE_TASK_STATUS_SET = new Set(ACTIVE_TASK_STATUSES);
+    ATTENTION_TASK_STATUS_SET = new Set(ATTENTION_TASK_STATUSES);
+  }
+});
+
+// ../../packages/shared/dist/node/scanner.js
+import fs3 from "fs";
+import path3 from "path";
+function scanProject(projectPath, sourceName) {
+  const absPath = path3.resolve(projectPath);
+  const resolvedSourceName = sourceName ?? path3.basename(absPath);
+  const errors = [];
+  const tasks = [];
+  const repairs = [];
+  const projectYml = path3.join(absPath, "task0.yml");
+  const projectConfig = readYaml(projectYml);
+  if (!projectConfig)
+    return { tasks, errors: [`${projectYml} not found`], repairs };
+  if (projectConfig.kind !== "project")
+    return { tasks, errors: [`Invalid: kind="${projectConfig.kind}"`], repairs };
+  const tasksDir = path3.join(absPath, projectConfig.tasks_dir);
+  if (!fs3.existsSync(tasksDir))
+    return { tasks, errors: [`tasks_dir not found: ${tasksDir}`], repairs };
+  const entries = fs3.readdirSync(tasksDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isDirectory())
+      continue;
+    const taskDir = path3.join(tasksDir, entry.name);
+    const taskYml = path3.join(taskDir, "task0.yml");
+    const raw = readYaml(taskYml);
+    if (!raw || raw.kind !== "task")
+      continue;
+    let objectId = raw.object_id;
+    if (!objectId) {
+      objectId = generateObjectId("task");
+      repairs.push({
+        taskDir,
+        taskYml,
+        dirName: entry.name,
+        reason: "missing_object_id"
+      });
+    }
+    if (typeof raw.id === "string" && raw.id !== entry.name) {
+      repairs.push({
+        taskDir,
+        taskYml,
+        dirName: entry.name,
+        reason: "id_mismatch",
+        currentId: raw.id,
+        expectedId: entry.name
+      });
+    }
+    const id = raw.id || entry.name;
+    const title = raw.title;
+    const status = raw.status;
+    if (!id || !title || !status) {
+      errors.push(`${entry.name}: missing required fields (id, title, status)`);
+      continue;
+    }
+    if (!VALID_STATUSES.has(status)) {
+      errors.push(`${entry.name}: invalid status "${status}"`);
+      continue;
+    }
+    const context = readContext(taskDir);
+    const stat = fs3.statSync(taskYml);
+    const tags = raw.tags || [];
+    const summary = raw.summary || void 0;
+    const displayTitle = summary?.title || title;
+    const displayTags = summary?.tags ?? tags;
+    tasks.push({
+      id,
+      object_id: objectId,
+      metadata: raw.metadata || void 0,
+      kind: "task",
+      title,
+      description: raw.description || void 0,
+      project: resolvedSourceName,
+      status,
+      current_step: raw.current_step || "",
+      tags,
+      created_at: raw.created_at || stat.birthtime.toISOString(),
+      context: context || "",
+      project_root: absPath,
+      task_dir: taskDir,
+      last_update: stat.mtime.toISOString(),
+      linked_issues: raw.linked_issues || [],
+      workflow: raw.workflow || void 0,
+      summary,
+      comments: raw.comments || void 0,
+      display_title: displayTitle,
+      display_tags: displayTags
+    });
+  }
+  return { tasks, errors, repairs };
+}
+var VALID_STATUSES;
+var init_scanner = __esm({
+  "../../packages/shared/dist/node/scanner.js"() {
+    "use strict";
+    init_object_id();
+    init_task();
+    init_yaml();
+    VALID_STATUSES = new Set(TASK_STATUS_VALUES);
+  }
+});
+
+// ../../packages/shared/dist/node/open-questions.js
+import fs4 from "fs";
+import path4 from "path";
+function readOpenQuestions(taskDir, issueFiles) {
+  const result = [];
+  for (const file of issueFiles) {
+    const m = file.match(/^ISSUE-(\d+)\.md$/);
+    if (!m)
+      continue;
+    const fullPath = path4.join(taskDir, file);
+    if (!fs4.existsSync(fullPath))
+      continue;
+    const md = fs4.readFileSync(fullPath, "utf-8");
+    const match = md.match(OPEN_QUESTIONS_SECTION_RE);
+    if (!match)
+      continue;
+    const body = match[1].trim();
+    if (!body || /^none\b/i.test(body))
+      continue;
+    const bullets = body.split("\n").filter((line) => /^\s*[-*]\s+\S/.test(line));
+    if (bullets.length === 0)
+      continue;
+    result.push({ file, index: m[1], bullets });
+  }
+  return result;
+}
+var OPEN_QUESTIONS_SECTION_RE;
+var init_open_questions = __esm({
+  "../../packages/shared/dist/node/open-questions.js"() {
+    "use strict";
+    OPEN_QUESTIONS_SECTION_RE = /## Open Questions\s*\n([\s\S]*?)(\n## |\n*$)/i;
+  }
+});
+
+// ../../packages/shared/dist/node/task-state.js
+import fs5 from "fs";
+import os from "os";
+import path5 from "path";
+import yaml3 from "js-yaml";
+function findProjectRoot(start = process.cwd()) {
+  let dir = path5.resolve(start);
+  while (true) {
+    const ymlPath = path5.join(dir, "task0.yml");
+    if (fs5.existsSync(ymlPath)) {
+      try {
+        const raw = yaml3.load(fs5.readFileSync(ymlPath, "utf-8"));
+        if (raw?.kind === "project")
+          return dir;
+      } catch {
+      }
+    }
+    const parent = path5.dirname(dir);
+    if (parent === dir)
+      return null;
+    dir = parent;
+  }
+}
+function readProjectConfig(projectRoot) {
+  return yaml3.load(fs5.readFileSync(path5.join(projectRoot, "task0.yml"), "utf-8"));
+}
+function resolveTasksDir(projectRoot, projectConfig) {
+  const cfg = projectConfig ?? readProjectConfig(projectRoot);
+  return path5.isAbsolute(cfg.tasks_dir) ? cfg.tasks_dir : path5.join(projectRoot, cfg.tasks_dir);
+}
+function resolveTaskByObjectId(objectId, projectRoot) {
+  const root = projectRoot ?? findProjectRoot();
+  if (!root) {
+    throw new Error("Not inside a task0 project (no task0.yml with kind: project found).");
+  }
+  if (!isTaskObjectId(objectId)) {
+    throw new Error(`Expected a task object_id like 'tsk_XXXXX', got '${objectId}'. Directory names are no longer accepted; run 'task0 task list' to find the object_id.`);
+  }
+  const tasksDir = resolveTasksDir(root);
+  const entries = fs5.readdirSync(tasksDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isDirectory())
+      continue;
+    const taskDir = path5.join(tasksDir, entry.name);
+    const taskYml = path5.join(taskDir, "task0.yml");
+    if (!fs5.existsSync(taskYml))
+      continue;
+    try {
+      const raw = yaml3.load(fs5.readFileSync(taskYml, "utf-8"));
+      if (raw && raw.object_id === objectId) {
+        return { projectRoot: root, tasksDir, taskDir, taskYml };
+      }
+    } catch {
+    }
+  }
+  throw new Error(`No task with object_id '${objectId}' found under ${tasksDir}. If tasks pre-date object_id, run 'task0 task migrate' to seed them.`);
+}
+function readTaskYaml(taskYml) {
+  if (!fs5.existsSync(taskYml))
+    throw new Error(`task0.yml not found: ${taskYml}`);
+  return yaml3.load(fs5.readFileSync(taskYml, "utf-8")) || {};
+}
+function writeTaskYaml(taskYml, data) {
+  fs5.writeFileSync(taskYml, yaml3.dump(data, { lineWidth: 120 }), "utf-8");
+}
+function taskYamlLockPath(taskDir) {
+  return path5.join(taskDir, TASK_YAML_LOCKFILE);
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function readTaskYamlLockInfo(file) {
+  try {
+    return JSON.parse(fs5.readFileSync(file, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function writeTaskYamlLockInfo(file, info) {
+  const fd = fs5.openSync(file, "wx");
+  try {
+    fs5.writeFileSync(fd, JSON.stringify(info, null, 2), "utf-8");
+  } finally {
+    fs5.closeSync(fd);
+  }
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function acquireTaskYamlLock(taskDir) {
+  const file = taskYamlLockPath(taskDir);
+  const info = {
+    pid: process.pid,
+    hostname: os.hostname(),
+    started_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const deadline = Date.now() + TASK_YAML_LOCK_TIMEOUT_MS;
+  let backoffMs = TASK_YAML_LOCK_RETRY_BASE_MS;
+  while (Date.now() < deadline) {
+    try {
+      writeTaskYamlLockInfo(file, info);
+      return info;
+    } catch (err) {
+      if (err.code !== "EEXIST")
+        throw err;
+    }
+    const existing = readTaskYamlLockInfo(file);
+    if (existing && existing.hostname === info.hostname && !isProcessAlive(existing.pid)) {
+      try {
+        fs5.unlinkSync(file);
+        continue;
+      } catch (err) {
+        if (err.code !== "ENOENT") {
+          throw err;
+        }
+      }
+    }
+    await sleep(backoffMs);
+    backoffMs = Math.min(backoffMs * 2, TASK_YAML_LOCK_RETRY_MAX_MS);
+  }
+  throw new Error(`Timed out acquiring task YAML lock for ${taskDir}`);
+}
+function releaseTaskYamlLock(taskDir, info) {
+  const file = taskYamlLockPath(taskDir);
+  const existing = readTaskYamlLockInfo(file);
+  if (!existing)
+    return;
+  if (existing.pid !== info.pid || existing.hostname !== info.hostname || existing.started_at !== info.started_at) {
+    return;
+  }
+  try {
+    fs5.unlinkSync(file);
+  } catch (err) {
+    if (err.code !== "ENOENT") {
+      throw err;
+    }
+  }
+}
+async function withTaskYamlLock(taskDir, fn) {
+  const key = path5.resolve(taskDir);
+  const prev = yamlLocks.get(key) ?? Promise.resolve();
+  const next = prev.then(async () => {
+    const lock = await acquireTaskYamlLock(taskDir);
+    try {
+      return await fn();
+    } finally {
+      releaseTaskYamlLock(taskDir, lock);
+    }
+  }, async () => {
+    const lock = await acquireTaskYamlLock(taskDir);
+    try {
+      return await fn();
+    } finally {
+      releaseTaskYamlLock(taskDir, lock);
+    }
+  });
+  const tracked = next.then(() => {
+  }, () => {
+  }).then(() => {
+    if (yamlLocks.get(key) === tracked)
+      yamlLocks.delete(key);
+  });
+  yamlLocks.set(key, tracked);
+  return next;
+}
+function readTaskWorkflow(taskYml) {
+  const raw = readTaskYaml(taskYml);
+  return raw.workflow || {};
+}
+async function updateTaskWorkflow(taskYml, patch) {
+  const taskDir = path5.dirname(taskYml);
+  return withTaskYamlLock(taskDir, () => {
+    const raw = readTaskYaml(taskYml);
+    const current = raw.workflow || {};
+    const merged = { ...current, ...patch, updated_at: (/* @__PURE__ */ new Date()).toISOString() };
+    if (patch.runtimes) {
+      merged.runtimes = { ...current.runtimes || {}, ...patch.runtimes };
+    }
+    if (patch.decisions) {
+      const next = { ...current.decisions || {} };
+      for (const [key, value] of Object.entries(patch.decisions)) {
+        next[key] = { ...next[key] || {}, ...value };
+      }
+      merged.decisions = next;
+    }
+    raw.workflow = merged;
+    writeTaskYaml(taskYml, raw);
+    return merged;
+  });
+}
+var yamlLocks, TASK_YAML_LOCKFILE, TASK_YAML_LOCK_TIMEOUT_MS, TASK_YAML_LOCK_RETRY_BASE_MS, TASK_YAML_LOCK_RETRY_MAX_MS;
+var init_task_state = __esm({
+  "../../packages/shared/dist/node/task-state.js"() {
+    "use strict";
+    init_object_id();
+    yamlLocks = /* @__PURE__ */ new Map();
+    TASK_YAML_LOCKFILE = ".task0.yml.lock";
+    TASK_YAML_LOCK_TIMEOUT_MS = 5e3;
+    TASK_YAML_LOCK_RETRY_BASE_MS = 10;
+    TASK_YAML_LOCK_RETRY_MAX_MS = 100;
+  }
+});
+
+// ../../packages/shared/dist/types/error-report.js
+var ERROR_REPORT_SCHEMA_VERSION;
+var init_error_report = __esm({
+  "../../packages/shared/dist/types/error-report.js"() {
+    "use strict";
+    ERROR_REPORT_SCHEMA_VERSION = 1;
+  }
+});
+
+// ../../packages/shared/dist/node/redact.js
+function redactString(input) {
+  if (!input)
+    return { value: input, redacted: false };
+  let value = input;
+  let redacted = false;
+  for (const { re, replace } of REDACTION_PATTERNS) {
+    value = value.replace(re, (...args) => {
+      redacted = true;
+      return replace(...args);
+    });
+  }
+  return { value, redacted };
+}
+function redactArgv(argv) {
+  let redacted = false;
+  const out = argv.map((a) => {
+    const r = redactString(a);
+    if (r.redacted)
+      redacted = true;
+    return r.value;
+  });
+  return { argv: out, redacted };
+}
+function filterEnv(env = process.env) {
+  const out = {};
+  for (const [key, rawValue] of Object.entries(env)) {
+    if (rawValue === void 0)
+      continue;
+    const allowed = DEFAULT_ENV_ALLOWLIST.has(key) || key.startsWith(LC_PREFIX) || key.startsWith(TASK0_PREFIX);
+    if (!allowed)
+      continue;
+    if (SECRET_KEY_RE.test(key) && rawValue.length > 0) {
+      out[key] = REDACTED_VALUE;
+      continue;
+    }
+    const { value } = redactString(rawValue);
+    out[key] = value;
+  }
+  return out;
+}
+var REDACTED, REDACTION_PATTERNS, DEFAULT_ENV_ALLOWLIST, LC_PREFIX, TASK0_PREFIX, SECRET_KEY_RE, REDACTED_VALUE;
+var init_redact = __esm({
+  "../../packages/shared/dist/node/redact.js"() {
+    "use strict";
+    REDACTED = "[REDACTED]";
+    REDACTION_PATTERNS = [
+      {
+        re: /Bearer\s+[A-Za-z0-9._~+/=-]+/gi,
+        replace: () => `Bearer ${REDACTED}`
+      },
+      {
+        re: /Authorization\s*:\s*Bearer\s+[A-Za-z0-9._~+/=-]+/gi,
+        replace: () => `Authorization: Bearer ${REDACTED}`
+      },
+      {
+        re: /\b([A-Z0-9_]*(?:TOKEN|KEY|SECRET|PASSWORD))\s*=\s*([^\s"'&]+)/gi,
+        replace: (_m, name) => `${name}=${REDACTED}`
+      },
+      {
+        re: /\b(token|key|secret|password)\s*=\s*([^\s"'&]+)/gi,
+        replace: (_m, name) => `${name}=${REDACTED}`
+      }
+    ];
+    DEFAULT_ENV_ALLOWLIST = /* @__PURE__ */ new Set([
+      "PATH",
+      "SHELL",
+      "LANG",
+      "TERM",
+      "TERM_PROGRAM",
+      "TERM_PROGRAM_VERSION",
+      "COLORTERM",
+      "CI"
+    ]);
+    LC_PREFIX = "LC_";
+    TASK0_PREFIX = "TASK0_";
+    SECRET_KEY_RE = /(?:TOKEN|KEY|SECRET|PASSWORD)$/;
+    REDACTED_VALUE = "[REDACTED]";
+  }
+});
+
+// ../../packages/shared/dist/node/error-reports.js
+import fs6 from "fs";
+import os2 from "os";
+import path6 from "path";
+import { spawnSync } from "child_process";
+import crypto from "crypto";
+function task0Home() {
+  const override = process.env.TASK0_HOME;
+  if (override && override.length > 0)
+    return override;
+  return path6.join(os2.homedir(), ".task0");
+}
+function errorsRoot() {
+  return path6.join(task0Home(), "errors");
+}
+function createErrorReportId() {
+  return `err_${crypto.randomBytes(4).toString("hex")}`;
+}
+function toUtcBasicTs(date) {
+  const iso = date.toISOString();
+  return iso.replace(/[-:]/g, "").replace(/\.\d{3}Z$/, "Z");
+}
+function errorReportDirName(date, id) {
+  return `${toUtcBasicTs(date)}-${id}`;
+}
+function runGit(args, cwd) {
+  try {
+    const res = spawnSync("git", args, {
+      cwd,
+      timeout: 1e3,
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    if (res.status !== 0 || res.error)
+      return null;
+    const out = (res.stdout ?? "").toString().trim();
+    return out.length > 0 ? out : null;
+  } catch {
+    return null;
+  }
+}
+function readGitContext(cwd) {
+  const root = runGit(["rev-parse", "--show-toplevel"], cwd);
+  if (!root)
+    return null;
+  const head = runGit(["rev-parse", "HEAD"], cwd);
+  const branch = runGit(["branch", "--show-current"], cwd);
+  return { root, head, branch };
+}
+function normalizeError(input) {
+  if (input instanceof Error) {
+    return {
+      name: input.name || "Error",
+      message: input.message || "",
+      stack: input.stack || ""
+    };
+  }
+  const message = typeof input === "string" ? input : safeStringify(input);
+  return {
+    name: "NonError",
+    message,
+    stack: message
+  };
+}
+function safeStringify(value) {
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function buildErrorReport(input) {
+  const now = input.now ?? /* @__PURE__ */ new Date();
+  const id = createErrorReportId();
+  const normalized = normalizeError(input.error);
+  const argvResult = redactArgv(input.argv);
+  const messageResult = redactString(normalized.message);
+  const stackResult = redactString(normalized.stack);
+  const env = filterEnv(input.env ?? process.env);
+  const command = ["task0", ...argvResult.argv].join(" ");
+  const git = input.includeGit === false ? null : readGitContext(input.cwd);
+  return {
+    schema_version: ERROR_REPORT_SCHEMA_VERSION,
+    id,
+    captured_at: now.toISOString(),
+    origin: input.origin,
+    command,
+    argv: argvResult.argv,
+    cwd: input.cwd,
+    task0_version: input.task0Version,
+    node_version: process.version,
+    platform: process.platform,
+    arch: process.arch,
+    pid: process.pid,
+    ppid: typeof process.ppid === "number" ? process.ppid : 0,
+    git,
+    error: {
+      name: normalized.name,
+      message: messageResult.value,
+      stack: stackResult.value,
+      exit_code: input.exitCode ?? null
+    },
+    env,
+    redaction: {
+      argv_redacted: argvResult.redacted,
+      message_redacted: messageResult.redacted,
+      stack_redacted: stackResult.redacted,
+      env_strategy: "allowlist"
+    }
+  };
+}
+function writeErrorReportSync(report, rootOverride) {
+  const root = rootOverride ?? errorsRoot();
+  const dirName = errorReportDirName(new Date(report.captured_at), report.id);
+  const dir = path6.join(root, dirName);
+  fs6.mkdirSync(dir, { recursive: true });
+  const finalPath = path6.join(dir, REPORT_FILENAME);
+  const tmpPath = path6.join(dir, TMP_FILENAME);
+  const json = JSON.stringify(report, null, 2);
+  fs6.writeFileSync(tmpPath, json, "utf-8");
+  fs6.renameSync(tmpPath, finalPath);
+  return { dir, path: finalPath };
+}
+function parseReportDir(name) {
+  const m = /^(\d{8}T\d{6}Z)-(err_[0-9a-f]{8})$/.exec(name);
+  if (!m)
+    return null;
+  return { ts: m[1], id: m[2] };
+}
+function listErrorReports(rootOverride) {
+  const root = rootOverride ?? errorsRoot();
+  const result = {
+    reports: [],
+    skipped: { unsupported_schema: 0, unreadable: 0 }
+  };
+  let entries;
+  try {
+    entries = fs6.readdirSync(root, { withFileTypes: true });
+  } catch (err) {
+    if (err.code === "ENOENT")
+      return result;
+    throw err;
+  }
+  for (const entry of entries) {
+    if (!entry.isDirectory())
+      continue;
+    const parsed = parseReportDir(entry.name);
+    if (!parsed)
+      continue;
+    const dir = path6.join(root, entry.name);
+    const file = path6.join(dir, REPORT_FILENAME);
+    let raw;
+    try {
+      raw = fs6.readFileSync(file, "utf-8");
+    } catch {
+      result.skipped.unreadable += 1;
+      continue;
+    }
+    let data = null;
+    try {
+      data = JSON.parse(raw);
+    } catch {
+      result.skipped.unreadable += 1;
+      continue;
+    }
+    if (!data || data.schema_version !== ERROR_REPORT_SCHEMA_VERSION) {
+      result.skipped.unsupported_schema += 1;
+      continue;
+    }
+    let size = 0;
+    try {
+      size = fs6.statSync(file).size;
+    } catch {
+    }
+    result.reports.push({
+      id: data.id ?? parsed.id,
+      dir,
+      path: file,
+      captured_at: data.captured_at ?? "",
+      command: data.command ?? "",
+      error_name: data.error?.name ?? "",
+      error_message: data.error?.message ?? "",
+      size_bytes: size
+    });
+  }
+  result.reports.sort((a, b) => {
+    if (a.captured_at === b.captured_at)
+      return b.id.localeCompare(a.id);
+    return b.captured_at.localeCompare(a.captured_at);
+  });
+  return result;
+}
+function resolveErrorReport(query, rootOverride) {
+  const list = listErrorReports(rootOverride);
+  const exact = list.reports.find((r) => r.id === query);
+  if (exact)
+    return { kind: "hit", summary: exact };
+  const prefixMatches = list.reports.filter((r) => r.id.startsWith(query));
+  if (prefixMatches.length === 1)
+    return { kind: "hit", summary: prefixMatches[0] };
+  if (prefixMatches.length > 1) {
+    return { kind: "ambiguous", query, candidates: prefixMatches };
+  }
+  return { kind: "miss", query };
+}
+function readErrorReport(summary) {
+  const raw = fs6.readFileSync(summary.path, "utf-8");
+  return JSON.parse(raw);
+}
+function pruneErrorReports(opts, rootOverride) {
+  const list = listErrorReports(rootOverride);
+  const removed = [];
+  if (opts.all) {
+    for (const r of list.reports) {
+      if (removeReportDir(r.dir))
+        removed.push(r.dir);
+    }
+    return { removed, kept: 0 };
+  }
+  const toRemove = /* @__PURE__ */ new Set();
+  if (typeof opts.olderThanMs === "number" && opts.olderThanMs >= 0) {
+    const cutoff = Date.now() - opts.olderThanMs;
+    for (const r of list.reports) {
+      const t = Date.parse(r.captured_at);
+      if (!Number.isFinite(t))
+        continue;
+      if (t < cutoff)
+        toRemove.add(r.dir);
+    }
+  }
+  if (typeof opts.keep === "number" && opts.keep >= 0) {
+    for (let i = opts.keep; i < list.reports.length; i += 1) {
+      toRemove.add(list.reports[i].dir);
+    }
+  }
+  for (const dir of toRemove) {
+    if (removeReportDir(dir))
+      removed.push(dir);
+  }
+  const kept = list.reports.length - removed.length;
+  return { removed, kept };
+}
+function removeReportDir(dir) {
+  try {
+    fs6.rmSync(dir, { recursive: true, force: true });
+    return true;
+  } catch {
+    return false;
+  }
+}
+var REPORT_FILENAME, TMP_FILENAME;
+var init_error_reports = __esm({
+  "../../packages/shared/dist/node/error-reports.js"() {
+    "use strict";
+    init_error_report();
+    init_redact();
+    REPORT_FILENAME = "report.json";
+    TMP_FILENAME = "report.json.tmp";
+  }
+});
+
+// ../../packages/shared/dist/node/file-lock.js
+import fs7 from "fs";
+import os3 from "os";
+import path7 from "path";
+var init_file_lock = __esm({
+  "../../packages/shared/dist/node/file-lock.js"() {
+    "use strict";
+  }
+});
+
+// ../../packages/shared/dist/node/tmux.js
+import { spawnSync as spawnSync2 } from "child_process";
+var init_tmux = __esm({
+  "../../packages/shared/dist/node/tmux.js"() {
+    "use strict";
+  }
+});
+
+// ../../packages/shared/dist/node/index.js
+var init_node = __esm({
+  "../../packages/shared/dist/node/index.js"() {
+    "use strict";
+    init_yaml();
+    init_scanner();
+    init_open_questions();
+    init_task_state();
+    init_error_reports();
+    init_redact();
+    init_file_lock();
+    init_tmux();
+    init_error_report();
+  }
+});
+
+// src/core/task-state.ts
+var task_state_exports = {};
+__export(task_state_exports, {
+  findProjectRoot: () => findProjectRoot,
+  latestArtifact: () => latestArtifact,
+  nextArtifactIndex: () => nextArtifactIndex,
+  readProjectConfig: () => readProjectConfig,
+  readTaskYaml: () => readTaskYaml,
+  readWorkflow: () => readWorkflow,
+  resolveTaskByObjectId: () => resolveTaskByObjectId,
+  resolveTasksDir: () => resolveTasksDir,
+  updateWorkflow: () => updateWorkflow,
+  withTaskYamlLock: () => withTaskYamlLock,
+  writeTaskYaml: () => writeTaskYaml
+});
+import fs9 from "fs";
+function readWorkflow(taskYml) {
+  return readTaskWorkflow(taskYml);
+}
+async function updateWorkflow(taskYml, patch) {
+  return updateTaskWorkflow(taskYml, patch);
+}
+function nextArtifactIndex(taskDir, prefix, ext = "md") {
+  const pattern = new RegExp(`^${prefix}-(\\d+).*\\.${ext}$`);
+  const entries = fs9.readdirSync(taskDir);
+  const indices = entries.map((name) => name.match(pattern)?.[1]).filter((v) => v != null).map(Number);
+  const next = indices.length > 0 ? Math.max(...indices) + 1 : 1;
+  return String(next).padStart(2, "0");
+}
+function latestArtifact(taskDir, pattern) {
+  if (!fs9.existsSync(taskDir)) return null;
+  const matches = fs9.readdirSync(taskDir).filter((name) => pattern.test(name));
+  if (matches.length === 0) return null;
+  matches.sort();
+  return matches[matches.length - 1] || null;
+}
+var init_task_state2 = __esm({
+  "src/core/task-state.ts"() {
+    "use strict";
+    init_node();
+  }
+});
+
+// src/main.ts
+import { Command as Command22 } from "commander";
+
+// src/commands/source.ts
+import { Command } from "commander";
+import path8 from "path";
+import chalk from "chalk";
+
+// src/core/config.ts
+import fs from "fs";
+import path from "path";
+import yaml from "js-yaml";
+var CONFIG_DIR = path.join(
+  process.env.HOME || process.env.USERPROFILE || "~",
+  ".config",
+  "task0"
+);
+var CONFIG_FILE = path.join(CONFIG_DIR, "config.yml");
+function ensureConfigDir() {
+  fs.mkdirSync(CONFIG_DIR, { recursive: true });
+}
+function defaultConfig() {
+  return { sources: [] };
+}
+function loadConfig() {
+  if (!fs.existsSync(CONFIG_FILE)) return defaultConfig();
+  const raw = fs.readFileSync(CONFIG_FILE, "utf-8");
+  const data = yaml.load(raw);
+  return {
+    ...data ?? {},
+    sources: Array.isArray(data?.sources) ? data.sources : []
+  };
+}
+function saveConfig(config) {
+  ensureConfigDir();
+  fs.writeFileSync(CONFIG_FILE, yaml.dump(config, { lineWidth: 120 }), "utf-8");
+}
+function addSource(entry) {
+  const config = loadConfig();
+  const existing = config.sources.findIndex((s) => s.name === entry.name);
+  if (existing >= 0) {
+    config.sources[existing] = entry;
+  } else {
+    config.sources.push(entry);
+  }
+  saveConfig(config);
+}
+function removeSource(name) {
+  const config = loadConfig();
+  const idx = config.sources.findIndex((s) => s.name === name);
+  if (idx < 0) return false;
+  config.sources.splice(idx, 1);
+  saveConfig(config);
+  return true;
+}
+function getSource(name) {
+  return loadConfig().sources.find((s) => s.name === name);
+}
+
+// src/commands/source.ts
+init_node();
+
+// src/types.ts
+init_task();
+
+// src/commands/source.ts
+var source = new Command("source").description("Manage task sources");
+source.command("add <path>").description("Add a local project as task source").option("-n, --name <name>", "Source name (defaults to directory name)").action((inputPath, opts) => {
+  const absPath = path8.resolve(inputPath);
+  const name = opts.name || path8.basename(absPath);
+  const result = scanProject(absPath);
+  if (result.errors.length > 0 && result.tasks.length === 0) {
+    for (const err of result.errors) console.error(chalk.red(`  error: ${err}`));
+    process.exit(1);
+  }
+  addSource({ name, type: "project", path: absPath, enabled: true });
+  console.log(chalk.green(`Added source "${name}" \u2192 ${absPath}`));
+  console.log(`  ${result.tasks.length} tasks found`);
+  if (result.errors.length > 0) {
+    for (const err of result.errors) console.warn(chalk.yellow(`  warn: ${err}`));
+  }
+});
+source.command("list").description("List registered task sources").action(() => {
+  const config = loadConfig();
+  if (config.sources.length === 0) {
+    console.log("No sources registered. Use `task0 source add <path>` to add one.");
+    return;
+  }
+  for (const s of config.sources) {
+    const status = s.enabled ? chalk.green("\u25CF") : chalk.dim("\u25CB");
+    console.log(`${status} ${s.name}  ${chalk.dim(s.type)}  ${s.path}`);
+  }
+});
+source.command("remove <name>").description("Remove a task source").action((name) => {
+  if (removeSource(name)) {
+    console.log(chalk.green(`Removed source "${name}"`));
+  } else {
+    console.error(chalk.red(`Source "${name}" not found`));
+    process.exit(1);
+  }
+});
+source.command("scan [name]").description("Scan source(s) and display tasks").option("--json", "Output as JSON").action((name, opts) => {
+  const config = loadConfig();
+  const sources = name ? (() => {
+    const s = getSource(name);
+    if (!s) {
+      console.error(chalk.red(`Source "${name}" not found`));
+      process.exit(1);
+    }
+    return [s];
+  })() : config.sources.filter((s) => s.enabled);
+  if (sources.length === 0) {
+    console.log("No sources to scan.");
+    return;
+  }
+  const allTasks = [];
+  for (const s of sources) {
+    const result = scanProject(s.path, s.name);
+    if (opts.json) {
+      allTasks.push(...result.tasks.map((t) => ({ ...t, _source: s.name })));
+    } else {
+      console.log(chalk.bold(`
+${s.name}`) + chalk.dim(` (${s.path})`));
+      if (result.errors.length > 0) {
+        for (const err of result.errors) console.warn(chalk.yellow(`  warn: ${err}`));
+      }
+      const objectIdWidth = Math.max(...result.tasks.map((t) => (t.object_id || "").length), 9);
+      for (const t of result.tasks) {
+        const statusColor2 = isActiveTaskStatus(t.status) ? chalk.green : t.status === "blocked" ? chalk.red : t.status === "todo" ? chalk.yellow : t.status === "done" ? chalk.dim : chalk.white;
+        const objectId = chalk.cyan((t.object_id || "-").padEnd(objectIdWidth));
+        console.log(`  ${objectId}  ${statusColor2(t.status.padEnd(8))}  ${chalk.dim(t.id)}  ${t.title}`);
+      }
+      console.log(chalk.dim(`  ${result.tasks.length} tasks`));
+    }
+  }
+  if (opts.json) {
+    console.log(JSON.stringify(allTasks, null, 2));
+  }
+});
+
+// src/commands/project.ts
+import { Command as Command2 } from "commander";
+import fs8 from "fs";
+import path9 from "path";
+import yaml4 from "js-yaml";
+import chalk2 from "chalk";
+
+// ../../packages/shared/dist/index.js
+init_object_id();
+
+// src/commands/project.ts
+var project = new Command2("project").description("Manage projects");
+function readProjectObjectId(projectPath) {
+  const ymlPath = path9.join(projectPath, "task0.yml");
+  if (!fs8.existsSync(ymlPath)) return "-";
+  try {
+    const raw = yaml4.load(fs8.readFileSync(ymlPath, "utf-8"));
+    const id = raw && typeof raw.object_id === "string" ? raw.object_id : "";
+    return id || "-";
+  } catch {
+    return "-";
+  }
+}
+project.command("list").description("List registered projects").action(() => {
+  const projects = loadConfig().sources.filter((s) => s.type === "project");
+  if (projects.length === 0) {
+    console.log("No projects registered. Use `task0 source add <path>` to add one.");
+    return;
+  }
+  const rows = projects.map((p) => ({ p, objectId: readProjectObjectId(p.path) }));
+  const objectIdWidth = Math.max(...rows.map((r) => r.objectId.length), 9);
+  const nameWidth = Math.max(...rows.map((r) => r.p.name.length), 4);
+  for (const { p, objectId } of rows) {
+    const status = p.enabled ? chalk2.green("\u25CF") : chalk2.dim("\u25CB");
+    const oid = chalk2.cyan(objectId.padEnd(objectIdWidth));
+    const name = p.name.padEnd(nameWidth);
+    console.log(`${status} ${oid}  ${name}  ${chalk2.dim(p.path)}`);
+  }
+});
+project.command("init").description("Initialize task0.yml in the current directory").option("-d, --tasks-dir <dir>", "Tasks directory", ".task0/tasks").action((opts) => {
+  const cwd = process.cwd();
+  const ymlPath = path9.join(cwd, "task0.yml");
+  if (fs8.existsSync(ymlPath)) {
+    console.error(chalk2.yellow("task0.yml already exists"));
+    process.exit(1);
+  }
+  const config = { kind: "project", object_id: generateObjectId("project"), tasks_dir: opts.tasksDir };
+  fs8.writeFileSync(ymlPath, yaml4.dump(config), "utf-8");
+  const tasksDir = path9.join(cwd, opts.tasksDir);
+  fs8.mkdirSync(tasksDir, { recursive: true });
+  console.log(chalk2.green("Initialized task0 project"));
+  console.log(`  ${ymlPath}`);
+  console.log(`  ${tasksDir}/`);
+});
+
+// src/commands/task.ts
+import { Command as Command8 } from "commander";
+import { execSync } from "child_process";
+import fs14 from "fs";
+import path12 from "path";
+import yaml5 from "js-yaml";
+import chalk8 from "chalk";
+
+// src/lib/api.ts
+var DEFAULT_BASE = "http://127.0.0.1:4318";
+function apiBaseUrl() {
+  return process.env.TASK0_API_URL || DEFAULT_BASE;
+}
+async function request(method, pathname, body) {
+  const url = apiBaseUrl().replace(/\/$/, "") + pathname;
+  let res;
+  try {
+    res = await fetch(url, {
+      method,
+      headers: body !== void 0 ? { "content-type": "application/json" } : void 0,
+      body: body !== void 0 ? JSON.stringify(body) : void 0
+    });
+  } catch (error2) {
+    const err = new Error(
+      `Cannot reach task0 API at ${apiBaseUrl()}. Start it with \`task0 serve\` (or \`task0 ui\` for dev).`
+    );
+    err.cause = error2;
+    throw err;
+  }
+  const text = await res.text();
+  let parsed = null;
+  try {
+    parsed = text ? JSON.parse(text) : null;
+  } catch {
+    parsed = text;
+  }
+  if (!res.ok) {
+    const message = parsed?.error || text || res.statusText;
+    const err = new Error(`API ${method} ${pathname} failed (${res.status}): ${message}`);
+    err.status = res.status;
+    err.body = parsed;
+    throw err;
+  }
+  return parsed;
+}
+var api = {
+  get: (path21) => request("GET", path21),
+  post: (path21, body) => request("POST", path21, body ?? {}),
+  put: (path21, body) => request("PUT", path21, body ?? {}),
+  patch: (path21, body) => request("PATCH", path21, body ?? {}),
+  del: (path21) => request("DELETE", path21)
+};
+
+// src/commands/task/triage.ts
+import { Command as Command3 } from "commander";
+import chalk3 from "chalk";
+import fs10 from "fs";
+import path10 from "path";
+
+// src/core/runtime-wait.ts
+async function getRuntime(id) {
+  return api.get(`/api/runtimes/${encodeURIComponent(id)}`);
+}
+async function waitForRuntime(id, opts = {}) {
+  const interval = opts.intervalMs ?? 2e3;
+  const deadline = opts.timeoutMs ? Date.now() + opts.timeoutMs : null;
+  let lastStatus = "";
+  while (true) {
+    const snap = await getRuntime(id);
+    if (snap.status !== lastStatus) {
+      lastStatus = snap.status;
+      opts.onTick?.(snap);
+    }
+    if (snap.status === "done" || snap.status === "error") return snap;
+    if (deadline && Date.now() > deadline) {
+      throw new Error(`Timeout waiting for runtime ${id} (last status: ${snap.status})`);
+    }
+    await new Promise((r) => setTimeout(r, interval));
+  }
+}
+
+// src/core/model-options.ts
+function resolveModelOptions(agent2, cli, warn = () => {
+}) {
+  const entry = loadConfig().agentModels?.[agent2];
+  const known = entry?.models ?? [];
+  const cliModel = cli.model?.trim() || void 0;
+  let model = cliModel || entry?.defaultModel?.trim() || void 0;
+  if (cliModel) {
+    const byAlias = known.find((m) => m.alias && m.alias === cliModel);
+    if (byAlias) {
+      model = byAlias.id;
+    } else if (!known.some((m) => m.id === cliModel)) {
+      warn(`model "${cliModel}" not in cached list for ${agent2} (run \`task0 models refresh\`); forwarding as-is`);
+    }
+  }
+  const effort = cli.effort?.trim() || entry?.defaultEffort?.trim() || void 0;
+  return {
+    ...model ? { model } : {},
+    ...effort ? { effort } : {}
+  };
+}
+
+// src/commands/task/triage.ts
+init_task_state2();
+var ISSUE_DETAIL_RE = /^ISSUE-\d+\.md$/;
+var TRIAGE_SKILL_NAME = "triage";
+function resolveSkillFilePath(projectRoot, skillName) {
+  const p = path10.join(projectRoot, ".claude", "skills", skillName, "SKILL.md");
+  return fs10.existsSync(p) ? p : null;
+}
+var triage = new Command3("triage").description("Decompose IDEA into ISSUE.md + ISSUE-NN.md").argument("<objectId>", "Task object_id (tsk_XXXXX)").option("--agent <name>", "Agent (claude-code|codex)", "claude-code").option("--model <id>", "Model id or alias (see `task0 models refresh`)").option("--effort <level>", "Reasoning effort (e.g. low|medium|high)").option("--idea <file>", "IDEA file (default: latest IDEA-NN.md)").option("--force", "Overwrite existing ISSUE files").option("--wait", "Wait for completion").option("--json", "Output JSON").action(async (objectId, opts) => {
+  try {
+    const loc = resolveTaskByObjectId(objectId);
+    const ideaFile = opts.idea || latestArtifact(loc.taskDir, /^IDEA-\d+\.md$/);
+    if (!ideaFile) {
+      console.error(chalk3.red(`No IDEA-NN.md found in ${loc.taskDir}. Pass --idea or create one first.`));
+      process.exit(1);
+    }
+    const existingIssues = listIssueArtifacts(loc.taskDir);
+    if (existingIssues.length > 0) {
+      if (!opts.force) {
+        console.error(chalk3.red(
+          `ISSUE files already exist: ${existingIssues.join(", ")}. Pass --force to overwrite.`
+        ));
+        process.exit(1);
+      }
+      for (const name of existingIssues) {
+        fs10.rmSync(path10.join(loc.taskDir, name), { force: true });
+      }
+    }
+    if (opts.model || opts.effort) {
+      resolveModelOptions(
+        opts.agent,
+        { model: opts.model, effort: opts.effort },
+        opts.json ? void 0 : (m) => console.error(chalk3.dim(m))
+      );
+    }
+    const skillFilePath = resolveSkillFilePath(loc.projectRoot, TRIAGE_SKILL_NAME);
+    const prompt = [
+      `task_id: ${objectId}`,
+      `Skill: ${TRIAGE_SKILL_NAME}`,
+      `Idea file: ${ideaFile}`
+    ].join("\n");
+    const body = {
+      task_id: objectId,
+      prompt,
+      ...skillFilePath ? { skill_file_path: skillFilePath } : {}
+    };
+    const resp = await api.post(
+      `/api/agents/${encodeURIComponent(opts.agent)}/run`,
+      body
+    );
+    const runtimeId = resp.runtime.id;
+    if (!opts.json) console.log(chalk3.green(`triage runtime ${runtimeId}`));
+    await updateWorkflow(loc.taskYml, { runtimes: { triage: runtimeId } });
+    if (opts.wait) {
+      const final = await waitForRuntime(runtimeId, {
+        onTick: (s) => {
+          if (!opts.json) console.log(chalk3.dim(`[triage] ${s.status}${s.phase ? " " + s.phase : ""}`));
+        }
+      });
+      if (final.status !== "done") {
+        console.error(chalk3.red(`triage failed: ${final.error || "unknown"}`));
+        process.exit(1);
+      }
+      const hasOverview = fs10.existsSync(path10.join(loc.taskDir, "ISSUE.md"));
+      const issueFiles = fs10.readdirSync(loc.taskDir).filter((name) => ISSUE_DETAIL_RE.test(name)).sort();
+      if (!hasOverview || issueFiles.length === 0) {
+        const missing = [];
+        if (!hasOverview) missing.push("ISSUE.md");
+        if (issueFiles.length === 0) missing.push("ISSUE-NN.md (\u22651)");
+        console.error(chalk3.red(`triage completed but missing: ${missing.join(", ")}`));
+        process.exit(1);
+      }
+      let blockingQuestionCount = 0;
+      for (const name of issueFiles) {
+        const content = fs10.readFileSync(path10.join(loc.taskDir, name), "utf-8");
+        blockingQuestionCount += countBlockingQuestions(content);
+      }
+      await updateWorkflow(loc.taskYml, {
+        phase: "triaged",
+        issue_overview: "ISSUE.md",
+        issue_files: issueFiles
+      });
+      if (!opts.json) {
+        console.log(chalk3.green(`ISSUE.md (+${issueFiles.length} details)`));
+        console.log(chalk3.dim(`blockingQuestionCount: ${blockingQuestionCount}`));
+      } else {
+        console.log(JSON.stringify({
+          runtimeId,
+          issueOverview: "ISSUE.md",
+          issueFiles,
+          blockingQuestionCount
+        }, null, 2));
+      }
+      process.exit(blockingQuestionCount > 0 ? 2 : 0);
+    }
+    if (opts.json) console.log(JSON.stringify({ runtimeId }, null, 2));
+  } catch (err) {
+    console.error(chalk3.red(err.message));
+    process.exit(1);
+  }
+});
+function listIssueArtifacts(taskDir) {
+  if (!fs10.existsSync(taskDir)) return [];
+  return fs10.readdirSync(taskDir).filter((name) => name === "ISSUE.md" || ISSUE_DETAIL_RE.test(name)).sort();
+}
+function countBlockingQuestions(md) {
+  const match = md.match(/## Open Questions\s*\n([\s\S]*?)(\n## |\n*$)/i);
+  if (!match) return 0;
+  const body = match[1].trim();
+  if (!body || /^none\b/i.test(body)) return 0;
+  const bullets = body.split("\n").filter((line) => /^\s*[-*]\s+\S/.test(line));
+  return bullets.length;
+}
+
+// src/commands/task/exec.ts
+import { Command as Command4 } from "commander";
+import chalk4 from "chalk";
+import fs11 from "fs";
+import path11 from "path";
+init_task_state2();
+var PLAN_EXECUTE_SKILL_NAME = "plan-execute";
+function resolveSkillFilePath2(projectRoot, skillName) {
+  const p = path11.join(projectRoot, ".claude", "skills", skillName, "SKILL.md");
+  return fs11.existsSync(p) ? p : null;
+}
+var exec = new Command4("exec").description("Execute a plan against the task (cwd = project root; agent sets up its own worktree if needed)").argument("<objectId>", "Task object_id (tsk_XXXXX)").option("--agent <name>", "Agent (claude-code|codex|cursor)", "claude-code").option("--model <id>", "Model id or alias (see `task0 models refresh`)").option("--effort <level>", "Reasoning effort (e.g. low|medium|high)").option("--plan <file>", "Plan file (default: refined plan, else latest PLAN)").option("--no-commit", "Skip commit").option("--wait", "Wait for completion").option("--json", "Output JSON").action(async (objectId, opts) => {
+  try {
+    const loc = resolveTaskByObjectId(objectId);
+    const wf = readWorkflow(loc.taskYml);
+    const planFile = opts.plan || wf.refined_plan_file || latestArtifact(loc.taskDir, /^PLAN-\d+-refined\.md$/) || latestArtifact(loc.taskDir, /^PLAN-\d+-[a-z-]+\.md$/);
+    if (!planFile) {
+      console.error(chalk4.red("No plan file found. Run `task0 plan generate` / `task0 plan refine` first, or pass --plan."));
+      process.exit(1);
+    }
+    if (opts.model || opts.effort) {
+      resolveModelOptions(
+        opts.agent,
+        { model: opts.model, effort: opts.effort },
+        opts.json ? void 0 : (m) => console.error(chalk4.dim(m))
+      );
+    }
+    const skillFilePath = resolveSkillFilePath2(loc.projectRoot, PLAN_EXECUTE_SKILL_NAME);
+    const prompt = [
+      `task_id: ${objectId}`,
+      `Skill: ${PLAN_EXECUTE_SKILL_NAME}`,
+      `Plan file: ${planFile}`,
+      opts.commit ? "Commit your changes when done." : "Do NOT commit \u2014 leave changes staged for review."
+      // PR creation is delegated to SKILL.md; the CLI no longer flips a
+      // server-side flag for it. If the operator wants a PR they can say
+      // so in --additional-prompt or invoke the skill again with that.
+    ].filter(Boolean).join("\n");
+    const body = {
+      task_id: objectId,
+      prompt,
+      ...skillFilePath ? { skill_file_path: skillFilePath } : {}
+    };
+    const resp = await api.post(
+      `/api/agents/${encodeURIComponent(opts.agent)}/run`,
+      body
+    );
+    const runtimeId = resp.runtime.id;
+    if (!opts.json) console.log(chalk4.green(`exec runtime ${runtimeId} (plan: ${planFile})`));
+    await updateWorkflow(loc.taskYml, { phase: "executing", runtimes: { exec: runtimeId } });
+    if (opts.wait) {
+      const final = await waitForRuntime(runtimeId, {
+        onTick: (s) => {
+          if (!opts.json) console.log(chalk4.dim(`[exec] ${s.status}${s.phase ? " " + s.phase : ""}`));
+        }
+      });
+      if (final.status === "done") {
+        if (!opts.json) console.log(chalk4.green("exec completed"));
+        if (opts.json) console.log(JSON.stringify({ runtimeId, planFile, result: final.result }, null, 2));
+        return;
+      }
+      console.error(chalk4.red(`exec failed: ${final.error || "unknown"}`));
+      process.exit(1);
+    }
+    if (opts.json) console.log(JSON.stringify({ runtimeId, planFile }, null, 2));
+  } catch (err) {
+    console.error(chalk4.red(err.message));
+    process.exit(1);
+  }
+});
+
+// src/commands/task/summarize.ts
+import { Command as Command5 } from "commander";
+import chalk5 from "chalk";
+init_task_state2();
+var summarize = new Command5("summarize").description("Generate a concise title and tag set for a task (preview by default)").argument("<objectId>", "Task object_id (tsk_XXXXX)").option("--apply", "Write the generated summary to task0.yml (preview-only by default)").option("--json", "Output JSON").action(async (objectId, opts) => {
+  try {
+    resolveTaskByObjectId(objectId);
+    const resp = await api.post(
+      `/api/tasks/${encodeURIComponent(objectId)}/summarize`,
+      { apply: Boolean(opts.apply) }
+    );
+    if (opts.json) {
+      console.log(JSON.stringify(resp, null, 2));
+      return;
+    }
+    const { summary, applied } = resp;
+    const tagList = summary.tags.length > 0 ? summary.tags.join(", ") : chalk5.dim("(none)");
+    const label = applied ? chalk5.green("applied") : chalk5.yellow("preview");
+    console.log(`${label}`);
+    console.log(`  title: ${summary.title}`);
+    console.log(`  tags:  ${tagList}`);
+    console.log(chalk5.dim(`  at:    ${summary.summarized_at}`));
+    if (!applied) {
+      console.log(chalk5.dim("\nRun again with --apply to write summary to task0.yml."));
+    }
+  } catch (err) {
+    console.error(chalk5.red(err.message));
+    process.exit(1);
+  }
+});
+
+// src/commands/task/comment.ts
+import fs12 from "fs";
+import { Command as Command6 } from "commander";
+import chalk6 from "chalk";
+var comment = new Command6("comment").description("Manage comments on a task");
+function fail(err) {
+  console.error(chalk6.red(err.message));
+  process.exit(1);
+}
+function readBodyFromOpts(opts) {
+  if (opts.body !== void 0) return opts.body;
+  if (opts.file === "-") return fs12.readFileSync(0, "utf-8");
+  if (opts.file) return fs12.readFileSync(opts.file, "utf-8");
+  throw new Error("Provide --body or --file");
+}
+function preview(body, width = 60) {
+  const single = body.replace(/\s+/g, " ").trim();
+  return single.length > width ? single.slice(0, width - 1) + "\u2026" : single;
+}
+function printRow(c) {
+  const id = chalk6.cyan(c.id.padEnd(14));
+  const author = chalk6.magenta(c.author.padEnd(12));
+  console.log(`${id} ${author} ${preview(c.body)}  ${chalk6.dim(c.updated_at)}`);
+}
+function printDetail(c) {
+  console.log(`${chalk6.bold("id:")}         ${c.id}`);
+  console.log(`${chalk6.bold("author:")}     ${c.author}`);
+  console.log(`${chalk6.bold("created:")}    ${c.created_at}`);
+  console.log(`${chalk6.bold("updated:")}    ${c.updated_at}`);
+  console.log(chalk6.bold("body:"));
+  console.log(c.body.split("\n").map((l) => "  " + l).join("\n"));
+}
+async function resolveCommentByObjectId(cmtId) {
+  const { type, resource } = await api.get(`/api/resolve/${encodeURIComponent(cmtId)}`);
+  if (type !== "task_comment" || !resource.task_object_id) {
+    throw new Error(`object ${cmtId} is not a task_comment (got ${type})`);
+  }
+  const { task_object_id, ...rest } = resource;
+  return { taskObjectId: task_object_id, comment: rest };
+}
+comment.command("list <taskId>").description("List comments on a task (taskId is short id or tsk_)").option("--json", "Output JSON").action(async (taskId, opts) => {
+  try {
+    const { comments } = await api.get(
+      `/api/tasks/${encodeURIComponent(taskId)}/comments`
+    );
+    if (opts.json) {
+      console.log(JSON.stringify({ comments }, null, 2));
+      return;
+    }
+    if (!comments.length) {
+      console.log(chalk6.dim("No comments."));
+      return;
+    }
+    for (const c of comments) printRow(c);
+  } catch (err) {
+    fail(err);
+  }
+});
+comment.command("add <taskId>").description("Add a comment to a task").option("--body <text>", "Comment body (markdown)").option("--file <path>", "Read body from file (- for stdin)").option("--author <name>", "Author label (default: user)", "user").option("--json", "Output JSON").action(async (taskId, opts) => {
+  try {
+    const body = readBodyFromOpts(opts);
+    const { comment: created } = await api.post(
+      `/api/tasks/${encodeURIComponent(taskId)}/comments`,
+      { body, author: opts.author }
+    );
+    if (opts.json) {
+      console.log(JSON.stringify({ comment: created }, null, 2));
+      return;
+    }
+    console.log(chalk6.green(`Created ${created.id}`));
+    printDetail(created);
+  } catch (err) {
+    fail(err);
+  }
+});
+comment.command("edit <cmtId>").description("Edit a comment by its cmt_ id").option("--body <text>", "New body (markdown)").option("--file <path>", "Read body from file (- for stdin)").option("--json", "Output JSON").action(async (cmtId, opts) => {
+  try {
+    const body = readBodyFromOpts(opts);
+    const { comment: updated } = await api.patch(
+      `/api/comments/${encodeURIComponent(cmtId)}`,
+      { body }
+    );
+    if (opts.json) {
+      console.log(JSON.stringify({ comment: updated }, null, 2));
+      return;
+    }
+    console.log(chalk6.green(`Updated ${updated.id}`));
+    printDetail(updated);
+  } catch (err) {
+    fail(err);
+  }
+});
+comment.command("delete <cmtId>").description("Delete a comment by its cmt_ id").action(async (cmtId) => {
+  try {
+    const { taskObjectId } = await resolveCommentByObjectId(cmtId);
+    await api.del(`/api/comments/${encodeURIComponent(cmtId)}`);
+    console.log(chalk6.green(`Deleted ${cmtId}`) + chalk6.dim(` (task ${taskObjectId})`));
+  } catch (err) {
+    fail(err);
+  }
+});
+
+// src/commands/task/description.ts
+import fs13 from "fs";
+import { Command as Command7 } from "commander";
+import chalk7 from "chalk";
+var description = new Command7("description").description("Show or update the task description");
+function fail2(err) {
+  console.error(chalk7.red(err.message));
+  process.exit(1);
+}
+function readBodyFromOpts2(opts) {
+  if (opts.body !== void 0) return opts.body;
+  if (opts.file === "-") return fs13.readFileSync(0, "utf-8");
+  if (opts.file) return fs13.readFileSync(opts.file, "utf-8");
+  throw new Error("Provide --body or --file (use --file - to read stdin)");
+}
+description.command("show <taskId>").description("Print the current description (taskId is short id or tsk_)").option("--json", "Output JSON").action(async (taskId, opts) => {
+  try {
+    const { type, resource } = await api.get(
+      `/api/resolve/${encodeURIComponent(taskId)}`
+    );
+    if (type !== "task") throw new Error(`object ${taskId} is not a task (got ${type})`);
+    const desc = resource.description ?? "";
+    if (opts.json) {
+      console.log(JSON.stringify({ description: desc }, null, 2));
+      return;
+    }
+    if (!desc) {
+      console.log(chalk7.dim("(no description)"));
+      return;
+    }
+    console.log(desc);
+  } catch (err) {
+    fail2(err);
+  }
+});
+description.command("set <taskId>").description("Replace the task description (markdown)").option("--body <text>", "New description body").option("--file <path>", "Read description from file (- for stdin)").option("--json", "Output JSON").action(async (taskId, opts) => {
+  try {
+    const body = readBodyFromOpts2(opts);
+    const resp = await api.patch(
+      `/api/tasks/${encodeURIComponent(taskId)}/description`,
+      { description: body }
+    );
+    if (opts.json) {
+      console.log(JSON.stringify(resp, null, 2));
+      return;
+    }
+    console.log(chalk7.green("Updated description"));
+  } catch (err) {
+    fail2(err);
+  }
+});
+
+// src/commands/task.ts
+var task = new Command8("task").description("Manage tasks");
+task.addCommand(triage);
+task.addCommand(exec);
+task.addCommand(summarize);
+task.addCommand(comment);
+task.addCommand(description);
+task.command("init <input>").description("Create a task from a description or Linear/GitHub issue URL").action(async (input) => {
+  const cwd = process.cwd();
+  const projectYml = path12.join(cwd, "task0.yml");
+  if (!fs14.existsSync(projectYml)) {
+    console.error(chalk8.red("Not a task0 project (task0.yml not found). Run `task0 project init` first."));
+    process.exit(1);
+  }
+  const projectConfig = yaml5.load(fs14.readFileSync(projectYml, "utf-8"));
+  if (projectConfig.kind !== "project") {
+    console.error(chalk8.red('Invalid task0.yml: kind is not "project"'));
+    process.exit(1);
+  }
+  try {
+    const { task: task2 } = await api.post("/api/tasks/init", { projectPath: cwd, input });
+    console.log(chalk8.green(`Created task "${task2.id}"`));
+    console.log(`  ${task2.path}`);
+  } catch (err) {
+    console.error(chalk8.red(err.message));
+    process.exit(1);
+  }
+});
+task.command("migrate").description("Add task0.yml to legacy task directories that lack one").option("--dry-run", "Show what would be created without writing").action((opts) => {
+  const cwd = process.cwd();
+  const projectYml = path12.join(cwd, "task0.yml");
+  if (!fs14.existsSync(projectYml)) {
+    console.error(chalk8.red("Not a task0 project (task0.yml not found). Run `task0 project init` first."));
+    process.exit(1);
+  }
+  const projectConfig = yaml5.load(fs14.readFileSync(projectYml, "utf-8"));
+  if (projectConfig.kind !== "project") {
+    console.error(chalk8.red('Invalid task0.yml: kind is not "project"'));
+    process.exit(1);
+  }
+  const tasksDir = path12.join(cwd, projectConfig.tasks_dir);
+  if (!fs14.existsSync(tasksDir)) {
+    console.error(chalk8.red(`Tasks directory not found: ${tasksDir}`));
+    process.exit(1);
+  }
+  const entries = fs14.readdirSync(tasksDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+  let migrated = 0;
+  let skipped = 0;
+  let seededObjectIds = 0;
+  for (const name of entries) {
+    const taskDir = path12.join(tasksDir, name);
+    const taskYml = path12.join(taskDir, "task0.yml");
+    if (fs14.existsSync(taskYml)) {
+      skipped++;
+      try {
+        const raw = yaml5.load(fs14.readFileSync(taskYml, "utf-8"));
+        if (raw && raw.kind === "task" && !raw.object_id) {
+          raw.object_id = generateObjectId("task");
+          if (opts.dryRun) {
+            console.log(chalk8.dim(`[dry-run] seed object_id: ${taskYml}`));
+          } else {
+            fs14.writeFileSync(taskYml, yaml5.dump(raw, { lineWidth: 120 }), "utf-8");
+            console.log(chalk8.green(`  seed object_id: ${taskYml}`));
+          }
+          seededObjectIds++;
+        }
+      } catch {
+      }
+      continue;
+    }
+    const match = name.match(/^(\d{8})_(.+)$/);
+    const title = match ? match[2].replace(/[-_]/g, " ") : name;
+    const createdAt = match ? `${match[1].slice(0, 4)}-${match[1].slice(4, 6)}-${match[1].slice(6, 8)}T00:00:00Z` : (/* @__PURE__ */ new Date()).toISOString();
+    const taskConfig = {
+      id: name,
+      object_id: generateObjectId("task"),
+      kind: "task",
+      title,
+      status: "todo",
+      current_step: "",
+      tags: [],
+      created_at: createdAt
+    };
+    if (opts.dryRun) {
+      console.log(chalk8.dim(`[dry-run] ${taskYml}`));
+    } else {
+      fs14.writeFileSync(taskYml, yaml5.dump(taskConfig), "utf-8");
+      console.log(chalk8.green(`  ${taskYml}`));
+    }
+    migrated++;
+  }
+  console.log(`
+Migrated ${migrated} tasks, skipped ${skipped} (already initialized), seeded object_id on ${seededObjectIds}`);
+});
+task.command("list").description("List tasks").option("-s, --status <status>", `Filter by status (${TASK_STATUS_VALUES.join("|")})`).option("--source <name>", "Filter by source name").option("--tag <tag>", "Filter by tag").option("--project <name>", "Filter by project name").option("--all", "Include done and archived tasks").option("--json", "Output JSON").action(async (opts) => {
+  try {
+    const query = opts.source ? `?source=${encodeURIComponent(opts.source)}` : "";
+    const { tasks, errors } = await api.get(`/api/tasks${query}`);
+    let filtered = tasks;
+    if (opts.status) filtered = filtered.filter((t) => t.status === opts.status);
+    if (opts.tag) filtered = filtered.filter((t) => (t.display_tags ?? t.tags ?? []).includes(opts.tag));
+    if (opts.project) filtered = filtered.filter((t) => t.project === opts.project);
+    if (!opts.all && !opts.status) {
+      filtered = filtered.filter((t) => t.status !== "done" && t.status !== "archived");
+    }
+    filtered.sort((a, b) => (b.last_update || b.created_at || "").localeCompare(a.last_update || a.created_at || ""));
+    if (opts.json) {
+      console.log(JSON.stringify(filtered, null, 2));
+      return;
+    }
+    for (const err of errors) console.error(chalk8.red(err));
+    if (filtered.length === 0) {
+      console.log(chalk8.dim("No tasks."));
+      return;
+    }
+    const projectWidth = Math.min(20, Math.max(...filtered.map((t) => t.project.length), 7));
+    const idWidth = Math.min(40, Math.max(...filtered.map((t) => t.id.length), 2));
+    const objectIdWidth = Math.max(...filtered.map((t) => (t.object_id || "").length), 9);
+    for (const t of filtered) {
+      const status = statusColor(t.status)(t.status.padEnd(8));
+      const project2 = chalk8.dim(t.project.padEnd(projectWidth));
+      const objectId = chalk8.cyan((t.object_id || "-").padEnd(objectIdWidth));
+      const id = chalk8.dim(t.id.padEnd(idWidth));
+      const displayTags = t.display_tags ?? t.tags ?? [];
+      const tags = displayTags.length > 0 ? chalk8.dim(` [${displayTags.join(",")}]`) : "";
+      const displayTitle = t.display_title || t.title;
+      console.log(`${status} ${objectId} ${project2} ${id} ${displayTitle}${tags}`);
+    }
+    console.log(chalk8.dim(`
+${filtered.length} tasks${!opts.all && !opts.status ? " (done/archived hidden, --all to show)" : ""}`));
+  } catch (err) {
+    console.error(chalk8.red(err.message));
+    process.exit(1);
+  }
+});
+function statusColor(status) {
+  if (status === "blocked") return chalk8.yellow;
+  if (status === "done") return chalk8.green;
+  if (status === "archived") return chalk8.dim;
+  if (isActiveTaskStatus(status)) return chalk8.cyan;
+  return chalk8.white;
+}
+task.command("done <id>").description("Write task lifecycle state to task0.yml \u2014 defaults to `status: done`; pass `--phase <phase>` to only update workflow.phase").option("--phase <phase>", "Set workflow.phase to this value instead of marking the task done").action(async (id, opts) => {
+  try {
+    const { resolveTaskByObjectId: resolveTaskByObjectId2 } = await Promise.resolve().then(() => (init_task_state2(), task_state_exports));
+    const loc = resolveTaskByObjectId2(id);
+    const raw = yaml5.load(fs14.readFileSync(loc.taskYml, "utf-8"));
+    if (opts.phase) {
+      const phase = opts.phase.trim();
+      if (!phase) {
+        console.error(chalk8.red("--phase value cannot be empty"));
+        process.exit(1);
+      }
+      const workflow2 = raw.workflow ?? {};
+      if (workflow2.phase === phase) {
+        console.log(chalk8.dim(`${id} already at phase ${phase}`));
+        return;
+      }
+      raw.workflow = { ...workflow2, phase };
+      fs14.writeFileSync(loc.taskYml, yaml5.dump(raw, { lineWidth: 120 }), "utf-8");
+      console.log(chalk8.green(`${id} phase: ${phase}`));
+      return;
+    }
+    if (raw.status === "done") {
+      console.log(chalk8.dim(`${id} already done`));
+      return;
+    }
+    raw.status = "done";
+    const workflow = raw.workflow ?? {};
+    raw.workflow = { ...workflow, phase: "completed" };
+    fs14.writeFileSync(loc.taskYml, yaml5.dump(raw, { lineWidth: 120 }), "utf-8");
+    console.log(chalk8.green(`${id} marked as done`));
+  } catch (err) {
+    console.error(chalk8.red(err.message));
+    process.exit(1);
+  }
+});
+task.command("archive <id>").description("Archive a task (append to tasks.tar, remove from tasks/)").action((id) => {
+  const cwd = process.cwd();
+  const projectYml = path12.join(cwd, "task0.yml");
+  if (!fs14.existsSync(projectYml)) {
+    console.error(chalk8.red("Not a task0 project (task0.yml not found)."));
+    process.exit(1);
+  }
+  const projectConfig = yaml5.load(fs14.readFileSync(projectYml, "utf-8"));
+  if (projectConfig.kind !== "project") {
+    console.error(chalk8.red('Invalid task0.yml: kind is not "project"'));
+    process.exit(1);
+  }
+  const tasksDir = path12.join(cwd, projectConfig.tasks_dir);
+  const taskDir = path12.join(tasksDir, id);
+  if (!fs14.existsSync(taskDir)) {
+    console.error(chalk8.red(`Task "${id}" not found at ${taskDir}`));
+    process.exit(1);
+  }
+  const tarFile = tasksDir + ".tar";
+  archiveTaskToTar(tasksDir, id, tarFile);
+  fs14.rmSync(taskDir, { recursive: true });
+  console.log(chalk8.green(`Archived "${id}" \u2192 ${tarFile}`));
+});
+function archiveTaskToTar(tasksDir, taskId, tarFile) {
+  if (fs14.existsSync(tarFile) && !fs14.statSync(tarFile).isFile()) {
+    console.error(chalk8.red(`${tarFile} exists but is not a file (likely a leftover directory). Remove it manually first.`));
+    process.exit(1);
+  }
+  if (fs14.existsSync(tarFile)) {
+    execSync(`tar -rf ${JSON.stringify(tarFile)} -C ${JSON.stringify(tasksDir)} ${JSON.stringify(taskId)}`);
+  } else {
+    execSync(`tar -cf ${JSON.stringify(tarFile)} -C ${JSON.stringify(tasksDir)} ${JSON.stringify(taskId)}`);
+  }
+}
+
+// src/commands/ui.ts
+import { Command as Command9 } from "commander";
+import { spawn } from "child_process";
+import path13 from "path";
+import chalk9 from "chalk";
+var DASHBOARD_DIR = path13.resolve(
+  import.meta.dirname,
+  "..",
+  "..",
+  "..",
+  "dashboard"
+);
+var ui = new Command9("ui").description("Launch the dashboard").option("-p, --port <port>", "Port number", "5173").option("-H, --host <address>", "Bind address (use 0.0.0.0 for LAN access)", "localhost").option("--no-open", "Do not open browser").action((opts) => {
+  console.log(chalk9.green("Starting dashboard..."));
+  const args = ["dev", "--port", opts.port, "--host", opts.host];
+  if (opts.open) args.push("--open");
+  const child = spawn("pnpm", args, {
+    cwd: DASHBOARD_DIR,
+    stdio: "inherit",
+    shell: true
+  });
+  child.on("error", (err) => {
+    console.error(chalk9.red(`Failed to start dashboard: ${err.message}`));
+    process.exit(1);
+  });
+  child.on("exit", (code) => {
+    process.exit(code ?? 0);
+  });
+  process.on("SIGINT", () => child.kill("SIGINT"));
+  process.on("SIGTERM", () => child.kill("SIGTERM"));
+});
+
+// src/commands/serve.ts
+import { Command as Command10 } from "commander";
+import { spawn as spawn2 } from "child_process";
+import fs15 from "fs";
+import path14 from "path";
+import chalk10 from "chalk";
+var SERVER_DIR = path14.resolve(
+  import.meta.dirname,
+  "..",
+  "..",
+  "..",
+  "server"
+);
+var HTTP_ENTRY = path14.join(SERVER_DIR, "src", "main.ts");
+var CLI_TSX = path14.resolve(
+  import.meta.dirname,
+  "..",
+  "..",
+  "node_modules",
+  ".bin",
+  "tsx"
+);
+var serve = new Command10("serve").description("Run the headless task0 API server").option("-p, --port <port>", "Port number", "4318").option("-H, --host <address>", "Bind address", "127.0.0.1").action((opts) => {
+  if (!fs15.existsSync(HTTP_ENTRY)) {
+    console.error(chalk10.red(`Server entry not found: ${HTTP_ENTRY}`));
+    process.exit(1);
+  }
+  if (!fs15.existsSync(CLI_TSX)) {
+    console.error(chalk10.red(`tsx not found at ${CLI_TSX}. Run \`pnpm install\` in the CLI package.`));
+    process.exit(1);
+  }
+  console.log(chalk10.green(`Starting task0 API on http://${opts.host}:${opts.port}`));
+  const child = spawn2(CLI_TSX, [HTTP_ENTRY], {
+    cwd: SERVER_DIR,
+    stdio: "inherit",
+    env: {
+      ...process.env,
+      TASK0_API_PORT: opts.port,
+      TASK0_API_HOST: opts.host
+    }
+  });
+  child.on("error", (err) => {
+    console.error(chalk10.red(`Failed to start server: ${err.message}`));
+    process.exit(1);
+  });
+  child.on("exit", (code) => {
+    process.exit(code ?? 0);
+  });
+  process.on("SIGINT", () => child.kill("SIGINT"));
+  process.on("SIGTERM", () => child.kill("SIGTERM"));
+});
+
+// src/commands/models.ts
+import { Command as Command11 } from "commander";
+import chalk11 from "chalk";
+
+// ../../packages/shared/dist/types/agent.js
+var AGENT_KINDS = ["coding", "llm_api", "workflow"];
+var AGENT_KIND_SET = new Set(AGENT_KINDS);
+var CODING_RUNTIME_AGENTS = ["claude-code", "codex", "cursor"];
+var CODING_RUNTIME_AGENT_SET = new Set(CODING_RUNTIME_AGENTS);
+function isCodingRuntimeAgent(value) {
+  return typeof value === "string" && CODING_RUNTIME_AGENT_SET.has(value);
+}
+
+// ../../packages/shared/dist/types/runtime.js
+var RUNTIME_STATUS_VALUES = ["starting", "running", "done", "error"];
+var RUNTIME_STATUS_SET = new Set(RUNTIME_STATUS_VALUES);
+var RUNTIME_AGENTS = CODING_RUNTIME_AGENTS;
+var isRuntimeAgent = isCodingRuntimeAgent;
+var AGENT_MODEL_DEFAULTS = {
+  "claude-code": [
+    { id: "opus", label: "Opus" },
+    { id: "sonnet", label: "Sonnet" },
+    { id: "haiku", label: "Haiku" }
+  ],
+  codex: [
+    { id: "gpt-5.4", label: "GPT-5.4" },
+    { id: "o3", label: "o3" },
+    { id: "o4-mini", label: "o4-mini" }
+  ],
+  cursor: [
+    { id: "", label: "Default" },
+    { id: "gpt-5", label: "GPT-5" },
+    { id: "sonnet-4", label: "Sonnet 4" },
+    { id: "sonnet-4-thinking", label: "Sonnet 4 Thinking" }
+  ]
+};
+function defaultAgentModelFetchCommand(agent2) {
+  if (agent2 === "cursor")
+    return "cursor-agent models";
+  return void 0;
+}
+function defaultAgentModelOutputFormat(agent2) {
+  if (agent2 === "cursor")
+    return "lines";
+  return void 0;
+}
+
+// src/core/agent-models.ts
+import { execSync as execSync2 } from "child_process";
+var ANSI_ESCAPE_RE = new RegExp(String.raw`\u001B\[[0-9;]*[A-Za-z]`, "g");
+var MODEL_ID_RE = /^[A-Za-z0-9._:+/-]+$/;
+function builtinModelsFor(agent2) {
+  return AGENT_MODEL_DEFAULTS[agent2].map((model) => ({ ...model }));
+}
+function stripAnsi(value) {
+  return value.replace(ANSI_ESCAPE_RE, "");
+}
+function ensureAgentModels(config) {
+  if (!config.agentModels) config.agentModels = {};
+  for (const agent2 of RUNTIME_AGENTS) {
+    const current = config.agentModels[agent2];
+    if (current) continue;
+    const fetchCommand = defaultAgentModelFetchCommand(agent2);
+    const outputFormat = defaultAgentModelOutputFormat(agent2);
+    config.agentModels[agent2] = {
+      models: builtinModelsFor(agent2),
+      ...fetchCommand ? { fetchCommand } : {},
+      ...outputFormat ? { outputFormat } : {}
+    };
+  }
+  return config.agentModels;
+}
+function cacheEntryForAgent(config, agent2) {
+  return ensureAgentModels(config)[agent2] ?? { models: builtinModelsFor(agent2) };
+}
+function normalizeLineModel(line) {
+  const cleaned = stripAnsi(line).trim().replace(/^[*-]\s+/, "");
+  if (!cleaned) return null;
+  if (/^loading\b/i.test(cleaned)) return null;
+  if (/^available models\b/i.test(cleaned)) return null;
+  if (/^(tip|note|usage)\b[:\s-]/i.test(cleaned)) return null;
+  const idLabelMatch = cleaned.match(/^([A-Za-z0-9._:-]+)\s+-\s+(.+)$/);
+  if (idLabelMatch) return { id: idLabelMatch[1], label: idLabelMatch[2].trim() };
+  const labelIdMatch = cleaned.match(/^(.+?)\s+\(([A-Za-z0-9._:-]+)\)$/);
+  if (labelIdMatch) return { id: labelIdMatch[2], label: labelIdMatch[1].trim() };
+  if (!MODEL_ID_RE.test(cleaned)) return null;
+  return { id: cleaned, label: cleaned };
+}
+function parseJsonModels(raw) {
+  const parsed = JSON.parse(raw);
+  const source2 = Array.isArray(parsed) ? parsed : parsed && typeof parsed === "object" && Array.isArray(parsed.models) ? parsed.models : null;
+  if (!source2) return [];
+  return source2.flatMap((item) => {
+    if (typeof item === "string" && item.trim()) {
+      return [{ id: item.trim(), label: item.trim() }];
+    }
+    if (!item || typeof item !== "object") return [];
+    const record = item;
+    const id = typeof record.id === "string" && record.id.trim() ? record.id.trim() : typeof record.value === "string" && record.value.trim() ? record.value.trim() : "";
+    if (!id) return [];
+    const label = typeof record.label === "string" && record.label.trim() ? record.label.trim() : typeof record.name === "string" && record.name.trim() ? record.name.trim() : id;
+    return [{
+      id,
+      label,
+      ...typeof record.alias === "string" && record.alias.trim() ? { alias: record.alias.trim() } : {}
+    }];
+  });
+}
+function dedupeModels(models2) {
+  const deduped = /* @__PURE__ */ new Map();
+  for (const model of models2) {
+    const id = model.id.trim();
+    if (!id && model.label !== "Default") continue;
+    deduped.set(id, {
+      id,
+      ...model.label ? { label: model.label.trim() } : {},
+      ...model.alias ? { alias: model.alias.trim() } : {}
+    });
+  }
+  return [...deduped.values()];
+}
+function parseCommandOutput(output, format) {
+  const normalized = output.trim();
+  if (!normalized) return [];
+  if (format === "json") {
+    return dedupeModels(parseJsonModels(normalized));
+  }
+  return dedupeModels(
+    normalized.split(/\r?\n/).flatMap((line) => {
+      const parsed = normalizeLineModel(line);
+      return parsed ? [parsed] : [];
+    })
+  );
+}
+function refreshAgentModelsInConfig(config, agent2) {
+  const entry = cacheEntryForAgent(config, agent2);
+  const aliases = new Map((entry.models ?? []).map((model) => [model.id, model.alias]));
+  let models2 = builtinModelsFor(agent2);
+  let source2 = "builtin";
+  if (entry.fetchCommand?.trim()) {
+    try {
+      const output = execSync2(entry.fetchCommand, {
+        encoding: "utf-8",
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      const parsed = parseCommandOutput(output, entry.outputFormat ?? "lines");
+      if (parsed.length === 0) {
+        throw new Error("no models detected in command output");
+      }
+      models2 = parsed;
+      source2 = "command";
+    } catch (error2) {
+      const stdout = error2 && typeof error2 === "object" && "stdout" in error2 && typeof error2.stdout === "string" ? error2.stdout : "";
+      const stderr = error2 && typeof error2 === "object" && "stderr" in error2 && typeof error2.stderr === "string" ? error2.stderr : "";
+      const details = stripAnsi(`${stdout}
+${stderr}`).trim();
+      throw new Error(details || `failed to refresh ${agent2} models`);
+    }
+  }
+  const mergedModels = models2.map((model) => ({
+    ...model,
+    ...aliases.get(model.id)?.trim() ? { alias: aliases.get(model.id).trim() } : {}
+  }));
+  ensureAgentModels(config)[agent2] = {
+    ...entry,
+    models: mergedModels,
+    fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  return {
+    agent: agent2,
+    source: source2,
+    modelCount: mergedModels.length,
+    ...entry.fetchCommand?.trim() ? { fetchCommand: entry.fetchCommand.trim() } : {}
+  };
+}
+function refreshAgentModels(agent2) {
+  const config = loadConfig();
+  const targets = agent2 ? [agent2] : RUNTIME_AGENTS;
+  const results = [];
+  const failures = [];
+  for (const target of targets) {
+    try {
+      results.push(refreshAgentModelsInConfig(config, target));
+    } catch (error2) {
+      failures.push({
+        agent: target,
+        error: error2 instanceof Error ? error2.message : String(error2)
+      });
+    }
+  }
+  if (results.length > 0) {
+    saveConfig(config);
+  }
+  return { results, failures };
+}
+
+// src/commands/models.ts
+function parseAgent(raw) {
+  const trimmed = raw.trim();
+  if (!isRuntimeAgent(trimmed)) {
+    console.error(chalk11.red(`Invalid agent "${raw}" (expected one of ${RUNTIME_AGENTS.join(", ")})`));
+    process.exit(1);
+  }
+  return trimmed;
+}
+var models = new Command11("models").description("Manage cached agent model lists");
+models.command("refresh").description("Refresh cached agent model lists into local config").option("-a, --agent <agent>", "Refresh a single agent only (claude-code, codex, cursor)").action((opts) => {
+  const agent2 = opts.agent ? parseAgent(opts.agent) : void 0;
+  try {
+    const summary = refreshAgentModels(agent2);
+    for (const result of summary.results) {
+      const source2 = result.source === "command" ? chalk11.cyan("command") : chalk11.dim("builtin");
+      console.log(chalk11.green(`Refreshed ${result.agent}`) + `  ${source2}  ${result.modelCount} models`);
+      if (result.fetchCommand) {
+        console.log(chalk11.dim(`  ${result.fetchCommand}`));
+      }
+    }
+    for (const failure of summary.failures) {
+      console.error(chalk11.red(`Failed ${failure.agent}: ${failure.error}`));
+    }
+    if (summary.failures.length > 0) {
+      process.exit(1);
+    }
+  } catch (error2) {
+    console.error(chalk11.red(error2 instanceof Error ? error2.message : String(error2)));
+    process.exit(1);
+  }
+});
+models.command("default <agent>").description("Get or set default model / effort for an agent").option("--model <id>", 'Set default model id (pass "" to clear)').option("--effort <level>", 'Set default effort (pass "" to clear)').action((rawAgent, opts) => {
+  const agent2 = parseAgent(rawAgent);
+  const config = loadConfig();
+  const agentModels = config.agentModels ?? (config.agentModels = {});
+  const entry = agentModels[agent2] ?? (agentModels[agent2] = {});
+  const wroteModel = opts.model !== void 0;
+  const wroteEffort = opts.effort !== void 0;
+  if (wroteModel) {
+    const trimmed = opts.model.trim();
+    if (trimmed) entry.defaultModel = trimmed;
+    else delete entry.defaultModel;
+  }
+  if (wroteEffort) {
+    const trimmed = opts.effort.trim();
+    if (trimmed) entry.defaultEffort = trimmed;
+    else delete entry.defaultEffort;
+  }
+  if (wroteModel || wroteEffort) {
+    saveConfig(config);
+  }
+  console.log(chalk11.green(agent2));
+  console.log(`  model:  ${entry.defaultModel ?? chalk11.dim("(unset)")}`);
+  console.log(`  effort: ${entry.defaultEffort ?? chalk11.dim("(unset)")}`);
+});
+
+// src/commands/runtime.ts
+import { Command as Command12 } from "commander";
+import chalk12 from "chalk";
+import { spawn as spawn3 } from "child_process";
+var runtime = new Command12("runtime").description("Inspect and control runtimes");
+runtime.command("list").description("List active runtimes").option("--json", "Output JSON").option("--task <id>", "Filter by task id").action(async (opts) => {
+  try {
+    const { runtimes } = await api.get("/api/runtimes");
+    const filtered = opts.task ? runtimes.filter((r) => r.taskId === opts.task) : runtimes;
+    if (opts.json) {
+      console.log(JSON.stringify(filtered, null, 2));
+      return;
+    }
+    if (filtered.length === 0) {
+      console.log(chalk12.dim("No runtimes."));
+      return;
+    }
+    const objectIdWidth = Math.max(...filtered.map((r) => (r.objectId || "").length), 8);
+    for (const r of filtered) {
+      const statusColor2 = r.status === "done" ? chalk12.green : r.status === "error" ? chalk12.red : r.status === "running" ? chalk12.cyan : chalk12.dim;
+      const objectId = chalk12.cyan((r.objectId || "-").padEnd(objectIdWidth));
+      console.log(`${statusColor2(r.status.padEnd(8))} ${objectId} ${chalk12.dim(r.type.padEnd(12))} ${r.taskId.padEnd(30)} ${chalk12.dim(r.id)}`);
+    }
+  } catch (err) {
+    console.error(chalk12.red(err.message));
+    process.exit(1);
+  }
+});
+runtime.command("show <id>").description("Show runtime details").option("--json", "Output JSON").action(async (id, opts) => {
+  try {
+    const r = await getRuntime(id);
+    if (opts.json) {
+      console.log(JSON.stringify(r, null, 2));
+      return;
+    }
+    console.log(`${chalk12.bold("id:")}       ${r.id}`);
+    if (r.objectId) console.log(`${chalk12.bold("object_id:")} ${r.objectId}`);
+    console.log(`${chalk12.bold("type:")}     ${r.type}`);
+    console.log(`${chalk12.bold("agent:")}    ${r.agent}`);
+    console.log(`${chalk12.bold("task:")}     ${r.taskId}`);
+    console.log(`${chalk12.bold("status:")}   ${r.status}`);
+    if (r.phase) console.log(`${chalk12.bold("phase:")}    ${r.phase}`);
+    if (r.error) console.log(`${chalk12.red("error:")}    ${r.error}`);
+    console.log(`${chalk12.bold("tmux:")}     ${r.tmuxSession} (alive: ${r.sessionAlive ?? "unknown"})`);
+    if (r.result) {
+      console.log(chalk12.bold("result:"));
+      console.log("  " + JSON.stringify(r.result, null, 2).split("\n").join("\n  "));
+    }
+  } catch (err) {
+    console.error(chalk12.red(err.message));
+    process.exit(1);
+  }
+});
+runtime.command("wait <id>").description("Block until runtime reaches done or error").option("--timeout <seconds>", "Max seconds to wait", "1800").option("--json", "Output final JSON").action(async (id, opts) => {
+  try {
+    const final = await waitForRuntime(id, {
+      timeoutMs: Number(opts.timeout) * 1e3,
+      onTick: (s) => {
+        if (!opts.json) console.log(chalk12.dim(`[${s.status}] ${s.phase ?? ""}`));
+      }
+    });
+    if (opts.json) {
+      console.log(JSON.stringify(final, null, 2));
+    }
+    process.exit(final.status === "done" ? 0 : 1);
+  } catch (err) {
+    console.error(chalk12.red(err.message));
+    process.exit(1);
+  }
+});
+runtime.command("cancel <id>").description("Cancel a runtime").action(async (id) => {
+  try {
+    await api.post(`/api/runtimes/${encodeURIComponent(id)}/cancel`);
+    console.log(chalk12.green(`Canceled ${id}`));
+  } catch (err) {
+    console.error(chalk12.red(err.message));
+    process.exit(1);
+  }
+});
+runtime.command("attach <id>").description("Attach to the tmux session backing a runtime").action(async (id) => {
+  try {
+    const r = await getRuntime(id);
+    if (!r.tmuxSession) {
+      console.error(chalk12.red("No tmux session recorded for this runtime."));
+      process.exit(1);
+    }
+    const child = spawn3("tmux", ["attach", "-t", r.tmuxSession], { stdio: "inherit" });
+    child.on("exit", (code) => process.exit(code ?? 0));
+    child.on("error", (err) => {
+      console.error(chalk12.red(`Failed to attach: ${err.message}`));
+      process.exit(1);
+    });
+  } catch (err) {
+    console.error(chalk12.red(err.message));
+    process.exit(1);
+  }
+});
+
+// src/commands/plan.ts
+import { Command as Command13 } from "commander";
+import chalk13 from "chalk";
+import fs16 from "fs";
+import path15 from "path";
+init_task_state2();
+var PLAN_GENERATE_SKILL_NAME = "plan-generate";
+function resolveSkillFilePath3(projectRoot, skillName) {
+  const p = path15.join(projectRoot, ".claude", "skills", skillName, "SKILL.md");
+  return fs16.existsSync(p) ? p : null;
+}
+var plan = new Command13("plan").description("Generate and refine plans");
+plan.command("generate <objectId>").description("Generate plan(s) from an IDEA file \u2014 supports agent fan-out").option("-a, --agents <list>", "Comma-separated agents (claude-code,codex,cursor)", "codex,claude-code").option("--model <id>", "Model id or alias \u2014 only with a single agent; use `task0 models default` for fan-out").option("--effort <level>", "Reasoning effort \u2014 only with a single agent; use `task0 models default` for fan-out").option("--idea <file>", "IDEA file name (default: latest IDEA-NN.md)").option("--additional-prompt <text>", "Extra prompt content").option("--wait", "Wait for completion").option("--force", "Overwrite existing plan files").option("--json", "Output JSON").action(async (objectId, opts) => {
+  try {
+    const loc = resolveTaskByObjectId(objectId);
+    const ideaFile = opts.idea || latestArtifact(loc.taskDir, /^IDEA-\d+\.md$/);
+    if (!ideaFile) {
+      console.error(chalk13.red(`No IDEA-NN.md found in ${loc.taskDir}. Pass --idea.`));
+      process.exit(1);
+    }
+    const agents = opts.agents.split(",").map((a) => a.trim()).filter(Boolean);
+    if (agents.length === 0) {
+      console.error(chalk13.red("No agents specified."));
+      process.exit(1);
+    }
+    if ((opts.model || opts.effort) && agents.length > 1) {
+      console.error(chalk13.red(
+        `--model/--effort only works with a single agent; got ${agents.length} (${agents.join(", ")}). Use \`task0 models default <agent>\` to set per-agent defaults for fan-out.`
+      ));
+      process.exit(1);
+    }
+    const warn = opts.json ? void 0 : (m) => console.error(chalk13.dim(m));
+    const skillFilePath = resolveSkillFilePath3(loc.projectRoot, PLAN_GENERATE_SKILL_NAME);
+    if (opts.model || opts.effort) {
+      resolveModelOptions(agents[0], { model: opts.model, effort: opts.effort }, warn);
+    }
+    const promptForAgent = (agent2) => {
+      const lines = [
+        `task_id: ${objectId}`,
+        `Skill: ${PLAN_GENERATE_SKILL_NAME}`,
+        `Idea file: ${ideaFile}`,
+        `Target plan file: PLAN-${ideaFile.match(/^IDEA-(\d+)\.md$/)?.[1] ?? "01"}-${agent2}.md`,
+        opts.force ? "Overwrite existing plan file." : "",
+        opts.additionalPrompt ? "" : "",
+        opts.additionalPrompt || ""
+      ].filter((line) => line !== "");
+      return lines.join("\n");
+    };
+    const kicks = await Promise.all(agents.map(async (agent2) => {
+      const body = {
+        task_id: objectId,
+        prompt: promptForAgent(agent2),
+        ...skillFilePath ? { skill_file_path: skillFilePath } : {}
+      };
+      try {
+        const resp = await api.post(
+          `/api/agents/${encodeURIComponent(agent2)}/run`,
+          body
+        );
+        return {
+          agent: agent2,
+          runtimeId: resp.runtime.id,
+          sessionName: "",
+          error: null
+        };
+      } catch (err) {
+        return { agent: agent2, runtimeId: "", sessionName: "", error: err.message };
+      }
+    }));
+    const launched = kicks.filter((k) => !k.error);
+    const failed = kicks.filter((k) => k.error);
+    if (!opts.json) {
+      for (const k of launched) {
+        console.log(chalk13.green(`[${k.agent}]`) + ` runtime ${k.runtimeId}`);
+      }
+      for (const k of failed) {
+        console.error(chalk13.red(`[${k.agent}] ${k.error}`));
+      }
+    }
+    const runtimeIds = {};
+    for (const k of launched) runtimeIds[k.agent] = k.runtimeId;
+    await updateWorkflow(loc.taskYml, {
+      runtimes: { plan: runtimeIds }
+    });
+    const planFiles = [];
+    if (opts.wait) {
+      const results = await Promise.all(launched.map(async (k) => {
+        try {
+          const final = await waitForRuntime(k.runtimeId, {
+            onTick: (s) => {
+              if (!opts.json) console.log(chalk13.dim(`[${k.agent}] ${s.status}${s.phase ? " " + s.phase : ""}`));
+            }
+          });
+          return { agent: k.agent, final, error: null };
+        } catch (err) {
+          return { agent: k.agent, final: null, error: err.message };
+        }
+      }));
+      for (const r of results) {
+        if (r.final?.status === "done") {
+          const planFile = r.final.result?.planFile;
+          if (planFile) {
+            planFiles.push(planFile);
+            if (!opts.json) console.log(chalk13.green(`[${r.agent}] ${planFile}`));
+          }
+        } else {
+          if (!opts.json) console.error(chalk13.red(`[${r.agent}] failed: ${r.error || r.final?.error || "unknown"}`));
+        }
+      }
+      const existingPlanFiles = readWorkflow(loc.taskYml).plan_files || [];
+      await updateWorkflow(loc.taskYml, {
+        phase: "planned",
+        plan_files: Array.from(/* @__PURE__ */ new Set([...planFiles, ...existingPlanFiles]))
+      });
+    }
+    if (opts.json) {
+      console.log(JSON.stringify({ ideaFile, launched, failed, planFiles }, null, 2));
+    }
+    if (failed.length > 0) process.exit(1);
+  } catch (err) {
+    console.error(chalk13.red(err.message));
+    process.exit(1);
+  }
+});
+var PLAN_REFINE_SKILL_NAME = "plan-refine";
+plan.command("refine <objectId>").description("Synthesize plan files + ISSUE files into a refined plan").option("--agent <name>", "Agent to run refine (claude-code|codex)", "claude-code").option("--model <id>", "Model id or alias (see `task0 models refresh`)").option("--effort <level>", "Reasoning effort (e.g. low|medium|high)").option("--wait", "Wait for completion").option("--json", "Output JSON").action(async (objectId, opts) => {
+  try {
+    const loc = resolveTaskByObjectId(objectId);
+    const files = fs16.readdirSync(loc.taskDir);
+    const planFiles = files.filter((f) => /^PLAN-\d+-(codex|claude-code|cursor)\.md$/.test(f));
+    if (planFiles.length === 0) {
+      console.error(chalk13.red("No PLAN-NN-<agent>.md files found. Run `task0 plan generate` first."));
+      process.exit(1);
+    }
+    const idx = planFiles[0].match(/^PLAN-(\d+)/)?.[1] || nextArtifactIndex(loc.taskDir, "PLAN");
+    const refinedFile = `PLAN-${idx}-refined.md`;
+    if (opts.model || opts.effort) {
+      resolveModelOptions(
+        opts.agent,
+        { model: opts.model, effort: opts.effort },
+        opts.json ? void 0 : (m) => console.error(chalk13.dim(m))
+      );
+    }
+    const skillFilePath = resolveSkillFilePath3(loc.projectRoot, PLAN_REFINE_SKILL_NAME);
+    const prompt = [
+      `task_id: ${objectId}`,
+      `Skill: ${PLAN_REFINE_SKILL_NAME}`,
+      `Target file: ${refinedFile}`,
+      `Source plans: ${planFiles.join(", ")}`
+    ].join("\n");
+    const body = {
+      task_id: objectId,
+      prompt,
+      ...skillFilePath ? { skill_file_path: skillFilePath } : {}
+    };
+    const resp = await api.post(
+      `/api/agents/${encodeURIComponent(opts.agent)}/run`,
+      body
+    );
+    const runtimeId = resp.runtime.id;
+    if (!opts.json) console.log(chalk13.green(`refine runtime ${runtimeId}`));
+    await updateWorkflow(loc.taskYml, {
+      runtimes: { refine: runtimeId }
+    });
+    if (opts.wait) {
+      const final = await waitForRuntime(runtimeId, {
+        onTick: (s) => {
+          if (!opts.json) console.log(chalk13.dim(`[refine] ${s.status}${s.phase ? " " + s.phase : ""}`));
+        }
+      });
+      const refinedPath = path15.join(loc.taskDir, refinedFile);
+      const wrote = fs16.existsSync(refinedPath);
+      if (final.status === "done" && wrote) {
+        await updateWorkflow(loc.taskYml, {
+          phase: "refined",
+          refined_plan_file: refinedFile
+        });
+        if (!opts.json) console.log(chalk13.green(refinedFile));
+        if (opts.json) console.log(JSON.stringify({ runtimeId, refinedFile }, null, 2));
+        return;
+      }
+      if (final.status !== "done") {
+        console.error(chalk13.red(`refine failed: ${final.error || "unknown"}`));
+      } else if (!wrote) {
+        console.error(chalk13.red(`refine completed but ${refinedFile} was not written`));
+      }
+      process.exit(1);
+    }
+    if (opts.json) console.log(JSON.stringify({ runtimeId, refinedFile }, null, 2));
+  } catch (err) {
+    console.error(chalk13.red(err.message));
+    process.exit(1);
+  }
+});
+
+// src/commands/run.ts
+init_task_state2();
+import { Command as Command14 } from "commander";
+import chalk14 from "chalk";
+import { spawnSync as spawnSync3 } from "child_process";
+var PHASES = ["triage", "plan", "refine", "exec"];
+var PAUSE_AFTER = /* @__PURE__ */ new Set(["refine"]);
+var CHECKPOINT_EXIT = 78;
+function nextPhaseFromWorkflow(wf) {
+  switch (wf.phase) {
+    case void 0:
+      return "triage";
+    case "triaged":
+      return "plan";
+    case "planned":
+      return "refine";
+    case "refined":
+      return "exec";
+    case "executing":
+    case "completed":
+      return null;
+  }
+}
+var run = new Command14("run").description("Run the full task orchestration (triage \u2192 plan \u2192 refine \u2192 exec)").argument("<objectId>", "Task object_id (tsk_XXXXX)").option("--from <phase>", "Start from phase (triage|plan|refine|exec)").option("--to <phase>", "Stop after phase").option("--auto", "Skip pauses (no exit 78 at checkpoints)").option("--planners <list>", "Comma-separated plan agents", "codex,claude-code").option("--executor <agent>", "Executor agent", "claude-code").option("--triage-agent <agent>", "Triage agent", "claude-code").option("--refine-agent <agent>", "Refine agent", "claude-code").option("--json", "Output JSON summary at end").action(async (objectId, opts) => {
+  try {
+    const loc = resolveTaskByObjectId(objectId);
+    const wf = readWorkflow(loc.taskYml);
+    const fromCandidate = opts.from ?? nextPhaseFromWorkflow(wf);
+    if (!fromCandidate) {
+      if (!opts.json) console.log(chalk14.dim(`Nothing to do \u2014 workflow phase is "${wf.phase}".`));
+      return;
+    }
+    const from = fromCandidate;
+    const to = opts.to || "exec";
+    if (!PHASES.includes(from)) throw new Error(`Invalid --from: ${from}`);
+    if (!PHASES.includes(to)) throw new Error(`Invalid --to: ${to}`);
+    const fromIdx = PHASES.indexOf(from);
+    const toIdx = PHASES.indexOf(to);
+    if (fromIdx > toIdx) throw new Error(`--from (${from}) is past --to (${to})`);
+    if (!opts.json) {
+      console.log(chalk14.bold(`task0 run ${objectId}`) + chalk14.dim(` \u2014 ${from} \u2192 ${to}`));
+    }
+    for (let i = fromIdx; i <= toIdx; i++) {
+      const phase = PHASES[i];
+      if (!opts.json) console.log(chalk14.bold.cyan(`
+\u25B6 ${phase}`));
+      const code = runPhase(phase, objectId, opts);
+      if (code !== 0) {
+        console.error(chalk14.red(`Phase "${phase}" failed (exit ${code}). Resume with: task0 run ${objectId} --from ${phase}`));
+        process.exit(code);
+      }
+      if (!opts.auto && PAUSE_AFTER.has(phase) && i < toIdx) {
+        const next = PHASES[i + 1];
+        if (!opts.json) {
+          console.log(chalk14.yellow(`
+\u23F8  checkpoint after ${phase}. Review and resume with:`));
+          console.log(chalk14.yellow(`   task0 run ${objectId} --from ${next}`));
+        }
+        process.exit(CHECKPOINT_EXIT);
+      }
+    }
+    const finalWf = readWorkflow(loc.taskYml);
+    if (opts.json) {
+      console.log(JSON.stringify({ objectId, from, to, workflow: finalWf }, null, 2));
+    } else {
+      console.log(chalk14.green(`
+\u2713 done (phase: ${finalWf.phase})`));
+    }
+  } catch (err) {
+    console.error(chalk14.red(err.message));
+    process.exit(1);
+  }
+});
+function runPhase(phase, objectId, opts) {
+  const cli = process.argv[1];
+  const node = process.argv[0];
+  let args = [];
+  switch (phase) {
+    case "triage":
+      args = ["task", "triage", objectId, "--wait", "--agent", opts.triageAgent];
+      break;
+    case "plan":
+      args = ["plan", "generate", objectId, "--wait", "--agents", opts.planners];
+      break;
+    case "refine":
+      args = ["plan", "refine", objectId, "--wait", "--agent", opts.refineAgent];
+      break;
+    case "exec":
+      args = ["task", "exec", objectId, "--wait", "--agent", opts.executor];
+      break;
+  }
+  const r = spawnSync3(node, [cli, ...args], { stdio: "inherit" });
+  return r.status ?? 1;
+}
+run.command("status <objectId>").description("Show current workflow state").option("--json", "Output JSON").action((objectId, opts) => {
+  try {
+    const loc = resolveTaskByObjectId(objectId);
+    const wf = readWorkflow(loc.taskYml);
+    if (opts.json) {
+      console.log(JSON.stringify(wf, null, 2));
+      return;
+    }
+    console.log(`${chalk14.bold("phase:")}           ${wf.phase ?? chalk14.dim("(not started)")}`);
+    if (wf.issue_overview) {
+      const extra = wf.issue_files?.length ? ` (+${wf.issue_files.length} details)` : "";
+      console.log(`${chalk14.bold("issues:")}          ${wf.issue_overview}${extra}`);
+    }
+    if (wf.plan_files?.length) console.log(`${chalk14.bold("plans:")}           ${wf.plan_files.join(", ")}`);
+    if (wf.refined_plan_file) console.log(`${chalk14.bold("refined:")}         ${wf.refined_plan_file}`);
+    if (wf.runtimes) {
+      console.log(chalk14.bold("runtimes:"));
+      for (const [k, v] of Object.entries(wf.runtimes)) {
+        console.log(`  ${k.padEnd(8)} ${typeof v === "string" ? v : JSON.stringify(v)}`);
+      }
+    }
+    if (wf.updated_at) console.log(chalk14.dim(`updated_at: ${wf.updated_at}`));
+  } catch (err) {
+    console.error(chalk14.red(err.message));
+    process.exit(1);
+  }
+});
+
+// src/commands/okr.ts
+import { Command as Command15 } from "commander";
+import chalk15 from "chalk";
+
+// src/lib/project.ts
+import path16 from "path";
+import fs17 from "fs";
+function resolveProjectName(opts) {
+  if (opts.project && opts.project.length > 0) return opts.project;
+  const config = loadConfig();
+  const projects = config.sources.filter((s) => s.type === "project" && s.enabled !== false);
+  if (projects.length === 0) {
+    throw new Error(
+      "Cannot resolve project: no registered projects. Use `task0 source add <path>` first, or pass --project <name>."
+    );
+  }
+  const cwd = fs17.realpathSync(process.cwd());
+  for (const source2 of projects) {
+    let sourceAbs;
+    try {
+      sourceAbs = fs17.realpathSync(path16.resolve(source2.path));
+    } catch {
+      sourceAbs = path16.resolve(source2.path);
+    }
+    if (cwd === sourceAbs || cwd.startsWith(sourceAbs + path16.sep)) {
+      return source2.name;
+    }
+  }
+  throw new Error(
+    "Cannot resolve project from cwd. Pass --project <name> or run from a registered project directory."
+  );
+}
+
+// src/commands/okr.ts
+function fail3(message) {
+  console.error(chalk15.red(message));
+  process.exit(1);
+}
+function parseNumber(value) {
+  const n = Number(value);
+  if (!Number.isFinite(n)) throw new Error(`invalid number: ${value}`);
+  return n;
+}
+async function withProject(opts, fn) {
+  try {
+    const name = resolveProjectName(opts);
+    return await fn(name);
+  } catch (err) {
+    fail3(err instanceof Error ? err.message : String(err));
+  }
+}
+function maybeJson(view, opts) {
+  if (opts.json) {
+    console.log(JSON.stringify(view, null, 2));
+    return true;
+  }
+  return false;
+}
+function dateShort(iso) {
+  if (!iso) return "\u2014";
+  return iso.slice(0, 10);
+}
+function planEncodedPath(projectName, planId) {
+  return `/api/projects/${encodeURIComponent(projectName)}/okrs/${encodeURIComponent(planId)}`;
+}
+function planBasePath(projectName) {
+  return `/api/projects/${encodeURIComponent(projectName)}/okrs`;
+}
+function countKRs(plan3) {
+  return plan3.objectives.reduce((sum, o) => sum + o.key_results.length, 0);
+}
+function printPlanSummary(plan3) {
+  const oid = chalk15.cyan((plan3.object_id || "-").padEnd(10));
+  const id = plan3.id.padEnd(16);
+  const status = chalk15.yellow(plan3.status.padEnd(8));
+  const range = `${dateShort(plan3.start_at)} \u2192 ${dateShort(plan3.end_at)}`;
+  const counts = chalk15.dim(
+    `${plan3.objectives.length} obj \xB7 ${countKRs(plan3)} kr \xB7 ${plan3.milestones.length} ms`
+  );
+  console.log(`${oid}  ${id}  ${status}  ${range}  ${counts}  ${plan3.title}`);
+}
+function krProgress(kr2) {
+  const start = kr2.start_value ?? 0;
+  const target = kr2.target_value;
+  const current = kr2.current_value;
+  if (target === null || current === null) return "\u2014";
+  const span = target - start;
+  if (span === 0) return "\u2014";
+  const ratio = Math.max(0, Math.min(1, (current - start) / span));
+  const filled = Math.round(ratio * 8);
+  const bar = "\u2588".repeat(filled) + "\u2591".repeat(8 - filled);
+  return `[${bar}] ${Math.round(ratio * 100)}%`;
+}
+function printPlanDetail(plan3) {
+  console.log(
+    `${chalk15.bold(plan3.id)}  ${chalk15.dim(plan3.object_id || "")}  ${chalk15.yellow(plan3.status)}   ${dateShort(plan3.start_at)} \u2192 ${dateShort(plan3.end_at)}`
+  );
+  if (plan3.title) console.log(`  ${plan3.title}`);
+  for (const obj of plan3.objectives) {
+    console.log(
+      `  ${chalk15.bold(obj.id)}  ${obj.title}  ${chalk15.dim(`(${obj.status})`)}  ${chalk15.dim(obj.object_id || "")}`
+    );
+    for (const kr2 of obj.key_results) {
+      const unit = kr2.unit ? kr2.unit : "";
+      const vals = kr2.target_value !== null ? `${kr2.start_value ?? 0}${unit}\u2192${kr2.target_value}${unit} now ${kr2.current_value ?? 0}${unit}` : "\u2014";
+      console.log(
+        `    ${kr2.id.padEnd(20)} ${vals}  ${krProgress(kr2)}  ${chalk15.dim(`(${kr2.status}/${kr2.confidence})`)}  ${chalk15.dim(kr2.object_id || "")}`
+      );
+    }
+  }
+  for (const ms of plan3.milestones) {
+    const links = ms.linked_kr_ids.length ? chalk15.dim(`\u2192 ${ms.linked_kr_ids.join(",")}`) : "";
+    console.log(
+      `  ${chalk15.bold(ms.id)}  ${dateShort(ms.due_at)}  ${ms.title}  ${chalk15.dim(`(${ms.status})`)}  ${links}  ${chalk15.dim(ms.object_id || "")}`
+    );
+  }
+  if (plan3.task_kr_links.length) {
+    console.log(chalk15.dim("links:"));
+    for (const link of plan3.task_kr_links) {
+      console.log(
+        `  ${link.task_id} \u2192 ${link.kr_id}  ${chalk15.dim(`${link.contribution} w=${link.weight}`)}`
+      );
+    }
+  }
+}
+var okr = new Command15("okr").description(
+  "Manage OKR plans, objectives, key results, milestones"
+);
+var plan2 = okr.command("plan").description("OKR plans");
+plan2.command("list").description("List OKR plans for the project").option("-p, --project <name>", "Project name (defaults to cwd)").option("--json", "Output JSON").action(async (opts) => {
+  await withProject(opts, async (name) => {
+    const { plans } = await api.get(planBasePath(name));
+    if (maybeJson(plans, opts)) return;
+    if (plans.length === 0) {
+      console.log("No OKR plans. Use `task0 okr plan create <id> --title ...` to create one.");
+      return;
+    }
+    for (const p of plans) printPlanSummary(p);
+  });
+});
+plan2.command("get <plan-id>").description("Show a plan with its objectives, KRs, milestones").option("-p, --project <name>", "Project name (defaults to cwd)").option("--json", "Output JSON").action(async (planId, opts) => {
+  await withProject(opts, async (name) => {
+    const { plan: view } = await api.get(planEncodedPath(name, planId));
+    if (maybeJson(view, opts)) return;
+    printPlanDetail(view);
+  });
+});
+plan2.command("create <plan-id>").description("Create a new OKR plan").requiredOption("-t, --title <title>", "Plan title").option("-s, --status <status>", "draft|active|closed|archived").option("--start-at <iso>", "ISO 8601 UTC start").option("--end-at <iso>", "ISO 8601 UTC end").option("-p, --project <name>", "Project name (defaults to cwd)").option("--json", "Output JSON").action(
+  async (planId, opts) => {
+    await withProject(opts, async (name) => {
+      const body = {
+        id: planId,
+        title: opts.title,
+        status: opts.status,
+        start_at: opts.startAt,
+        end_at: opts.endAt
+      };
+      const { plan: view } = await api.post(planBasePath(name), body);
+      if (maybeJson(view, opts)) return;
+      console.log(chalk15.green("ok"), view.id, chalk15.dim(view.object_id || ""));
+      printPlanSummary(view);
+    });
+  }
+);
+plan2.command("update <plan-id>").description("Update plan fields").option("-t, --title <title>", "Plan title").option("-s, --status <status>", "draft|active|closed|archived").option("--start-at <iso>", "ISO 8601 UTC start").option("--end-at <iso>", "ISO 8601 UTC end").option("-p, --project <name>", "Project name (defaults to cwd)").option("--json", "Output JSON").action(
+  async (planId, opts) => {
+    await withProject(opts, async (name) => {
+      const body = {
+        title: opts.title,
+        status: opts.status,
+        start_at: opts.startAt,
+        end_at: opts.endAt
+      };
+      const { plan: view } = await api.patch(
+        planEncodedPath(name, planId),
+        body
+      );
+      if (maybeJson(view, opts)) return;
+      console.log(chalk15.green("updated"), view.id, chalk15.dim(view.object_id || ""));
+      printPlanSummary(view);
+    });
+  }
+);
+var objective = okr.command("objective").description("Objectives inside a plan");
+objective.command("create <plan-id> <objective-id>").description("Create an objective under a plan").requiredOption("-t, --title <title>", "Objective title").option("-d, --description <text>", "Description").option("--order <n>", "Display order", (v) => parseNumber(v)).option("-s, --status <status>", "draft|active|at_risk|done|cancelled").option("-o, --owner <owner>", "Owner").option("-p, --project <name>", "Project name (defaults to cwd)").option("--json", "Output JSON").action(
+  async (planId, objectiveId, opts) => {
+    await withProject(opts, async (name) => {
+      const body = {
+        id: objectiveId,
+        title: opts.title,
+        description: opts.description,
+        order: opts.order,
+        status: opts.status,
+        owner: opts.owner
+      };
+      const { objective: view } = await api.post(
+        `${planEncodedPath(name, planId)}/objectives`,
+        body
+      );
+      if (maybeJson(view, opts)) return;
+      console.log(
+        chalk15.green("ok"),
+        view.id,
+        chalk15.dim(view.object_id || ""),
+        chalk15.dim(`(${view.status})`),
+        view.title
+      );
+    });
+  }
+);
+objective.command("update <plan-id> <objective-id>").description("Update objective fields").option("-t, --title <title>", "Title").option("-d, --description <text>", "Description").option("--order <n>", "Display order", (v) => parseNumber(v)).option("-s, --status <status>", "draft|active|at_risk|done|cancelled").option("-o, --owner <owner>", "Owner").option("-p, --project <name>", "Project name (defaults to cwd)").option("--json", "Output JSON").action(
+  async (planId, objectiveId, opts) => {
+    await withProject(opts, async (name) => {
+      const body = {
+        title: opts.title,
+        description: opts.description,
+        order: opts.order,
+        status: opts.status,
+        owner: opts.owner
+      };
+      const { objective: view } = await api.patch(
+        `${planEncodedPath(name, planId)}/objectives/${encodeURIComponent(objectiveId)}`,
+        body
+      );
+      if (maybeJson(view, opts)) return;
+      console.log(chalk15.green("updated"), view.id, chalk15.dim(`(${view.status})`), view.title);
+    });
+  }
+);
+var kr = okr.command("kr").description("Key results inside an objective");
+kr.command("create <plan-id> <objective-id> <kr-id>").description("Create a key result under an objective").requiredOption("-t, --title <title>", "Key result title").option("-d, --description <text>", "Description").option("--metric-type <type>", "binary|numeric|percentage|milestone_count").option("--unit <unit>", "Unit (e.g. ms, %, count)").option("--start-value <n>", "Baseline value", (v) => parseNumber(v)).option("--current-value <n>", "Current value", (v) => parseNumber(v)).option("--target-value <n>", "Target value", (v) => parseNumber(v)).option("-s, --status <status>", "draft|active|at_risk|done|cancelled").option("-c, --confidence <level>", "low|medium|high").option("--due-at <iso>", "ISO 8601 UTC due").option("-o, --owner <owner>", "Owner").option("-p, --project <name>", "Project name (defaults to cwd)").option("--json", "Output JSON").action(
+  async (planId, objectiveId, krId, opts) => {
+    await withProject(opts, async (name) => {
+      const body = {
+        id: krId,
+        title: opts.title,
+        description: opts.description,
+        metric_type: opts.metricType,
+        unit: opts.unit,
+        start_value: opts.startValue,
+        current_value: opts.currentValue,
+        target_value: opts.targetValue,
+        status: opts.status,
+        confidence: opts.confidence,
+        due_at: opts.dueAt,
+        owner: opts.owner
+      };
+      const { key_result: view } = await api.post(
+        `${planEncodedPath(name, planId)}/objectives/${encodeURIComponent(objectiveId)}/key-results`,
+        body
+      );
+      if (maybeJson(view, opts)) return;
+      console.log(
+        chalk15.green("ok"),
+        view.id,
+        chalk15.dim(view.object_id || ""),
+        chalk15.dim(`(${view.status}/${view.confidence})`),
+        view.title
+      );
+    });
+  }
+);
+kr.command("update <plan-id> <kr-id>").description("Update a key result").option("-t, --title <title>", "Title").option("-d, --description <text>", "Description").option("--metric-type <type>", "binary|numeric|percentage|milestone_count").option("--unit <unit>", "Unit").option("--start-value <n>", "Baseline value", (v) => parseNumber(v)).option("--current-value <n>", "Current value", (v) => parseNumber(v)).option("--target-value <n>", "Target value", (v) => parseNumber(v)).option("-s, --status <status>", "draft|active|at_risk|done|cancelled").option("-c, --confidence <level>", "low|medium|high").option("--due-at <iso>", "ISO 8601 UTC due").option("-o, --owner <owner>", "Owner").option("-p, --project <name>", "Project name (defaults to cwd)").option("--json", "Output JSON").action(
+  async (planId, krId, opts) => {
+    await withProject(opts, async (name) => {
+      const body = {
+        title: opts.title,
+        description: opts.description,
+        metric_type: opts.metricType,
+        unit: opts.unit,
+        start_value: opts.startValue,
+        current_value: opts.currentValue,
+        target_value: opts.targetValue,
+        status: opts.status,
+        confidence: opts.confidence,
+        due_at: opts.dueAt,
+        owner: opts.owner
+      };
+      const { key_result: view } = await api.patch(
+        `${planEncodedPath(name, planId)}/key-results/${encodeURIComponent(krId)}`,
+        body
+      );
+      if (maybeJson(view, opts)) return;
+      console.log(
+        chalk15.green("updated"),
+        view.id,
+        chalk15.dim(`(${view.status}/${view.confidence})`),
+        view.title
+      );
+    });
+  }
+);
+kr.command("progress <plan-id> <kr-id>").description("Update key result progress (current/confidence/status)").requiredOption("--current <n>", "Current value", (v) => parseNumber(v)).option("-c, --confidence <level>", "low|medium|high").option("-s, --status <status>", "draft|active|at_risk|done|cancelled").option("-p, --project <name>", "Project name (defaults to cwd)").option("--json", "Output JSON").action(
+  async (planId, krId, opts) => {
+    await withProject(opts, async (name) => {
+      const body = {
+        current_value: opts.current,
+        confidence: opts.confidence,
+        status: opts.status
+      };
+      const { key_result: view } = await api.patch(
+        `${planEncodedPath(name, planId)}/key-results/${encodeURIComponent(krId)}`,
+        body
+      );
+      if (maybeJson(view, opts)) return;
+      console.log(
+        chalk15.green("progress"),
+        view.id,
+        krProgress(view),
+        chalk15.dim(`(${view.status}/${view.confidence})`)
+      );
+    });
+  }
+);
+var milestone = okr.command("milestone").description("Milestones inside a plan");
+milestone.command("create <plan-id> <milestone-id>").description("Create a milestone under a plan").requiredOption("-t, --title <title>", "Milestone title").option("-d, --description <text>", "Description").option("--due-at <iso>", "ISO 8601 UTC due").option("--order <n>", "Display order", (v) => parseNumber(v)).option("-s, --status <status>", "pending|in_progress|done|delayed|cancelled").option("--linked-kr <id...>", "Linked key result ids (repeatable)").option("-p, --project <name>", "Project name (defaults to cwd)").option("--json", "Output JSON").action(
+  async (planId, milestoneId, opts) => {
+    await withProject(opts, async (name) => {
+      const body = {
+        id: milestoneId,
+        title: opts.title,
+        description: opts.description,
+        due_at: opts.dueAt,
+        order: opts.order,
+        status: opts.status,
+        linked_kr_ids: opts.linkedKr
+      };
+      const { milestone: view } = await api.post(
+        `${planEncodedPath(name, planId)}/milestones`,
+        body
+      );
+      if (maybeJson(view, opts)) return;
+      console.log(
+        chalk15.green("ok"),
+        view.id,
+        chalk15.dim(view.object_id || ""),
+        dateShort(view.due_at),
+        chalk15.dim(`(${view.status})`),
+        view.title
+      );
+    });
+  }
+);
+milestone.command("update <plan-id> <milestone-id>").description("Update a milestone").option("-t, --title <title>", "Title").option("-d, --description <text>", "Description").option("--due-at <iso>", "ISO 8601 UTC due").option("--order <n>", "Display order", (v) => parseNumber(v)).option("-s, --status <status>", "pending|in_progress|done|delayed|cancelled").option("--linked-kr <id...>", "Linked key result ids (repeatable, replaces set)").option("-p, --project <name>", "Project name (defaults to cwd)").option("--json", "Output JSON").action(
+  async (planId, milestoneId, opts) => {
+    await withProject(opts, async (name) => {
+      const body = {
+        title: opts.title,
+        description: opts.description,
+        due_at: opts.dueAt,
+        order: opts.order,
+        status: opts.status,
+        linked_kr_ids: opts.linkedKr
+      };
+      const { milestone: view } = await api.patch(
+        `${planEncodedPath(name, planId)}/milestones/${encodeURIComponent(milestoneId)}`,
+        body
+      );
+      if (maybeJson(view, opts)) return;
+      console.log(
+        chalk15.green("updated"),
+        view.id,
+        dateShort(view.due_at),
+        chalk15.dim(`(${view.status})`),
+        view.title
+      );
+    });
+  }
+);
+okr.command("link <plan-id>").description("Link a task to a key result").requiredOption("--task <id>", "Task id (tsk_...)").requiredOption("--kr <id>", "Key result id").option("--contribution <type>", "direct|indirect|blocker|enabler").option("--weight <n>", "Weight (> 0)", (v) => parseNumber(v)).option("--note <text>", "Note").option("-p, --project <name>", "Project name (defaults to cwd)").option("--json", "Output JSON").action(
+  async (planId, opts) => {
+    await withProject(opts, async (name) => {
+      const body = {
+        task_id: opts.task,
+        kr_id: opts.kr,
+        contribution: opts.contribution,
+        weight: opts.weight,
+        note: opts.note
+      };
+      const { link } = await api.post(
+        `${planEncodedPath(name, planId)}/task-kr-links`,
+        body
+      );
+      if (maybeJson(link, opts)) return;
+      console.log(
+        chalk15.green("linked"),
+        `${link.task_id} \u2192 ${link.kr_id}`,
+        chalk15.dim(`${link.contribution} w=${link.weight}`)
+      );
+    });
+  }
+);
+okr.command("unlink <plan-id>").description("Unlink a task from a key result").requiredOption("--task <id>", "Task id (tsk_...)").requiredOption("--kr <id>", "Key result id").option("-p, --project <name>", "Project name (defaults to cwd)").option("--json", "Output JSON").action(
+  async (planId, opts) => {
+    await withProject(opts, async (name) => {
+      const result = await api.del(
+        `${planEncodedPath(name, planId)}/task-kr-links/${encodeURIComponent(opts.task)}/${encodeURIComponent(opts.kr)}`
+      );
+      if (maybeJson(result, opts)) return;
+      console.log(chalk15.green("unlinked"), `${opts.task} \u2715 ${opts.kr}`);
+    });
+  }
+);
+
+// src/commands/note.ts
+import { Command as Command16 } from "commander";
+import chalk16 from "chalk";
+var note = new Command16("note").description("Manage inbox notes");
+async function fetchAllInboxNotes() {
+  const { inboxes } = await api.get("/api/inboxes");
+  const results = [];
+  for (const inbox of inboxes) {
+    const { notes } = await api.get(`/api/inboxes/${encodeURIComponent(inbox.id)}/notes`);
+    results.push({ inbox, notes });
+  }
+  return results;
+}
+async function resolveByObjectId(objectId) {
+  const { type, resource } = await api.get(
+    `/api/resolve/${encodeURIComponent(objectId)}`
+  );
+  if (type !== "inbox_note" || !resource.inboxId) {
+    throw new Error(`object ${objectId} is not an inbox_note (got ${type})`);
+  }
+  const { inboxId, ...rest } = resource;
+  return { inboxId, note: rest };
+}
+async function findNoteById(noteId, inboxHint) {
+  if (noteId.startsWith("note_")) return resolveByObjectId(noteId);
+  if (inboxHint) {
+    const { notes } = await api.get(
+      `/api/inboxes/${encodeURIComponent(inboxHint)}/notes`
+    );
+    const found = notes.find((n) => n.id === noteId);
+    if (!found) throw new Error(`note ${noteId} not found in inbox ${inboxHint}`);
+    return { inboxId: inboxHint, note: found };
+  }
+  const all = await fetchAllInboxNotes();
+  for (const { inbox, notes } of all) {
+    const found = notes.find((n) => n.id === noteId);
+    if (found) return { inboxId: inbox.id, note: found };
+  }
+  throw new Error(`note ${noteId} not found in any inbox`);
+}
+function preview2(body, width = 60) {
+  const single = body.replace(/\s+/g, " ").trim();
+  return single.length > width ? single.slice(0, width - 1) + "\u2026" : single;
+}
+function printNoteRow(n, inboxName) {
+  const oid = chalk16.cyan((n.object_id || "-").padEnd(14));
+  const id = chalk16.dim(n.id.padEnd(10));
+  const tags = n.tags.length ? chalk16.yellow(n.tags.join(",")) : chalk16.dim("-");
+  const linked = n.linked_task_id ? chalk16.magenta(n.linked_task_id) : chalk16.dim("-");
+  const inboxPart = inboxName ? chalk16.dim(`[${inboxName}] `) : "";
+  console.log(`${oid} ${id} ${inboxPart}${preview2(n.body)}  ${tags}  ${linked}  ${chalk16.dim(n.updated_at)}`);
+}
+function printNoteDetail(n, inboxId) {
+  if (n.object_id) console.log(`${chalk16.bold("object_id:")}    ${n.object_id}`);
+  console.log(`${chalk16.bold("id:")}           ${n.id}`);
+  if (inboxId) console.log(`${chalk16.bold("inbox:")}        ${inboxId}`);
+  console.log(`${chalk16.bold("tags:")}         ${n.tags.length ? n.tags.join(", ") : "-"}`);
+  if (n.linked_task_id) console.log(`${chalk16.bold("linked_task:")} ${n.linked_task_id}`);
+  if (n.linked_project) console.log(`${chalk16.bold("linked_project:")} ${n.linked_project}`);
+  console.log(`${chalk16.bold("created_at:")}   ${n.created_at}`);
+  console.log(`${chalk16.bold("updated_at:")}   ${n.updated_at}`);
+  if (n.published_to?.length) {
+    console.log(chalk16.bold("published_to:"));
+    for (const p of n.published_to) {
+      console.log(`  - ${p.source_type}:${p.source_name} ${p.identifier} ${chalk16.dim(p.url)}`);
+    }
+  }
+  console.log(chalk16.bold("body:"));
+  console.log(n.body.split("\n").map((l) => "  " + l).join("\n"));
+}
+function fail4(err) {
+  console.error(chalk16.red(err.message));
+  process.exit(1);
+}
+note.command("list").description("List inbox notes").option("--inbox <id>", "Restrict to a specific inbox").option("--json", "Output JSON").action(async (opts) => {
+  try {
+    if (opts.inbox) {
+      const { notes } = await api.get(
+        `/api/inboxes/${encodeURIComponent(opts.inbox)}/notes`
+      );
+      if (opts.json) {
+        console.log(JSON.stringify({ notes }, null, 2));
+        return;
+      }
+      if (!notes.length) {
+        console.log(chalk16.dim("No notes."));
+        return;
+      }
+      for (const n of notes) printNoteRow(n);
+      return;
+    }
+    const all = await fetchAllInboxNotes();
+    if (opts.json) {
+      console.log(JSON.stringify(all, null, 2));
+      return;
+    }
+    const flat = all.flatMap(({ inbox, notes }) => notes.map((n) => ({ n, inboxName: inbox.name })));
+    if (!flat.length) {
+      console.log(chalk16.dim("No notes."));
+      return;
+    }
+    for (const { n, inboxName } of flat) printNoteRow(n, inboxName);
+  } catch (err) {
+    fail4(err);
+  }
+});
+note.command("get <id>").description("Show a note by id or object_id (note_\u2026)").option("--inbox <id>", "Inbox id (optional when <id> is a note_ object_id)").option("--json", "Output JSON").action(async (id, opts) => {
+  try {
+    const { inboxId, note: found } = await findNoteById(id, opts.inbox);
+    if (opts.json) {
+      console.log(JSON.stringify({ inboxId, note: found }, null, 2));
+      return;
+    }
+    printNoteDetail(found, inboxId);
+  } catch (err) {
+    fail4(err);
+  }
+});
+note.command("create").description("Create a note in an inbox").requiredOption("--inbox <id>", "Inbox id").requiredOption("--body <text>", "Note body (markdown)").option("--tag <value>", "Tag (repeatable)", (v, prev) => prev.concat([v]), []).option("--linked-task <tsk>", "Linked task id").option("--linked-project <name>", "Linked project name").option("--json", "Output JSON").action(async (opts) => {
+  try {
+    const payload = { body: opts.body, tags: opts.tag };
+    if (opts.linkedTask) payload.linked_task_id = opts.linkedTask;
+    if (opts.linkedProject) payload.linked_project = opts.linkedProject;
+    const { note: created } = await api.post(
+      `/api/inboxes/${encodeURIComponent(opts.inbox)}/notes`,
+      payload
+    );
+    if (opts.json) {
+      console.log(JSON.stringify({ note: created }, null, 2));
+      return;
+    }
+    console.log(chalk16.green(`Created ${created.object_id || created.id}`));
+    printNoteDetail(created, opts.inbox);
+  } catch (err) {
+    fail4(err);
+  }
+});
+note.command("update <id>").description("Update a note (accepts short id or note_ object_id)").option("--inbox <id>", "Inbox id (optional when <id> is a note_ object_id)").option("--body <text>", "New body").option("--tag <value>", "Replace tags (repeatable)", (v, prev) => prev.concat([v]), []).option("--clear-tags", "Clear all tags").option("--linked-task <tsk>", "Linked task id (empty string clears)").option("--linked-project <name>", "Linked project name (empty string clears)").option("--json", "Output JSON").action(async (id, opts) => {
+  try {
+    const { inboxId, note: existing } = await findNoteById(id, opts.inbox);
+    const payload = {};
+    if (opts.body !== void 0) payload.body = opts.body;
+    if (opts.clearTags) payload.tags = [];
+    else if (opts.tag.length) payload.tags = opts.tag;
+    if (opts.linkedTask !== void 0) payload.linked_task_id = opts.linkedTask;
+    if (opts.linkedProject !== void 0) payload.linked_project = opts.linkedProject;
+    if (!Object.keys(payload).length) {
+      console.error(chalk16.yellow("Nothing to update. Pass --body, --tag, --clear-tags, --linked-task, or --linked-project."));
+      process.exit(1);
+    }
+    const { note: updated } = await api.patch(
+      `/api/inboxes/${encodeURIComponent(inboxId)}/notes/${encodeURIComponent(existing.id)}`,
+      payload
+    );
+    if (opts.json) {
+      console.log(JSON.stringify({ note: updated }, null, 2));
+      return;
+    }
+    console.log(chalk16.green(`Updated ${updated.object_id || updated.id}`));
+    printNoteDetail(updated, inboxId);
+  } catch (err) {
+    fail4(err);
+  }
+});
+note.command("delete <id>").description("Delete a note (accepts short id or note_ object_id)").option("--inbox <id>", "Inbox id (optional when <id> is a note_ object_id)").action(async (id, opts) => {
+  try {
+    const { inboxId, note: existing } = await findNoteById(id, opts.inbox);
+    await api.del(
+      `/api/inboxes/${encodeURIComponent(inboxId)}/notes/${encodeURIComponent(existing.id)}`
+    );
+    console.log(chalk16.green(`Deleted ${existing.object_id || existing.id}`));
+  } catch (err) {
+    fail4(err);
+  }
+});
+note.command("publish <id>").description("Publish a note to a github/linear source").requiredOption("--source <name>", "Source name (non-project)").option("--inbox <id>", "Inbox id (optional when <id> is a note_ object_id)").option("--project-id <linear>", "Linear project id (linear sources only)").option("--json", "Output JSON").action(async (id, opts) => {
+  try {
+    const { inboxId, note: existing } = await findNoteById(id, opts.inbox);
+    const payload = { source_name: opts.source };
+    if (opts.projectId) payload.project_id = opts.projectId;
+    const { published } = await api.post(
+      `/api/inboxes/${encodeURIComponent(inboxId)}/notes/${encodeURIComponent(existing.id)}/publish`,
+      payload
+    );
+    if (opts.json) {
+      console.log(JSON.stringify({ published }, null, 2));
+      return;
+    }
+    console.log(chalk16.green(`Published to ${published.source_type}:${published.source_name} ${published.identifier}`));
+    console.log(`  ${chalk16.dim(published.url)}`);
+  } catch (err) {
+    fail4(err);
+  }
+});
+note.command("convert <id>").description("Convert a note into a task under a project source").requiredOption("--project <name>", "Project source name").option("--inbox <id>", "Inbox id (optional when <id> is a note_ object_id)").option("--json", "Output JSON").action(async (id, opts) => {
+  try {
+    const { inboxId, note: existing } = await findNoteById(id, opts.inbox);
+    const { task: task2 } = await api.post(
+      `/api/inboxes/${encodeURIComponent(inboxId)}/notes/${encodeURIComponent(existing.id)}/convert`,
+      { project: opts.project }
+    );
+    if (opts.json) {
+      console.log(JSON.stringify({ task: task2 }, null, 2));
+      return;
+    }
+    console.log(chalk16.green(`Converted to task ${task2.object_id} (${task2.id}) in ${task2.project}`));
+  } catch (err) {
+    fail4(err);
+  }
+});
+
+// src/commands/object.ts
+import { Command as Command17 } from "commander";
+import chalk17 from "chalk";
+var object = new Command17("object").description("Resolve any object by its object_id");
+function pickFirst(resource, keys) {
+  for (const k of keys) {
+    const value = resource[k];
+    if (typeof value === "string" && value.length) return value;
+  }
+  return void 0;
+}
+function printSummary(result) {
+  const { type, resource } = result;
+  console.log(`${chalk17.bold("type:")}      ${type}`);
+  const title = pickFirst(resource, ["title", "name"]);
+  const id = pickFirst(resource, ["object_id", "objectId", "id"]);
+  const status = pickFirst(resource, ["status"]);
+  if (id) console.log(`${chalk17.bold("object_id:")} ${id}`);
+  if (title) console.log(`${chalk17.bold("title:")}     ${title}`);
+  if (status) console.log(`${chalk17.bold("status:")}    ${status}`);
+  const updatedAt = pickFirst(resource, ["updated_at", "updatedAt"]);
+  if (updatedAt) console.log(`${chalk17.bold("updated_at:")} ${updatedAt}`);
+  console.log(chalk17.dim("(pass --json for full payload)"));
+}
+object.command("get <object-id>").description("Resolve an object by object_id (tsk_\u2026, note_\u2026, obj_\u2026, rt_\u2026, \u2026)").option("--json", "Output full JSON envelope").action(async (objectId, opts) => {
+  try {
+    const result = await api.get(`/api/resolve/${encodeURIComponent(objectId)}`);
+    if (opts.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    printSummary(result);
+  } catch (err) {
+    const apiErr = err;
+    if (apiErr.status === 404) {
+      console.error(chalk17.red(`not found: ${objectId}`));
+      process.exit(1);
+    }
+    console.error(chalk17.red(err.message));
+    process.exit(1);
+  }
+});
+
+// src/commands/issue.ts
+import { Command as Command18 } from "commander";
+import chalk18 from "chalk";
+
+// src/core/issue/decision.ts
+init_node();
+import fs18 from "fs";
+import path17 from "path";
+init_task_state2();
+var DECISION_FILE_RE = /^DECISION-(\d+)-([a-z0-9-]+)\.md$/;
+function selectBlockingIssues(taskDir, explicitIssue) {
+  const files = fs18.existsSync(taskDir) ? fs18.readdirSync(taskDir) : [];
+  const issueFiles = files.filter((f) => /^ISSUE-\d+\.md$/.test(f)).sort();
+  const all = readOpenQuestions(taskDir, issueFiles);
+  if (!explicitIssue) return all;
+  const normalized = normalizeIssueFile(explicitIssue);
+  const match = all.find((iq) => iq.file === normalized);
+  if (!match) {
+    const hint = all.length === 0 ? "no ISSUE-NN.md files have Open Questions" : `blocking ISSUEs: ${all.map((iq) => iq.file).join(", ")}`;
+    throw new Error(`${normalized} has no Open Questions (${hint})`);
+  }
+  return [match];
+}
+function normalizeIssueFile(input) {
+  if (/^ISSUE-\d+\.md$/.test(input)) return input;
+  if (/^\d+$/.test(input)) return `ISSUE-${input.padStart(2, "0")}.md`;
+  if (/^ISSUE-\d+$/.test(input)) return `${input}.md`;
+  throw new Error(`--issue expects NN, ISSUE-NN, or ISSUE-NN.md (got: ${input})`);
+}
+function decisionFileName(issue2, agent2) {
+  return `DECISION-${issue2.index}-${agent2}.md`;
+}
+function consolidatedFileName(issue2) {
+  return `DECISION-${issue2.index}-consolidated.md`;
+}
+function buildProposePrompt(issue2, decisionFile, extra) {
+  const lines = [
+    `You are proposing resolutions to "Open Questions" in ${issue2.file} for task planning.`,
+    ``,
+    `Task context files:`,
+    `- ${issue2.file} (contains the "## Open Questions" section)`,
+    `- ISSUE.md (task overview, if present)`,
+    `- IDEA-${issue2.index}.md (original idea, if present)`,
+    ``,
+    `For EACH bullet under "## Open Questions" in ${issue2.file}, produce one answer section in your output file.`,
+    ``,
+    `Output:`,
+    `- Write to ${decisionFile} in the task directory.`,
+    `- Structure the file as:`,
+    ``,
+    `  # Proposed Decisions for ${issue2.file}`,
+    ``,
+    `  ## Q1: <verbatim question text>`,
+    ``,
+    `  **Recommendation:** <single-sentence answer>`,
+    ``,
+    `  **Reasoning:** <1-3 sentences>`,
+    ``,
+    `  **Evidence:**`,
+    `  - \`path/to/file.ts:NN\` \u2014 <what this shows>`,
+    ``,
+    `  ## Q2: ...`,
+    ``,
+    `Rules:`,
+    `- One Q heading per bullet, in the same order they appear in ${issue2.file}.`,
+    `- Cite concrete file:line evidence from the repo when available; if no evidence exists, write "Evidence: none \u2014 judgment call" and give reasoning.`,
+    `- Do NOT modify ${issue2.file}.`,
+    `- Do NOT write any files other than ${decisionFile}.`
+  ];
+  if (extra) {
+    lines.push(``, `Additional instructions:`, extra);
+  }
+  return lines.join("\n");
+}
+function buildConsolidatePrompt(issue2, proposalFiles, consolidatedFile) {
+  return [
+    `You are consolidating multiple "Proposed Decisions" drafts into a single consolidated decision file.`,
+    ``,
+    `Inputs:`,
+    `- ${issue2.file} (source of "## Open Questions")`,
+    ...proposalFiles.map((f) => `- ${f} (one agent's proposal)`),
+    ``,
+    `Output:`,
+    `- Write to ${consolidatedFile} in the task directory.`,
+    `- For each "## Qn" heading that appears in the proposals, produce ONE consolidated answer.`,
+    `- When agents agree, adopt the shared answer and keep reasoning terse.`,
+    `- When agents disagree, pick the option better supported by cited evidence and add a short line: "Chose X over Y because <reason>".`,
+    `- Preserve the Q heading ordering from ${issue2.file}.`,
+    `- Match the structure used by the proposals (Recommendation / Reasoning / Evidence).`,
+    ``,
+    `Rules:`,
+    `- Do NOT modify ${issue2.file} or any DECISION-*-<agent>.md.`,
+    `- Do NOT write any files other than ${consolidatedFile}.`
+  ].join("\n");
+}
+function parseConsolidatedAnswers(md) {
+  const sections = [];
+  const qRe = /^##\s+(Q\d+:?\s*.*)$/gm;
+  const matches = [];
+  let match;
+  while (match = qRe.exec(md)) {
+    matches.push({
+      heading: match[1].trim(),
+      start: match.index,
+      contentStart: match.index + match[0].length
+    });
+  }
+  for (let i = 0; i < matches.length; i++) {
+    const end = i + 1 < matches.length ? matches[i + 1].start : md.length;
+    const body = md.slice(matches[i].contentStart, end).trim();
+    sections.push({ heading: matches[i].heading, body });
+  }
+  return sections;
+}
+function rewriteIssueWithDecisions(taskDir, issueFile, consolidatedFile) {
+  const issuePath = path17.join(taskDir, issueFile);
+  const consolidatedPath = path17.join(taskDir, consolidatedFile);
+  if (!fs18.existsSync(issuePath)) throw new Error(`${issueFile} not found in ${taskDir}`);
+  if (!fs18.existsSync(consolidatedPath)) throw new Error(`${consolidatedFile} not found in ${taskDir}`);
+  const issueMd = fs18.readFileSync(issuePath, "utf-8");
+  const consolidatedMd = fs18.readFileSync(consolidatedPath, "utf-8");
+  const answers = parseConsolidatedAnswers(consolidatedMd);
+  if (answers.length === 0) {
+    throw new Error(`${consolidatedFile} has no "## Qn" sections; cannot derive Decisions`);
+  }
+  const decisionsBody = answers.map((a) => {
+    const recMatch = a.body.match(/\*\*Recommendation:\*\*\s*(.+?)(?:\n|$)/);
+    const recommendation = recMatch?.[1]?.trim() ?? a.body.split("\n")[0] ?? "";
+    return `- **${a.heading}** \u2014 ${recommendation}`;
+  }).join("\n");
+  const decisionsSection = `## Decisions
+
+${decisionsBody}
+
+_Resolved from [${consolidatedFile}](${consolidatedFile}); see that file for reasoning and evidence._
+`;
+  const openQRe = /## Open Questions\s*\n[\s\S]*?(?=\n## |\n*$)/i;
+  const openQMatch = issueMd.match(openQRe);
+  if (!openQMatch) {
+    throw new Error(`${issueFile} has no "## Open Questions" section to replace`);
+  }
+  const next = issueMd.replace(openQRe, decisionsSection.trimEnd() + "\n");
+  fs18.writeFileSync(issuePath, next, "utf-8");
+  return { replaced: answers.length };
+}
+async function propose(opts) {
+  const loc = resolveTaskByObjectId(opts.objectId);
+  let issues;
+  try {
+    issues = selectBlockingIssues(loc.taskDir, opts.issue);
+  } catch (err) {
+    if (opts.ifNeeded) return { issues: [] };
+    throw err;
+  }
+  if (issues.length === 0) {
+    if (opts.ifNeeded) return { issues: [] };
+    throw new Error(`No blocking "## Open Questions" found in ${loc.taskDir}`);
+  }
+  if (opts.agents.length === 0) throw new Error("No agents specified for propose");
+  if ((opts.model || opts.effort) && opts.agents.length > 1) {
+    throw new Error(
+      `--model/--effort only works with a single agent; got ${opts.agents.length} (${opts.agents.join(", ")}).`
+    );
+  }
+  const warn = opts.warn;
+  const issuesOut = [];
+  for (const issue2 of issues) {
+    const kicks = [];
+    for (const agent2 of opts.agents) {
+      const decisionFile = decisionFileName(issue2, agent2);
+      const decisionPath = path17.join(loc.taskDir, decisionFile);
+      if (fs18.existsSync(decisionPath) && !opts.force) {
+        if (opts.ifNeeded) {
+          kicks.push({
+            issue: issue2.file,
+            agent: agent2,
+            runtimeId: "",
+            sessionName: "",
+            decisionFile,
+            error: null,
+            skipped: "already-exists"
+          });
+        } else {
+          kicks.push({
+            issue: issue2.file,
+            agent: agent2,
+            runtimeId: "",
+            sessionName: "",
+            decisionFile,
+            error: `${decisionFile} already exists (pass --force to overwrite)`
+          });
+        }
+        continue;
+      }
+      if (opts.model || opts.effort) {
+        resolveModelOptions(agent2, { model: opts.model, effort: opts.effort }, warn);
+      }
+      void buildReferenceFiles;
+      const prompt = buildProposePrompt(issue2, decisionFile, opts.additionalPrompt);
+      try {
+        const resp = await api.post(
+          `/api/agents/${encodeURIComponent(agent2)}/run`,
+          {
+            task_id: opts.objectId,
+            prompt
+          }
+        );
+        kicks.push({
+          issue: issue2.file,
+          agent: agent2,
+          runtimeId: resp.runtime.id,
+          sessionName: "",
+          decisionFile,
+          error: null
+        });
+      } catch (err) {
+        kicks.push({
+          issue: issue2.file,
+          agent: agent2,
+          runtimeId: "",
+          sessionName: "",
+          decisionFile,
+          error: err.message
+        });
+      }
+    }
+    const runtimesByAgent = {};
+    for (const k of kicks) if (!k.error && k.runtimeId) runtimesByAgent[k.agent] = k.runtimeId;
+    const proposalFiles = kicks.filter((k) => !k.error).map((k) => k.decisionFile);
+    if (Object.keys(runtimesByAgent).length > 0 || proposalFiles.length > 0) {
+      await updateWorkflow(loc.taskYml, {
+        decisions: {
+          [issue2.file]: {
+            proposal_files: proposalFiles.length > 0 ? proposalFiles : void 0,
+            proposal_runtimes: Object.keys(runtimesByAgent).length > 0 ? runtimesByAgent : void 0
+          }
+        }
+      });
+    }
+    if (opts.wait) {
+      for (const k of kicks) {
+        if (k.error || !k.runtimeId) continue;
+        try {
+          const final = await waitForRuntime(k.runtimeId);
+          if (final.status !== "done") {
+            k.error = final.error || `runtime ${k.runtimeId} ended with ${final.status}`;
+          } else if (!fs18.existsSync(path17.join(loc.taskDir, k.decisionFile))) {
+            k.error = `runtime completed but ${k.decisionFile} was not written`;
+          }
+        } catch (err) {
+          k.error = err.message;
+        }
+      }
+    }
+    issuesOut.push({ issue: issue2.file, kicks });
+  }
+  return { issues: issuesOut };
+}
+async function consolidate(opts) {
+  const loc = resolveTaskByObjectId(opts.objectId);
+  const issues = selectBlockingIssues(loc.taskDir, opts.issue);
+  if (issues.length === 0) {
+    throw new Error(`No blocking "## Open Questions" found in ${loc.taskDir}`);
+  }
+  const kicks = [];
+  const modelOpts = resolveModelOptions(opts.agent, { model: opts.model, effort: opts.effort }, opts.warn);
+  for (const issue2 of issues) {
+    const files = fs18.readdirSync(loc.taskDir);
+    const proposalFiles = files.filter((f) => {
+      const m = f.match(DECISION_FILE_RE);
+      return !!m && m[1] === issue2.index && m[2] !== "consolidated";
+    }).sort();
+    if (proposalFiles.length === 0) {
+      kicks.push({
+        issue: issue2.file,
+        runtimeId: "",
+        sessionName: "",
+        consolidatedFile: consolidatedFileName(issue2),
+        error: `no DECISION-${issue2.index}-<agent>.md proposals found. Run \`task0 issue propose\` first.`
+      });
+      continue;
+    }
+    const consolidatedFile = consolidatedFileName(issue2);
+    void proposalFiles;
+    void modelOpts;
+    const prompt = buildConsolidatePrompt(issue2, proposalFiles, consolidatedFile);
+    try {
+      const resp = await api.post(
+        `/api/agents/${encodeURIComponent(opts.agent)}/run`,
+        {
+          task_id: opts.objectId,
+          prompt
+        }
+      );
+      const runtimeId = resp.runtime.id;
+      await updateWorkflow(loc.taskYml, {
+        decisions: {
+          [issue2.file]: {
+            consolidated_file: consolidatedFile,
+            consolidate_runtime: runtimeId
+          }
+        }
+      });
+      const kick = {
+        issue: issue2.file,
+        runtimeId,
+        sessionName: "",
+        consolidatedFile,
+        error: null
+      };
+      if (opts.wait) {
+        try {
+          const final = await waitForRuntime(runtimeId);
+          const wrote = fs18.existsSync(path17.join(loc.taskDir, consolidatedFile));
+          if (final.status !== "done") {
+            kick.error = final.error || `runtime ${runtimeId} ended with ${final.status}`;
+          } else if (!wrote) {
+            kick.error = `runtime completed but ${consolidatedFile} was not written`;
+          }
+          kick.wrote = wrote;
+        } catch (err) {
+          kick.error = err.message;
+        }
+      }
+      kicks.push(kick);
+    } catch (err) {
+      kicks.push({
+        issue: issue2.file,
+        runtimeId: "",
+        sessionName: "",
+        consolidatedFile,
+        error: err.message
+      });
+    }
+  }
+  return { kicks };
+}
+async function approve(opts) {
+  const loc = resolveTaskByObjectId(opts.objectId);
+  const workflow = readWorkflow(loc.taskYml);
+  const decisions = workflow.decisions || {};
+  const candidates = [];
+  if (opts.issue) {
+    const normalized = normalizeIssueFile(opts.issue);
+    const record = decisions[normalized];
+    if (!record?.consolidated_file) {
+      throw new Error(`${normalized} has no consolidated decision. Run \`task0 issue consolidate-propose\` first.`);
+    }
+    candidates.push({ issueFile: normalized, record });
+  } else {
+    for (const [issueFile, record] of Object.entries(decisions)) {
+      if (record?.consolidated_file && !record.approved_at) {
+        candidates.push({ issueFile, record });
+      }
+    }
+    if (candidates.length === 0) {
+      throw new Error("No consolidated decisions pending approval. Run `task0 issue consolidate-propose` first.");
+    }
+  }
+  const updated = [];
+  const approvedAt = (/* @__PURE__ */ new Date()).toISOString();
+  for (const c of candidates) {
+    const consolidatedFile = c.record.consolidated_file;
+    const { replaced } = rewriteIssueWithDecisions(loc.taskDir, c.issueFile, consolidatedFile);
+    await updateWorkflow(loc.taskYml, {
+      decisions: {
+        [c.issueFile]: { approved_at: approvedAt }
+      }
+    });
+    updated.push({
+      issue: c.issueFile.replace(/\.md$/, ""),
+      issueFile: c.issueFile,
+      questionsReplaced: replaced,
+      consolidatedFile
+    });
+  }
+  return { updated };
+}
+function buildReferenceFiles(taskDir, issue2) {
+  const names = fs18.readdirSync(taskDir);
+  const refs = [issue2.file];
+  if (names.includes("ISSUE.md")) refs.push("ISSUE.md");
+  const ideaFile = `IDEA-${issue2.index}.md`;
+  if (names.includes(ideaFile)) refs.push(ideaFile);
+  return refs;
+}
+
+// src/commands/issue.ts
+var issue = new Command18("issue").description(
+  "Resolve blocking ISSUE Open Questions via multi-agent decision proposals"
+);
+issue.command("propose <taskId>").description(`Fan out agents to propose decisions for the task's blocking "## Open Questions"`).option("--issue <file>", "Specific ISSUE file (ISSUE-NN, NN, or ISSUE-NN.md); defaults to all blocking ISSUEs").option("-a, --agents <list>", "Comma-separated agents", "codex,claude-code").option("--additional-prompt <text>", "Extra prompt content appended to the default propose prompt").option("--model <id>", "Model id or alias (only valid with a single agent)").option("--effort <level>", "Reasoning effort (only valid with a single agent)").option("--wait", "Wait for each runtime to finish").option("--force", "Overwrite existing DECISION files").option("--if-needed", "Idempotent: skip issues with no Open Questions and agents whose DECISION file already exists (exit 0)").option("--json", "Output JSON").action(async (taskId, opts) => {
+  try {
+    const agents = opts.agents.split(",").map((a) => a.trim()).filter(Boolean);
+    const result = await propose({
+      objectId: taskId,
+      issue: opts.issue,
+      agents,
+      additionalPrompt: opts.additionalPrompt,
+      model: opts.model,
+      effort: opts.effort,
+      wait: opts.wait,
+      force: opts.force,
+      ifNeeded: opts.ifNeeded,
+      warn: opts.json ? void 0 : (m) => console.error(chalk18.dim(m))
+    });
+    if (opts.json) {
+      console.log(JSON.stringify(result, null, 2));
+      const anyFailed2 = result.issues.some((i) => i.kicks.some((k) => k.error));
+      if (anyFailed2) process.exit(1);
+      return;
+    }
+    if (opts.ifNeeded && result.issues.length === 0) {
+      console.log(chalk18.dim("no blocking Open Questions; nothing to propose"));
+      return;
+    }
+    let anyFailed = false;
+    for (const item of result.issues) {
+      console.log(chalk18.bold(item.issue));
+      for (const k of item.kicks) {
+        if (k.error) {
+          anyFailed = true;
+          console.error(chalk18.red(`  [${k.agent}] ${k.error}`));
+        } else if (k.skipped === "already-exists") {
+          console.log(chalk18.dim(`  [${k.agent}] skipped (${k.decisionFile} exists)`));
+        } else {
+          console.log(chalk18.green(`  [${k.agent}]`) + ` runtime ${k.runtimeId} \u2192 ${k.decisionFile}`);
+        }
+      }
+    }
+    if (anyFailed) process.exit(1);
+  } catch (err) {
+    console.error(chalk18.red(err.message));
+    process.exit(1);
+  }
+});
+issue.command("consolidate-propose <taskId>").description("Synthesize DECISION-NN-<agent>.md proposals into DECISION-NN-consolidated.md").option("--issue <file>", "Specific ISSUE file; defaults to all blocking ISSUEs with proposals").option("--agent <name>", "Agent to run consolidation", "claude-code").option("--model <id>", "Model id or alias").option("--effort <level>", "Reasoning effort").option("--wait", "Wait for the consolidation runtime to finish").option("--json", "Output JSON").action(async (taskId, opts) => {
+  try {
+    const result = await consolidate({
+      objectId: taskId,
+      issue: opts.issue,
+      agent: opts.agent,
+      model: opts.model,
+      effort: opts.effort,
+      wait: opts.wait,
+      warn: opts.json ? void 0 : (m) => console.error(chalk18.dim(m))
+    });
+    if (opts.json) {
+      console.log(JSON.stringify(result, null, 2));
+      const anyFailed2 = result.kicks.some((k) => k.error);
+      if (anyFailed2) process.exit(1);
+      return;
+    }
+    let anyFailed = false;
+    for (const k of result.kicks) {
+      if (k.error) {
+        anyFailed = true;
+        console.error(chalk18.red(`[${k.issue}] ${k.error}`));
+      } else {
+        console.log(
+          chalk18.green(`[${k.issue}]`) + ` runtime ${k.runtimeId} \u2192 ${k.consolidatedFile}` + (k.wrote === false ? chalk18.yellow(" (pending write)") : "")
+        );
+      }
+    }
+    if (anyFailed) process.exit(1);
+  } catch (err) {
+    console.error(chalk18.red(err.message));
+    process.exit(1);
+  }
+});
+issue.command("approve <taskId>").description("Apply the consolidated decisions to ISSUE files").option("--issue <file>", "Specific ISSUE file; defaults to every un-approved consolidated decision").option("--json", "Output JSON").action(async (taskId, opts) => {
+  try {
+    const result = await approve({ objectId: taskId, issue: opts.issue });
+    if (opts.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    for (const u of result.updated) {
+      console.log(chalk18.green(`approved ${u.issueFile}`) + ` (${u.questionsReplaced} decisions \u2190 ${u.consolidatedFile})`);
+    }
+  } catch (err) {
+    console.error(chalk18.red(err.message));
+    process.exit(1);
+  }
+});
+
+// src/commands/agent.ts
+import fs19 from "fs";
+import path18 from "path";
+import { spawnSync as spawnSync4 } from "child_process";
+import { Command as Command19 } from "commander";
+import chalk19 from "chalk";
+import yaml6 from "js-yaml";
+function fail5(message, code = 1) {
+  console.error(chalk19.red(message));
+  process.exit(code);
+}
+function formatAgent(a, withDetails = false) {
+  const tag = a.system ? chalk19.dim("(system)") : a.scope ? chalk19.dim(`(${a.scope})`) : "";
+  const head = `${chalk19.bold(a.slug.padEnd(24))} ${chalk19.dim(a.object_id.padEnd(16))} ${a.kind.padEnd(10)} ${tag}`;
+  if (!withDetails) return head;
+  const lines = [head];
+  if (a.description) lines.push(chalk19.dim("  " + a.description));
+  return lines.join("\n");
+}
+var agent = new Command19("agent").description("Manage agents and run them against tasks");
+agent.command("list").description("List visible agents (project + user + built-in cascade)").option("--kind <kind>", "Filter by kind: coding | llm-api | workflow").option("--include-system", "Include built-in system agents (default true)").option("--json", "Output JSON").action(async (opts) => {
+  try {
+    const params = new URLSearchParams();
+    if (opts.kind) params.set("kind", opts.kind.replace("-", "_"));
+    if (opts.includeSystem === false) params.set("include_system", "false");
+    const qs = params.toString() ? `?${params}` : "";
+    const result = await api.get(`/api/agents${qs}`);
+    if (opts.json) return console.log(JSON.stringify(result.agents, null, 2));
+    if (!result.agents.length) {
+      console.log(chalk19.dim("(no agents)"));
+      return;
+    }
+    for (const a of result.agents) console.log(formatAgent(a, true));
+  } catch (err) {
+    fail5(err.message);
+  }
+});
+agent.command("get <ref>").description("Show one agent by object_id or slug").option("--json", "Output JSON").action(async (ref, opts) => {
+  try {
+    const result = await api.get(`/api/agents/${encodeURIComponent(ref)}`);
+    if (opts.json) return console.log(JSON.stringify(result.agent, null, 2));
+    console.log(formatAgent(result.agent, true));
+    console.log();
+    console.log(chalk19.dim("--- spec ---"));
+    console.log(yaml6.dump(result.agent.spec, { lineWidth: 100 }));
+  } catch (err) {
+    const apiErr = err;
+    if (apiErr.status === 404) fail5(`not found: ${ref}`);
+    fail5(err.message);
+  }
+});
+agent.command("create").description("Create an agent from a YAML spec file").requiredOption("--from-file <file>", "YAML spec file with at least kind, slug, spec").option("--scope <scope>", "Storage scope: user (default) or project", "user").option("--project-root <path>", "Project root (required for --scope project)").action(async (opts) => {
+  let parsed;
+  try {
+    const raw = fs19.readFileSync(path18.resolve(opts.fromFile), "utf-8");
+    parsed = yaml6.load(raw);
+  } catch (err) {
+    fail5(`cannot read ${opts.fromFile}: ${err.message}`);
+  }
+  try {
+    const body = { ...parsed, scope: opts.scope, project_root: opts.projectRoot };
+    const result = await api.post("/api/agents", body);
+    console.log(chalk19.green(`created ${result.agent.slug} (${result.agent.object_id})`));
+  } catch (err) {
+    fail5(err.message);
+  }
+});
+agent.command("edit <ref>").description("Open the agent YAML in $EDITOR and save changes").action(async (ref) => {
+  try {
+    const result = await api.get(`/api/agents/${encodeURIComponent(ref)}`);
+    if (result.agent.system) fail5("cannot edit a system agent");
+    const tmp = path18.join(
+      process.env.TMPDIR || "/tmp",
+      `task0-agent-${result.agent.slug}-${Date.now()}.yml`
+    );
+    fs19.writeFileSync(tmp, yaml6.dump(result.agent, { lineWidth: 100 }), "utf-8");
+    const editor = process.env.EDITOR || "vi";
+    const r = spawnSync4(editor, [tmp], { stdio: "inherit" });
+    if (r.status !== 0) fail5(`editor exited with status ${r.status}`);
+    const updated = yaml6.load(fs19.readFileSync(tmp, "utf-8"));
+    await api.put(`/api/agents/${encodeURIComponent(ref)}`, updated);
+    fs19.unlinkSync(tmp);
+    console.log(chalk19.green(`updated ${ref}`));
+  } catch (err) {
+    fail5(err.message);
+  }
+});
+agent.command("delete <ref>").description("Delete an agent").action(async (ref) => {
+  try {
+    const result = await api.del(`/api/agents/${encodeURIComponent(ref)}`);
+    if (!result.deleted) fail5(`not deleted: ${ref}`);
+    console.log(chalk19.green(`deleted ${ref}`));
+  } catch (err) {
+    fail5(err.message);
+  }
+});
+agent.command("run <ref>").description("Run an agent against a task with a user prompt").requiredOption("--task <task-id>", "Task id (tsk_\u2026 or directory name)").requiredOption("--prompt <text>", "User prompt to send the agent").option("--stream", "Stream output.jsonl to stdout as it arrives").option("--attach", "Open tmux session (coding agents only)").action(async (ref, opts) => {
+  try {
+    const result = await api.post(
+      `/api/agents/${encodeURIComponent(ref)}/run`,
+      { task_id: opts.task, prompt: opts.prompt }
+    );
+    console.log(chalk19.green(`runtime ${result.runtime.id} started`));
+    if (result.runtime.objectId) console.log(chalk19.dim(`object_id: ${result.runtime.objectId}`));
+    if (opts.stream) {
+      await streamOutput(ref, result.runtime.id);
+    }
+    if (opts.attach) {
+      console.log(chalk19.dim("--attach not yet wired; runtime is visible in dashboard"));
+    }
+  } catch (err) {
+    fail5(err.message);
+  }
+});
+async function streamOutput(ref, runtimeId) {
+  let lastCount = 0;
+  for (let i = 0; i < 600; i++) {
+    const result = await api.get(
+      `/api/agents/${encodeURIComponent(ref)}/runs/${encodeURIComponent(runtimeId)}/output`
+    );
+    for (const line of result.lines.slice(lastCount)) {
+      if (line.error?.message) {
+        console.error(chalk19.red(`[error] ${line.error.message}`));
+        return;
+      }
+      const text = line.message?.content?.map((c) => c.text ?? "").join("") ?? "";
+      if (text) process.stdout.write(text);
+    }
+    lastCount = result.lines.length;
+    await new Promise((r) => setTimeout(r, 500));
+  }
+}
+
+// src/commands/daemon.ts
+import os5 from "os";
+import { Command as Command20 } from "commander";
+import chalk20 from "chalk";
+import WebSocket from "ws";
+
+// src/core/daemon-config.ts
+import fs20 from "fs";
+import os4 from "os";
+import path19 from "path";
+var CONFIG_DIR2 = path19.join(os4.homedir(), ".config", "task0");
+var CONFIG_FILE2 = path19.join(CONFIG_DIR2, "daemon.json");
+function daemonConfigPath() {
+  return CONFIG_FILE2;
+}
+function readDaemonIdentity() {
+  if (!fs20.existsSync(CONFIG_FILE2)) return null;
+  try {
+    const raw = fs20.readFileSync(CONFIG_FILE2, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function writeDaemonIdentity(identity) {
+  fs20.mkdirSync(CONFIG_DIR2, { recursive: true });
+  fs20.writeFileSync(CONFIG_FILE2, JSON.stringify(identity, null, 2) + "\n", { encoding: "utf-8", mode: 384 });
+  try {
+    fs20.chmodSync(CONFIG_FILE2, 384);
+  } catch {
+  }
+}
+function clearDaemonIdentity() {
+  if (!fs20.existsSync(CONFIG_FILE2)) return false;
+  fs20.unlinkSync(CONFIG_FILE2);
+  return true;
+}
+
+// src/core/daemon-rpc-handlers.ts
+init_node();
+import fs21 from "fs";
+import path20 from "path";
+var MAX_FILE_BYTES = 1 * 1024 * 1024;
+function ensureString(value, name) {
+  if (typeof value !== "string" || value.length === 0) {
+    throw Object.assign(new Error(`${name} is required (string)`), { code: "invalid_params" });
+  }
+  return value;
+}
+var rpcHandlers = {
+  // Scan a local project for its task manifest. Returns the same shape the
+  // in-process server's /api/tasks scanProject() returns.
+  async scan_project(params) {
+    const rootPath = ensureString(params.rootPath, "rootPath");
+    const name = typeof params.name === "string" && params.name ? params.name : path20.basename(rootPath);
+    return scanProject(rootPath, name);
+  },
+  // Read a file from disk on the daemon's host. The dashboard uses this to
+  // peek into archived task content, runtime logs, etc. Cap is 1 MiB to
+  // avoid streaming huge files over a single RPC envelope.
+  async read_file(params) {
+    const filePath = ensureString(params.path, "path");
+    let stat;
+    try {
+      stat = fs21.statSync(filePath);
+    } catch {
+      throw Object.assign(new Error("file not found"), { code: "not_found" });
+    }
+    if (stat.isDirectory()) {
+      throw Object.assign(new Error("path is a directory"), { code: "invalid_target" });
+    }
+    if (stat.size > MAX_FILE_BYTES) {
+      throw Object.assign(new Error(`file too large (${stat.size} bytes > ${MAX_FILE_BYTES})`), { code: "too_large" });
+    }
+    const content = fs21.readFileSync(filePath, "utf-8");
+    return { content, size: stat.size, modifiedAt: stat.mtime.toISOString() };
+  }
+};
+
+// src/commands/daemon.ts
+var DAEMON_VERSION = "0.1.0";
+async function dispatchRpc(ws, id, method, params) {
+  const handler = rpcHandlers[method];
+  if (!handler) {
+    sendRpc(ws, { type: "rpc_error", id, error: { code: "unknown_method", message: `unknown method: ${method}` } });
+    return;
+  }
+  try {
+    const result = await handler(params ?? {});
+    sendRpc(ws, { type: "rpc_response", id, result });
+  } catch (error2) {
+    const code = error2 && typeof error2 === "object" && "code" in error2 && typeof error2.code === "string" ? error2.code : "handler_error";
+    const message = error2 instanceof Error ? error2.message : String(error2);
+    sendRpc(ws, { type: "rpc_error", id, error: { code, message } });
+  }
+}
+function sendRpc(ws, payload) {
+  if (ws.readyState === ws.OPEN) {
+    ws.send(JSON.stringify(payload));
+  }
+}
+function fail6(message, code = 1) {
+  console.error(chalk20.red(message));
+  process.exit(code);
+}
+function loadRequiredIdentity() {
+  const identity = readDaemonIdentity();
+  if (!identity) {
+    fail6(`No daemon identity at ${daemonConfigPath()}. Run \`task0 daemon register --server <url>\` first.`);
+  }
+  return identity;
+}
+function serverBase(identity) {
+  if (identity) return identity.server_url.replace(/\/$/, "");
+  return (process.env.TASK0_API_URL || "http://127.0.0.1:4318").replace(/\/$/, "");
+}
+async function jsonGet(url) {
+  let res;
+  try {
+    res = await fetch(url);
+  } catch (error2) {
+    fail6(`Cannot reach ${url}: ${error2 instanceof Error ? error2.message : String(error2)}`);
+  }
+  if (!res.ok) {
+    fail6(`Server returned ${res.status}: ${await res.text()}`);
+  }
+  return res.json();
+}
+var daemonCmd = new Command20("daemon").description("Manage this host as a task0 daemon registered with a central server");
+daemonCmd.command("register").description("Register this host with a central server and save the identity locally").requiredOption("-s, --server <url>", "Central server URL (e.g. https://central.example.com:4318)").option("-n, --name <name>", "Display name for this daemon (defaults to hostname)").option("--force", "Overwrite existing identity if present").action(async (opts) => {
+  const existing = readDaemonIdentity();
+  if (existing && !opts.force) {
+    fail6(`Already registered as ${existing.daemon_id}. Pass --force to re-register.`);
+  }
+  const base = opts.server.replace(/\/$/, "");
+  const body = {
+    hostname: os5.hostname(),
+    platform: process.platform,
+    name: opts.name
+  };
+  let res;
+  try {
+    res = await fetch(`${base}/api/daemons/register`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(body)
+    });
+  } catch (error2) {
+    fail6(`Cannot reach ${base}: ${error2 instanceof Error ? error2.message : String(error2)}`);
+  }
+  if (!res.ok) {
+    fail6(`Server rejected registration (${res.status}): ${await res.text()}`);
+  }
+  const data = await res.json();
+  const identity = {
+    daemon_id: data.daemon.object_id,
+    name: data.daemon.name,
+    hostname: data.daemon.hostname,
+    platform: data.daemon.platform,
+    server_url: base,
+    token: data.token,
+    registered_at: data.daemon.registered_at
+  };
+  writeDaemonIdentity(identity);
+  console.log(chalk20.green(`Registered as ${data.daemon.object_id} (${data.daemon.name})`));
+  console.log(`Identity saved to ${daemonConfigPath()}`);
+});
+daemonCmd.command("start").description("Start the local daemon and connect to the registered server (long-running)").action(async () => {
+  const identity = loadRequiredIdentity();
+  const wsUrl = identity.server_url.replace(/^http/, "ws").replace(/\/$/, "") + "/ws/daemon";
+  console.log(chalk20.green(`Starting daemon ${identity.daemon_id} \u2192 ${wsUrl}`));
+  let reconnectDelay = 1e3;
+  let shouldRun = true;
+  let activeWs = null;
+  function connect() {
+    const ws = new WebSocket(wsUrl, {
+      headers: { authorization: `Bearer ${identity.token}` }
+    });
+    activeWs = ws;
+    ws.on("open", () => {
+      reconnectDelay = 1e3;
+      console.log(chalk20.green(`[${(/* @__PURE__ */ new Date()).toISOString()}] connected`));
+      const hello = {
+        type: "hello",
+        daemon_id: identity.daemon_id,
+        version: DAEMON_VERSION,
+        hostname: identity.hostname,
+        platform: identity.platform
+      };
+      ws.send(JSON.stringify(hello));
+      const projects = loadConfig().sources.filter((source2) => source2.type === "project").map((source2) => ({ name: source2.name, path: source2.path, enabled: source2.enabled }));
+      const manifest = { type: "manifest", projects };
+      ws.send(JSON.stringify(manifest));
+      console.log(chalk20.dim(`pushed manifest: ${projects.length} project(s)`));
+    });
+    ws.on("message", (raw) => {
+      let msg;
+      try {
+        msg = JSON.parse(raw.toString("utf-8"));
+      } catch {
+        return;
+      }
+      if (msg.type === "welcome") {
+        console.log(chalk20.green(`welcomed ${msg.server_time}`));
+      } else if (msg.type === "ping") {
+        const beat = { type: "heartbeat", ts: (/* @__PURE__ */ new Date()).toISOString() };
+        if (ws.readyState === ws.OPEN) ws.send(JSON.stringify(beat));
+      } else if (msg.type === "error") {
+        console.error(chalk20.yellow(`server error: ${msg.message}`));
+      } else if (msg.type === "rpc_request") {
+        void dispatchRpc(ws, msg.id, msg.method, msg.params);
+      }
+    });
+    ws.on("close", (code, reason) => {
+      activeWs = null;
+      const reasonText = reason.toString("utf-8") || "no reason";
+      console.log(chalk20.yellow(`[${(/* @__PURE__ */ new Date()).toISOString()}] disconnected (code=${code}, ${reasonText})`));
+      if (code === 4001) {
+        console.error(chalk20.red("superseded by another daemon connection; exiting"));
+        process.exit(0);
+      }
+      if (shouldRun) {
+        setTimeout(connect, reconnectDelay);
+        reconnectDelay = Math.min(reconnectDelay * 2, 3e4);
+      }
+    });
+    ws.on("error", (err) => {
+      console.error(chalk20.red(`ws error: ${err.message}`));
+    });
+  }
+  const shutdown = () => {
+    shouldRun = false;
+    try {
+      activeWs?.close(1e3, "shutdown");
+    } catch {
+    }
+    setTimeout(() => process.exit(0), 200).unref();
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  connect();
+  await new Promise(() => {
+  });
+});
+daemonCmd.command("list").description("List daemons registered on the configured server").action(async () => {
+  const base = serverBase(readDaemonIdentity());
+  const data = await jsonGet(`${base}/api/daemons`);
+  if (data.daemons.length === 0) {
+    console.log("No daemons registered.");
+    return;
+  }
+  for (const d of data.daemons) {
+    const status = d.status === "online" ? chalk20.green(d.status) : chalk20.dim(d.status);
+    console.log(
+      `${chalk20.bold(d.object_id)}  ${d.name.padEnd(20)}  ${d.hostname.padEnd(24)}  ${d.platform.padEnd(8)}  ${status}`
+    );
+  }
+});
+daemonCmd.command("show [daemonId]").description("Show local daemon identity (no arg) or remote daemon by id").action(async (daemonId) => {
+  if (!daemonId) {
+    const identity = loadRequiredIdentity();
+    console.log(JSON.stringify({ ...identity, token: "***" }, null, 2));
+    return;
+  }
+  const base = serverBase(readDaemonIdentity());
+  const data = await jsonGet(`${base}/api/daemons/${encodeURIComponent(daemonId)}`);
+  console.log(JSON.stringify(data.daemon, null, 2));
+});
+daemonCmd.command("logout").description("Forget the locally stored daemon identity").action(() => {
+  if (clearDaemonIdentity()) {
+    console.log(chalk20.green("Daemon identity cleared."));
+  } else {
+    console.log("No daemon identity to clear.");
+  }
+});
+
+// src/commands/error.ts
+init_node();
+import { Command as Command21 } from "commander";
+import chalk21 from "chalk";
+import readline from "readline";
+var error = new Command21("error").description("Browse and manage captured CLI error reports (local, ~/.task0/errors)");
+function truncate(s, n) {
+  if (s.length <= n) return s;
+  return s.slice(0, Math.max(0, n - 1)) + "\u2026";
+}
+function formatSize(bytes) {
+  if (bytes < 1024) return `${bytes}B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}K`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)}M`;
+}
+function printListTable(reports) {
+  if (reports.length === 0) {
+    console.log(chalk21.dim("No error reports."));
+    return;
+  }
+  const idW = Math.max(...reports.map((r) => r.id.length), 12);
+  for (const r of reports) {
+    const id = r.id.padEnd(idW);
+    const ts = r.captured_at.padEnd(24);
+    const name = truncate(r.error_name || "-", 20).padEnd(20);
+    const cmd = truncate(r.command || "-", 50).padEnd(50);
+    const size = formatSize(r.size_bytes).padStart(6);
+    console.log(`${chalk21.cyan(id)} ${chalk21.dim(ts)} ${name} ${cmd} ${chalk21.dim(size)}`);
+  }
+}
+error.command("ls").description("List captured error reports (newest first)").option("--json", "Output JSON envelope").option("--limit <n>", "Max rows to display", "50").action((opts) => {
+  const result = listErrorReports();
+  const limit = Math.max(0, Number(opts.limit) || 50);
+  const reports = result.reports.slice(0, limit);
+  if (opts.json) {
+    console.log(JSON.stringify({ reports, skipped: result.skipped }, null, 2));
+    return;
+  }
+  printListTable(reports);
+  if (result.skipped.unreadable > 0 || result.skipped.unsupported_schema > 0) {
+    console.log(
+      chalk21.dim(
+        `  (skipped: unreadable=${result.skipped.unreadable}, unsupported_schema=${result.skipped.unsupported_schema})`
+      )
+    );
+  }
+});
+function resolveOrFail(query) {
+  const result = resolveErrorReport(query);
+  if (result.kind === "hit") return result.summary;
+  if (result.kind === "ambiguous") {
+    const ids = result.candidates.map((c) => c.id).join(", ");
+    console.error(chalk21.red(`ambiguous id prefix "${query}"; candidates: ${ids}`));
+    process.exit(1);
+  }
+  console.error(chalk21.red(`no error report found matching "${query}"`));
+  process.exit(1);
+}
+function printReportPretty(report) {
+  console.log(`${chalk21.bold("id:")}           ${report.id}`);
+  console.log(`${chalk21.bold("captured_at:")}  ${report.captured_at}`);
+  console.log(`${chalk21.bold("origin:")}       ${report.origin}`);
+  console.log(`${chalk21.bold("task0:")}        ${report.task0_version}`);
+  console.log(`${chalk21.bold("node:")}         ${report.node_version}  ${report.platform}/${report.arch}`);
+  console.log(`${chalk21.bold("pid/ppid:")}     ${report.pid}/${report.ppid}`);
+  console.log("");
+  console.log(chalk21.bold("command:"));
+  console.log(`  ${report.command}`);
+  console.log(`  ${chalk21.dim("argv:")} ${JSON.stringify(report.argv)}`);
+  console.log(`  ${chalk21.dim("cwd:")}  ${report.cwd}`);
+  console.log("");
+  console.log(chalk21.bold("error:"));
+  console.log(`  ${chalk21.red(report.error.name)}: ${report.error.message}`);
+  if (report.error.exit_code !== null) {
+    console.log(`  ${chalk21.dim("exit_code:")} ${report.error.exit_code}`);
+  }
+  if (report.error.stack) {
+    console.log(chalk21.dim("--- stack ---"));
+    console.log(report.error.stack);
+  }
+  console.log("");
+  if (report.git) {
+    console.log(chalk21.bold("git:"));
+    console.log(`  root:   ${report.git.root ?? "-"}`);
+    console.log(`  head:   ${report.git.head ?? "-"}`);
+    console.log(`  branch: ${report.git.branch ?? "-"}`);
+    console.log("");
+  }
+  const envKeys = Object.keys(report.env).sort();
+  if (envKeys.length > 0) {
+    console.log(chalk21.bold("env:"));
+    for (const k of envKeys) {
+      console.log(`  ${k}=${report.env[k]}`);
+    }
+    console.log("");
+  }
+  console.log(chalk21.bold("redaction:"));
+  console.log(`  argv_redacted:    ${report.redaction.argv_redacted}`);
+  console.log(`  message_redacted: ${report.redaction.message_redacted}`);
+  console.log(`  stack_redacted:   ${report.redaction.stack_redacted}`);
+  console.log(`  env_strategy:     ${report.redaction.env_strategy}`);
+}
+error.command("show <id>").description("Print a captured error report (full id or unique prefix)").option("--json", "Output the full JSON report").action((id, opts) => {
+  const summary = resolveOrFail(id);
+  const report = readErrorReport(summary);
+  if (opts.json) {
+    console.log(JSON.stringify(report, null, 2));
+    return;
+  }
+  printReportPretty(report);
+});
+error.command("path <id>").description("Print the absolute path to a captured error report").action((id) => {
+  const summary = resolveOrFail(id);
+  console.log(summary.path);
+});
+var DURATION_RE = /^(\d+)(s|m|h|d)$/i;
+function parseDuration(input) {
+  const m = DURATION_RE.exec(input.trim());
+  if (!m) throw new Error(`invalid duration "${input}" (expected e.g. 7d, 12h, 30m, 120s)`);
+  const n = Number(m[1]);
+  const unit = m[2].toLowerCase();
+  const mult = unit === "s" ? 1e3 : unit === "m" ? 6e4 : unit === "h" ? 36e5 : 864e5;
+  return n * mult;
+}
+async function confirmTty(message) {
+  if (!process.stdin.isTTY || !process.stdout.isTTY) return false;
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  const answer = await new Promise((resolve) => {
+    rl.question(message, resolve);
+  });
+  rl.close();
+  return /^(y|yes)$/i.test(answer.trim());
+}
+error.command("prune").description("Remove captured error reports by age, count, or all").option("--older-than <duration>", "Remove reports older than duration (e.g. 7d, 12h, 30m, 120s)").option("--keep <n>", "Keep the newest N reports and remove the rest").option("--all", "Remove every captured report").option("--yes", "Skip confirmation prompt (required for --all on non-TTY)").option("--json", "Output JSON summary").action(async (opts) => {
+  const hasAny = Boolean(opts.olderThan) || opts.keep !== void 0 || opts.all === true;
+  if (!hasAny) {
+    console.error(chalk21.red("prune: require at least one of --older-than, --keep, or --all"));
+    process.exit(1);
+  }
+  if (opts.all && (opts.olderThan || opts.keep !== void 0)) {
+    console.error(chalk21.red("prune: --all is mutually exclusive with --older-than / --keep"));
+    process.exit(1);
+  }
+  if (opts.all && !opts.yes) {
+    const ok = await confirmTty("Remove ALL captured error reports? [y/N] ");
+    if (!ok) {
+      console.error(chalk21.red("prune --all aborted (pass --yes to confirm non-interactively)."));
+      process.exit(1);
+    }
+  }
+  const olderThanMs = opts.olderThan ? parseDuration(opts.olderThan) : void 0;
+  const keep = opts.keep !== void 0 ? Math.max(0, Number(opts.keep)) : void 0;
+  const res = pruneErrorReports({
+    olderThanMs,
+    keep,
+    all: opts.all === true
+  });
+  if (opts.json) {
+    console.log(JSON.stringify({ removed: res.removed.length, kept: res.kept, paths: res.removed }, null, 2));
+    return;
+  }
+  console.log(`Removed ${res.removed.length} report(s); ${res.kept} remaining.`);
+});
+
+// src/core/error-capture.ts
+init_node();
+var DEFAULT_KEEP = 50;
+var DEFAULT_MAX_AGE_MS = 14 * 24 * 60 * 60 * 1e3;
+var state = {
+  captured: false,
+  seen: /* @__PURE__ */ new WeakSet(),
+  lastReportPath: null
+};
+function isCaptureDisabled() {
+  return process.env.TASK0_DISABLE_ERROR_CAPTURE === "1";
+}
+var COMMANDER_BENIGN_CODES = /* @__PURE__ */ new Set([
+  "commander.helpDisplayed",
+  "commander.help",
+  "commander.version",
+  "commander.missingArgument",
+  "commander.unknownOption",
+  "commander.unknownCommand",
+  "commander.missingMandatoryOptionValue",
+  "commander.invalidArgument",
+  "commander.excessArguments",
+  "commander.optionMissingArgument",
+  "commander.error"
+]);
+function isCommanderBenignError(err) {
+  if (!err || typeof err !== "object") return false;
+  const e = err;
+  if (typeof e.code === "string" && COMMANDER_BENIGN_CODES.has(e.code)) return true;
+  return false;
+}
+function captureAndWrite(ctx) {
+  if (isCaptureDisabled()) return null;
+  if (state.captured) return state.lastReportPath;
+  if (ctx.error instanceof Error) {
+    if (state.seen.has(ctx.error)) return state.lastReportPath;
+    state.seen.add(ctx.error);
+  }
+  state.captured = true;
+  try {
+    const argv = ctx.options.argv ?? process.argv.slice(2);
+    const cwd = ctx.options.cwd ?? process.cwd();
+    const report = buildErrorReport({
+      origin: ctx.origin,
+      error: ctx.error,
+      argv,
+      cwd,
+      task0Version: ctx.options.version,
+      exitCode: ctx.exitCode ?? null
+    });
+    const { path: reportPath } = writeErrorReportSync(report);
+    state.lastReportPath = reportPath;
+    try {
+      pruneErrorReports({ keep: DEFAULT_KEEP, olderThanMs: DEFAULT_MAX_AGE_MS });
+    } catch {
+    }
+    return reportPath;
+  } catch {
+    return null;
+  }
+}
+function normalizeReason(reason) {
+  if (reason instanceof Error) return reason;
+  const err = new Error(typeof reason === "string" ? reason : safeStringify2(reason));
+  err.name = "UnhandledRejection";
+  return err;
+}
+function safeStringify2(value) {
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+var installed = false;
+function installErrorCapture(options) {
+  if (installed) return;
+  installed = true;
+  if (isCaptureDisabled()) return;
+  process.on("uncaughtExceptionMonitor", (err) => {
+    captureAndWrite({ origin: "uncaught_exception", error: err, options });
+  });
+  process.on("unhandledRejection", (reason) => {
+    const err = normalizeReason(reason);
+    captureAndWrite({ origin: "unhandled_rejection", error: err, options });
+  });
+}
+function captureTopLevel(err, options) {
+  return captureAndWrite({
+    origin: "top_level_catch",
+    error: err,
+    options,
+    exitCode: 1
+  });
+}
+
+// src/main.ts
+var TASK0_VERSION = "0.1.0";
+var program = new Command22().name("task0").description("Task-centric control layer for agent workflow").version(TASK0_VERSION);
+program.addCommand(source);
+program.addCommand(project);
+program.addCommand(task);
+program.addCommand(runtime);
+program.addCommand(plan);
+program.addCommand(okr);
+program.addCommand(note);
+program.addCommand(run);
+program.addCommand(ui);
+program.addCommand(serve);
+program.addCommand(models);
+program.addCommand(object);
+program.addCommand(issue);
+program.addCommand(agent);
+program.addCommand(daemonCmd);
+program.addCommand(error);
+async function main() {
+  installErrorCapture({ version: TASK0_VERSION });
+  try {
+    await program.parseAsync(process.argv);
+  } catch (err) {
+    if (!isCommanderBenignError(err)) {
+      captureTopLevel(err, { version: TASK0_VERSION });
+    }
+    throw err;
+  }
+}
+main().catch((err) => {
+  const exitErr = err;
+  if (exitErr && typeof exitErr.exitCode === "number") {
+    process.exit(exitErr.exitCode);
+  }
+  const msg = err instanceof Error ? err.stack ?? err.message : String(err);
+  console.error(msg);
+  process.exit(1);
+});