@hasna/todos 0.10.22 → 0.11.2

package/dist/cli/index.js

@@ -2347,6 +2347,15 @@ function ensureSchema(db) {
   ensureColumn("tasks", "assigned_by", "TEXT");
   ensureColumn("tasks", "assigned_from_project", "TEXT");
   ensureColumn("tasks", "started_at", "TEXT");
+  ensureColumn("tasks", "task_type", "TEXT");
+  ensureColumn("tasks", "cost_tokens", "INTEGER DEFAULT 0");
+  ensureColumn("tasks", "cost_usd", "REAL DEFAULT 0");
+  ensureColumn("tasks", "delegated_from", "TEXT");
+  ensureColumn("tasks", "delegation_depth", "INTEGER DEFAULT 0");
+  ensureColumn("tasks", "retry_count", "INTEGER DEFAULT 0");
+  ensureColumn("tasks", "max_retries", "INTEGER DEFAULT 3");
+  ensureColumn("tasks", "retry_after", "TEXT");
+  ensureColumn("tasks", "sla_minutes", "INTEGER");
   ensureColumn("agents", "role", "TEXT DEFAULT 'agent'");
   ensureColumn("agents", "permissions", `TEXT DEFAULT '["*"]'`);
   ensureColumn("agents", "reports_to", "TEXT");
@@ -2960,6 +2969,58 @@ var init_database = __esm(() => {
     `
   ALTER TABLE tasks ADD COLUMN task_type TEXT;
   CREATE INDEX IF NOT EXISTS idx_tasks_task_type ON tasks(task_type);
+  ALTER TABLE tasks ADD COLUMN cost_tokens INTEGER DEFAULT 0;
+  ALTER TABLE tasks ADD COLUMN cost_usd REAL DEFAULT 0;
+  ALTER TABLE tasks ADD COLUMN delegated_from TEXT;
+  ALTER TABLE tasks ADD COLUMN delegation_depth INTEGER DEFAULT 0;
+  ALTER TABLE tasks ADD COLUMN retry_count INTEGER DEFAULT 0;
+  ALTER TABLE tasks ADD COLUMN max_retries INTEGER DEFAULT 3;
+  ALTER TABLE tasks ADD COLUMN retry_after TEXT;
+  ALTER TABLE tasks ADD COLUMN sla_minutes INTEGER;
+
+  CREATE TABLE IF NOT EXISTS task_traces (
+    id TEXT PRIMARY KEY,
+    task_id TEXT NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+    agent_id TEXT,
+    trace_type TEXT NOT NULL CHECK(trace_type IN ('tool_call','llm_call','error','handoff','custom')),
+    name TEXT,
+    input_summary TEXT,
+    output_summary TEXT,
+    duration_ms INTEGER,
+    tokens INTEGER,
+    cost_usd REAL,
+    created_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+  CREATE INDEX IF NOT EXISTS idx_task_traces_task ON task_traces(task_id);
+  CREATE INDEX IF NOT EXISTS idx_task_traces_agent ON task_traces(agent_id);
+
+  CREATE TABLE IF NOT EXISTS context_snapshots (
+    id TEXT PRIMARY KEY,
+    agent_id TEXT,
+    task_id TEXT REFERENCES tasks(id) ON DELETE SET NULL,
+    project_id TEXT REFERENCES projects(id) ON DELETE SET NULL,
+    snapshot_type TEXT NOT NULL CHECK(snapshot_type IN ('interrupt','complete','handoff','checkpoint')),
+    plan_summary TEXT,
+    files_open TEXT DEFAULT '[]',
+    attempts TEXT DEFAULT '[]',
+    blockers TEXT DEFAULT '[]',
+    next_steps TEXT,
+    metadata TEXT DEFAULT '{}',
+    created_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+  CREATE INDEX IF NOT EXISTS idx_snapshots_agent ON context_snapshots(agent_id);
+  CREATE INDEX IF NOT EXISTS idx_snapshots_task ON context_snapshots(task_id);
+
+  CREATE TABLE IF NOT EXISTS agent_budgets (
+    agent_id TEXT PRIMARY KEY,
+    max_concurrent INTEGER DEFAULT 5,
+    max_cost_usd REAL,
+    max_task_minutes INTEGER,
+    period_hours INTEGER DEFAULT 24,
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+
   INSERT OR IGNORE INTO _migrations (id) VALUES (35);
   `
   ];
@@ -3755,12 +3816,14 @@ var exports_tasks = {};
 __export(exports_tasks, {
   updateTask: () => updateTask,
   unlockTask: () => unlockTask,
+  stealTask: () => stealTask,
   startTask: () => startTask,
   setTaskStatus: () => setTaskStatus,
   setTaskPriority: () => setTaskPriority,
   removeDependency: () => removeDependency,
   redistributeStaleTasks: () => redistributeStaleTasks,
   moveTask: () => moveTask,
+  logCost: () => logCost,
   lockTask: () => lockTask,
   listTasks: () => listTasks,
   getTasksChangedSince: () => getTasksChangedSince,
@@ -3783,6 +3846,7 @@ __export(exports_tasks, {
   countTasks: () => countTasks,
   completeTask: () => completeTask,
   cloneTask: () => cloneTask,
+  claimOrSteal: () => claimOrSteal,
   claimNextTask: () => claimNextTask,
   bulkUpdateTasks: () => bulkUpdateTasks,
   bulkCreateTasks: () => bulkCreateTasks,
@@ -4264,6 +4328,20 @@ function completeTask(id, agentId, db, options) {
   if (spawnedFromTemplate) {
     meta._spawned_task = { id: spawnedFromTemplate.id, short_id: spawnedFromTemplate.short_id, title: spawnedFromTemplate.title };
   }
+  const unblockedDeps = d.query(`SELECT DISTINCT t.id, t.short_id, t.title FROM tasks t
+     JOIN task_dependencies td ON td.task_id = t.id
+     WHERE td.depends_on = ? AND t.status = 'pending'
+     AND NOT EXISTS (
+       SELECT 1 FROM task_dependencies td2
+       JOIN tasks dep2 ON dep2.id = td2.depends_on
+       WHERE td2.task_id = t.id AND dep2.status NOT IN ('completed', 'cancelled') AND dep2.id != ?
+     )`).all(id, id);
+  if (unblockedDeps.length > 0) {
+    meta._unblocked = unblockedDeps.map((d2) => ({ id: d2.id, short_id: d2.short_id, title: d2.title }));
+    for (const dep of unblockedDeps) {
+      dispatchWebhook("task.unblocked", { id: dep.id, unblocked_by: id, title: dep.title }, d).catch(() => {});
+    }
+  }
   return { ...task, status: "completed", locked_by: null, locked_at: null, completed_at: timestamp, confidence, version: task.version + 1, updated_at: timestamp, metadata: meta };
 }
 function lockTask(id, agentId, db) {
@@ -4560,24 +4638,36 @@ function failTask(id, agentId, reason, options, db) {
   };
   let retryTask;
   if (options?.retry) {
-    let title = task.title;
-    if (task.short_id && title.startsWith(task.short_id + ": ")) {
-      title = title.slice(task.short_id.length + 2);
+    const retryCount = (task.retry_count || 0) + 1;
+    const maxRetries = task.max_retries || 3;
+    if (retryCount > maxRetries) {
+      d.run("UPDATE tasks SET metadata = ? WHERE id = ?", [
+        JSON.stringify({ ...meta, _retry_exhausted: { retry_count: retryCount - 1, max_retries: maxRetries } }),
+        id
+      ]);
+    } else {
+      const backoffMinutes = Math.pow(5, retryCount - 1);
+      const retryAfter = options.retry_after || new Date(Date.now() + backoffMinutes * 60 * 1000).toISOString();
+      let title = task.title;
+      if (task.short_id && title.startsWith(task.short_id + ": ")) {
+        title = title.slice(task.short_id.length + 2);
+      }
+      retryTask = createTask({
+        title,
+        description: task.description ?? undefined,
+        priority: task.priority,
+        project_id: task.project_id ?? undefined,
+        task_list_id: task.task_list_id ?? undefined,
+        plan_id: task.plan_id ?? undefined,
+        assigned_to: task.assigned_to ?? undefined,
+        tags: task.tags,
+        metadata: { ...task.metadata, _retry: { original_id: task.id, retry_count: retryCount, max_retries: maxRetries, retry_after: retryAfter, failure_reason: reason } },
+        estimated_minutes: task.estimated_minutes ?? undefined,
+        recurrence_rule: task.recurrence_rule ?? undefined,
+        due_at: retryAfter
+      }, d);
+      d.run("UPDATE tasks SET retry_count = ?, max_retries = ?, retry_after = ? WHERE id = ?", [retryCount, maxRetries, retryAfter, retryTask.id]);
     }
-    retryTask = createTask({
-      title,
-      description: task.description ?? undefined,
-      priority: task.priority,
-      project_id: task.project_id ?? undefined,
-      task_list_id: task.task_list_id ?? undefined,
-      plan_id: task.plan_id ?? undefined,
-      assigned_to: task.assigned_to ?? undefined,
-      tags: task.tags,
-      metadata: { ...task.metadata, _retry: { original_id: task.id, retry_after: options.retry_after || null, failure_reason: reason } },
-      estimated_minutes: task.estimated_minutes ?? undefined,
-      recurrence_rule: task.recurrence_rule ?? undefined,
-      due_at: options.retry_after || task.due_at || undefined
-    }, d);
   }
   return { task: failedTask, retryTask };
 }
@@ -4601,6 +4691,40 @@ function getStaleTasks(staleMinutes = 30, filters, db) {
   const rows = d.query(`SELECT * FROM tasks WHERE ${where} ORDER BY updated_at ASC`).all(...params);
   return rows.map(rowToTask);
 }
+function logCost(taskId, tokens, usd, db) {
+  const d = db || getDatabase();
+  d.run("UPDATE tasks SET cost_tokens = cost_tokens + ?, cost_usd = cost_usd + ?, updated_at = ? WHERE id = ?", [tokens, usd, now(), taskId]);
+}
+function stealTask(agentId, opts, db) {
+  const d = db || getDatabase();
+  const staleMinutes = opts?.stale_minutes ?? 30;
+  const staleTasks = getStaleTasks(staleMinutes, { project_id: opts?.project_id, task_list_id: opts?.task_list_id }, d);
+  if (staleTasks.length === 0)
+    return null;
+  const priorityOrder = { critical: 0, high: 1, medium: 2, low: 3 };
+  staleTasks.sort((a, b) => (priorityOrder[a.priority] ?? 9) - (priorityOrder[b.priority] ?? 9));
+  const target = staleTasks[0];
+  const timestamp = now();
+  d.run(`UPDATE tasks SET assigned_to = ?, locked_by = ?, locked_at = ?, updated_at = ?, version = version + 1 WHERE id = ?`, [agentId, agentId, timestamp, timestamp, target.id]);
+  logTaskChange(target.id, "steal", "assigned_to", target.assigned_to, agentId, agentId, d);
+  dispatchWebhook("task.assigned", { id: target.id, agent_id: agentId, title: target.title, stolen_from: target.assigned_to }, d).catch(() => {});
+  return { ...target, assigned_to: agentId, locked_by: agentId, locked_at: timestamp, updated_at: timestamp, version: target.version + 1 };
+}
+function claimOrSteal(agentId, filters, db) {
+  const d = db || getDatabase();
+  const tx = d.transaction(() => {
+    const next = getNextTask(agentId, filters, d);
+    if (next) {
+      const started = startTask(next.id, agentId, d);
+      return { task: started, stolen: false };
+    }
+    const stolen = stealTask(agentId, { stale_minutes: filters?.stale_minutes, project_id: filters?.project_id, task_list_id: filters?.task_list_id }, d);
+    if (stolen)
+      return { task: stolen, stolen: true };
+    return null;
+  });
+  return tx();
+}
 function getStatus(filters, agentId, options, db) {
   const d = db || getDatabase();
   const pending = countTasks({ ...filters, status: "pending" }, d);
@@ -6199,8 +6323,8 @@ __export(exports_extract, {
   extractFromSource: () => extractFromSource,
   EXTRACT_TAGS: () => EXTRACT_TAGS
 });
-import { readFileSync as readFileSync3, statSync as statSync2 } from "fs";
-import { relative, resolve as resolve2, join as join6 } from "path";
+import { readFileSync as readFileSync4, statSync as statSync2 } from "fs";
+import { relative, resolve as resolve2, join as join8 } from "path";
 function tagToPriority(tag) {
   switch (tag) {
     case "BUG":
@@ -6272,9 +6396,9 @@ function extractTodos(options, db) {
   const files = collectFiles(basePath, extensions);
   const allComments = [];
   for (const file of files) {
-    const fullPath = statSync2(basePath).isFile() ? basePath : join6(basePath, file);
+    const fullPath = statSync2(basePath).isFile() ? basePath : join8(basePath, file);
     try {
-      const source = readFileSync3(fullPath, "utf-8");
+      const source = readFileSync4(fullPath, "utf-8");
       const relPath = statSync2(basePath).isFile() ? relative(resolve2(basePath, ".."), fullPath) : file;
       const comments = extractFromSource(source, relPath, tags);
       allComments.push(...comments);
@@ -10363,6 +10487,219 @@ var init_zod = __esm(() => {
   init_external();
 });
 
+// src/db/traces.ts
+var exports_traces = {};
+__export(exports_traces, {
+  logTrace: () => logTrace,
+  getTraceStats: () => getTraceStats,
+  getTaskTraces: () => getTaskTraces
+});
+function logTrace(input, db) {
+  const d = db || getDatabase();
+  const id = uuid();
+  const timestamp = now();
+  d.run(`INSERT INTO task_traces (id, task_id, agent_id, trace_type, name, input_summary, output_summary, duration_ms, tokens, cost_usd, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+    id,
+    input.task_id,
+    input.agent_id || null,
+    input.trace_type,
+    input.name || null,
+    input.input_summary || null,
+    input.output_summary || null,
+    input.duration_ms ?? null,
+    input.tokens ?? null,
+    input.cost_usd ?? null,
+    timestamp
+  ]);
+  return {
+    id,
+    task_id: input.task_id,
+    agent_id: input.agent_id || null,
+    trace_type: input.trace_type,
+    name: input.name || null,
+    input_summary: input.input_summary || null,
+    output_summary: input.output_summary || null,
+    duration_ms: input.duration_ms ?? null,
+    tokens: input.tokens ?? null,
+    cost_usd: input.cost_usd ?? null,
+    created_at: timestamp
+  };
+}
+function getTaskTraces(taskId, db) {
+  const d = db || getDatabase();
+  return d.query("SELECT * FROM task_traces WHERE task_id = ? ORDER BY created_at DESC").all(taskId);
+}
+function getTraceStats(taskId, db) {
+  const d = db || getDatabase();
+  const row = d.query(`SELECT COUNT(*) as total,
+       SUM(CASE WHEN trace_type = 'tool_call' THEN 1 ELSE 0 END) as tool_calls,
+       SUM(CASE WHEN trace_type = 'llm_call' THEN 1 ELSE 0 END) as llm_calls,
+       SUM(CASE WHEN trace_type = 'error' THEN 1 ELSE 0 END) as errors,
+       COALESCE(SUM(tokens), 0) as total_tokens,
+       COALESCE(SUM(cost_usd), 0) as total_cost_usd,
+       COALESCE(SUM(duration_ms), 0) as total_duration_ms
+     FROM task_traces WHERE task_id = ?`).get(taskId);
+  return row;
+}
+var init_traces = __esm(() => {
+  init_database();
+});
+
+// src/db/snapshots.ts
+var exports_snapshots = {};
+__export(exports_snapshots, {
+  saveSnapshot: () => saveSnapshot,
+  listSnapshots: () => listSnapshots,
+  getLatestSnapshot: () => getLatestSnapshot
+});
+function rowToSnapshot(row) {
+  return {
+    ...row,
+    snapshot_type: row.snapshot_type,
+    files_open: JSON.parse(row.files_open || "[]"),
+    attempts: JSON.parse(row.attempts || "[]"),
+    blockers: JSON.parse(row.blockers || "[]"),
+    metadata: JSON.parse(row.metadata || "{}")
+  };
+}
+function saveSnapshot(input, db) {
+  const d = db || getDatabase();
+  const id = uuid();
+  const timestamp = now();
+  d.run(`INSERT INTO context_snapshots (id, agent_id, task_id, project_id, snapshot_type, plan_summary, files_open, attempts, blockers, next_steps, metadata, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+    id,
+    input.agent_id || null,
+    input.task_id || null,
+    input.project_id || null,
+    input.snapshot_type,
+    input.plan_summary || null,
+    JSON.stringify(input.files_open || []),
+    JSON.stringify(input.attempts || []),
+    JSON.stringify(input.blockers || []),
+    input.next_steps || null,
+    JSON.stringify(input.metadata || {}),
+    timestamp
+  ]);
+  return {
+    id,
+    agent_id: input.agent_id || null,
+    task_id: input.task_id || null,
+    project_id: input.project_id || null,
+    snapshot_type: input.snapshot_type,
+    plan_summary: input.plan_summary || null,
+    files_open: input.files_open || [],
+    attempts: input.attempts || [],
+    blockers: input.blockers || [],
+    next_steps: input.next_steps || null,
+    metadata: input.metadata || {},
+    created_at: timestamp
+  };
+}
+function getLatestSnapshot(agentId, taskId, db) {
+  const d = db || getDatabase();
+  const conditions = [];
+  const params = [];
+  if (agentId) {
+    conditions.push("agent_id = ?");
+    params.push(agentId);
+  }
+  if (taskId) {
+    conditions.push("task_id = ?");
+    params.push(taskId);
+  }
+  if (conditions.length === 0)
+    return null;
+  const where = conditions.join(" AND ");
+  const row = d.query(`SELECT * FROM context_snapshots WHERE ${where} ORDER BY created_at DESC LIMIT 1`).get(...params);
+  return row ? rowToSnapshot(row) : null;
+}
+function listSnapshots(opts, db) {
+  const d = db || getDatabase();
+  const conditions = [];
+  const params = [];
+  if (opts.agent_id) {
+    conditions.push("agent_id = ?");
+    params.push(opts.agent_id);
+  }
+  if (opts.task_id) {
+    conditions.push("task_id = ?");
+    params.push(opts.task_id);
+  }
+  if (opts.project_id) {
+    conditions.push("project_id = ?");
+    params.push(opts.project_id);
+  }
+  const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  const limit = opts.limit || 20;
+  params.push(limit);
+  return d.query(`SELECT * FROM context_snapshots ${where} ORDER BY created_at DESC LIMIT ?`).all(...params).map(rowToSnapshot);
+}
+var init_snapshots = __esm(() => {
+  init_database();
+});
+
+// src/db/budgets.ts
+var exports_budgets = {};
+__export(exports_budgets, {
+  setBudget: () => setBudget,
+  getBudget: () => getBudget,
+  checkBudget: () => checkBudget
+});
+function setBudget(agentId, opts, db) {
+  const d = db || getDatabase();
+  const timestamp = now();
+  d.run(`INSERT INTO agent_budgets (agent_id, max_concurrent, max_cost_usd, max_task_minutes, period_hours, created_at, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?)
+     ON CONFLICT(agent_id) DO UPDATE SET
+       max_concurrent = COALESCE(?, max_concurrent),
+       max_cost_usd = COALESCE(?, max_cost_usd),
+       max_task_minutes = COALESCE(?, max_task_minutes),
+       period_hours = COALESCE(?, period_hours),
+       updated_at = ?`, [
+    agentId,
+    opts.max_concurrent ?? 5,
+    opts.max_cost_usd ?? null,
+    opts.max_task_minutes ?? null,
+    opts.period_hours ?? 24,
+    timestamp,
+    timestamp,
+    opts.max_concurrent ?? null,
+    opts.max_cost_usd ?? null,
+    opts.max_task_minutes ?? null,
+    opts.period_hours ?? null,
+    timestamp
+  ]);
+  return getBudget(agentId, d);
+}
+function getBudget(agentId, db) {
+  const d = db || getDatabase();
+  return d.query("SELECT * FROM agent_budgets WHERE agent_id = ?").get(agentId);
+}
+function checkBudget(agentId, db) {
+  const d = db || getDatabase();
+  const budget = getBudget(agentId, d);
+  if (!budget)
+    return { allowed: true, current_concurrent: 0, max_concurrent: 999 };
+  const concurrent = countTasks({ status: "in_progress", assigned_to: agentId }, d);
+  if (concurrent >= budget.max_concurrent) {
+    return { allowed: false, reason: `Concurrent limit reached (${concurrent}/${budget.max_concurrent})`, current_concurrent: concurrent, max_concurrent: budget.max_concurrent };
+  }
+  if (budget.max_cost_usd != null) {
+    const periodStart = new Date(Date.now() - budget.period_hours * 60 * 60 * 1000).toISOString();
+    const costRow = d.query("SELECT COALESCE(SUM(cost_usd), 0) as total FROM tasks WHERE (assigned_to = ? OR agent_id = ?) AND updated_at > ?").get(agentId, agentId, periodStart);
+    if (costRow.total >= budget.max_cost_usd) {
+      return { allowed: false, reason: `Cost limit reached ($${costRow.total.toFixed(2)}/$${budget.max_cost_usd.toFixed(2)} in ${budget.period_hours}h)`, current_concurrent: concurrent, max_concurrent: budget.max_concurrent, current_cost_usd: costRow.total, max_cost_usd: budget.max_cost_usd };
+    }
+  }
+  return { allowed: true, current_concurrent: concurrent, max_concurrent: budget.max_concurrent };
+}
+var init_budgets = __esm(() => {
+  init_database();
+  init_tasks();
+});
+
 // src/lib/github.ts
 var exports_github = {};
 __export(exports_github, {
@@ -11462,14 +11799,14 @@ __export(exports_mcp, {
 });
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { readFileSync as readFileSync4 } from "fs";
-import { join as join7, dirname as dirname2 } from "path";
+import { readFileSync as readFileSync5 } from "fs";
+import { join as join9, dirname as dirname2 } from "path";
 import { fileURLToPath } from "url";
 function getMcpVersion() {
   try {
     const __dir = dirname2(fileURLToPath(import.meta.url));
-    const pkgPath = join7(__dir, "..", "package.json");
-    return JSON.parse(readFileSync4(pkgPath, "utf-8")).version || "0.0.0";
+    const pkgPath = join9(__dir, "..", "package.json");
+    return JSON.parse(readFileSync5(pkgPath, "utf-8")).version || "0.0.0";
   } catch {
     return "0.0.0";
   }
@@ -11533,7 +11870,23 @@ function formatError(error) {
     return JSON.stringify({ code: CompletionGuardError.code, message: error.reason, suggestion: CompletionGuardError.suggestion, ...retry });
   }
   if (error instanceof Error) {
-    return JSON.stringify({ code: "UNKNOWN_ERROR", message: error.message });
+    const msg = error.message;
+    if (msg.includes("UNIQUE constraint failed: projects.path")) {
+      const db = getDatabase();
+      const existing = db.prepare("SELECT id, name FROM projects WHERE path = ?").get(msg.match(/'([^']+)'$/)?.[1] ?? "");
+      return JSON.stringify({ code: "DUPLICATE_PROJECT", message: `Project already exists at this path${existing ? ` (id: ${existing.id}, name: ${existing.name})` : ""}. Use list_projects to find it.`, suggestion: "Use list_projects or get_project to retrieve the existing project." });
+    }
+    if (msg.includes("UNIQUE constraint failed: projects.name")) {
+      return JSON.stringify({ code: "DUPLICATE_PROJECT", message: "A project with this name already exists. Use a different name or list_projects to find the existing one.", suggestion: "Use list_projects to see existing projects." });
+    }
+    if (msg.includes("UNIQUE constraint failed")) {
+      const table = msg.match(/UNIQUE constraint failed: (\w+)\./)?.[1] ?? "unknown";
+      return JSON.stringify({ code: "DUPLICATE_ENTRY", message: `Duplicate entry in ${table}. The record already exists.`, suggestion: `Use the list or get endpoint for ${table} to find the existing record.` });
+    }
+    if (msg.includes("FOREIGN KEY constraint failed")) {
+      return JSON.stringify({ code: "REFERENCE_ERROR", message: "Referenced record does not exist. Check that the ID is correct.", suggestion: "Verify the referenced ID exists before creating this record." });
+    }
+    return JSON.stringify({ code: "UNKNOWN_ERROR", message: msg });
   }
   return JSON.stringify({ code: "UNKNOWN_ERROR", message: String(error) });
 }
@@ -13037,6 +13390,135 @@ Blocked:`);
       }
     });
   }
+  if (shouldRegisterTool("log_cost")) {
+    server.tool("log_cost", "Log token usage and cost to a task. Accumulates \u2014 call after each LLM invocation.", { task_id: exports_external.string(), tokens: exports_external.number().describe("Token count"), usd: exports_external.number().describe("Cost in USD") }, async ({ task_id, tokens, usd }) => {
+      try {
+        const { logCost: logCost2 } = await Promise.resolve().then(() => (init_tasks(), exports_tasks));
+        const resolvedId = resolveId(task_id, "tasks");
+        logCost2(resolvedId, tokens, usd);
+        return { content: [{ type: "text", text: `Logged ${tokens} tokens ($${usd.toFixed(4)}) to ${task_id}` }] };
+      } catch (e) {
+        return { content: [{ type: "text", text: formatError(e) }], isError: true };
+      }
+    });
+  }
+  if (shouldRegisterTool("log_trace")) {
+    server.tool("log_trace", "Log a trace entry (tool call, LLM call, error, handoff) to a task for observability.", {
+      task_id: exports_external.string(),
+      agent_id: exports_external.string().optional(),
+      trace_type: exports_external.enum(["tool_call", "llm_call", "error", "handoff", "custom"]),
+      name: exports_external.string().optional(),
+      input_summary: exports_external.string().optional(),
+      output_summary: exports_external.string().optional(),
+      duration_ms: exports_external.number().optional(),
+      tokens: exports_external.number().optional(),
+      cost_usd: exports_external.number().optional()
+    }, async ({ task_id, agent_id, trace_type, name, input_summary, output_summary, duration_ms, tokens, cost_usd }) => {
+      try {
+        const { logTrace: logTrace2 } = await Promise.resolve().then(() => (init_traces(), exports_traces));
+        const resolvedId = resolveId(task_id, "tasks");
+        const trace = logTrace2({ task_id: resolvedId, agent_id, trace_type, name, input_summary, output_summary, duration_ms, tokens, cost_usd });
+        return { content: [{ type: "text", text: `Trace logged: ${trace.id} [${trace_type}] ${name || ""}` }] };
+      } catch (e) {
+        return { content: [{ type: "text", text: formatError(e) }], isError: true };
+      }
+    });
+  }
+  if (shouldRegisterTool("get_traces")) {
+    server.tool("get_traces", "Get execution traces for a task \u2014 tool calls, LLM invocations, errors, handoffs.", { task_id: exports_external.string() }, async ({ task_id }) => {
+      try {
+        const { getTaskTraces: getTaskTraces2, getTraceStats: getTraceStats2 } = await Promise.resolve().then(() => (init_traces(), exports_traces));
+        const resolvedId = resolveId(task_id, "tasks");
+        const traces = getTaskTraces2(resolvedId);
+        const stats = getTraceStats2(resolvedId);
+        const lines = [`Traces for ${task_id}: ${stats.total} total (${stats.tool_calls} tools, ${stats.llm_calls} LLM, ${stats.errors} errors) | ${stats.total_tokens} tokens | $${stats.total_cost_usd.toFixed(4)} | ${stats.total_duration_ms}ms`];
+        for (const t of traces.slice(0, 20)) {
+          lines.push(`  ${t.created_at} [${t.trace_type}] ${t.name || ""} ${t.tokens ? t.tokens + "tok" : ""} ${t.duration_ms ? t.duration_ms + "ms" : ""}`);
+        }
+        return { content: [{ type: "text", text: lines.join(`
+`) }] };
+      } catch (e) {
+        return { content: [{ type: "text", text: formatError(e) }], isError: true };
+      }
+    });
+  }
+  if (shouldRegisterTool("save_snapshot")) {
+    server.tool("save_snapshot", "Save a structured context snapshot \u2014 what you were working on, what files are open, what was tried, blockers, next steps. Call on session end or before handoff.", {
+      agent_id: exports_external.string().optional(),
+      task_id: exports_external.string().optional(),
+      project_id: exports_external.string().optional(),
+      snapshot_type: exports_external.enum(["interrupt", "complete", "handoff", "checkpoint"]),
+      plan_summary: exports_external.string().optional(),
+      files_open: exports_external.array(exports_external.string()).optional(),
+      attempts: exports_external.array(exports_external.string()).optional(),
+      blockers: exports_external.array(exports_external.string()).optional(),
+      next_steps: exports_external.string().optional()
+    }, async ({ agent_id, task_id, project_id, snapshot_type, plan_summary, files_open, attempts, blockers, next_steps }) => {
+      try {
+        const { saveSnapshot: saveSnapshot2 } = await Promise.resolve().then(() => (init_snapshots(), exports_snapshots));
+        const snap = saveSnapshot2({ agent_id, task_id, project_id, snapshot_type, plan_summary, files_open, attempts, blockers, next_steps });
+        return { content: [{ type: "text", text: `Snapshot saved: ${snap.id} [${snapshot_type}]${plan_summary ? " \u2014 " + plan_summary.slice(0, 80) : ""}` }] };
+      } catch (e) {
+        return { content: [{ type: "text", text: formatError(e) }], isError: true };
+      }
+    });
+  }
+  if (shouldRegisterTool("get_snapshot")) {
+    server.tool("get_snapshot", "Get the latest context snapshot for an agent or task \u2014 use to resume work after interruption.", { agent_id: exports_external.string().optional(), task_id: exports_external.string().optional() }, async ({ agent_id, task_id }) => {
+      try {
+        const { getLatestSnapshot: getLatestSnapshot2 } = await Promise.resolve().then(() => (init_snapshots(), exports_snapshots));
+        const snap = getLatestSnapshot2(agent_id, task_id);
+        if (!snap)
+          return { content: [{ type: "text", text: "No snapshot found." }] };
+        const lines = [`Snapshot [${snap.snapshot_type}] from ${snap.created_at}`];
+        if (snap.plan_summary)
+          lines.push(`Plan: ${snap.plan_summary}`);
+        if (snap.files_open.length > 0)
+          lines.push(`Files: ${snap.files_open.join(", ")}`);
+        if (snap.blockers.length > 0)
+          lines.push(`Blockers: ${snap.blockers.join(", ")}`);
+        if (snap.next_steps)
+          lines.push(`Next: ${snap.next_steps}`);
+        if (snap.attempts.length > 0)
+          lines.push(`Attempts: ${snap.attempts.join("; ")}`);
+        return { content: [{ type: "text", text: lines.join(`
+`) }] };
+      } catch (e) {
+        return { content: [{ type: "text", text: formatError(e) }], isError: true };
+      }
+    });
+  }
+  if (shouldRegisterTool("set_budget")) {
+    server.tool("set_budget", "Set execution budget for an agent \u2014 max concurrent tasks, cost limit, time limit per period.", {
+      agent_id: exports_external.string(),
+      max_concurrent: exports_external.number().optional(),
+      max_cost_usd: exports_external.number().optional(),
+      max_task_minutes: exports_external.number().optional(),
+      period_hours: exports_external.number().optional()
+    }, async ({ agent_id, max_concurrent, max_cost_usd, max_task_minutes, period_hours }) => {
+      try {
+        const { setBudget: setBudget2 } = await Promise.resolve().then(() => (init_budgets(), exports_budgets));
+        const budget = setBudget2(agent_id, { max_concurrent, max_cost_usd, max_task_minutes, period_hours });
+        return { content: [{ type: "text", text: `Budget set for ${agent_id}: max ${budget.max_concurrent} concurrent, $${budget.max_cost_usd ?? "\u221E"} cost limit, ${budget.period_hours}h period` }] };
+      } catch (e) {
+        return { content: [{ type: "text", text: formatError(e) }], isError: true };
+      }
+    });
+  }
+  if (shouldRegisterTool("check_budget")) {
+    server.tool("check_budget", "Check if an agent is within their execution budget (concurrent tasks, cost, time).", { agent_id: exports_external.string() }, async ({ agent_id }) => {
+      try {
+        const { checkBudget: checkBudget2 } = await Promise.resolve().then(() => (init_budgets(), exports_budgets));
+        const result = checkBudget2(agent_id);
+        if (result.allowed) {
+          return { content: [{ type: "text", text: `Budget OK: ${result.current_concurrent}/${result.max_concurrent} concurrent tasks` }] };
+        }
+        return { content: [{ type: "text", text: `BUDGET EXCEEDED: ${result.reason}` }], isError: true };
+      } catch (e) {
+        return { content: [{ type: "text", text: formatError(e) }], isError: true };
+      }
+    });
+  }
   if (shouldRegisterTool("import_github_issue")) {
     server.tool("import_github_issue", "Import a GitHub issue as a task. Requires gh CLI installed and authenticated.", {
       url: exports_external.string().describe("GitHub issue URL (e.g. https://github.com/owner/repo/issues/42)"),
@@ -13747,6 +14229,56 @@ ${formatTaskDetail(task, 300)}` }] };
       }
     });
   }
+  if (shouldRegisterTool("steal_task")) {
+    server.tool("steal_task", "Work-stealing: take the highest-priority stale in_progress task from another agent and reassign it to you.", {
+      agent_id: exports_external.string().describe("Your agent ID"),
+      stale_minutes: exports_external.number().optional().describe("How long a task must be stale before stealing (default: 30)"),
+      project_id: exports_external.string().optional(),
+      task_list_id: exports_external.string().optional()
+    }, async ({ agent_id, stale_minutes, project_id, task_list_id }) => {
+      try {
+        const task = stealTask(agent_id, { stale_minutes, project_id, task_list_id });
+        if (!task)
+          return { content: [{ type: "text", text: "No stale tasks available to steal." }] };
+        return { content: [{ type: "text", text: `Stolen: ${formatTask(task)}
+Previous owner: ${task.metadata?._stolen_from || "unknown"}` }] };
+      } catch (e) {
+        return { content: [{ type: "text", text: formatError(e) }], isError: true };
+      }
+    });
+  }
+  if (shouldRegisterTool("claim_or_steal")) {
+    server.tool("claim_or_steal", "Try to claim a pending task first; if none available, steal from a stale agent. Best single call for getting work.", {
+      agent_id: exports_external.string(),
+      project_id: exports_external.string().optional(),
+      task_list_id: exports_external.string().optional(),
+      plan_id: exports_external.string().optional(),
+      tags: exports_external.array(exports_external.string()).optional(),
+      stale_minutes: exports_external.number().optional().describe("Stale threshold for work-stealing fallback (default: 30)")
+    }, async ({ agent_id, project_id, task_list_id, plan_id, tags, stale_minutes }) => {
+      try {
+        const filters = {};
+        if (project_id)
+          filters.project_id = resolveId(project_id, "projects");
+        if (task_list_id)
+          filters.task_list_id = resolveId(task_list_id, "task_lists");
+        if (plan_id)
+          filters.plan_id = resolveId(plan_id, "plans");
+        if (tags)
+          filters.tags = tags;
+        if (stale_minutes)
+          filters.stale_minutes = stale_minutes;
+        const result = claimOrSteal(agent_id, Object.keys(filters).length > 0 ? filters : undefined);
+        if (!result)
+          return { content: [{ type: "text", text: "No tasks available to claim or steal." }] };
+        const prefix = result.stolen ? "Stolen" : "Claimed";
+        return { content: [{ type: "text", text: `${prefix}: ${formatTask(result.task)}
+${formatTaskDetail(result.task, 300)}` }] };
+      } catch (e) {
+        return { content: [{ type: "text", text: formatError(e) }], isError: true };
+      }
+    });
+  }
   if (shouldRegisterTool("get_stale_tasks")) {
     server.tool("get_stale_tasks", "Find stale in_progress tasks with no recent activity.", {
       stale_minutes: exports_external.number().optional(),
@@ -15414,27 +15946,27 @@ var exports_serve = {};
 __export(exports_serve, {
   startServer: () => startServer
 });
-import { existsSync as existsSync6 } from "fs";
-import { join as join8, dirname as dirname3, extname, resolve as resolve3, sep } from "path";
+import { existsSync as existsSync8 } from "fs";
+import { join as join10, dirname as dirname3, extname, resolve as resolve3, sep } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function resolveDashboardDir() {
   const candidates = [];
   try {
     const scriptDir = dirname3(fileURLToPath2(import.meta.url));
-    candidates.push(join8(scriptDir, "..", "dashboard", "dist"));
-    candidates.push(join8(scriptDir, "..", "..", "dashboard", "dist"));
+    candidates.push(join10(scriptDir, "..", "dashboard", "dist"));
+    candidates.push(join10(scriptDir, "..", "..", "dashboard", "dist"));
   } catch {}
   if (process.argv[1]) {
     const mainDir = dirname3(process.argv[1]);
-    candidates.push(join8(mainDir, "..", "dashboard", "dist"));
-    candidates.push(join8(mainDir, "..", "..", "dashboard", "dist"));
+    candidates.push(join10(mainDir, "..", "dashboard", "dist"));
+    candidates.push(join10(mainDir, "..", "..", "dashboard", "dist"));
   }
-  candidates.push(join8(process.cwd(), "dashboard", "dist"));
+  candidates.push(join10(process.cwd(), "dashboard", "dist"));
   for (const candidate of candidates) {
-    if (existsSync6(candidate))
+    if (existsSync8(candidate))
       return candidate;
   }
-  return join8(process.cwd(), "dashboard", "dist");
+  return join10(process.cwd(), "dashboard", "dist");
 }
 function json(data, status = 200, port) {
   return new Response(JSON.stringify(data), {
@@ -15447,7 +15979,7 @@ function json(data, status = 200, port) {
   });
 }
 function serveStaticFile(filePath) {
-  if (!existsSync6(filePath))
+  if (!existsSync8(filePath))
     return null;
   const ext = extname(filePath);
   const contentType = MIME_TYPES[ext] || "application/octet-stream";
@@ -15514,7 +16046,7 @@ data: ${data}
     }
   }
   const dashboardDir = resolveDashboardDir();
-  const dashboardExists = existsSync6(dashboardDir);
+  const dashboardExists = existsSync8(dashboardDir);
   if (!dashboardExists) {
     console.error(`
 Dashboard not found at: ${dashboardDir}`);
@@ -16238,7 +16770,7 @@ data: ${JSON.stringify({ type: "connected", agent_id: agentId, timestamp: new Da
       }
       if (dashboardExists && (method === "GET" || method === "HEAD")) {
         if (path !== "/") {
-          const filePath = join8(dashboardDir, path);
+          const filePath = join10(dashboardDir, path);
           const resolvedFile = resolve3(filePath);
           const resolvedBase = resolve3(dashboardDir);
           if (!resolvedFile.startsWith(resolvedBase + sep) && resolvedFile !== resolvedBase) {
@@ -16248,7 +16780,7 @@ data: ${JSON.stringify({ type: "connected", agent_id: agentId, timestamp: new Da
           if (res2)
             return res2;
         }
-        const indexPath = join8(dashboardDir, "index.html");
+        const indexPath = join10(dashboardDir, "index.html");
         const res = serveStaticFile(indexPath);
         if (res)
           return res;
@@ -17667,15 +18199,318 @@ init_comments();
 init_search();
 init_sync();
 init_config();
-import chalk from "chalk";
+import chalk2 from "chalk";
 import { execSync as execSync2 } from "child_process";
-import { existsSync as existsSync7, mkdirSync as mkdirSync3, readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "fs";
-import { basename, dirname as dirname4, join as join9, resolve as resolve4 } from "path";
+import { existsSync as existsSync9, mkdirSync as mkdirSync5, readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "fs";
+import { basename, dirname as dirname4, join as join11, resolve as resolve4 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
+
+// src/cli/brains.ts
+import {
+  existsSync as existsSync7,
+  mkdirSync as mkdirSync4,
+  writeFileSync as writeFileSync4,
+  readdirSync as readdirSync3
+} from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join7 } from "path";
+import chalk from "chalk";
+
+// src/lib/gatherer.ts
+init_tasks();
+var SYSTEM_PROMPT = "You are a task management assistant that creates, updates, and tracks tasks and projects.";
+function taskToCreateExample(task) {
+  const userMsg = `Create a task: ${task.title}${task.description ? `
+
+Description: ${task.description}` : ""}`;
+  const taskDetails = {
+    id: task.short_id ?? task.id,
+    title: task.title,
+    description: task.description ?? "",
+    status: task.status,
+    priority: task.priority,
+    tags: task.tags,
+    created_at: task.created_at
+  };
+  return {
+    messages: [
+      { role: "system", content: SYSTEM_PROMPT },
+      { role: "user", content: userMsg },
+      {
+        role: "assistant",
+        content: `Created task: ${JSON.stringify(taskDetails, null, 2)}`
+      }
+    ]
+  };
+}
+function taskToStatusUpdateExample(task) {
+  if (!task.completed_at && task.status === "pending")
+    return null;
+  const id = task.short_id ?? task.id;
+  return {
+    messages: [
+      { role: "system", content: SYSTEM_PROMPT },
+      { role: "user", content: `Mark task ${id} as ${task.status}` },
+      {
+        role: "assistant",
+        content: `Task ${id} has been updated to status: ${task.status}. ${task.completed_at ? `Completed at: ${task.completed_at}` : ""}`.trim()
+      }
+    ]
+  };
+}
+function taskToSearchExample(tasks, query) {
+  const matched = tasks.filter((t) => t.title.toLowerCase().includes(query.toLowerCase())).slice(0, 5);
+  return {
+    messages: [
+      { role: "system", content: SYSTEM_PROMPT },
+      { role: "user", content: `Search tasks for: "${query}"` },
+      {
+        role: "assistant",
+        content: matched.length > 0 ? `Found ${matched.length} task(s):
+${matched.map((t) => `- [${t.short_id ?? t.id}] ${t.title} (${t.status})`).join(`
+`)}` : `No tasks found matching "${query}".`
+      }
+    ]
+  };
+}
+var gatherTrainingData = async (options = {}) => {
+  const allTasks = listTasks({});
+  const filtered = options.since ? allTasks.filter((t) => new Date(t.created_at) >= options.since) : allTasks;
+  const sorted = filtered.slice().sort((a, b) => new Date(b.created_at).getTime() - new Date(a.created_at).getTime());
+  const fetchSet = options.limit ? sorted.slice(0, options.limit * 2) : sorted;
+  const examples = [];
+  for (const task of fetchSet) {
+    examples.push(taskToCreateExample(task));
+    const statusEx = taskToStatusUpdateExample(task);
+    if (statusEx)
+      examples.push(statusEx);
+  }
+  const searchTerms = ["urgent", "fix", "implement", "create", "update", "review"];
+  for (const term of searchTerms) {
+    examples.push(taskToSearchExample(sorted, term));
+  }
+  const finalExamples = options.limit ? examples.slice(0, options.limit) : examples;
+  return {
+    source: "todos",
+    examples: finalExamples,
+    count: finalExamples.length
+  };
+};
+
+// src/lib/model-config.ts
+import { existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
+import { homedir } from "os";
+import { join as join6 } from "path";
+var DEFAULT_MODEL = "gpt-4o-mini";
+var CONFIG_DIR = join6(homedir(), ".todos");
+var CONFIG_PATH = join6(CONFIG_DIR, "config.json");
+function readConfig() {
+  if (!existsSync6(CONFIG_PATH))
+    return {};
+  try {
+    const raw = readFileSync3(CONFIG_PATH, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+function writeConfig(config) {
+  if (!existsSync6(CONFIG_DIR)) {
+    mkdirSync3(CONFIG_DIR, { recursive: true });
+  }
+  writeFileSync3(CONFIG_PATH, JSON.stringify(config, null, 2) + `
+`, "utf-8");
+}
+function getActiveModel() {
+  const config = readConfig();
+  return config.activeModel ?? DEFAULT_MODEL;
+}
+function setActiveModel(modelId) {
+  const config = readConfig();
+  config.activeModel = modelId;
+  writeConfig(config);
+}
+function clearActiveModel() {
+  const config = readConfig();
+  delete config.activeModel;
+  writeConfig(config);
+}
+
+// src/cli/brains.ts
+function printSuccess(msg) {
+  console.log(chalk.green("\u2713 " + msg));
+}
+function printError(msg) {
+  console.error(chalk.red("\u2717 " + msg));
+}
+function printInfo(msg) {
+  console.log(chalk.cyan("\u2139 " + msg));
+}
+function makeBrainsCommand() {
+  const brains = new Command("brains");
+  brains.description("Fine-tuned model training and management (via @hasna/brains)");
+  brains.command("gather").description("Gather training data from tasks and write to JSONL").option("--limit <n>", "Maximum number of examples to gather", parseInt).option("--since <date>", "Only include tasks created since this date (ISO 8601)").option("--output <dir>", "Output directory (default: ~/.todos/training/)").option("--json", "Output result summary as JSON").action(async (opts) => {
+    try {
+      const since = opts.since ? new Date(opts.since) : undefined;
+      if (since && isNaN(since.getTime())) {
+        printError(`Invalid date: ${opts.since}`);
+        process.exit(1);
+      }
+      if (!opts.json) {
+        printInfo("Gathering training data from tasks...");
+      }
+      const result = await gatherTrainingData({
+        limit: opts.limit,
+        since
+      });
+      const outputDir = opts.output ?? join7(homedir2(), ".todos", "training");
+      if (!existsSync7(outputDir)) {
+        mkdirSync4(outputDir, { recursive: true });
+      }
+      const timestamp = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
+      const outputPath = join7(outputDir, `todos-training-${timestamp}.jsonl`);
+      const jsonl = result.examples.map((ex) => JSON.stringify(ex)).join(`
+`);
+      writeFileSync4(outputPath, jsonl + `
+`, "utf-8");
+      if (opts.json) {
+        console.log(JSON.stringify({
+          source: result.source,
+          count: result.count,
+          path: outputPath
+        }));
+      } else {
+        printSuccess(`Gathered ${result.count} training examples from tasks`);
+        console.log(chalk.dim(`  Output: ${outputPath}`));
+      }
+    } catch (err) {
+      printError(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  });
+  brains.command("train").description("Start a fine-tuning job using gathered task training data").option("--base-model <model>", "Base model to fine-tune", "gpt-4o-mini-2024-07-18").option("--provider <provider>", "Provider (openai|thinker-labs)", "openai").option("--dataset <path>", "Path to JSONL dataset (auto-detects latest if omitted)").option("--name <name>", "Display name for the fine-tuned model").option("--json", "Output result as JSON").action(async (opts) => {
+    try {
+      let datasetPath = opts.dataset;
+      if (!datasetPath) {
+        const trainingDir = join7(homedir2(), ".todos", "training");
+        if (!existsSync7(trainingDir)) {
+          printError("No training data found. Run `todos brains gather` first.");
+          process.exit(1);
+        }
+        const files = readdirSync3(trainingDir).filter((f) => f.endsWith(".jsonl")).sort().reverse();
+        const latestFile = files[0];
+        if (!latestFile) {
+          printError("No JSONL training files found. Run `todos brains gather` first.");
+          process.exit(1);
+        }
+        datasetPath = join7(trainingDir, latestFile);
+      }
+      if (!datasetPath || !existsSync7(datasetPath)) {
+        printError(`Dataset file not found: ${datasetPath ?? "(unresolved)"}`);
+        process.exit(1);
+      }
+      if (!opts.json) {
+        printInfo(`Starting fine-tuning job with dataset: ${datasetPath}`);
+      }
+      let brainsSDK;
+      try {
+        brainsSDK = await import("@hasna/brains");
+      } catch {
+        printError("@hasna/brains is not installed. Run `bun add @hasna/brains` to enable training.");
+        process.exit(1);
+      }
+      const startFinetune = brainsSDK["startFinetune"];
+      if (typeof startFinetune !== "function") {
+        printError("@hasna/brains does not export startFinetune. Please update @hasna/brains.");
+        process.exit(1);
+      }
+      const modelName = opts.name ?? `todos-${new Date().toISOString().slice(0, 10)}`;
+      const jobResult = await startFinetune({
+        provider: opts.provider,
+        baseModel: opts.baseModel,
+        datasetPath,
+        name: modelName
+      });
+      if (opts.json) {
+        console.log(JSON.stringify(jobResult));
+      } else {
+        printSuccess(`Fine-tuning job started: ${String(jobResult["jobId"] ?? "(unknown)")}`);
+        console.log(chalk.dim(`  Provider:   ${opts.provider}`));
+        console.log(chalk.dim(`  Base model: ${opts.baseModel}`));
+        console.log(chalk.dim(`  Name:       ${modelName}`));
+        if (jobResult["jobId"]) {
+          console.log();
+          printInfo(`Use \`todos brains model set <model-id>\` once training completes.`);
+        }
+      }
+    } catch (err) {
+      printError(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  });
+  const modelCmd = brains.command("model").description("Manage the active fine-tuned model");
+  modelCmd.command("get").description("Show the currently active fine-tuned model").option("--json", "Output as JSON").action((opts) => {
+    try {
+      const active = getActiveModel();
+      const isDefault = active === DEFAULT_MODEL;
+      if (opts.json) {
+        console.log(JSON.stringify({ activeModel: active, isDefault }));
+      } else {
+        if (isDefault) {
+          console.log(`Active model: ${chalk.cyan(active)} ${chalk.dim("(default)")}`);
+        } else {
+          console.log(`Active model: ${chalk.green(active)}`);
+        }
+      }
+    } catch (err) {
+      printError(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  });
+  modelCmd.command("set <modelId>").description("Set the active fine-tuned model ID").action((modelId) => {
+    try {
+      setActiveModel(modelId);
+      printSuccess(`Active model set to: ${modelId}`);
+    } catch (err) {
+      printError(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  });
+  modelCmd.command("clear").description(`Clear the active fine-tuned model (reverts to ${DEFAULT_MODEL})`).action(() => {
+    try {
+      clearActiveModel();
+      printSuccess(`Active model cleared. Using default: ${DEFAULT_MODEL}`);
+    } catch (err) {
+      printError(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  });
+  modelCmd.action((opts) => {
+    try {
+      const active = getActiveModel();
+      const isDefault = active === DEFAULT_MODEL;
+      if (opts.json) {
+        console.log(JSON.stringify({ activeModel: active, isDefault }));
+      } else {
+        if (isDefault) {
+          console.log(`Active model: ${chalk.cyan(active)} ${chalk.dim("(default)")}`);
+        } else {
+          console.log(`Active model: ${chalk.green(active)}`);
+        }
+      }
+    } catch (err) {
+      printError(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  });
+  return brains;
+}
+
+// src/cli/index.tsx
 function getPackageVersion() {
   try {
-    const pkgPath = join9(dirname4(fileURLToPath3(import.meta.url)), "..", "..", "package.json");
-    return JSON.parse(readFileSync5(pkgPath, "utf-8")).version || "0.0.0";
+    const pkgPath = join11(dirname4(fileURLToPath3(import.meta.url)), "..", "..", "package.json");
+    return JSON.parse(readFileSync6(pkgPath, "utf-8")).version || "0.0.0";
   } catch {
     return "0.0.0";
   }
@@ -17686,7 +18521,7 @@ function handleError(e) {
   if (globalOpts.json) {
     console.log(JSON.stringify({ error: e instanceof Error ? e.message : String(e) }));
   } else {
-    console.error(chalk.red(e instanceof Error ? e.message : String(e)));
+    console.error(chalk2.red(e instanceof Error ? e.message : String(e)));
   }
   process.exit(1);
 }
@@ -17696,10 +18531,10 @@ function resolveTaskId(partialId) {
   if (!id) {
     const similar = db.query("SELECT id FROM tasks WHERE id LIKE ? LIMIT 3").all(`%${partialId}%`);
     if (similar.length > 0) {
-      console.error(chalk.red(`Could not resolve task ID: ${partialId}`));
-      console.error(chalk.dim(`Did you mean: ${similar.map((s) => s.id.slice(0, 8)).join(", ")}?`));
+      console.error(chalk2.red(`Could not resolve task ID: ${partialId}`));
+      console.error(chalk2.dim(`Did you mean: ${similar.map((s) => s.id.slice(0, 8)).join(", ")}?`));
     } else {
-      console.error(chalk.red(`Could not resolve task ID: ${partialId}`));
+      console.error(chalk2.red(`Could not resolve task ID: ${partialId}`));
     }
     process.exit(1);
   }
@@ -17733,26 +18568,26 @@ function output(data, jsonMode) {
   }
 }
 var statusColors4 = {
-  pending: chalk.yellow,
-  in_progress: chalk.blue,
-  completed: chalk.green,
-  failed: chalk.red,
-  cancelled: chalk.gray
+  pending: chalk2.yellow,
+  in_progress: chalk2.blue,
+  completed: chalk2.green,
+  failed: chalk2.red,
+  cancelled: chalk2.gray
 };
 var priorityColors2 = {
-  critical: chalk.red.bold,
-  high: chalk.red,
-  medium: chalk.yellow,
-  low: chalk.gray
+  critical: chalk2.red.bold,
+  high: chalk2.red,
+  medium: chalk2.yellow,
+  low: chalk2.gray
 };
 function formatTaskLine(t) {
-  const statusFn = statusColors4[t.status] || chalk.white;
-  const priorityFn = priorityColors2[t.priority] || chalk.white;
-  const lock = t.locked_by ? chalk.magenta(` [locked:${t.locked_by}]`) : "";
-  const assigned = t.assigned_to ? chalk.cyan(` -> ${t.assigned_to}`) : "";
-  const tags = t.tags.length > 0 ? chalk.dim(` [${t.tags.join(",")}]`) : "";
-  const plan = t.plan_id ? chalk.magenta(` [plan:${t.plan_id.slice(0, 8)}]`) : "";
-  return `${chalk.dim(t.id.slice(0, 8))} ${statusFn(t.status.padEnd(11))} ${priorityFn(t.priority.padEnd(8))} ${t.title}${assigned}${lock}${tags}${plan}`;
+  const statusFn = statusColors4[t.status] || chalk2.white;
+  const priorityFn = priorityColors2[t.priority] || chalk2.white;
+  const lock = t.locked_by ? chalk2.magenta(` [locked:${t.locked_by}]`) : "";
+  const assigned = t.assigned_to ? chalk2.cyan(` -> ${t.assigned_to}`) : "";
+  const tags = t.tags.length > 0 ? chalk2.dim(` [${t.tags.join(",")}]`) : "";
+  const plan = t.plan_id ? chalk2.magenta(` [plan:${t.plan_id.slice(0, 8)}]`) : "";
+  return `${chalk2.dim(t.id.slice(0, 8))} ${statusFn(t.status.padEnd(11))} ${priorityFn(t.priority.padEnd(8))} ${t.title}${assigned}${lock}${tags}${plan}`;
 }
 program2.name("todos").description("Universal task management for AI coding agents").version(getPackageVersion()).option("--project <path>", "Project path").option("--json", "Output as JSON").option("--agent <name>", "Agent name").option("--session <id>", "Session ID");
 program2.command("add <title>").description("Create a new task").option("-d, --description <text>", "Task description").option("-p, --priority <level>", "Priority: low, medium, high, critical").option("--parent <id>", "Parent task ID").option("-t, --tags <tags>", "Comma-separated tags").option("--tag <tags>", "Comma-separated tags (alias for --tags)").option("--plan <id>", "Assign to a plan").option("--assign <agent>", "Assign to agent").option("--status <status>", "Initial status").option("--list <id>", "Task list ID").option("--task-list <id>", "Task list ID (alias for --list)").option("--estimated <minutes>", "Estimated time in minutes").option("--approval", "Require approval before completion").option("--recurrence <rule>", "Recurrence rule, e.g. 'every day', 'every weekday', 'every 2 weeks'").option("--due <date>", "Due date (ISO string or YYYY-MM-DD)").option("--reason <text>", "Why this task exists").action((title, opts) => {
@@ -17764,7 +18599,7 @@ program2.command("add <title>").description("Create a new task").option("-d, --d
     const db = getDatabase();
     const id = resolvePartialId(db, "task_lists", opts.list);
     if (!id) {
-      console.error(chalk.red(`Could not resolve task list ID: ${opts.list}`));
+      console.error(chalk2.red(`Could not resolve task list ID: ${opts.list}`));
       process.exit(1);
     }
     return id;
@@ -17779,7 +18614,7 @@ program2.command("add <title>").description("Create a new task").option("-d, --d
       const db = getDatabase();
       const id = resolvePartialId(db, "plans", opts.plan);
       if (!id) {
-        console.error(chalk.red(`Could not resolve plan ID: ${opts.plan}`));
+        console.error(chalk2.red(`Could not resolve plan ID: ${opts.plan}`));
         process.exit(1);
       }
       return id;
@@ -17800,7 +18635,7 @@ program2.command("add <title>").description("Create a new task").option("-d, --d
   if (globalOpts.json) {
     output(task, true);
   } else {
-    console.log(chalk.green("Task created:"));
+    console.log(chalk2.green("Task created:"));
     console.log(formatTaskLine(task));
   }
 });
@@ -17816,7 +18651,7 @@ program2.command("list").description("List tasks").option("-s, --status <status>
     const db = getDatabase();
     const listId = resolvePartialId(db, "task_lists", opts.list);
     if (!listId) {
-      console.error(chalk.red(`Could not resolve task list ID: ${opts.list}`));
+      console.error(chalk2.red(`Could not resolve task list ID: ${opts.list}`));
       process.exit(1);
     }
     filter["task_list_id"] = listId;
@@ -17838,7 +18673,7 @@ program2.command("list").description("List tasks").option("-s, --status <status>
     if (match) {
       filter["project_id"] = match.id;
     } else {
-      console.error(chalk.red(`No project matching: ${opts.projectName}`));
+      console.error(chalk2.red(`No project matching: ${opts.projectName}`));
       process.exit(1);
     }
   }
@@ -17882,7 +18717,7 @@ program2.command("list").description("List tasks").option("-s, --status <status>
     if (fmt === "compact" || fmt === "csv")
       process.stdout.write("");
     else
-      console.log(chalk.dim("No tasks found."));
+      console.log(chalk2.dim("No tasks found."));
     return;
   }
   if (fmt === "csv") {
@@ -17909,7 +18744,7 @@ program2.command("list").description("List tasks").option("-s, --status <status>
     }
     return;
   }
-  console.log(chalk.bold(`${tasks.length} task(s):
+  console.log(chalk2.bold(`${tasks.length} task(s):
 `));
   for (const t of tasks) {
     console.log(formatTaskLine(t));
@@ -17926,12 +18761,12 @@ program2.command("count").description("Show task count by status").action(() =>
     output(counts, true);
   } else {
     const parts = [
-      `total: ${chalk.bold(String(counts.total))}`,
-      `pending: ${chalk.yellow(String(counts["pending"] || 0))}`,
-      `in_progress: ${chalk.blue(String(counts["in_progress"] || 0))}`,
-      `completed: ${chalk.green(String(counts["completed"] || 0))}`,
-      `failed: ${chalk.red(String(counts["failed"] || 0))}`,
-      `cancelled: ${chalk.gray(String(counts["cancelled"] || 0))}`
+      `total: ${chalk2.bold(String(counts.total))}`,
+      `pending: ${chalk2.yellow(String(counts["pending"] || 0))}`,
+      `in_progress: ${chalk2.blue(String(counts["in_progress"] || 0))}`,
+      `completed: ${chalk2.green(String(counts["completed"] || 0))}`,
+      `failed: ${chalk2.red(String(counts["failed"] || 0))}`,
+      `cancelled: ${chalk2.gray(String(counts["cancelled"] || 0))}`
     ];
     console.log(parts.join("  "));
   }
@@ -17941,83 +18776,83 @@ program2.command("show <id>").description("Show full task details").action((id)
   const resolvedId = resolveTaskId(id);
   const task = getTaskWithRelations(resolvedId);
   if (!task) {
-    console.error(chalk.red(`Task not found: ${id}`));
+    console.error(chalk2.red(`Task not found: ${id}`));
     process.exit(1);
   }
   if (globalOpts.json) {
     output(task, true);
     return;
   }
-  console.log(chalk.bold(`Task Details:
+  console.log(chalk2.bold(`Task Details:
 `));
-  console.log(`  ${chalk.dim("ID:")}       ${task.id}`);
-  console.log(`  ${chalk.dim("Title:")}    ${task.title}`);
-  console.log(`  ${chalk.dim("Status:")}   ${(statusColors4[task.status] || chalk.white)(task.status)}`);
-  console.log(`  ${chalk.dim("Priority:")} ${(priorityColors2[task.priority] || chalk.white)(task.priority)}`);
+  console.log(`  ${chalk2.dim("ID:")}       ${task.id}`);
+  console.log(`  ${chalk2.dim("Title:")}    ${task.title}`);
+  console.log(`  ${chalk2.dim("Status:")}   ${(statusColors4[task.status] || chalk2.white)(task.status)}`);
+  console.log(`  ${chalk2.dim("Priority:")} ${(priorityColors2[task.priority] || chalk2.white)(task.priority)}`);
   if (task.description)
-    console.log(`  ${chalk.dim("Desc:")}     ${task.description}`);
+    console.log(`  ${chalk2.dim("Desc:")}     ${task.description}`);
   if (task.assigned_to)
-    console.log(`  ${chalk.dim("Assigned:")} ${task.assigned_to}`);
+    console.log(`  ${chalk2.dim("Assigned:")} ${task.assigned_to}`);
   if (task.agent_id)
-    console.log(`  ${chalk.dim("Agent:")}    ${task.agent_id}`);
+    console.log(`  ${chalk2.dim("Agent:")}    ${task.agent_id}`);
   if (task.session_id)
-    console.log(`  ${chalk.dim("Session:")}  ${task.session_id}`);
+    console.log(`  ${chalk2.dim("Session:")}  ${task.session_id}`);
   if (task.locked_by)
-    console.log(`  ${chalk.dim("Locked:")}   ${task.locked_by} (at ${task.locked_at})`);
+    console.log(`  ${chalk2.dim("Locked:")}   ${task.locked_by} (at ${task.locked_at})`);
   if (task.requires_approval) {
-    const approvalStatus = task.approved_by ? chalk.green(`approved by ${task.approved_by}`) : chalk.yellow("pending approval");
-    console.log(`  ${chalk.dim("Approval:")} ${approvalStatus}`);
+    const approvalStatus = task.approved_by ? chalk2.green(`approved by ${task.approved_by}`) : chalk2.yellow("pending approval");
+    console.log(`  ${chalk2.dim("Approval:")} ${approvalStatus}`);
   }
   if (task.estimated_minutes)
-    console.log(`  ${chalk.dim("Estimate:")} ${task.estimated_minutes} minutes`);
+    console.log(`  ${chalk2.dim("Estimate:")} ${task.estimated_minutes} minutes`);
   if (task.project_id)
-    console.log(`  ${chalk.dim("Project:")}  ${task.project_id}`);
+    console.log(`  ${chalk2.dim("Project:")}  ${task.project_id}`);
   if (task.plan_id)
-    console.log(`  ${chalk.dim("Plan:")}     ${task.plan_id}`);
+    console.log(`  ${chalk2.dim("Plan:")}     ${task.plan_id}`);
   if (task.working_dir)
-    console.log(`  ${chalk.dim("WorkDir:")}  ${task.working_dir}`);
+    console.log(`  ${chalk2.dim("WorkDir:")}  ${task.working_dir}`);
   if (task.parent)
-    console.log(`  ${chalk.dim("Parent:")}   ${task.parent.id.slice(0, 8)} | ${task.parent.title}`);
+    console.log(`  ${chalk2.dim("Parent:")}   ${task.parent.id.slice(0, 8)} | ${task.parent.title}`);
   if (task.tags.length > 0)
-    console.log(`  ${chalk.dim("Tags:")}     ${task.tags.join(", ")}`);
-  console.log(`  ${chalk.dim("Version:")}  ${task.version}`);
-  console.log(`  ${chalk.dim("Created:")}  ${task.created_at}`);
+    console.log(`  ${chalk2.dim("Tags:")}     ${task.tags.join(", ")}`);
+  console.log(`  ${chalk2.dim("Version:")}  ${task.version}`);
+  console.log(`  ${chalk2.dim("Created:")}  ${task.created_at}`);
   if (task.started_at)
-    console.log(`  ${chalk.dim("Started:")}  ${task.started_at}`);
+    console.log(`  ${chalk2.dim("Started:")}  ${task.started_at}`);
   if (task.completed_at) {
-    console.log(`  ${chalk.dim("Done:")}     ${task.completed_at}`);
+    console.log(`  ${chalk2.dim("Done:")}     ${task.completed_at}`);
     if (task.started_at) {
       const dur = Math.round((new Date(task.completed_at).getTime() - new Date(task.started_at).getTime()) / 60000);
-      console.log(`  ${chalk.dim("Duration:")} ${dur}m`);
+      console.log(`  ${chalk2.dim("Duration:")} ${dur}m`);
     }
   }
   if (task.subtasks.length > 0) {
-    console.log(chalk.bold(`
+    console.log(chalk2.bold(`
   Subtasks (${task.subtasks.length}):`));
     for (const st of task.subtasks) {
       console.log(`    ${formatTaskLine(st)}`);
     }
   }
   if (task.dependencies.length > 0) {
-    console.log(chalk.bold(`
+    console.log(chalk2.bold(`
   Depends on (${task.dependencies.length}):`));
     for (const dep of task.dependencies) {
       console.log(`    ${formatTaskLine(dep)}`);
     }
   }
   if (task.blocked_by.length > 0) {
-    console.log(chalk.bold(`
+    console.log(chalk2.bold(`
   Blocks (${task.blocked_by.length}):`));
     for (const b of task.blocked_by) {
       console.log(`    ${formatTaskLine(b)}`);
     }
   }
   if (task.comments.length > 0) {
-    console.log(chalk.bold(`
+    console.log(chalk2.bold(`
   Comments (${task.comments.length}):`));
     for (const c of task.comments) {
-      const agent = c.agent_id ? chalk.cyan(`[${c.agent_id}] `) : "";
-      console.log(`    ${agent}${chalk.dim(c.created_at)}: ${c.content}`);
+      const agent = c.agent_id ? chalk2.cyan(`[${c.agent_id}] `) : "";
+      console.log(`    ${agent}${chalk2.dim(c.created_at)}: ${c.content}`);
     }
   }
 });
@@ -18031,12 +18866,12 @@ program2.command("inspect [id]").description("Full orientation for a task \u2014
       resolvedId = active[0].id;
   }
   if (!resolvedId) {
-    console.error(chalk.red("No task ID given and no active task found. Pass an ID or use --agent."));
+    console.error(chalk2.red("No task ID given and no active task found. Pass an ID or use --agent."));
     process.exit(1);
   }
   const task = getTaskWithRelations(resolvedId);
   if (!task) {
-    console.error(chalk.red(`Task not found: ${id || resolvedId}`));
+    console.error(chalk2.red(`Task not found: ${id || resolvedId}`));
     process.exit(1);
   }
   if (globalOpts.json) {
@@ -18056,59 +18891,59 @@ program2.command("inspect [id]").description("Full orientation for a task \u2014
     return;
   }
   const sid = task.short_id || task.id.slice(0, 8);
-  const statusColor = statusColors4[task.status] || chalk.white;
-  const prioColor = priorityColors2[task.priority] || chalk.white;
-  console.log(chalk.bold(`
-${chalk.cyan(sid)} ${statusColor(task.status)} ${prioColor(task.priority)} ${task.title}
+  const statusColor = statusColors4[task.status] || chalk2.white;
+  const prioColor = priorityColors2[task.priority] || chalk2.white;
+  console.log(chalk2.bold(`
+${chalk2.cyan(sid)} ${statusColor(task.status)} ${prioColor(task.priority)} ${task.title}
 `));
   if (task.description) {
-    console.log(chalk.dim("Description:"));
+    console.log(chalk2.dim("Description:"));
     console.log(`  ${task.description}
 `);
   }
   if (task.assigned_to)
-    console.log(`  ${chalk.dim("Assigned:")}  ${task.assigned_to}`);
+    console.log(`  ${chalk2.dim("Assigned:")}  ${task.assigned_to}`);
   if (task.locked_by)
-    console.log(`  ${chalk.dim("Locked by:")} ${task.locked_by}`);
+    console.log(`  ${chalk2.dim("Locked by:")} ${task.locked_by}`);
   if (task.project_id)
-    console.log(`  ${chalk.dim("Project:")}   ${task.project_id}`);
+    console.log(`  ${chalk2.dim("Project:")}   ${task.project_id}`);
   if (task.plan_id)
-    console.log(`  ${chalk.dim("Plan:")}      ${task.plan_id}`);
+    console.log(`  ${chalk2.dim("Plan:")}      ${task.plan_id}`);
   if (task.started_at)
-    console.log(`  ${chalk.dim("Started:")}   ${task.started_at}`);
+    console.log(`  ${chalk2.dim("Started:")}   ${task.started_at}`);
   if (task.completed_at) {
-    console.log(`  ${chalk.dim("Completed:")} ${task.completed_at}`);
+    console.log(`  ${chalk2.dim("Completed:")} ${task.completed_at}`);
     if (task.started_at) {
       const dur = Math.round((new Date(task.completed_at).getTime() - new Date(task.started_at).getTime()) / 60000);
-      console.log(`  ${chalk.dim("Duration:")}  ${dur}m`);
+      console.log(`  ${chalk2.dim("Duration:")}  ${dur}m`);
     }
   }
   if (task.estimated_minutes)
-    console.log(`  ${chalk.dim("Estimate:")}  ${task.estimated_minutes}m`);
+    console.log(`  ${chalk2.dim("Estimate:")}  ${task.estimated_minutes}m`);
   if (task.tags.length > 0)
-    console.log(`  ${chalk.dim("Tags:")}      ${task.tags.join(", ")}`);
+    console.log(`  ${chalk2.dim("Tags:")}      ${task.tags.join(", ")}`);
   const unfinishedDeps = task.dependencies.filter((d) => d.status !== "completed" && d.status !== "cancelled");
   if (task.dependencies.length > 0) {
-    console.log(chalk.bold(`
+    console.log(chalk2.bold(`
   Depends on (${task.dependencies.length}):`));
     for (const dep of task.dependencies) {
       const blocked = dep.status !== "completed" && dep.status !== "cancelled";
-      const icon = blocked ? chalk.red("\u2717") : chalk.green("\u2713");
+      const icon = blocked ? chalk2.red("\u2717") : chalk2.green("\u2713");
       console.log(`    ${icon} ${formatTaskLine(dep)}`);
     }
   }
   if (unfinishedDeps.length > 0) {
-    console.log(chalk.red(`
+    console.log(chalk2.red(`
   BLOCKED by ${unfinishedDeps.length} unfinished dep(s)`));
   }
   if (task.blocked_by.length > 0) {
-    console.log(chalk.bold(`
+    console.log(chalk2.bold(`
   Blocks (${task.blocked_by.length}):`));
     for (const b of task.blocked_by)
       console.log(`    ${formatTaskLine(b)}`);
   }
   if (task.subtasks.length > 0) {
-    console.log(chalk.bold(`
+    console.log(chalk2.bold(`
   Subtasks (${task.subtasks.length}):`));
     for (const st of task.subtasks)
       console.log(`    ${formatTaskLine(st)}`);
@@ -18117,36 +18952,36 @@ ${chalk.cyan(sid)} ${statusColor(task.status)} ${prioColor(task.priority)} ${tas
     const { listTaskFiles: listTaskFiles2 } = (init_task_files(), __toCommonJS(exports_task_files));
     const files = listTaskFiles2(task.id);
     if (files.length > 0) {
-      console.log(chalk.bold(`
+      console.log(chalk2.bold(`
   Files (${files.length}):`));
       for (const f of files)
-        console.log(`    ${chalk.dim(f.role || "file")} ${f.path}`);
+        console.log(`    ${chalk2.dim(f.role || "file")} ${f.path}`);
     }
   } catch {}
   try {
     const { getTaskCommits: getTaskCommits2 } = (init_task_commits(), __toCommonJS(exports_task_commits));
     const commits = getTaskCommits2(task.id);
     if (commits.length > 0) {
-      console.log(chalk.bold(`
+      console.log(chalk2.bold(`
   Commits (${commits.length}):`));
       for (const c of commits)
-        console.log(`    ${chalk.yellow(c.commit_hash.slice(0, 7))} ${c.message || ""}`);
+        console.log(`    ${chalk2.yellow(c.commit_hash.slice(0, 7))} ${c.message || ""}`);
     }
   } catch {}
   if (task.comments.length > 0) {
-    console.log(chalk.bold(`
+    console.log(chalk2.bold(`
   Comments (${task.comments.length}):`));
     for (const c of task.comments) {
-      const agent = c.agent_id ? chalk.cyan(`[${c.agent_id}] `) : "";
-      console.log(`    ${agent}${chalk.dim(c.created_at)}: ${c.content}`);
+      const agent = c.agent_id ? chalk2.cyan(`[${c.agent_id}] `) : "";
+      console.log(`    ${agent}${chalk2.dim(c.created_at)}: ${c.content}`);
     }
   }
   if (task.checklist && task.checklist.length > 0) {
     const done = task.checklist.filter((c) => c.checked).length;
-    console.log(chalk.bold(`
+    console.log(chalk2.bold(`
   Checklist (${done}/${task.checklist.length}):`));
     for (const item of task.checklist) {
-      const icon = item.checked ? chalk.green("\u2611") : chalk.dim("\u2610");
+      const icon = item.checked ? chalk2.green("\u2611") : chalk2.dim("\u2610");
       console.log(`    ${icon} ${item.text || item.title}`);
     }
   }
@@ -18162,16 +18997,16 @@ program2.command("history <id>").description("Show change history for a task (au
     return;
   }
   if (history.length === 0) {
-    console.log(chalk.dim("No history for this task."));
+    console.log(chalk2.dim("No history for this task."));
     return;
   }
-  console.log(chalk.bold(`${history.length} change(s):
+  console.log(chalk2.bold(`${history.length} change(s):
 `));
   for (const h of history) {
-    const agent = h.agent_id ? chalk.cyan(` by ${h.agent_id}`) : "";
-    const field = h.field ? chalk.yellow(` ${h.field}`) : "";
-    const change = h.old_value && h.new_value ? ` ${chalk.red(h.old_value)} \u2192 ${chalk.green(h.new_value)}` : h.new_value ? ` \u2192 ${chalk.green(h.new_value)}` : "";
-    console.log(`  ${chalk.dim(h.created_at)} ${chalk.bold(h.action)}${field}${change}${agent}`);
+    const agent = h.agent_id ? chalk2.cyan(` by ${h.agent_id}`) : "";
+    const field = h.field ? chalk2.yellow(` ${h.field}`) : "";
+    const change = h.old_value && h.new_value ? ` ${chalk2.red(h.old_value)} \u2192 ${chalk2.green(h.new_value)}` : h.new_value ? ` \u2192 ${chalk2.green(h.new_value)}` : "";
+    console.log(`  ${chalk2.dim(h.created_at)} ${chalk2.bold(h.action)}${field}${change}${agent}`);
   }
 });
 program2.command("update <id>").description("Update a task").option("--title <text>", "New title").option("-d, --description <text>", "New description").option("-s, --status <status>", "New status").option("-p, --priority <priority>", "New priority").option("--assign <agent>", "Assign to agent").option("--tags <tags>", "New tags (comma-separated)").option("--tag <tags>", "New tags (alias for --tags)").option("--list <id>", "Move to a task list").option("--task-list <id>", "Move to a task list (alias for --list)").option("--estimated <minutes>", "Estimated time in minutes").option("--approval", "Require approval before completion").action((id, opts) => {
@@ -18181,14 +19016,14 @@ program2.command("update <id>").description("Update a task").option("--title <te
   const resolvedId = resolveTaskId(id);
   const current = getTask(resolvedId);
   if (!current) {
-    console.error(chalk.red(`Task not found: ${id}`));
+    console.error(chalk2.red(`Task not found: ${id}`));
     process.exit(1);
   }
   const taskListId = opts.list ? (() => {
     const db = getDatabase();
     const resolved = resolvePartialId(db, "task_lists", opts.list);
     if (!resolved) {
-      console.error(chalk.red(`Could not resolve task list ID: ${opts.list}`));
+      console.error(chalk2.red(`Could not resolve task list ID: ${opts.list}`));
       process.exit(1);
     }
     return resolved;
@@ -18213,7 +19048,7 @@ program2.command("update <id>").description("Update a task").option("--title <te
   if (globalOpts.json) {
     output(task, true);
   } else {
-    console.log(chalk.green("Task updated:"));
+    console.log(chalk2.green("Task updated:"));
     console.log(formatTaskLine(task));
   }
 });
@@ -18233,7 +19068,7 @@ program2.command("done <id>").description("Mark a task as completed").option("--
   if (globalOpts.json) {
     output(task, true);
   } else {
-    console.log(chalk.green("Task completed:"));
+    console.log(chalk2.green("Task completed:"));
     console.log(formatTaskLine(task));
   }
 });
@@ -18242,15 +19077,15 @@ program2.command("approve <id>").description("Approve a task that requires appro
   const resolvedId = resolveTaskId(id);
   const task = getTask(resolvedId);
   if (!task) {
-    console.error(chalk.red(`Task not found: ${id}`));
+    console.error(chalk2.red(`Task not found: ${id}`));
     process.exit(1);
   }
   if (!task.requires_approval) {
-    console.log(chalk.yellow("This task does not require approval."));
+    console.log(chalk2.yellow("This task does not require approval."));
     return;
   }
   if (task.approved_by) {
-    console.log(chalk.yellow(`Already approved by ${task.approved_by}.`));
+    console.log(chalk2.yellow(`Already approved by ${task.approved_by}.`));
     return;
   }
   try {
@@ -18258,7 +19093,7 @@ program2.command("approve <id>").description("Approve a task that requires appro
     if (globalOpts.json) {
       output(updated, true);
     } else {
-      console.log(chalk.green(`Task approved by ${globalOpts.agent || "cli"}:`));
+      console.log(chalk2.green(`Task approved by ${globalOpts.agent || "cli"}:`));
       console.log(formatTaskLine(updated));
     }
   } catch (e) {
@@ -18278,7 +19113,7 @@ program2.command("start <id>").description("Claim, lock, and start a task").acti
   if (globalOpts.json) {
     output(task, true);
   } else {
-    console.log(chalk.green(`Task started by ${agentId}:`));
+    console.log(chalk2.green(`Task started by ${agentId}:`));
     console.log(formatTaskLine(task));
   }
 });
@@ -18295,9 +19130,9 @@ program2.command("lock <id>").description("Acquire exclusive lock on a task").ac
   if (globalOpts.json) {
     output(result, true);
   } else if (result.success) {
-    console.log(chalk.green(`Lock acquired by ${agentId}`));
+    console.log(chalk2.green(`Lock acquired by ${agentId}`));
   } else {
-    console.error(chalk.red(`Lock failed: ${result.error}`));
+    console.error(chalk2.red(`Lock failed: ${result.error}`));
     process.exit(1);
   }
 });
@@ -18312,7 +19147,7 @@ program2.command("unlock <id>").description("Release lock on a task").action((id
   if (globalOpts.json) {
     output({ success: true }, true);
   } else {
-    console.log(chalk.green("Lock released."));
+    console.log(chalk2.green("Lock released."));
   }
 });
 program2.command("delete <id>").description("Delete a task").action((id) => {
@@ -18322,9 +19157,9 @@ program2.command("delete <id>").description("Delete a task").action((id) => {
   if (globalOpts.json) {
     output({ deleted }, true);
   } else if (deleted) {
-    console.log(chalk.green("Task deleted."));
+    console.log(chalk2.green("Task deleted."));
   } else {
-    console.error(chalk.red("Task not found."));
+    console.error(chalk2.red("Task not found."));
     process.exit(1);
   }
 });
@@ -18335,9 +19170,9 @@ program2.command("remove <id>").description("Remove/delete a task (alias for del
   if (globalOpts.json) {
     output({ deleted }, true);
   } else if (deleted) {
-    console.log(chalk.green("Task removed."));
+    console.log(chalk2.green("Task removed."));
   } else {
-    console.error(chalk.red("Task not found."));
+    console.error(chalk2.red("Task not found."));
     process.exit(1);
   }
 });
@@ -18357,7 +19192,7 @@ program2.command("bulk <action> <ids...>").description("Bulk operation on multip
         deleteTask(resolvedId);
         results.push({ id: resolvedId, success: true });
       } else {
-        console.error(chalk.red(`Unknown action: ${action}. Use: done, start, delete`));
+        console.error(chalk2.red(`Unknown action: ${action}. Use: done, start, delete`));
         process.exit(1);
       }
     } catch (e) {
@@ -18369,9 +19204,9 @@ program2.command("bulk <action> <ids...>").description("Bulk operation on multip
   if (globalOpts.json) {
     output({ results, succeeded, failed }, true);
   } else {
-    console.log(chalk.green(`${action}: ${succeeded} succeeded, ${failed} failed`));
+    console.log(chalk2.green(`${action}: ${succeeded} succeeded, ${failed} failed`));
     for (const r of results.filter((r2) => !r2.success)) {
-      console.log(chalk.red(`  ${r.id}: ${r.error}`));
+      console.log(chalk2.red(`  ${r.id}: ${r.error}`));
     }
   }
 });
@@ -18387,8 +19222,8 @@ program2.command("plans").description("List and manage plans").option("--add <na
     if (globalOpts.json) {
       output(plan, true);
     } else {
-      console.log(chalk.green("Plan created:"));
-      console.log(`${chalk.dim(plan.id.slice(0, 8))} ${chalk.bold(plan.name)} ${chalk.cyan(`[${plan.status}]`)}`);
+      console.log(chalk2.green("Plan created:"));
+      console.log(`${chalk2.dim(plan.id.slice(0, 8))} ${chalk2.bold(plan.name)} ${chalk2.cyan(`[${plan.status}]`)}`);
     }
     return;
   }
@@ -18396,12 +19231,12 @@ program2.command("plans").description("List and manage plans").option("--add <na
     const db = getDatabase();
     const resolvedId = resolvePartialId(db, "plans", opts.show);
     if (!resolvedId) {
-      console.error(chalk.red(`Could not resolve plan ID: ${opts.show}`));
+      console.error(chalk2.red(`Could not resolve plan ID: ${opts.show}`));
       process.exit(1);
     }
     const plan = getPlan(resolvedId);
     if (!plan) {
-      console.error(chalk.red(`Plan not found: ${opts.show}`));
+      console.error(chalk2.red(`Plan not found: ${opts.show}`));
       process.exit(1);
     }
     const tasks = listTasks({ plan_id: resolvedId });
@@ -18409,24 +19244,24 @@ program2.command("plans").description("List and manage plans").option("--add <na
       output({ plan, tasks }, true);
       return;
     }
-    console.log(chalk.bold(`Plan Details:
+    console.log(chalk2.bold(`Plan Details:
 `));
-    console.log(`  ${chalk.dim("ID:")}       ${plan.id}`);
-    console.log(`  ${chalk.dim("Name:")}     ${plan.name}`);
-    console.log(`  ${chalk.dim("Status:")}   ${chalk.cyan(plan.status)}`);
+    console.log(`  ${chalk2.dim("ID:")}       ${plan.id}`);
+    console.log(`  ${chalk2.dim("Name:")}     ${plan.name}`);
+    console.log(`  ${chalk2.dim("Status:")}   ${chalk2.cyan(plan.status)}`);
     if (plan.description)
-      console.log(`  ${chalk.dim("Desc:")}     ${plan.description}`);
+      console.log(`  ${chalk2.dim("Desc:")}     ${plan.description}`);
     if (plan.project_id)
-      console.log(`  ${chalk.dim("Project:")}  ${plan.project_id}`);
-    console.log(`  ${chalk.dim("Created:")}  ${plan.created_at}`);
+      console.log(`  ${chalk2.dim("Project:")}  ${plan.project_id}`);
+    console.log(`  ${chalk2.dim("Created:")}  ${plan.created_at}`);
     if (tasks.length > 0) {
-      console.log(chalk.bold(`
+      console.log(chalk2.bold(`
   Tasks (${tasks.length}):`));
       for (const t of tasks) {
         console.log(`    ${formatTaskLine(t)}`);
       }
     } else {
-      console.log(chalk.dim(`
+      console.log(chalk2.dim(`
   No tasks in this plan.`));
     }
     return;
@@ -18435,16 +19270,16 @@ program2.command("plans").description("List and manage plans").option("--add <na
     const db = getDatabase();
     const resolvedId = resolvePartialId(db, "plans", opts.delete);
     if (!resolvedId) {
-      console.error(chalk.red(`Could not resolve plan ID: ${opts.delete}`));
+      console.error(chalk2.red(`Could not resolve plan ID: ${opts.delete}`));
       process.exit(1);
     }
     const deleted = deletePlan(resolvedId);
     if (globalOpts.json) {
       output({ deleted }, true);
     } else if (deleted) {
-      console.log(chalk.green("Plan deleted."));
+      console.log(chalk2.green("Plan deleted."));
     } else {
-      console.error(chalk.red("Plan not found."));
+      console.error(chalk2.red("Plan not found."));
       process.exit(1);
     }
     return;
@@ -18453,7 +19288,7 @@ program2.command("plans").description("List and manage plans").option("--add <na
     const db = getDatabase();
     const resolvedId = resolvePartialId(db, "plans", opts.complete);
     if (!resolvedId) {
-      console.error(chalk.red(`Could not resolve plan ID: ${opts.complete}`));
+      console.error(chalk2.red(`Could not resolve plan ID: ${opts.complete}`));
       process.exit(1);
     }
     try {
@@ -18461,8 +19296,8 @@ program2.command("plans").description("List and manage plans").option("--add <na
       if (globalOpts.json) {
         output(plan, true);
       } else {
-        console.log(chalk.green("Plan completed:"));
-        console.log(`${chalk.dim(plan.id.slice(0, 8))} ${chalk.bold(plan.name)} ${chalk.cyan(`[${plan.status}]`)}`);
+        console.log(chalk2.green("Plan completed:"));
+        console.log(`${chalk2.dim(plan.id.slice(0, 8))} ${chalk2.bold(plan.name)} ${chalk2.cyan(`[${plan.status}]`)}`);
       }
     } catch (e) {
       handleError(e);
@@ -18475,14 +19310,14 @@ program2.command("plans").description("List and manage plans").option("--add <na
     return;
   }
   if (plans.length === 0) {
-    console.log(chalk.dim("No plans found."));
+    console.log(chalk2.dim("No plans found."));
     return;
   }
-  console.log(chalk.bold(`${plans.length} plan(s):
+  console.log(chalk2.bold(`${plans.length} plan(s):
 `));
   for (const p of plans) {
-    const desc = p.description ? chalk.dim(` - ${p.description}`) : "";
-    console.log(`${chalk.dim(p.id.slice(0, 8))} ${chalk.bold(p.name)} ${chalk.cyan(`[${p.status}]`)}${desc}`);
+    const desc = p.description ? chalk2.dim(` - ${p.description}`) : "";
+    console.log(`${chalk2.dim(p.id.slice(0, 8))} ${chalk2.bold(p.name)} ${chalk2.cyan(`[${p.status}]`)}${desc}`);
   }
 });
 program2.command("templates").description("List and manage task templates").option("--add <name>", "Create a template").option("--title <pattern>", "Title pattern (with --add)").option("-d, --description <text>", "Default description").option("-p, --priority <level>", "Default priority").option("-t, --tags <tags>", "Default tags (comma-separated)").option("--delete <id>", "Delete a template").option("--use <id>", "Create a task from a template").action((opts) => {
@@ -18490,7 +19325,7 @@ program2.command("templates").description("List and manage task templates").opti
   const { createTemplate: createTemplate2, listTemplates: listTemplates2, deleteTemplate: deleteTemplate2, taskFromTemplate: taskFromTemplate2 } = (init_templates(), __toCommonJS(exports_templates));
   if (opts.add) {
     if (!opts.title) {
-      console.error(chalk.red("--title is required with --add"));
+      console.error(chalk2.red("--title is required with --add"));
       process.exit(1);
     }
     const projectId = autoProject(globalOpts);
@@ -18505,7 +19340,7 @@ program2.command("templates").description("List and manage task templates").opti
     if (globalOpts.json) {
       output(template, true);
     } else {
-      console.log(chalk.green(`Template created: ${template.id.slice(0, 8)} | ${template.name} | "${template.title_pattern}"`));
+      console.log(chalk2.green(`Template created: ${template.id.slice(0, 8)} | ${template.name} | "${template.title_pattern}"`));
     }
     return;
   }
@@ -18514,9 +19349,9 @@ program2.command("templates").description("List and manage task templates").opti
     if (globalOpts.json) {
       output({ deleted }, true);
     } else if (deleted) {
-      console.log(chalk.green("Template deleted."));
+      console.log(chalk2.green("Template deleted."));
     } else {
-      console.error(chalk.red("Template not found."));
+      console.error(chalk2.red("Template not found."));
       process.exit(1);
     }
     return;
@@ -18532,7 +19367,7 @@ program2.command("templates").description("List and manage task templates").opti
       if (globalOpts.json) {
         output(task, true);
       } else {
-        console.log(chalk.green("Task created from template:"));
+        console.log(chalk2.green("Task created from template:"));
         console.log(formatTaskLine(task));
       }
     } catch (e) {
@@ -18546,13 +19381,13 @@ program2.command("templates").description("List and manage task templates").opti
     return;
   }
   if (templates.length === 0) {
-    console.log(chalk.dim("No templates."));
+    console.log(chalk2.dim("No templates."));
     return;
   }
-  console.log(chalk.bold(`${templates.length} template(s):
+  console.log(chalk2.bold(`${templates.length} template(s):
 `));
   for (const t of templates) {
-    console.log(`  ${chalk.dim(t.id.slice(0, 8))} ${chalk.bold(t.name)} ${chalk.cyan(`"${t.title_pattern}"`)} ${chalk.yellow(t.priority)}`);
+    console.log(`  ${chalk2.dim(t.id.slice(0, 8))} ${chalk2.bold(t.name)} ${chalk2.cyan(`"${t.title_pattern}"`)} ${chalk2.yellow(t.priority)}`);
   }
 });
 program2.command("comment <id> <text>").description("Add a comment to a task").action((id, text) => {
@@ -18567,7 +19402,7 @@ program2.command("comment <id> <text>").description("Add a comment to a task").a
   if (globalOpts.json) {
     output(comment, true);
   } else {
-    console.log(chalk.green("Comment added."));
+    console.log(chalk2.green("Comment added."));
   }
 });
 program2.command("search <query>").description("Search tasks").option("--status <status>", "Filter by status").option("--priority <p>", "Filter by priority").option("--assigned <agent>", "Filter by assigned agent").option("--since <date>", "Only tasks updated after this date (ISO)").option("--blocked", "Only blocked tasks (incomplete dependencies)").option("--has-deps", "Only tasks with dependencies").action((query, opts) => {
@@ -18592,10 +19427,10 @@ program2.command("search <query>").description("Search tasks").option("--status
     return;
   }
   if (tasks.length === 0) {
-    console.log(chalk.dim(`No tasks matching "${query}".`));
+    console.log(chalk2.dim(`No tasks matching "${query}".`));
     return;
   }
-  console.log(chalk.bold(`${tasks.length} result(s) for "${query}":
+  console.log(chalk2.bold(`${tasks.length} result(s) for "${query}":
 `));
   for (const t of tasks) {
     console.log(formatTaskLine(t));
@@ -18609,13 +19444,13 @@ program2.command("deps <id>").description("Manage task dependencies").option("--
     try {
       addDependency(resolvedId, depId);
     } catch (e) {
-      console.error(chalk.red(e instanceof Error ? e.message : String(e)));
+      console.error(chalk2.red(e instanceof Error ? e.message : String(e)));
       process.exit(1);
     }
     if (globalOpts.json) {
       output({ task_id: resolvedId, depends_on: depId }, true);
     } else {
-      console.log(chalk.green("Dependency added."));
+      console.log(chalk2.green("Dependency added."));
     }
   } else if (opts.remove) {
     const depId = resolveTaskId(opts.remove);
@@ -18623,12 +19458,12 @@ program2.command("deps <id>").description("Manage task dependencies").option("--
     if (globalOpts.json) {
       output({ removed }, true);
     } else {
-      console.log(removed ? chalk.green("Dependency removed.") : chalk.red("Dependency not found."));
+      console.log(removed ? chalk2.green("Dependency removed.") : chalk2.red("Dependency not found."));
     }
   } else {
     const task = getTaskWithRelations(resolvedId);
     if (!task) {
-      console.error(chalk.red("Task not found."));
+      console.error(chalk2.red("Task not found."));
       process.exit(1);
     }
     if (globalOpts.json) {
@@ -18636,19 +19471,19 @@ program2.command("deps <id>").description("Manage task dependencies").option("--
       return;
     }
     if (task.dependencies.length > 0) {
-      console.log(chalk.bold("Depends on:"));
+      console.log(chalk2.bold("Depends on:"));
       for (const dep of task.dependencies) {
         console.log(`  ${formatTaskLine(dep)}`);
       }
     }
     if (task.blocked_by.length > 0) {
-      console.log(chalk.bold("Blocks:"));
+      console.log(chalk2.bold("Blocks:"));
       for (const b of task.blocked_by) {
         console.log(`  ${formatTaskLine(b)}`);
       }
     }
     if (task.dependencies.length === 0 && task.blocked_by.length === 0) {
-      console.log(chalk.dim("No dependencies."));
+      console.log(chalk2.dim("No dependencies."));
     }
   }
 });
@@ -18670,9 +19505,9 @@ program2.command("projects").description("List and manage projects").option("--a
     if (globalOpts.json) {
       output(project, true);
     } else {
-      console.log(chalk.green(`Project registered: ${project.name} (${project.path})`));
+      console.log(chalk2.green(`Project registered: ${project.name} (${project.path})`));
       if (project.task_list_id)
-        console.log(chalk.dim(`  Task list: ${project.task_list_id}`));
+        console.log(chalk2.dim(`  Task list: ${project.task_list_id}`));
     }
     return;
   }
@@ -18682,14 +19517,14 @@ program2.command("projects").description("List and manage projects").option("--a
     return;
   }
   if (projects.length === 0) {
-    console.log(chalk.dim("No projects registered."));
+    console.log(chalk2.dim("No projects registered."));
     return;
   }
-  console.log(chalk.bold(`${projects.length} project(s):
+  console.log(chalk2.bold(`${projects.length} project(s):
 `));
   for (const p of projects) {
-    const taskList = p.task_list_id ? chalk.cyan(` [${p.task_list_id}]`) : "";
-    console.log(`${chalk.dim(p.id.slice(0, 8))} ${chalk.bold(p.name)} ${chalk.dim(p.path)}${taskList}${p.description ? ` - ${p.description}` : ""}`);
+    const taskList = p.task_list_id ? chalk2.cyan(` [${p.task_list_id}]`) : "";
+    console.log(`${chalk2.dim(p.id.slice(0, 8))} ${chalk2.bold(p.name)} ${chalk2.dim(p.path)}${taskList}${p.description ? ` - ${p.description}` : ""}`);
   }
 });
 program2.command("extract <path>").description("Extract TODO/FIXME/HACK/BUG/XXX/NOTE comments from source files and create tasks").option("--dry-run", "Show extracted comments without creating tasks").option("--pattern <tags>", "Comma-separated tags to look for (default: TODO,FIXME,HACK,XXX,BUG,NOTE)").option("-t, --tags <tags>", "Extra comma-separated tags to add to created tasks").option("--assign <agent>", "Assign extracted tasks to an agent").option("--list <id>", "Task list ID").option("--ext <extensions>", "Comma-separated file extensions to scan (e.g. ts,py,go)").action((scanPath, opts) => {
@@ -18702,7 +19537,7 @@ program2.command("extract <path>").description("Extract TODO/FIXME/HACK/BUG/XXX/
       const db = getDatabase();
       const id = resolvePartialId(db, "task_lists", opts.list);
       if (!id) {
-        console.error(chalk.red(`Could not resolve task list ID: ${opts.list}`));
+        console.error(chalk2.red(`Could not resolve task list ID: ${opts.list}`));
         process.exit(1);
       }
       return id;
@@ -18721,18 +19556,18 @@ program2.command("extract <path>").description("Extract TODO/FIXME/HACK/BUG/XXX/
     if (globalOpts.json) {
       console.log(JSON.stringify(opts.dryRun ? { comments: result.comments } : { tasks_created: result.tasks.length, skipped: result.skipped, comments: result.comments.length }, null, 2));
     } else if (opts.dryRun) {
-      console.log(chalk.cyan(`Found ${result.comments.length} comment(s):
+      console.log(chalk2.cyan(`Found ${result.comments.length} comment(s):
 `));
       for (const c of result.comments) {
-        console.log(`  ${chalk.yellow(`[${c.tag}]`)} ${c.message}`);
-        console.log(`    ${chalk.gray(`${c.file}:${c.line}`)}`);
+        console.log(`  ${chalk2.yellow(`[${c.tag}]`)} ${c.message}`);
+        console.log(`    ${chalk2.gray(`${c.file}:${c.line}`)}`);
       }
     } else {
-      console.log(chalk.green(`Created ${result.tasks.length} task(s)`));
+      console.log(chalk2.green(`Created ${result.tasks.length} task(s)`));
       if (result.skipped > 0) {
-        console.log(chalk.gray(`Skipped ${result.skipped} duplicate(s)`));
+        console.log(chalk2.gray(`Skipped ${result.skipped} duplicate(s)`));
       }
-      console.log(chalk.gray(`Total comments found: ${result.comments.length}`));
+      console.log(chalk2.gray(`Total comments found: ${result.comments.length}`));
       for (const t of result.tasks) {
         console.log(formatTaskLine(t));
       }
@@ -18782,7 +19617,7 @@ program2.command("sync").description("Sync tasks with an agent task list (Claude
     const agent = opts.agent || "claude";
     const taskListId = resolveTaskListId2(agent, opts.taskList, project?.task_list_id);
     if (!taskListId) {
-      console.error(chalk.red(`Could not detect task list ID for ${agent}. Use --task-list <id> or set appropriate env vars.`));
+      console.error(chalk2.red(`Could not detect task list ID for ${agent}. Use --task-list <id> or set appropriate env vars.`));
       process.exit(1);
     }
     result = syncWithAgent(agent, taskListId, projectId, direction, { prefer });
@@ -18792,14 +19627,14 @@ program2.command("sync").description("Sync tasks with an agent task list (Claude
     return;
   }
   if (result.pulled > 0)
-    console.log(chalk.green(`Pulled ${result.pulled} task(s).`));
+    console.log(chalk2.green(`Pulled ${result.pulled} task(s).`));
   if (result.pushed > 0)
-    console.log(chalk.green(`Pushed ${result.pushed} task(s).`));
+    console.log(chalk2.green(`Pushed ${result.pushed} task(s).`));
   if (result.pulled === 0 && result.pushed === 0 && result.errors.length === 0) {
-    console.log(chalk.dim("Nothing to sync."));
+    console.log(chalk2.dim("Nothing to sync."));
   }
   for (const err of result.errors) {
-    console.error(chalk.red(`  Error: ${err}`));
+    console.error(chalk2.red(`  Error: ${err}`));
   }
 });
 var hooks = program2.command("hooks").description("Manage Claude Code hook integration");
@@ -18810,9 +19645,9 @@ hooks.command("install").description("Install Claude Code hooks for auto-sync").
     if (p)
       todosBin = p;
   } catch {}
-  const hooksDir = join9(process.cwd(), ".claude", "hooks");
-  if (!existsSync7(hooksDir))
-    mkdirSync3(hooksDir, { recursive: true });
+  const hooksDir = join11(process.cwd(), ".claude", "hooks");
+  if (!existsSync9(hooksDir))
+    mkdirSync5(hooksDir, { recursive: true });
   const hookScript = `#!/usr/bin/env bash
 # Auto-generated by: todos hooks install
 # Syncs todos with Claude Code task list on tool use events.
@@ -18836,11 +19671,11 @@ esac
 
 exit 0
 `;
-  const hookPath = join9(hooksDir, "todos-sync.sh");
-  writeFileSync3(hookPath, hookScript);
+  const hookPath = join11(hooksDir, "todos-sync.sh");
+  writeFileSync5(hookPath, hookScript);
   execSync2(`chmod +x "${hookPath}"`);
-  console.log(chalk.green(`Hook script created: ${hookPath}`));
-  const settingsPath = join9(process.cwd(), ".claude", "settings.json");
+  console.log(chalk2.green(`Hook script created: ${hookPath}`));
+  const settingsPath = join11(process.cwd(), ".claude", "settings.json");
   const settings = readJsonFile2(settingsPath);
   if (!settings["hooks"]) {
     settings["hooks"] = {};
@@ -18866,8 +19701,8 @@ exit 0
   });
   hooksConfig["PostToolUse"] = filtered;
   writeJsonFile2(settingsPath, settings);
-  console.log(chalk.green(`Claude Code hooks configured in: ${settingsPath}`));
-  console.log(chalk.dim("Task list ID auto-detected from project."));
+  console.log(chalk2.green(`Claude Code hooks configured in: ${settingsPath}`));
+  console.log(chalk2.dim("Task list ID auto-detected from project."));
 });
 program2.command("mcp").description("Start MCP server (stdio)").option("--register <agent>", "Register MCP server with an agent (claude, codex, gemini, all)").option("--unregister <agent>", "Unregister MCP server from an agent (claude, codex, gemini, all)").option("-g, --global", "Register/unregister globally (user-level) instead of project-level").action(async (opts) => {
   if (opts.register) {
@@ -18887,37 +19722,37 @@ function getMcpBinaryPath() {
     if (p)
       return p;
   } catch {}
-  const bunBin = join9(HOME2, ".bun", "bin", "todos-mcp");
-  if (existsSync7(bunBin))
+  const bunBin = join11(HOME2, ".bun", "bin", "todos-mcp");
+  if (existsSync9(bunBin))
     return bunBin;
   return "todos-mcp";
 }
 function readJsonFile2(path) {
-  if (!existsSync7(path))
+  if (!existsSync9(path))
     return {};
   try {
-    return JSON.parse(readFileSync5(path, "utf-8"));
+    return JSON.parse(readFileSync6(path, "utf-8"));
   } catch {
     return {};
   }
 }
 function writeJsonFile2(path, data) {
   const dir = dirname4(path);
-  if (!existsSync7(dir))
-    mkdirSync3(dir, { recursive: true });
-  writeFileSync3(path, JSON.stringify(data, null, 2) + `
+  if (!existsSync9(dir))
+    mkdirSync5(dir, { recursive: true });
+  writeFileSync5(path, JSON.stringify(data, null, 2) + `
 `);
 }
 function readTomlFile(path) {
-  if (!existsSync7(path))
+  if (!existsSync9(path))
     return "";
-  return readFileSync5(path, "utf-8");
+  return readFileSync6(path, "utf-8");
 }
 function writeTomlFile(path, content) {
   const dir = dirname4(path);
-  if (!existsSync7(dir))
-    mkdirSync3(dir, { recursive: true });
-  writeFileSync3(path, content);
+  if (!existsSync9(dir))
+    mkdirSync5(dir, { recursive: true });
+  writeFileSync5(path, content);
 }
 function registerClaude(binPath, global) {
   const scope = global ? "user" : "project";
@@ -18925,24 +19760,24 @@ function registerClaude(binPath, global) {
   try {
     const { execSync: execSync3 } = __require("child_process");
     execSync3(cmd, { stdio: "pipe" });
-    console.log(chalk.green(`Claude Code (${scope}): registered via 'claude mcp add'`));
+    console.log(chalk2.green(`Claude Code (${scope}): registered via 'claude mcp add'`));
   } catch {
-    console.log(chalk.yellow(`Claude Code: could not auto-register. Run this command manually:`));
-    console.log(chalk.cyan(`  ${cmd}`));
+    console.log(chalk2.yellow(`Claude Code: could not auto-register. Run this command manually:`));
+    console.log(chalk2.cyan(`  ${cmd}`));
   }
 }
 function unregisterClaude(_global) {
   try {
     const { execSync: execSync3 } = __require("child_process");
     execSync3("claude mcp remove todos", { stdio: "pipe" });
-    console.log(chalk.green(`Claude Code: removed todos MCP server`));
+    console.log(chalk2.green(`Claude Code: removed todos MCP server`));
   } catch {
-    console.log(chalk.yellow(`Claude Code: could not auto-remove. Run manually:`));
-    console.log(chalk.cyan("  claude mcp remove todos"));
+    console.log(chalk2.yellow(`Claude Code: could not auto-remove. Run manually:`));
+    console.log(chalk2.cyan("  claude mcp remove todos"));
   }
 }
 function registerCodex(binPath) {
-  const configPath = join9(HOME2, ".codex", "config.toml");
+  const configPath = join11(HOME2, ".codex", "config.toml");
   let content = readTomlFile(configPath);
   content = removeTomlBlock(content, "mcp_servers.todos");
   const block = `
@@ -18953,19 +19788,19 @@ args = []
   content = content.trimEnd() + `
 ` + block;
   writeTomlFile(configPath, content);
-  console.log(chalk.green(`Codex CLI: registered in ${configPath}`));
+  console.log(chalk2.green(`Codex CLI: registered in ${configPath}`));
 }
 function unregisterCodex() {
-  const configPath = join9(HOME2, ".codex", "config.toml");
+  const configPath = join11(HOME2, ".codex", "config.toml");
   let content = readTomlFile(configPath);
   if (!content.includes("[mcp_servers.todos]")) {
-    console.log(chalk.dim(`Codex CLI: todos not found in ${configPath}`));
+    console.log(chalk2.dim(`Codex CLI: todos not found in ${configPath}`));
     return;
   }
   content = removeTomlBlock(content, "mcp_servers.todos");
   writeTomlFile(configPath, content.trimEnd() + `
 `);
-  console.log(chalk.green(`Codex CLI: unregistered from ${configPath}`));
+  console.log(chalk2.green(`Codex CLI: unregistered from ${configPath}`));
 }
 function removeTomlBlock(content, blockName) {
   const lines = content.split(`
@@ -18989,7 +19824,7 @@ function removeTomlBlock(content, blockName) {
 `);
 }
 function registerGemini(binPath) {
-  const configPath = join9(HOME2, ".gemini", "settings.json");
+  const configPath = join11(HOME2, ".gemini", "settings.json");
   const config = readJsonFile2(configPath);
   if (!config["mcpServers"]) {
     config["mcpServers"] = {};
@@ -19000,19 +19835,19 @@ function registerGemini(binPath) {
     args: []
   };
   writeJsonFile2(configPath, config);
-  console.log(chalk.green(`Gemini CLI: registered in ${configPath}`));
+  console.log(chalk2.green(`Gemini CLI: registered in ${configPath}`));
 }
 function unregisterGemini() {
-  const configPath = join9(HOME2, ".gemini", "settings.json");
+  const configPath = join11(HOME2, ".gemini", "settings.json");
   const config = readJsonFile2(configPath);
   const servers = config["mcpServers"];
   if (!servers || !("todos" in servers)) {
-    console.log(chalk.dim(`Gemini CLI: todos not found in ${configPath}`));
+    console.log(chalk2.dim(`Gemini CLI: todos not found in ${configPath}`));
     return;
   }
   delete servers["todos"];
   writeJsonFile2(configPath, config);
-  console.log(chalk.green(`Gemini CLI: unregistered from ${configPath}`));
+  console.log(chalk2.green(`Gemini CLI: unregistered from ${configPath}`));
 }
 function registerMcp(agent, global) {
   const agents = agent === "all" ? ["claude", "codex", "gemini"] : [agent];
@@ -19029,7 +19864,7 @@ function registerMcp(agent, global) {
         registerGemini(binPath);
         break;
       default:
-        console.error(chalk.red(`Unknown agent: ${a}. Use: claude, codex, gemini, all`));
+        console.error(chalk2.red(`Unknown agent: ${a}. Use: claude, codex, gemini, all`));
     }
   }
 }
@@ -19047,7 +19882,7 @@ function unregisterMcp(agent, global) {
         unregisterGemini();
         break;
       default:
-        console.error(chalk.red(`Unknown agent: ${a}. Use: claude, codex, gemini, all`));
+        console.error(chalk2.red(`Unknown agent: ${a}. Use: claude, codex, gemini, all`));
     }
   }
 }
@@ -19056,7 +19891,7 @@ program2.command("import <url>").description("Import a GitHub issue as a task").
   const { parseGitHubUrl: parseGitHubUrl2, fetchGitHubIssue: fetchGitHubIssue2, issueToTask: issueToTask2 } = (init_github(), __toCommonJS(exports_github));
   const parsed = parseGitHubUrl2(url);
   if (!parsed) {
-    console.error(chalk.red("Invalid GitHub issue URL. Expected: https://github.com/owner/repo/issues/123"));
+    console.error(chalk2.red("Invalid GitHub issue URL. Expected: https://github.com/owner/repo/issues/123"));
     process.exit(1);
   }
   try {
@@ -19068,15 +19903,15 @@ program2.command("import <url>").description("Import a GitHub issue as a task").
       output(task, true);
       return;
     }
-    console.log(chalk.green(`Imported GH#${issue.number}: ${issue.title}`));
-    console.log(`  ${chalk.dim("Task ID:")} ${task.short_id || task.id}`);
-    console.log(`  ${chalk.dim("Labels:")}  ${issue.labels.join(", ") || "none"}`);
-    console.log(`  ${chalk.dim("Priority:")} ${task.priority}`);
+    console.log(chalk2.green(`Imported GH#${issue.number}: ${issue.title}`));
+    console.log(`  ${chalk2.dim("Task ID:")} ${task.short_id || task.id}`);
+    console.log(`  ${chalk2.dim("Labels:")}  ${issue.labels.join(", ") || "none"}`);
+    console.log(`  ${chalk2.dim("Priority:")} ${task.priority}`);
   } catch (e) {
     if (e.message?.includes("gh")) {
-      console.error(chalk.red("GitHub CLI (gh) not found or not authenticated. Install: https://cli.github.com"));
+      console.error(chalk2.red("GitHub CLI (gh) not found or not authenticated. Install: https://cli.github.com"));
     } else {
-      console.error(chalk.red(`Import failed: ${e.message}`));
+      console.error(chalk2.red(`Import failed: ${e.message}`));
     }
     process.exit(1);
   }
@@ -19096,7 +19931,7 @@ program2.command("link-commit <task-id> <sha>").description("Link a git commit t
     output(commit, true);
     return;
   }
-  console.log(chalk.green(`Linked commit ${sha.slice(0, 7)} to task ${taskId}`));
+  console.log(chalk2.green(`Linked commit ${sha.slice(0, 7)} to task ${taskId}`));
 });
 var hookCmd = program2.command("hook").description("Manage git hooks for auto-linking commits to tasks");
 hookCmd.command("install").description("Install post-commit hook that auto-links commits to tasks").action(() => {
@@ -19104,28 +19939,28 @@ hookCmd.command("install").description("Install post-commit hook that auto-links
   try {
     const gitDir = execSync3("git rev-parse --git-dir", { encoding: "utf-8" }).trim();
     const hookPath = `${gitDir}/hooks/post-commit`;
-    const { existsSync: existsSync8, readFileSync: readFileSync6, writeFileSync: writeFileSync4, chmodSync } = __require("fs");
+    const { existsSync: existsSync10, readFileSync: readFileSync7, writeFileSync: writeFileSync6, chmodSync } = __require("fs");
     const marker = "# todos-auto-link";
-    if (existsSync8(hookPath)) {
-      const existing = readFileSync6(hookPath, "utf-8");
+    if (existsSync10(hookPath)) {
+      const existing = readFileSync7(hookPath, "utf-8");
       if (existing.includes(marker)) {
-        console.log(chalk.yellow("Hook already installed."));
+        console.log(chalk2.yellow("Hook already installed."));
         return;
       }
-      writeFileSync4(hookPath, existing + `
+      writeFileSync6(hookPath, existing + `
 ${marker}
 $(dirname "$0")/../../scripts/post-commit-hook.sh
 `);
     } else {
-      writeFileSync4(hookPath, `#!/usr/bin/env bash
+      writeFileSync6(hookPath, `#!/usr/bin/env bash
 ${marker}
 $(dirname "$0")/../../scripts/post-commit-hook.sh
 `);
       chmodSync(hookPath, 493);
     }
-    console.log(chalk.green("Post-commit hook installed. Commits with task IDs (e.g. OPE-00042) will auto-link."));
+    console.log(chalk2.green("Post-commit hook installed. Commits with task IDs (e.g. OPE-00042) will auto-link."));
   } catch (e) {
-    console.error(chalk.red("Not in a git repository or hook install failed."));
+    console.error(chalk2.red("Not in a git repository or hook install failed."));
     process.exit(1);
   }
 });
@@ -19134,15 +19969,15 @@ hookCmd.command("uninstall").description("Remove the todos post-commit hook").ac
   try {
     const gitDir = execSync3("git rev-parse --git-dir", { encoding: "utf-8" }).trim();
     const hookPath = `${gitDir}/hooks/post-commit`;
-    const { existsSync: existsSync8, readFileSync: readFileSync6, writeFileSync: writeFileSync4 } = __require("fs");
+    const { existsSync: existsSync10, readFileSync: readFileSync7, writeFileSync: writeFileSync6 } = __require("fs");
     const marker = "# todos-auto-link";
-    if (!existsSync8(hookPath)) {
-      console.log(chalk.dim("No post-commit hook found."));
+    if (!existsSync10(hookPath)) {
+      console.log(chalk2.dim("No post-commit hook found."));
       return;
     }
-    const content = readFileSync6(hookPath, "utf-8");
+    const content = readFileSync7(hookPath, "utf-8");
     if (!content.includes(marker)) {
-      console.log(chalk.dim("Hook not managed by todos."));
+      console.log(chalk2.dim("Hook not managed by todos."));
       return;
     }
     const cleaned = content.split(`
@@ -19151,12 +19986,12 @@ hookCmd.command("uninstall").description("Remove the todos post-commit hook").ac
     if (cleaned === "#!/usr/bin/env bash" || cleaned === "") {
       __require("fs").unlinkSync(hookPath);
     } else {
-      writeFileSync4(hookPath, cleaned + `
+      writeFileSync6(hookPath, cleaned + `
 `);
     }
-    console.log(chalk.green("Post-commit hook removed."));
+    console.log(chalk2.green("Post-commit hook removed."));
   } catch (e) {
-    console.error(chalk.red("Not in a git repository or hook removal failed."));
+    console.error(chalk2.red("Not in a git repository or hook removal failed."));
     process.exit(1);
   }
 });
@@ -19165,17 +20000,17 @@ program2.command("init <name>").description("Register an agent and get a short U
   try {
     const result = registerAgent({ name, description: opts.description });
     if (isAgentConflict(result)) {
-      console.error(chalk.red("CONFLICT:"), result.message);
+      console.error(chalk2.red("CONFLICT:"), result.message);
       process.exit(1);
     }
     if (globalOpts.json) {
       output(result, true);
     } else {
-      console.log(chalk.green("Agent registered:"));
-      console.log(`  ${chalk.dim("ID:")}   ${result.id}`);
-      console.log(`  ${chalk.dim("Name:")} ${result.name}`);
+      console.log(chalk2.green("Agent registered:"));
+      console.log(`  ${chalk2.dim("ID:")}   ${result.id}`);
+      console.log(`  ${chalk2.dim("Name:")} ${result.name}`);
       console.log(`
-Use ${chalk.cyan(`--agent ${result.id}`)} on future commands.`);
+Use ${chalk2.cyan(`--agent ${result.id}`)} on future commands.`);
     }
   } catch (e) {
     handleError(e);
@@ -19185,51 +20020,51 @@ program2.command("heartbeat [agent]").description("Update last_seen_at to signal
   const globalOpts = program2.opts();
   const agentId = agent || globalOpts.agent;
   if (!agentId) {
-    console.error(chalk.red("Agent ID required. Use --agent or pass as argument."));
+    console.error(chalk2.red("Agent ID required. Use --agent or pass as argument."));
     process.exit(1);
   }
   const { updateAgentActivity: updateAgentActivity2, getAgent: getAgent2 } = (init_agents(), __toCommonJS(exports_agents));
   const a = getAgent2(agentId) || (init_agents(), __toCommonJS(exports_agents)).getAgentByName(agentId);
   if (!a) {
-    console.error(chalk.red(`Agent not found: ${agentId}`));
+    console.error(chalk2.red(`Agent not found: ${agentId}`));
     process.exit(1);
   }
   updateAgentActivity2(a.id);
   if (globalOpts.json) {
     console.log(JSON.stringify({ agent_id: a.id, name: a.name, last_seen_at: new Date().toISOString() }));
   } else {
-    console.log(chalk.green(`\u2665 ${a.name} (${a.id.slice(0, 8)}) \u2014 heartbeat sent`));
+    console.log(chalk2.green(`\u2665 ${a.name} (${a.id.slice(0, 8)}) \u2014 heartbeat sent`));
   }
 });
 program2.command("release [agent]").description("Release/logout an agent \u2014 clears session binding so the name is immediately available").option("--session-id <id>", "Only release if session ID matches").action((agent, opts) => {
   const globalOpts = program2.opts();
   const agentId = agent || globalOpts.agent;
   if (!agentId) {
-    console.error(chalk.red("Agent ID or name required. Use --agent or pass as argument."));
+    console.error(chalk2.red("Agent ID or name required. Use --agent or pass as argument."));
     process.exit(1);
   }
   const { getAgent: getAgent2, getAgentByName: getAgentByName2 } = (init_agents(), __toCommonJS(exports_agents));
   const a = getAgent2(agentId) || getAgentByName2(agentId);
   if (!a) {
-    console.error(chalk.red(`Agent not found: ${agentId}`));
+    console.error(chalk2.red(`Agent not found: ${agentId}`));
     process.exit(1);
   }
   const released = releaseAgent(a.id, opts?.sessionId);
   if (!released) {
-    console.error(chalk.red("Release denied: session_id does not match agent's current session."));
+    console.error(chalk2.red("Release denied: session_id does not match agent's current session."));
     process.exit(1);
   }
   if (globalOpts.json) {
     console.log(JSON.stringify({ agent_id: a.id, name: a.name, released: true }));
   } else {
-    console.log(chalk.green(`\u2713 ${a.name} (${a.id}) released \u2014 name is now available.`));
+    console.log(chalk2.green(`\u2713 ${a.name} (${a.id}) released \u2014 name is now available.`));
   }
 });
 program2.command("focus [project]").description("Focus on a project (or clear focus if no project given)").action((project) => {
   const globalOpts = program2.opts();
   const agentId = globalOpts.agent;
   if (!agentId) {
-    console.error(chalk.red("Agent ID required. Use --agent."));
+    console.error(chalk2.red("Agent ID required. Use --agent."));
     process.exit(1);
   }
   const db = getDatabase();
@@ -19238,10 +20073,10 @@ program2.command("focus [project]").description("Focus on a project (or clear fo
     const p = getProjectByPath2(process.cwd(), db) || getProjectByName(project, db);
     const projectId = p?.id || project;
     db.run("UPDATE agents SET active_project_id = ? WHERE id = ? OR name = ?", [projectId, agentId, agentId]);
-    console.log(chalk.green(`Focused on: ${p?.name || projectId}`));
+    console.log(chalk2.green(`Focused on: ${p?.name || projectId}`));
   } else {
     db.run("UPDATE agents SET active_project_id = NULL WHERE id = ? OR name = ?", [agentId, agentId]);
-    console.log(chalk.dim("Focus cleared."));
+    console.log(chalk2.dim("Focus cleared."));
   }
 });
 program2.command("agents").description("List registered agents").action(() => {
@@ -19253,11 +20088,11 @@ program2.command("agents").description("List registered agents").action(() => {
       return;
     }
     if (agents.length === 0) {
-      console.log(chalk.dim("No agents registered. Use 'todos init <name>' to register."));
+      console.log(chalk2.dim("No agents registered. Use 'todos init <name>' to register."));
       return;
     }
     for (const a of agents) {
-      console.log(`  ${chalk.cyan(a.id)} ${chalk.bold(a.name)} ${chalk.dim(a.last_seen_at)}`);
+      console.log(`  ${chalk2.cyan(a.id)} ${chalk2.bold(a.name)} ${chalk2.dim(a.last_seen_at)}`);
     }
   } catch (e) {
     handleError(e);
@@ -19269,7 +20104,7 @@ program2.command("agent-update <name>").alias("agents-update").description("Upda
     const { getAgentByName: findByName, updateAgent: doUpdate } = (init_agents(), __toCommonJS(exports_agents));
     const agent = findByName(name);
     if (!agent) {
-      console.error(chalk.red(`Agent not found: ${name}`));
+      console.error(chalk2.red(`Agent not found: ${name}`));
       process.exit(1);
     }
     const updates = {};
@@ -19283,11 +20118,11 @@ program2.command("agent-update <name>").alias("agents-update").description("Upda
     if (globalOpts.json) {
       output(updated, true);
     } else {
-      console.log(chalk.green(`Updated agent: ${updated.name} (${updated.id.slice(0, 8)})`));
+      console.log(chalk2.green(`Updated agent: ${updated.name} (${updated.id.slice(0, 8)})`));
       if (updated.description)
-        console.log(chalk.dim(`  Description: ${updated.description}`));
+        console.log(chalk2.dim(`  Description: ${updated.description}`));
       if (updated.role)
-        console.log(chalk.dim(`  Role: ${updated.role}`));
+        console.log(chalk2.dim(`  Role: ${updated.role}`));
     }
   } catch (e) {
     handleError(e);
@@ -19298,7 +20133,7 @@ program2.command("agent <name>").description("Show all info about an agent: task
   const { getAgentByName: findByName } = (init_agents(), __toCommonJS(exports_agents));
   const agent = findByName(name);
   if (!agent) {
-    console.error(chalk.red(`Agent not found: ${name}`));
+    console.error(chalk2.red(`Agent not found: ${name}`));
     process.exit(1);
   }
   const byAssigned = listTasks({ assigned_to: agent.name });
@@ -19317,53 +20152,53 @@ program2.command("agent <name>").description("Show all info about an agent: task
   const rate = allTasks.length > 0 ? Math.round(completed.length / allTasks.length * 100) : 0;
   const lastSeenMs = Date.now() - new Date(agent.last_seen_at).getTime();
   const lastSeenMins = Math.floor(lastSeenMs / 60000);
-  const lastSeenStr = lastSeenMins < 2 ? chalk.green("just now") : lastSeenMins < 60 ? chalk.yellow(`${lastSeenMins}m ago`) : lastSeenMins < 1440 ? chalk.yellow(`${Math.floor(lastSeenMins / 60)}h ago`) : chalk.dim(`${Math.floor(lastSeenMins / 1440)}d ago`);
+  const lastSeenStr = lastSeenMins < 2 ? chalk2.green("just now") : lastSeenMins < 60 ? chalk2.yellow(`${lastSeenMins}m ago`) : lastSeenMins < 1440 ? chalk2.yellow(`${Math.floor(lastSeenMins / 60)}h ago`) : chalk2.dim(`${Math.floor(lastSeenMins / 1440)}d ago`);
   const isOnline = lastSeenMins < 5;
   if (opts.json || globalOpts.json) {
     console.log(JSON.stringify({ agent, tasks: { pending: pending.length, in_progress: inProgress.length, completed: completed.length, failed: failed.length, total: allTasks.length, completion_rate: rate }, all_tasks: allTasks }, null, 2));
     return;
   }
   console.log(`
-${isOnline ? chalk.green("\u25CF") : chalk.dim("\u25CB")} ${chalk.bold(agent.name)} ${chalk.dim(`(${agent.id})`)}  ${lastSeenStr}`);
+${isOnline ? chalk2.green("\u25CF") : chalk2.dim("\u25CB")} ${chalk2.bold(agent.name)} ${chalk2.dim(`(${agent.id})`)}  ${lastSeenStr}`);
   if (agent.description)
-    console.log(chalk.dim(`  ${agent.description}`));
+    console.log(chalk2.dim(`  ${agent.description}`));
   if (agent.role)
-    console.log(chalk.dim(`  Role: ${agent.role}`));
+    console.log(chalk2.dim(`  Role: ${agent.role}`));
   console.log();
-  console.log(`  ${chalk.yellow(String(pending.length))} pending  ${chalk.blue(String(inProgress.length))} active  ${chalk.green(String(completed.length))} done  ${chalk.dim(`${rate}% rate`)}`);
+  console.log(`  ${chalk2.yellow(String(pending.length))} pending  ${chalk2.blue(String(inProgress.length))} active  ${chalk2.green(String(completed.length))} done  ${chalk2.dim(`${rate}% rate`)}`);
   console.log();
   if (inProgress.length > 0) {
-    console.log(chalk.bold("  In progress:"));
+    console.log(chalk2.bold("  In progress:"));
     for (const t of inProgress) {
       const id = t.short_id || t.id.slice(0, 8);
-      const staleFlag = new Date(t.updated_at).getTime() < Date.now() - 30 * 60 * 1000 ? chalk.red(" [stale]") : "";
-      console.log(`    ${chalk.cyan(id)} ${chalk.yellow(t.priority)} ${t.title}${staleFlag}`);
+      const staleFlag = new Date(t.updated_at).getTime() < Date.now() - 30 * 60 * 1000 ? chalk2.red(" [stale]") : "";
+      console.log(`    ${chalk2.cyan(id)} ${chalk2.yellow(t.priority)} ${t.title}${staleFlag}`);
     }
     console.log();
   }
   if (pending.length > 0) {
-    console.log(chalk.bold(`  Pending (${pending.length}):`));
+    console.log(chalk2.bold(`  Pending (${pending.length}):`));
     for (const t of pending.slice(0, 5)) {
       const id = t.short_id || t.id.slice(0, 8);
-      const due = t.due_at ? chalk.dim(` due:${t.due_at.slice(0, 10)}`) : "";
-      console.log(`    ${chalk.dim(id)} ${t.priority.padEnd(8)} ${t.title}${due}`);
+      const due = t.due_at ? chalk2.dim(` due:${t.due_at.slice(0, 10)}`) : "";
+      console.log(`    ${chalk2.dim(id)} ${t.priority.padEnd(8)} ${t.title}${due}`);
     }
     if (pending.length > 5)
-      console.log(chalk.dim(`    ... and ${pending.length - 5} more`));
+      console.log(chalk2.dim(`    ... and ${pending.length - 5} more`));
     console.log();
   }
   const recentDone = completed.filter((t) => t.completed_at).sort((a, b) => new Date(b.completed_at).getTime() - new Date(a.completed_at).getTime()).slice(0, 3);
   if (recentDone.length > 0) {
-    console.log(chalk.bold("  Recently completed:"));
+    console.log(chalk2.bold("  Recently completed:"));
     for (const t of recentDone) {
       const id = t.short_id || t.id.slice(0, 8);
-      const when = t.completed_at ? chalk.dim(new Date(t.completed_at).toLocaleDateString()) : "";
-      console.log(`    ${chalk.green("\u2713")} ${chalk.dim(id)} ${t.title} ${when}`);
+      const when = t.completed_at ? chalk2.dim(new Date(t.completed_at).toLocaleDateString()) : "";
+      console.log(`    ${chalk2.green("\u2713")} ${chalk2.dim(id)} ${t.title} ${when}`);
     }
     console.log();
   }
   if (allTasks.length === 0) {
-    console.log(chalk.dim("  No tasks assigned to this agent."));
+    console.log(chalk2.dim("  No tasks assigned to this agent."));
   }
 });
 program2.command("org").description("Show agent org chart \u2014 who reports to who").option("--set <agent=manager>", "Set reporting: 'seneca=julius' or 'seneca=' to clear").action((opts) => {
@@ -19373,14 +20208,14 @@ program2.command("org").description("Show agent org chart \u2014 who reports to
     const [agentName, managerName] = opts.set.split("=");
     const agent = getByName(agentName);
     if (!agent) {
-      console.error(chalk.red(`Agent not found: ${agentName}`));
+      console.error(chalk2.red(`Agent not found: ${agentName}`));
       process.exit(1);
     }
     let managerId = null;
     if (managerName) {
       const manager = getByName(managerName);
       if (!manager) {
-        console.error(chalk.red(`Manager not found: ${managerName}`));
+        console.error(chalk2.red(`Manager not found: ${managerName}`));
         process.exit(1);
       }
       managerId = manager.id;
@@ -19389,7 +20224,7 @@ program2.command("org").description("Show agent org chart \u2014 who reports to
     if (globalOpts.json) {
       output({ agent: agentName, reports_to: managerName || null }, true);
     } else {
-      console.log(chalk.green(managerId ? `${agentName} \u2192 ${managerName}` : `${agentName} \u2192 (top-level)`));
+      console.log(chalk2.green(managerId ? `${agentName} \u2192 ${managerName}` : `${agentName} \u2192 (top-level)`));
     }
     return;
   }
@@ -19399,15 +20234,15 @@ program2.command("org").description("Show agent org chart \u2014 who reports to
     return;
   }
   if (tree.length === 0) {
-    console.log(chalk.dim("No agents registered."));
+    console.log(chalk2.dim("No agents registered."));
     return;
   }
   function render2(nodes, indent = 0) {
     for (const n of nodes) {
       const prefix = "  ".repeat(indent);
-      const title = n.agent.title ? chalk.cyan(` \u2014 ${n.agent.title}`) : "";
-      const level = n.agent.level ? chalk.dim(` (${n.agent.level})`) : "";
-      console.log(`${prefix}${indent > 0 ? "\u251C\u2500\u2500 " : ""}${chalk.bold(n.agent.name)}${title}${level}`);
+      const title = n.agent.title ? chalk2.cyan(` \u2014 ${n.agent.title}`) : "";
+      const level = n.agent.level ? chalk2.dim(` (${n.agent.level})`) : "";
+      console.log(`${prefix}${indent > 0 ? "\u251C\u2500\u2500 " : ""}${chalk2.bold(n.agent.name)}${title}${level}`);
       render2(n.reports, indent + 1);
     }
   }
@@ -19423,21 +20258,21 @@ program2.command("lists").aliases(["task-lists", "tl"]).description("List and ma
         output(list, true);
         return;
       }
-      console.log(chalk.green("Task list created:"));
-      console.log(`  ${chalk.dim("ID:")}   ${list.id.slice(0, 8)}`);
-      console.log(`  ${chalk.dim("Slug:")} ${list.slug}`);
-      console.log(`  ${chalk.dim("Name:")} ${list.name}`);
+      console.log(chalk2.green("Task list created:"));
+      console.log(`  ${chalk2.dim("ID:")}   ${list.id.slice(0, 8)}`);
+      console.log(`  ${chalk2.dim("Slug:")} ${list.slug}`);
+      console.log(`  ${chalk2.dim("Name:")} ${list.name}`);
       return;
     }
     if (opts.delete) {
       const db = getDatabase();
       const resolved = resolvePartialId(db, "task_lists", opts.delete);
       if (!resolved) {
-        console.error(chalk.red("Task list not found"));
+        console.error(chalk2.red("Task list not found"));
         process.exit(1);
       }
       deleteTaskList(resolved);
-      console.log(chalk.green("Task list deleted."));
+      console.log(chalk2.green("Task list deleted."));
       return;
     }
     const lists = listTaskLists(projectId);
@@ -19446,11 +20281,11 @@ program2.command("lists").aliases(["task-lists", "tl"]).description("List and ma
       return;
     }
     if (lists.length === 0) {
-      console.log(chalk.dim("No task lists. Use 'todos lists --add <name>' to create one."));
+      console.log(chalk2.dim("No task lists. Use 'todos lists --add <name>' to create one."));
       return;
     }
     for (const l of lists) {
-      console.log(`  ${chalk.dim(l.id.slice(0, 8))} ${chalk.bold(l.name)} ${chalk.dim(`(${l.slug})`)}`);
+      console.log(`  ${chalk2.dim(l.id.slice(0, 8))} ${chalk2.bold(l.name)} ${chalk2.dim(`(${l.slug})`)}`);
     }
   } catch (e) {
     handleError(e);
@@ -19461,20 +20296,20 @@ program2.command("upgrade").alias("self-update").description("Update todos to th
     const currentVersion = getPackageVersion();
     const res = await fetch("https://registry.npmjs.org/@hasna/todos/latest");
     if (!res.ok) {
-      console.error(chalk.red("Failed to check for updates."));
+      console.error(chalk2.red("Failed to check for updates."));
       process.exit(1);
     }
     const data = await res.json();
     const latestVersion = data.version;
-    console.log(`  Current: ${chalk.dim(currentVersion)}`);
-    console.log(`  Latest:  ${chalk.green(latestVersion)}`);
+    console.log(`  Current: ${chalk2.dim(currentVersion)}`);
+    console.log(`  Latest:  ${chalk2.green(latestVersion)}`);
     if (currentVersion === latestVersion) {
-      console.log(chalk.green(`
+      console.log(chalk2.green(`
 Already up to date!`));
       return;
     }
     if (opts.check) {
-      console.log(chalk.yellow(`
+      console.log(chalk2.yellow(`
 Update available: ${currentVersion} \u2192 ${latestVersion}`));
       return;
     }
@@ -19484,10 +20319,10 @@ Update available: ${currentVersion} \u2192 ${latestVersion}`));
       useBun = true;
     } catch {}
     const cmd = useBun ? "bun add -g @hasna/todos@latest" : "npm install -g @hasna/todos@latest";
-    console.log(chalk.dim(`
+    console.log(chalk2.dim(`
 Running: ${cmd}`));
     execSync2(cmd, { stdio: "inherit" });
-    console.log(chalk.green(`
+    console.log(chalk2.green(`
 Updated to ${latestVersion}!`));
   } catch (e) {
     handleError(e);
@@ -19495,7 +20330,7 @@ Updated to ${latestVersion}!`));
 });
 program2.command("config").description("View or update configuration").option("--get <key>", "Get a config value").option("--set <key=value>", "Set a config value (e.g. completion_guard.enabled=true)").action((opts) => {
   const globalOpts = program2.opts();
-  const configPath = join9(process.env["HOME"] || "~", ".todos", "config.json");
+  const configPath = join11(process.env["HOME"] || "~", ".todos", "config.json");
   if (opts.get) {
     const config2 = loadConfig();
     const keys = opts.get.split(".");
@@ -19506,7 +20341,7 @@ program2.command("config").description("View or update configuration").option("-
     if (globalOpts.json) {
       output({ key: opts.get, value }, true);
     } else {
-      console.log(value !== undefined ? JSON.stringify(value, null, 2) : chalk.dim("(not set)"));
+      console.log(value !== undefined ? JSON.stringify(value, null, 2) : chalk2.dim("(not set)"));
     }
     return;
   }
@@ -19521,7 +20356,7 @@ program2.command("config").description("View or update configuration").option("-
     }
     let config2 = {};
     try {
-      config2 = JSON.parse(readFileSync5(configPath, "utf-8"));
+      config2 = JSON.parse(readFileSync6(configPath, "utf-8"));
     } catch {}
     const keys = key.split(".");
     let obj = config2;
@@ -19532,13 +20367,13 @@ program2.command("config").description("View or update configuration").option("-
     }
     obj[keys[keys.length - 1]] = parsedValue;
     const dir = dirname4(configPath);
-    if (!existsSync7(dir))
-      mkdirSync3(dir, { recursive: true });
-    writeFileSync3(configPath, JSON.stringify(config2, null, 2));
+    if (!existsSync9(dir))
+      mkdirSync5(dir, { recursive: true });
+    writeFileSync5(configPath, JSON.stringify(config2, null, 2));
     if (globalOpts.json) {
       output({ key, value: parsedValue }, true);
     } else {
-      console.log(chalk.green(`Set ${key} = ${JSON.stringify(parsedValue)}`));
+      console.log(chalk2.green(`Set ${key} = ${JSON.stringify(parsedValue)}`));
     }
     return;
   }
@@ -19579,25 +20414,25 @@ program2.command("watch").description("Live-updating task list (refreshes every
       counts[t.status] = (counts[t.status] || 0) + 1;
     process.stdout.write("\x1B[2J\x1B[0f");
     const now2 = new Date().toLocaleTimeString();
-    console.log(chalk.bold(`todos watch`) + chalk.dim(` \u2014 ${now2} \u2014 refreshing every ${opts.interval}s \u2014 Ctrl+C to stop
+    console.log(chalk2.bold(`todos watch`) + chalk2.dim(` \u2014 ${now2} \u2014 refreshing every ${opts.interval}s \u2014 Ctrl+C to stop
 `));
     const parts = [
-      `total: ${chalk.bold(String(all.length))}`,
-      `pending: ${chalk.yellow(String(counts["pending"] || 0))}`,
-      `in_progress: ${chalk.blue(String(counts["in_progress"] || 0))}`,
-      `completed: ${chalk.green(String(counts["completed"] || 0))}`,
-      `failed: ${chalk.red(String(counts["failed"] || 0))}`
+      `total: ${chalk2.bold(String(all.length))}`,
+      `pending: ${chalk2.yellow(String(counts["pending"] || 0))}`,
+      `in_progress: ${chalk2.blue(String(counts["in_progress"] || 0))}`,
+      `completed: ${chalk2.green(String(counts["completed"] || 0))}`,
+      `failed: ${chalk2.red(String(counts["failed"] || 0))}`
     ];
     console.log(parts.join("  ") + `
 `);
     if (tasks.length === 0) {
-      console.log(chalk.dim("No matching tasks."));
+      console.log(chalk2.dim("No matching tasks."));
       return;
     }
     for (const t of tasks) {
       console.log(formatTaskLine(t));
     }
-    console.log(chalk.dim(`
+    console.log(chalk2.dim(`
 ${tasks.length} task(s) shown`));
   }
   render2();
@@ -19617,19 +20452,19 @@ program2.command("stream").description("Subscribe to real-time task events via S
     params.set("events", opts.events);
   const url = `${baseUrl}/api/tasks/stream?${params}`;
   const eventColors = {
-    "task.created": chalk.blue,
-    "task.started": chalk.cyan,
-    "task.completed": chalk.green,
-    "task.failed": chalk.red,
-    "task.assigned": chalk.yellow,
-    "task.status_changed": chalk.magenta
+    "task.created": chalk2.blue,
+    "task.started": chalk2.cyan,
+    "task.completed": chalk2.green,
+    "task.failed": chalk2.red,
+    "task.assigned": chalk2.yellow,
+    "task.status_changed": chalk2.magenta
   };
-  console.log(chalk.dim(`Connecting to ${url} \u2014 Ctrl+C to stop
+  console.log(chalk2.dim(`Connecting to ${url} \u2014 Ctrl+C to stop
 `));
   try {
     const resp = await fetch(url);
     if (!resp.ok || !resp.body) {
-      console.error(chalk.red(`Failed to connect: ${resp.status}`));
+      console.error(chalk2.red(`Failed to connect: ${resp.status}`));
       process.exit(1);
     }
     const reader = resp.body.getReader();
@@ -19655,11 +20490,11 @@ program2.command("stream").description("Subscribe to real-time task events via S
             if (opts.json) {
               console.log(JSON.stringify({ event: eventName, ...data }));
             } else {
-              const colorFn = eventColors[eventName] || chalk.white;
+              const colorFn = eventColors[eventName] || chalk2.white;
               const ts = new Date(data.timestamp || Date.now()).toLocaleTimeString();
               const taskId = data.task_id ? data.task_id.slice(0, 8) : "";
               const agentInfo = data.agent_id ? ` [${data.agent_id}]` : "";
-              console.log(`${chalk.dim(ts)} ${colorFn(eventName.padEnd(25))} ${taskId}${agentInfo}`);
+              console.log(`${chalk2.dim(ts)} ${colorFn(eventName.padEnd(25))} ${taskId}${agentInfo}`);
             }
           } catch {}
           eventName = "";
@@ -19667,8 +20502,8 @@ program2.command("stream").description("Subscribe to real-time task events via S
       }
     }
   } catch (e) {
-    console.error(chalk.red(`Connection error: ${e instanceof Error ? e.message : e}`));
-    console.error(chalk.dim("Is `todos serve` running?"));
+    console.error(chalk2.red(`Connection error: ${e instanceof Error ? e.message : e}`));
+    console.error(chalk2.dim("Is `todos serve` running?"));
     process.exit(1);
   }
 });
@@ -19689,29 +20524,29 @@ program2.command("blame <file>").description("Show which tasks/agents touched a
     output({ file: filePath, task_files: taskFiles, commits: commitRows }, true);
     return;
   }
-  console.log(chalk.bold(`
+  console.log(chalk2.bold(`
 Blame: ${filePath}
 `));
   if (taskFiles.length > 0) {
-    console.log(chalk.bold("Task File Links:"));
+    console.log(chalk2.bold("Task File Links:"));
     for (const tf of taskFiles) {
       const task = getTask2(tf.task_id, db);
       const title = task ? task.title : "unknown";
       const sid = task?.short_id || tf.task_id.slice(0, 8);
-      console.log(`  ${chalk.cyan(sid)} ${title} \u2014 ${chalk.dim(tf.role || "file")} ${chalk.dim(tf.updated_at)}`);
+      console.log(`  ${chalk2.cyan(sid)} ${title} \u2014 ${chalk2.dim(tf.role || "file")} ${chalk2.dim(tf.updated_at)}`);
     }
   }
   if (commitRows.length > 0) {
-    console.log(chalk.bold(`
+    console.log(chalk2.bold(`
 Commit Links (${commitRows.length}):`));
     for (const c of commitRows) {
       const sid = c.short_id || c.task_id.slice(0, 8);
-      console.log(`  ${chalk.yellow(c.sha?.slice(0, 7) || "?")} ${chalk.cyan(sid)} ${c.title || ""} \u2014 ${chalk.dim(c.author || "")} ${chalk.dim(c.committed_at || "")}`);
+      console.log(`  ${chalk2.yellow(c.sha?.slice(0, 7) || "?")} ${chalk2.cyan(sid)} ${c.title || ""} \u2014 ${chalk2.dim(c.author || "")} ${chalk2.dim(c.committed_at || "")}`);
     }
   }
   if (taskFiles.length === 0 && commitRows.length === 0) {
-    console.log(chalk.dim("No task or commit links found for this file."));
-    console.log(chalk.dim("Use 'todos hook install' to auto-link future commits."));
+    console.log(chalk2.dim("No task or commit links found for this file."));
+    console.log(chalk2.dim("Use 'todos hook install' to auto-link future commits."));
   }
   console.log();
 });
@@ -19730,17 +20565,17 @@ program2.command("next").description("Show the best pending task to work on next
     filters.project_id = opts.project;
   const task = getNextTask(opts.agent, Object.keys(filters).length ? filters : undefined, db);
   if (!task) {
-    console.log(chalk.dim("No tasks available."));
+    console.log(chalk2.dim("No tasks available."));
     return;
   }
   if (opts.json) {
     console.log(JSON.stringify(task, null, 2));
     return;
   }
-  console.log(chalk.bold("Next task:"));
-  console.log(`  ${chalk.cyan(task.short_id || task.id.slice(0, 8))} ${chalk.yellow(task.priority)} ${task.title}`);
+  console.log(chalk2.bold("Next task:"));
+  console.log(`  ${chalk2.cyan(task.short_id || task.id.slice(0, 8))} ${chalk2.yellow(task.priority)} ${task.title}`);
   if (task.description)
-    console.log(chalk.dim(`  ${task.description.slice(0, 100)}`));
+    console.log(chalk2.dim(`  ${task.description.slice(0, 100)}`));
 });
 program2.command("claim <agent>").description("Atomically claim the best pending task for an agent").option("--project <id>", "Filter to project").option("--json", "Output as JSON").action(async (agent, opts) => {
   const db = getDatabase();
@@ -19749,14 +20584,28 @@ program2.command("claim <agent>").description("Atomically claim the best pending
     filters.project_id = opts.project;
   const task = claimNextTask(agent, Object.keys(filters).length ? filters : undefined, db);
   if (!task) {
-    console.log(chalk.dim("No tasks available to claim."));
+    console.log(chalk2.dim("No tasks available to claim."));
     return;
   }
   if (opts.json) {
     console.log(JSON.stringify(task, null, 2));
     return;
   }
-  console.log(chalk.green(`Claimed: ${task.short_id || task.id.slice(0, 8)} | ${task.priority} | ${task.title}`));
+  console.log(chalk2.green(`Claimed: ${task.short_id || task.id.slice(0, 8)} | ${task.priority} | ${task.title}`));
+});
+program2.command("steal <agent>").description("Work-stealing: take the highest-priority stale task from another agent").option("--stale-minutes <n>", "How long a task must be stale (default: 30)", "30").option("--project <id>", "Filter to project").action((agent, opts) => {
+  const globalOpts = program2.opts();
+  const { stealTask: stealTask2 } = (init_tasks(), __toCommonJS(exports_tasks));
+  const task = stealTask2(agent, { stale_minutes: parseInt(opts.staleMinutes, 10), project_id: opts.project });
+  if (!task) {
+    console.log(chalk2.dim("No stale tasks available to steal."));
+    return;
+  }
+  if (globalOpts.json) {
+    output(task, true);
+    return;
+  }
+  console.log(chalk2.green(`Stolen: ${task.short_id || task.id.slice(0, 8)} | ${task.priority} | ${task.title}`));
 });
 program2.command("status").description("Show full project health snapshot").option("--agent <id>", "Include next task for this agent").option("--project <id>", "Filter to project").option("--json", "Output as JSON").action(async (opts) => {
   const db = getDatabase();
@@ -19768,24 +20617,24 @@ program2.command("status").description("Show full project health snapshot").opti
     console.log(JSON.stringify(s, null, 2));
     return;
   }
-  console.log(`Tasks: ${chalk.yellow(s.pending)} pending | ${chalk.blue(s.in_progress)} active | ${chalk.green(s.completed)} done | ${s.total} total`);
+  console.log(`Tasks: ${chalk2.yellow(s.pending)} pending | ${chalk2.blue(s.in_progress)} active | ${chalk2.green(s.completed)} done | ${s.total} total`);
   if (s.stale_count > 0)
-    console.log(chalk.red(`\u26A0\uFE0F  ${s.stale_count} stale tasks (stuck in_progress)`));
+    console.log(chalk2.red(`\u26A0\uFE0F  ${s.stale_count} stale tasks (stuck in_progress)`));
   if (s.overdue_recurring > 0)
-    console.log(chalk.yellow(`\uD83D\uDD01 ${s.overdue_recurring} overdue recurring`));
+    console.log(chalk2.yellow(`\uD83D\uDD01 ${s.overdue_recurring} overdue recurring`));
   if (s.active_work.length > 0) {
-    console.log(chalk.bold(`
+    console.log(chalk2.bold(`
 Active:`));
     for (const w of s.active_work.slice(0, 5)) {
       const id = w.short_id || w.id.slice(0, 8);
-      console.log(`  ${chalk.cyan(id)} | ${w.assigned_to || w.locked_by || "?"} | ${w.title}`);
+      console.log(`  ${chalk2.cyan(id)} | ${w.assigned_to || w.locked_by || "?"} | ${w.title}`);
     }
   }
   if (s.next_task) {
-    console.log(chalk.bold(`
+    console.log(chalk2.bold(`
 Next up:`));
     const t = s.next_task;
-    console.log(`  ${chalk.cyan(t.short_id || t.id.slice(0, 8))} ${chalk.yellow(t.priority)} ${t.title}`);
+    console.log(`  ${chalk2.cyan(t.short_id || t.id.slice(0, 8))} ${chalk2.yellow(t.priority)} ${t.title}`);
   }
 });
 program2.command("recap").description("Show what happened in the last N hours \u2014 completed tasks, new tasks, agent activity, blockers").option("--hours <n>", "Look back N hours (default: 8)", "8").option("--project <id>", "Filter to project").action((opts) => {
@@ -19796,60 +20645,60 @@ program2.command("recap").description("Show what happened in the last N hours \u
     output(recap, true);
     return;
   }
-  console.log(chalk.bold(`
+  console.log(chalk2.bold(`
 Recap \u2014 last ${recap.hours} hours (since ${new Date(recap.since).toLocaleString()})
 `));
   if (recap.completed.length > 0) {
-    console.log(chalk.green.bold(`Completed (${recap.completed.length}):`));
+    console.log(chalk2.green.bold(`Completed (${recap.completed.length}):`));
     for (const t of recap.completed) {
       const id = t.short_id || t.id.slice(0, 8);
       const dur = t.duration_minutes != null ? ` (${t.duration_minutes}m)` : "";
-      console.log(`  ${chalk.green("\u2713")} ${chalk.cyan(id)} ${t.title}${dur}${t.assigned_to ? ` \u2014 ${chalk.dim(t.assigned_to)}` : ""}`);
+      console.log(`  ${chalk2.green("\u2713")} ${chalk2.cyan(id)} ${t.title}${dur}${t.assigned_to ? ` \u2014 ${chalk2.dim(t.assigned_to)}` : ""}`);
     }
   } else {
-    console.log(chalk.dim("No tasks completed in this period."));
+    console.log(chalk2.dim("No tasks completed in this period."));
   }
   if (recap.in_progress.length > 0) {
-    console.log(chalk.blue.bold(`
+    console.log(chalk2.blue.bold(`
 In Progress (${recap.in_progress.length}):`));
     for (const t of recap.in_progress) {
       const id = t.short_id || t.id.slice(0, 8);
-      console.log(`  ${chalk.blue("\u2192")} ${chalk.cyan(id)} ${t.title}${t.assigned_to ? ` \u2014 ${chalk.dim(t.assigned_to)}` : ""}`);
+      console.log(`  ${chalk2.blue("\u2192")} ${chalk2.cyan(id)} ${t.title}${t.assigned_to ? ` \u2014 ${chalk2.dim(t.assigned_to)}` : ""}`);
     }
   }
   if (recap.blocked.length > 0) {
-    console.log(chalk.red.bold(`
+    console.log(chalk2.red.bold(`
 Blocked (${recap.blocked.length}):`));
     for (const t of recap.blocked) {
       const id = t.short_id || t.id.slice(0, 8);
-      console.log(`  ${chalk.red("\u2717")} ${chalk.cyan(id)} ${t.title}`);
+      console.log(`  ${chalk2.red("\u2717")} ${chalk2.cyan(id)} ${t.title}`);
     }
   }
   if (recap.stale.length > 0) {
-    console.log(chalk.yellow.bold(`
+    console.log(chalk2.yellow.bold(`
 Stale (${recap.stale.length}):`));
     for (const t of recap.stale) {
       const id = t.short_id || t.id.slice(0, 8);
       const ago = Math.round((Date.now() - new Date(t.updated_at).getTime()) / 60000);
-      console.log(`  ${chalk.yellow("!")} ${chalk.cyan(id)} ${t.title} \u2014 last update ${ago}m ago`);
+      console.log(`  ${chalk2.yellow("!")} ${chalk2.cyan(id)} ${t.title} \u2014 last update ${ago}m ago`);
     }
   }
   if (recap.created.length > 0) {
-    console.log(chalk.dim.bold(`
+    console.log(chalk2.dim.bold(`
 Created (${recap.created.length}):`));
     for (const t of recap.created.slice(0, 10)) {
       const id = t.short_id || t.id.slice(0, 8);
-      console.log(`  ${chalk.dim("+")} ${chalk.cyan(id)} ${t.title}`);
+      console.log(`  ${chalk2.dim("+")} ${chalk2.cyan(id)} ${t.title}`);
     }
     if (recap.created.length > 10)
-      console.log(chalk.dim(`  ... and ${recap.created.length - 10} more`));
+      console.log(chalk2.dim(`  ... and ${recap.created.length - 10} more`));
   }
   if (recap.agents.length > 0) {
-    console.log(chalk.bold(`
+    console.log(chalk2.bold(`
 Agents:`));
     for (const a of recap.agents) {
       const seen = Math.round((Date.now() - new Date(a.last_seen_at).getTime()) / 60000);
-      console.log(`  ${a.name}: ${chalk.green(a.completed_count + " done")} | ${chalk.blue(a.in_progress_count + " active")} | last seen ${seen}m ago`);
+      console.log(`  ${a.name}: ${chalk2.green(a.completed_count + " done")} | ${chalk2.blue(a.in_progress_count + " active")} | last seen ${seen}m ago`);
     }
   }
   console.log();
@@ -19864,7 +20713,7 @@ program2.command("standup").description("Generate standup notes \u2014 completed
     output(recap, true);
     return;
   }
-  console.log(chalk.bold(`
+  console.log(chalk2.bold(`
 Standup \u2014 since ${sinceDate.toLocaleDateString()}
 `));
   const byAgent = new Map;
@@ -19875,29 +20724,29 @@ Standup \u2014 since ${sinceDate.toLocaleDateString()}
     byAgent.get(agent).push(t);
   }
   if (byAgent.size > 0) {
-    console.log(chalk.green.bold("Done:"));
+    console.log(chalk2.green.bold("Done:"));
     for (const [agent, tasks] of byAgent) {
-      console.log(`  ${chalk.cyan(agent)}:`);
+      console.log(`  ${chalk2.cyan(agent)}:`);
       for (const t of tasks) {
         const dur = t.duration_minutes != null ? ` (${t.duration_minutes}m)` : "";
-        console.log(`    ${chalk.green("\u2713")} ${t.short_id || t.id.slice(0, 8)} ${t.title}${dur}`);
+        console.log(`    ${chalk2.green("\u2713")} ${t.short_id || t.id.slice(0, 8)} ${t.title}${dur}`);
       }
     }
   } else {
-    console.log(chalk.dim("Nothing completed."));
+    console.log(chalk2.dim("Nothing completed."));
   }
   if (recap.in_progress.length > 0) {
-    console.log(chalk.blue.bold(`
+    console.log(chalk2.blue.bold(`
 In Progress:`));
     for (const t of recap.in_progress) {
-      console.log(`  ${chalk.blue("\u2192")} ${t.short_id || t.id.slice(0, 8)} ${t.title}${t.assigned_to ? ` \u2014 ${chalk.dim(t.assigned_to)}` : ""}`);
+      console.log(`  ${chalk2.blue("\u2192")} ${t.short_id || t.id.slice(0, 8)} ${t.title}${t.assigned_to ? ` \u2014 ${chalk2.dim(t.assigned_to)}` : ""}`);
     }
   }
   if (recap.blocked.length > 0) {
-    console.log(chalk.red.bold(`
+    console.log(chalk2.red.bold(`
 Blocked:`));
     for (const t of recap.blocked) {
-      console.log(`  ${chalk.red("\u2717")} ${t.short_id || t.id.slice(0, 8)} ${t.title}`);
+      console.log(`  ${chalk2.red("\u2717")} ${t.short_id || t.id.slice(0, 8)} ${t.title}`);
     }
   }
   console.log();
@@ -19906,7 +20755,7 @@ program2.command("fail <id>").description("Mark a task as failed with optional r
   const db = getDatabase();
   const resolvedId = resolvePartialId(db, "tasks", id);
   if (!resolvedId) {
-    console.error(chalk.red(`Task not found: ${id}`));
+    console.error(chalk2.red(`Task not found: ${id}`));
     process.exit(1);
   }
   const result = failTask(resolvedId, opts.agent, opts.reason, { retry: opts.retry }, db);
@@ -19914,11 +20763,11 @@ program2.command("fail <id>").description("Mark a task as failed with optional r
     console.log(JSON.stringify(result, null, 2));
     return;
   }
-  console.log(chalk.red(`Failed: ${result.task.short_id || result.task.id.slice(0, 8)} | ${result.task.title}`));
+  console.log(chalk2.red(`Failed: ${result.task.short_id || result.task.id.slice(0, 8)} | ${result.task.title}`));
   if (opts.reason)
-    console.log(chalk.dim(`Reason: ${opts.reason}`));
+    console.log(chalk2.dim(`Reason: ${opts.reason}`));
   if (result.retryTask)
-    console.log(chalk.yellow(`Retry created: ${result.retryTask.short_id || result.retryTask.id.slice(0, 8)} | ${result.retryTask.title}`));
+    console.log(chalk2.yellow(`Retry created: ${result.retryTask.short_id || result.retryTask.id.slice(0, 8)} | ${result.retryTask.title}`));
 });
 program2.command("active").description("Show all currently in-progress tasks").option("--project <id>", "Filter to project").option("--json", "Output as JSON").action(async (opts) => {
   const db = getDatabase();
@@ -19931,14 +20780,14 @@ program2.command("active").description("Show all currently in-progress tasks").o
     return;
   }
   if (work.length === 0) {
-    console.log(chalk.dim("No active work."));
+    console.log(chalk2.dim("No active work."));
     return;
   }
-  console.log(chalk.bold(`Active work (${work.length}):`));
+  console.log(chalk2.bold(`Active work (${work.length}):`));
   for (const w of work) {
     const id = w.short_id || w.id.slice(0, 8);
     const agent = w.assigned_to || w.locked_by || "unassigned";
-    console.log(`  ${chalk.cyan(id)} | ${chalk.yellow(w.priority)} | ${agent.padEnd(12)} | ${w.title}`);
+    console.log(`  ${chalk2.cyan(id)} | ${chalk2.yellow(w.priority)} | ${agent.padEnd(12)} | ${w.title}`);
   }
 });
 program2.command("stale").description("Find tasks stuck in_progress with no recent activity").option("--minutes <n>", "Stale threshold in minutes", "30").option("--project <id>", "Filter to project").option("--json", "Output as JSON").action(async (opts) => {
@@ -19952,14 +20801,14 @@ program2.command("stale").description("Find tasks stuck in_progress with no rece
     return;
   }
   if (tasks.length === 0) {
-    console.log(chalk.dim("No stale tasks."));
+    console.log(chalk2.dim("No stale tasks."));
     return;
   }
-  console.log(chalk.bold(`Stale tasks (${tasks.length}):`));
+  console.log(chalk2.bold(`Stale tasks (${tasks.length}):`));
   for (const t of tasks) {
     const id = t.short_id || t.id.slice(0, 8);
     const staleMin = Math.round((Date.now() - new Date(t.updated_at).getTime()) / 60000);
-    console.log(`  ${chalk.cyan(id)} | ${t.locked_by || t.assigned_to || "?"} | ${t.title} ${chalk.dim(`(${staleMin}min stale)`)}`);
+    console.log(`  ${chalk2.cyan(id)} | ${t.locked_by || t.assigned_to || "?"} | ${t.title} ${chalk2.dim(`(${staleMin}min stale)`)}`);
   }
 });
 program2.command("redistribute <agent>").description("Release stale in-progress tasks and claim the best one (work-stealing)").option("--max-age <minutes>", "Stale threshold in minutes", "60").option("--project <id>", "Limit to a specific project").option("--limit <n>", "Max stale tasks to release").option("--json", "Output as JSON").action(async (agent, opts) => {
@@ -19975,17 +20824,17 @@ program2.command("redistribute <agent>").description("Release stale in-progress
     console.log(JSON.stringify(result, null, 2));
     return;
   }
-  console.log(chalk.bold(`Released ${result.released.length} stale task(s).`));
+  console.log(chalk2.bold(`Released ${result.released.length} stale task(s).`));
   for (const t of result.released) {
     const id = t.short_id || t.id.slice(0, 8);
-    console.log(`  ${chalk.yellow("released")} ${chalk.cyan(id)} ${t.title}`);
+    console.log(`  ${chalk2.yellow("released")} ${chalk2.cyan(id)} ${t.title}`);
   }
   if (result.claimed) {
     const id = result.claimed.short_id || result.claimed.id.slice(0, 8);
-    console.log(chalk.green(`
-Claimed: ${chalk.cyan(id)} ${result.claimed.title}`));
+    console.log(chalk2.green(`
+Claimed: ${chalk2.cyan(id)} ${result.claimed.title}`));
   } else {
-    console.log(chalk.dim(`
+    console.log(chalk2.dim(`
 No task claimed (nothing available).`));
   }
 });
@@ -19995,7 +20844,7 @@ program2.command("assign <id> <agent>").description("Assign a task to an agent")
   const db = getDatabase();
   const task = getTask(resolvedId, db);
   if (!task) {
-    console.error(chalk.red(`Task not found: ${id}`));
+    console.error(chalk2.red(`Task not found: ${id}`));
     process.exit(1);
   }
   try {
@@ -20004,7 +20853,7 @@ program2.command("assign <id> <agent>").description("Assign a task to an agent")
       console.log(JSON.stringify(updated));
       return;
     }
-    console.log(chalk.green(`Assigned to ${agent}: ${formatTaskLine(updated)}`));
+    console.log(chalk2.green(`Assigned to ${agent}: ${formatTaskLine(updated)}`));
   } catch {
     handleError(new Error("Failed to assign"));
   }
@@ -20015,7 +20864,7 @@ program2.command("unassign <id>").description("Remove task assignment").option("
   const db = getDatabase();
   const task = getTask(resolvedId, db);
   if (!task) {
-    console.error(chalk.red(`Task not found: ${id}`));
+    console.error(chalk2.red(`Task not found: ${id}`));
     process.exit(1);
   }
   try {
@@ -20024,7 +20873,7 @@ program2.command("unassign <id>").description("Remove task assignment").option("
       console.log(JSON.stringify(updated));
       return;
     }
-    console.log(chalk.green(`Unassigned: ${formatTaskLine(updated)}`));
+    console.log(chalk2.green(`Unassigned: ${formatTaskLine(updated)}`));
   } catch {
     handleError(new Error("Failed to unassign"));
   }
@@ -20035,7 +20884,7 @@ program2.command("tag <id> <tag>").description("Add a tag to a task").option("--
   const db = getDatabase();
   const task = getTask(resolvedId, db);
   if (!task) {
-    console.error(chalk.red(`Task not found: ${id}`));
+    console.error(chalk2.red(`Task not found: ${id}`));
     process.exit(1);
   }
   const newTags = [...new Set([...task.tags, tag])];
@@ -20045,7 +20894,7 @@ program2.command("tag <id> <tag>").description("Add a tag to a task").option("--
       console.log(JSON.stringify(updated));
       return;
     }
-    console.log(chalk.green(`Tagged [${tag}]: ${formatTaskLine(updated)}`));
+    console.log(chalk2.green(`Tagged [${tag}]: ${formatTaskLine(updated)}`));
   } catch {
     handleError(new Error("Failed to tag"));
   }
@@ -20056,7 +20905,7 @@ program2.command("untag <id> <tag>").description("Remove a tag from a task").opt
   const db = getDatabase();
   const task = getTask(resolvedId, db);
   if (!task) {
-    console.error(chalk.red(`Task not found: ${id}`));
+    console.error(chalk2.red(`Task not found: ${id}`));
     process.exit(1);
   }
   const newTags = task.tags.filter((t) => t !== tag);
@@ -20066,7 +20915,7 @@ program2.command("untag <id> <tag>").description("Remove a tag from a task").opt
       console.log(JSON.stringify(updated));
       return;
     }
-    console.log(chalk.green(`Untagged [${tag}]: ${formatTaskLine(updated)}`));
+    console.log(chalk2.green(`Untagged [${tag}]: ${formatTaskLine(updated)}`));
   } catch {
     handleError(new Error("Failed to untag"));
   }
@@ -20082,7 +20931,7 @@ program2.command("pin <id>").description("Escalate task to critical priority").o
       console.log(JSON.stringify(updated));
       return;
     }
-    console.log(chalk.red(`\uD83D\uDCCC Pinned (critical): ${formatTaskLine(updated)}`));
+    console.log(chalk2.red(`\uD83D\uDCCC Pinned (critical): ${formatTaskLine(updated)}`));
   } catch {
     handleError(new Error("Failed to pin"));
   }
@@ -20169,19 +21018,19 @@ program2.command("doctor").description("Diagnose common task data issues").optio
     console.log(JSON.stringify({ issues, ok: !issues.some((i) => i.severity === "error") }));
     return;
   }
-  console.log(chalk.bold(`todos doctor
+  console.log(chalk2.bold(`todos doctor
 `));
   for (const issue of issues) {
-    const icon = issue.severity === "error" ? chalk.red("\u2717") : issue.severity === "warn" ? chalk.yellow("\u26A0") : chalk.green("\u2713");
+    const icon = issue.severity === "error" ? chalk2.red("\u2717") : issue.severity === "warn" ? chalk2.yellow("\u26A0") : chalk2.green("\u2713");
     console.log(`  ${icon} ${issue.message}`);
   }
   const errors2 = issues.filter((i) => i.severity === "error").length;
   const warns = issues.filter((i) => i.severity === "warn").length;
   if (errors2 === 0 && warns === 0)
-    console.log(chalk.green(`
+    console.log(chalk2.green(`
   All clear.`));
   else
-    console.log(chalk[errors2 > 0 ? "red" : "yellow"](`
+    console.log(chalk2[errors2 > 0 ? "red" : "yellow"](`
   ${errors2} error(s), ${warns} warning(s). Run with --fix to auto-resolve where possible.`));
 });
 program2.command("health").description("Check todos system health \u2014 database, config, connectivity").option("--json", "Output as JSON").action(async (opts) => {
@@ -20196,7 +21045,7 @@ program2.command("health").description("Check todos system health \u2014 databas
     try {
       size = `${(statSync3(dbPath).size / 1024 / 1024).toFixed(1)} MB`;
     } catch {}
-    checks.push({ name: "Database", ok: true, message: `${row.count} tasks \xB7 ${size} \xB7 ${chalk.dim(dbPath)}` });
+    checks.push({ name: "Database", ok: true, message: `${row.count} tasks \xB7 ${size} \xB7 ${chalk2.dim(dbPath)}` });
   } catch (e) {
     checks.push({ name: "Database", ok: false, message: e instanceof Error ? e.message : "Failed" });
   }
@@ -20229,15 +21078,15 @@ program2.command("health").description("Check todos system health \u2014 databas
     console.log(JSON.stringify({ ok, checks }));
     return;
   }
-  console.log(chalk.bold(`todos health
+  console.log(chalk2.bold(`todos health
 `));
   for (const c of checks) {
-    const icon = c.ok ? chalk.green("\u2713") : chalk.yellow("\u26A0");
+    const icon = c.ok ? chalk2.green("\u2713") : chalk2.yellow("\u26A0");
     console.log(`  ${icon} ${c.name.padEnd(14)} ${c.message}`);
   }
   const allOk = checks.every((c) => c.ok);
   console.log(`
-  ${allOk ? chalk.green("All checks passed.") : chalk.yellow("Some checks need attention.")}`);
+  ${allOk ? chalk2.green("All checks passed.") : chalk2.yellow("Some checks need attention.")}`);
 });
 program2.command("report").description("Analytics report: task activity, completion rates, agent breakdown").option("--days <n>", "Days to include in report", "7").option("--project <id>", "Filter to project").option("--markdown", "Output as markdown").option("--json", "Output as JSON").action(async (opts) => {
   const globalOpts = program2.opts();
@@ -20286,15 +21135,15 @@ program2.command("report").description("Analytics report: task activity, complet
     if (sparkline)
       lines.push(`| Activity | \`${sparkline}\` |`);
   } else {
-    lines.push(chalk.bold(`todos report \u2014 last ${days} day${days !== 1 ? "s" : ""}`));
+    lines.push(chalk2.bold(`todos report \u2014 last ${days} day${days !== 1 ? "s" : ""}`));
     lines.push("");
-    lines.push(`  Total:      ${chalk.bold(String(all.length))} tasks (${chalk.yellow(String(stats.pending))} pending, ${chalk.blue(String(stats.in_progress))} active)`);
-    lines.push(`  Changed:    ${chalk.bold(String(changed.length))} in period`);
-    lines.push(`  Completed:  ${chalk.green(String(completed.length))} (${completionRate}% rate)`);
+    lines.push(`  Total:      ${chalk2.bold(String(all.length))} tasks (${chalk2.yellow(String(stats.pending))} pending, ${chalk2.blue(String(stats.in_progress))} active)`);
+    lines.push(`  Changed:    ${chalk2.bold(String(changed.length))} in period`);
+    lines.push(`  Completed:  ${chalk2.green(String(completed.length))} (${completionRate}% rate)`);
     if (failed.length > 0)
-      lines.push(`  Failed:     ${chalk.red(String(failed.length))}`);
+      lines.push(`  Failed:     ${chalk2.red(String(failed.length))}`);
     if (sparkline)
-      lines.push(`  Activity:   ${chalk.dim(sparkline)}`);
+      lines.push(`  Activity:   ${chalk2.dim(sparkline)}`);
     if (Object.keys(byAgent).length > 0) {
       lines.push(`  By agent:   ${Object.entries(byAgent).map(([a, n]) => `${a}=${n}`).join(" ")}`);
     }
@@ -20318,21 +21167,21 @@ program2.command("today").description("Show task activity from today").option("-
     console.log(JSON.stringify({ date: start.toISOString().slice(0, 10), completed, started, changed: other }));
     return;
   }
-  console.log(chalk.bold(`Today \u2014 ${start.toISOString().slice(0, 10)}
+  console.log(chalk2.bold(`Today \u2014 ${start.toISOString().slice(0, 10)}
 `));
   if (completed.length > 0) {
-    console.log(chalk.green(`  \u2713 Completed (${completed.length}):`));
+    console.log(chalk2.green(`  \u2713 Completed (${completed.length}):`));
     for (const t of completed)
-      console.log(`    ${chalk.cyan(t.short_id || t.id.slice(0, 8))} ${t.title}${t.assigned_to ? chalk.dim(` \u2014 ${t.assigned_to}`) : ""}`);
+      console.log(`    ${chalk2.cyan(t.short_id || t.id.slice(0, 8))} ${t.title}${t.assigned_to ? chalk2.dim(` \u2014 ${t.assigned_to}`) : ""}`);
   }
   if (started.length > 0) {
-    console.log(chalk.blue(`
+    console.log(chalk2.blue(`
   \u25B6 Started (${started.length}):`));
     for (const t of started)
-      console.log(`    ${chalk.cyan(t.short_id || t.id.slice(0, 8))} ${t.title}${t.assigned_to ? chalk.dim(` \u2014 ${t.assigned_to}`) : ""}`);
+      console.log(`    ${chalk2.cyan(t.short_id || t.id.slice(0, 8))} ${t.title}${t.assigned_to ? chalk2.dim(` \u2014 ${t.assigned_to}`) : ""}`);
   }
   if (completed.length === 0 && started.length === 0)
-    console.log(chalk.dim("  No activity today."));
+    console.log(chalk2.dim("  No activity today."));
 });
 program2.command("yesterday").description("Show task activity from yesterday").option("--json", "Output as JSON").action(async (opts) => {
   const globalOpts = program2.opts();
@@ -20351,21 +21200,21 @@ program2.command("yesterday").description("Show task activity from yesterday").o
     console.log(JSON.stringify({ date: start.toISOString().slice(0, 10), completed, started }));
     return;
   }
-  console.log(chalk.bold(`Yesterday \u2014 ${start.toISOString().slice(0, 10)}
+  console.log(chalk2.bold(`Yesterday \u2014 ${start.toISOString().slice(0, 10)}
 `));
   if (completed.length > 0) {
-    console.log(chalk.green(`  \u2713 Completed (${completed.length}):`));
+    console.log(chalk2.green(`  \u2713 Completed (${completed.length}):`));
     for (const t of completed)
-      console.log(`    ${chalk.cyan(t.short_id || t.id.slice(0, 8))} ${t.title}${t.assigned_to ? chalk.dim(` \u2014 ${t.assigned_to}`) : ""}`);
+      console.log(`    ${chalk2.cyan(t.short_id || t.id.slice(0, 8))} ${t.title}${t.assigned_to ? chalk2.dim(` \u2014 ${t.assigned_to}`) : ""}`);
   }
   if (started.length > 0) {
-    console.log(chalk.blue(`
+    console.log(chalk2.blue(`
   \u25B6 Started (${started.length}):`));
     for (const t of started)
-      console.log(`    ${chalk.cyan(t.short_id || t.id.slice(0, 8))} ${t.title}`);
+      console.log(`    ${chalk2.cyan(t.short_id || t.id.slice(0, 8))} ${t.title}`);
   }
   if (completed.length === 0 && started.length === 0)
-    console.log(chalk.dim("  No activity yesterday."));
+    console.log(chalk2.dim("  No activity yesterday."));
 });
 program2.command("mine").description("Show tasks assigned to you, grouped by status").argument("<agent>", "Agent name or ID").option("--json", "Output as JSON").action(async (agent, opts) => {
   const globalOpts = program2.opts();
@@ -20400,23 +21249,23 @@ program2.command("mine").description("Show tasks assigned to you, grouped by sta
   }
   const statusOrder = ["in_progress", "pending", "blocked", "completed", "failed", "cancelled"];
   const statusIcons2 = { in_progress: "\u25B6", pending: "\u25CB", blocked: "\u2298", completed: "\u2713", failed: "\u2717", cancelled: "\u2014" };
-  const statusColors5 = { in_progress: chalk.blue, pending: chalk.white, blocked: chalk.red, completed: chalk.green, failed: chalk.red, cancelled: chalk.dim };
-  console.log(chalk.bold(`Tasks for ${agent} (${tasks.length} total):
+  const statusColors5 = { in_progress: chalk2.blue, pending: chalk2.white, blocked: chalk2.red, completed: chalk2.green, failed: chalk2.red, cancelled: chalk2.dim };
+  console.log(chalk2.bold(`Tasks for ${agent} (${tasks.length} total):
 `));
   for (const status of statusOrder) {
     const group = groups[status];
     if (!group || group.length === 0)
       continue;
-    const color = statusColors5[status] || chalk.white;
+    const color = statusColors5[status] || chalk2.white;
     const icon = statusIcons2[status] || "?";
     console.log(color(`  ${icon} ${status.replace("_", " ")} (${group.length}):`));
     for (const t of group) {
-      const priority = t.priority === "critical" || t.priority === "high" ? chalk.red(` [${t.priority}]`) : "";
-      console.log(`    ${chalk.cyan(t.short_id || t.id.slice(0, 8))} ${t.title}${priority}`);
+      const priority = t.priority === "critical" || t.priority === "high" ? chalk2.red(` [${t.priority}]`) : "";
+      console.log(`    ${chalk2.cyan(t.short_id || t.id.slice(0, 8))} ${t.title}${priority}`);
     }
   }
   if (tasks.length === 0)
-    console.log(chalk.dim(`  No tasks assigned to ${agent}.`));
+    console.log(chalk2.dim(`  No tasks assigned to ${agent}.`));
 });
 program2.command("blocked").description("Show tasks blocked by incomplete dependencies").option("--json", "Output as JSON").option("--project <id>", "Filter to project").action(async (opts) => {
   const globalOpts = program2.opts();
@@ -20438,15 +21287,15 @@ program2.command("blocked").description("Show tasks blocked by incomplete depend
     return;
   }
   if (blockedTasks.length === 0) {
-    console.log(chalk.green("  No blocked tasks!"));
+    console.log(chalk2.green("  No blocked tasks!"));
     return;
   }
-  console.log(chalk.bold(`Blocked (${blockedTasks.length}):
+  console.log(chalk2.bold(`Blocked (${blockedTasks.length}):
 `));
   for (const { task, blockers } of blockedTasks) {
-    console.log(`  ${chalk.cyan(task.short_id || task.id.slice(0, 8))} ${task.title}`);
+    console.log(`  ${chalk2.cyan(task.short_id || task.id.slice(0, 8))} ${task.title}`);
     for (const bl of blockers) {
-      console.log(`    ${chalk.red("\u2298")} ${chalk.dim(bl.short_id || bl.id.slice(0, 8))} ${chalk.dim(bl.title)} ${chalk.yellow(`[${bl.status}]`)}`);
+      console.log(`    ${chalk2.red("\u2298")} ${chalk2.dim(bl.short_id || bl.id.slice(0, 8))} ${chalk2.dim(bl.title)} ${chalk2.yellow(`[${bl.status}]`)}`);
     }
   }
 });
@@ -20460,16 +21309,16 @@ program2.command("overdue").description("Show tasks past their due date").option
     return;
   }
   if (tasks.length === 0) {
-    console.log(chalk.green("  No overdue tasks!"));
+    console.log(chalk2.green("  No overdue tasks!"));
     return;
   }
-  console.log(chalk.bold.red(`Overdue (${tasks.length}):
+  console.log(chalk2.bold.red(`Overdue (${tasks.length}):
 `));
   for (const t of tasks) {
     const dueDate = t.due_at.slice(0, 10);
     const daysOverdue = Math.floor((Date.now() - new Date(t.due_at).getTime()) / 86400000);
-    const urgency = daysOverdue > 7 ? chalk.bgRed.white(` ${daysOverdue}d `) : chalk.red(`${daysOverdue}d`);
-    console.log(`  ${urgency} ${chalk.cyan(t.short_id || t.id.slice(0, 8))} ${t.title}${t.assigned_to ? chalk.dim(` \u2014 ${t.assigned_to}`) : ""} ${chalk.dim(`(due ${dueDate})`)}`);
+    const urgency = daysOverdue > 7 ? chalk2.bgRed.white(` ${daysOverdue}d `) : chalk2.red(`${daysOverdue}d`);
+    console.log(`  ${urgency} ${chalk2.cyan(t.short_id || t.id.slice(0, 8))} ${t.title}${t.assigned_to ? chalk2.dim(` \u2014 ${t.assigned_to}`) : ""} ${chalk2.dim(`(due ${dueDate})`)}`);
   }
 });
 program2.command("week").description("Show task activity from the past 7 days").option("--json", "Output as JSON").action(async (opts) => {
@@ -20504,8 +21353,8 @@ program2.command("week").description("Show task activity from the past 7 days").
   }
   const totalCompleted = tasks.filter((t) => t.status === "completed").length;
   const totalStarted = tasks.filter((t) => t.status === "in_progress").length;
-  console.log(chalk.bold(`Week \u2014 ${start.toISOString().slice(0, 10)} to ${now2.toISOString().slice(0, 10)}`));
-  console.log(chalk.dim(`  ${totalCompleted} completed, ${totalStarted} in progress, ${tasks.length} total changes
+  console.log(chalk2.bold(`Week \u2014 ${start.toISOString().slice(0, 10)} to ${now2.toISOString().slice(0, 10)}`));
+  console.log(chalk2.dim(`  ${totalCompleted} completed, ${totalStarted} in progress, ${tasks.length} total changes
 `));
   const sortedDays = Object.keys(days).sort().reverse();
   for (const day of sortedDays) {
@@ -20516,14 +21365,14 @@ program2.command("week").description("Show task activity from the past 7 days").
     if (completed.length === 0 && started.length === 0)
       continue;
     const weekday = new Date(day + "T12:00:00").toLocaleDateString("en-US", { weekday: "short" });
-    console.log(chalk.bold(`  ${weekday} ${day}`));
+    console.log(chalk2.bold(`  ${weekday} ${day}`));
     for (const t of completed)
-      console.log(`    ${chalk.green("\u2713")} ${chalk.cyan(t.short_id || t.id.slice(0, 8))} ${t.title}${t.assigned_to ? chalk.dim(` \u2014 ${t.assigned_to}`) : ""}`);
+      console.log(`    ${chalk2.green("\u2713")} ${chalk2.cyan(t.short_id || t.id.slice(0, 8))} ${t.title}${t.assigned_to ? chalk2.dim(` \u2014 ${t.assigned_to}`) : ""}`);
     for (const t of started)
-      console.log(`    ${chalk.blue("\u25B6")} ${chalk.cyan(t.short_id || t.id.slice(0, 8))} ${t.title}${t.assigned_to ? chalk.dim(` \u2014 ${t.assigned_to}`) : ""}`);
+      console.log(`    ${chalk2.blue("\u25B6")} ${chalk2.cyan(t.short_id || t.id.slice(0, 8))} ${t.title}${t.assigned_to ? chalk2.dim(` \u2014 ${t.assigned_to}`) : ""}`);
   }
   if (tasks.length === 0)
-    console.log(chalk.dim("  No activity this week."));
+    console.log(chalk2.dim("  No activity this week."));
 });
 program2.command("burndown").description("Show task completion velocity over the past 7 days").option("--days <n>", "Number of days", "7").option("--json", "Output as JSON").action(async (opts) => {
   const globalOpts = program2.opts();
@@ -20551,20 +21400,20 @@ program2.command("burndown").description("Show task completion velocity over the
   }
   const maxVal = Math.max(...dayStats.map((d) => Math.max(d.completed, d.created)), 1);
   const barWidth = 30;
-  console.log(chalk.bold("Burndown (last " + numDays + ` days):
+  console.log(chalk2.bold("Burndown (last " + numDays + ` days):
 `));
-  console.log(chalk.dim("  Date        Done  New   Failed  Chart"));
+  console.log(chalk2.dim("  Date        Done  New   Failed  Chart"));
   for (const day of dayStats) {
     const weekday = new Date(day.date + "T12:00:00").toLocaleDateString("en-US", { weekday: "short" });
-    const completedBar = chalk.green("\u2588".repeat(Math.round(day.completed / maxVal * barWidth)));
-    const createdBar = chalk.blue("\u2591".repeat(Math.round(day.created / maxVal * barWidth)));
-    const failed = day.failed > 0 ? chalk.red(String(day.failed).padStart(4)) : chalk.dim("   0");
-    console.log(`  ${weekday} ${day.date.slice(5)}  ${chalk.green(String(day.completed).padStart(4))}  ${chalk.blue(String(day.created).padStart(4))}   ${failed}  ${completedBar}${createdBar}`);
+    const completedBar = chalk2.green("\u2588".repeat(Math.round(day.completed / maxVal * barWidth)));
+    const createdBar = chalk2.blue("\u2591".repeat(Math.round(day.created / maxVal * barWidth)));
+    const failed = day.failed > 0 ? chalk2.red(String(day.failed).padStart(4)) : chalk2.dim("   0");
+    console.log(`  ${weekday} ${day.date.slice(5)}  ${chalk2.green(String(day.completed).padStart(4))}  ${chalk2.blue(String(day.created).padStart(4))}   ${failed}  ${completedBar}${createdBar}`);
   }
   const totalCompleted = dayStats.reduce((s, d) => s + d.completed, 0);
   const totalCreated = dayStats.reduce((s, d) => s + d.created, 0);
   const velocity = (totalCompleted / numDays).toFixed(1);
-  console.log(chalk.dim(`
+  console.log(chalk2.dim(`
   Velocity: ${velocity}/day \xB7 ${totalCompleted} done \xB7 ${totalCreated} created`));
 });
 program2.command("log").description("Show recent task activity log (git-log style)").option("--limit <n>", "Number of entries", "30").option("--json", "Output as JSON").action(async (opts) => {
@@ -20577,38 +21426,38 @@ program2.command("log").description("Show recent task activity log (git-log styl
     return;
   }
   if (entries.length === 0) {
-    console.log(chalk.dim("  No activity yet."));
+    console.log(chalk2.dim("  No activity yet."));
     return;
   }
   const actionIcons = {
-    create: chalk.green("+"),
-    start: chalk.blue("\u25B6"),
-    complete: chalk.green("\u2713"),
-    fail: chalk.red("\u2717"),
-    update: chalk.yellow("~"),
-    approve: chalk.green("\u2605"),
-    lock: chalk.dim("\uD83D\uDD12"),
-    unlock: chalk.dim("\uD83D\uDD13")
+    create: chalk2.green("+"),
+    start: chalk2.blue("\u25B6"),
+    complete: chalk2.green("\u2713"),
+    fail: chalk2.red("\u2717"),
+    update: chalk2.yellow("~"),
+    approve: chalk2.green("\u2605"),
+    lock: chalk2.dim("\uD83D\uDD12"),
+    unlock: chalk2.dim("\uD83D\uDD13")
   };
   let lastDate = "";
   for (const e of entries) {
     const date = e.created_at.slice(0, 10);
     const time = e.created_at.slice(11, 16);
     if (date !== lastDate) {
-      console.log(chalk.bold(`
+      console.log(chalk2.bold(`
   ${date}`));
       lastDate = date;
     }
-    const icon = actionIcons[e.action] || chalk.dim("\xB7");
-    const agent = e.agent_id ? chalk.dim(` (${e.agent_id})`) : "";
-    const taskRef = chalk.cyan(e.task_id.slice(0, 8));
+    const icon = actionIcons[e.action] || chalk2.dim("\xB7");
+    const agent = e.agent_id ? chalk2.dim(` (${e.agent_id})`) : "";
+    const taskRef = chalk2.cyan(e.task_id.slice(0, 8));
     let detail = "";
     if (e.field && e.old_value && e.new_value) {
-      detail = chalk.dim(` ${e.field}: ${e.old_value} \u2192 ${e.new_value}`);
+      detail = chalk2.dim(` ${e.field}: ${e.old_value} \u2192 ${e.new_value}`);
     } else if (e.field && e.new_value) {
-      detail = chalk.dim(` ${e.field}: ${e.new_value}`);
+      detail = chalk2.dim(` ${e.field}: ${e.new_value}`);
     }
-    console.log(`  ${chalk.dim(time)} ${icon} ${e.action.padEnd(8)} ${taskRef}${detail}${agent}`);
+    console.log(`  ${chalk2.dim(time)} ${icon} ${e.action.padEnd(8)} ${taskRef}${detail}${agent}`);
   }
 });
 program2.command("ready").description("Show all tasks ready to be claimed (pending, unblocked, unlocked)").option("--json", "Output as JSON").option("--project <id>", "Filter to project").option("--limit <n>", "Max tasks to show", "20").action(async (opts) => {
@@ -20633,15 +21482,15 @@ program2.command("ready").description("Show all tasks ready to be claimed (pendi
     return;
   }
   if (limited.length === 0) {
-    console.log(chalk.dim("  No tasks ready to claim."));
+    console.log(chalk2.dim("  No tasks ready to claim."));
     return;
   }
-  console.log(chalk.bold(`Ready to claim (${ready.length}${ready.length > limited.length ? `, showing ${limited.length}` : ""}):
+  console.log(chalk2.bold(`Ready to claim (${ready.length}${ready.length > limited.length ? `, showing ${limited.length}` : ""}):
 `));
   for (const t of limited) {
-    const pri = t.priority === "critical" ? chalk.bgRed.white(" CRIT ") : t.priority === "high" ? chalk.red("[high]") : t.priority === "medium" ? chalk.yellow("[med]") : "";
-    const due = t.due_at ? chalk.dim(` due ${t.due_at.slice(0, 10)}`) : "";
-    console.log(`  ${chalk.cyan(t.short_id || t.id.slice(0, 8))} ${t.title} ${pri}${due}`);
+    const pri = t.priority === "critical" ? chalk2.bgRed.white(" CRIT ") : t.priority === "high" ? chalk2.red("[high]") : t.priority === "medium" ? chalk2.yellow("[med]") : "";
+    const due = t.due_at ? chalk2.dim(` due ${t.due_at.slice(0, 10)}`) : "";
+    console.log(`  ${chalk2.cyan(t.short_id || t.id.slice(0, 8))} ${t.title} ${pri}${due}`);
   }
 });
 program2.command("sprint").description("Sprint dashboard: in-progress, next up, blockers, and overdue").option("--json", "Output as JSON").option("--project <id>", "Filter to project").action(async (opts) => {
@@ -20668,41 +21517,41 @@ program2.command("sprint").description("Sprint dashboard: in-progress, next up,
     console.log(JSON.stringify({ in_progress: inProgress, next_up: nextUp, blocked, overdue }));
     return;
   }
-  console.log(chalk.bold(`Sprint Dashboard
+  console.log(chalk2.bold(`Sprint Dashboard
 `));
-  console.log(chalk.blue(`  \u25B6 In Progress (${inProgress.length}):`));
+  console.log(chalk2.blue(`  \u25B6 In Progress (${inProgress.length}):`));
   if (inProgress.length === 0)
-    console.log(chalk.dim("    (none)"));
+    console.log(chalk2.dim("    (none)"));
   for (const t of inProgress) {
-    const agent = t.assigned_to ? chalk.dim(` \u2014 ${t.assigned_to}`) : "";
-    console.log(`    ${chalk.cyan(t.short_id || t.id.slice(0, 8))} ${t.title}${agent}`);
+    const agent = t.assigned_to ? chalk2.dim(` \u2014 ${t.assigned_to}`) : "";
+    console.log(`    ${chalk2.cyan(t.short_id || t.id.slice(0, 8))} ${t.title}${agent}`);
   }
-  console.log(chalk.white(`
+  console.log(chalk2.white(`
   \u25CB Next Up (${nextUp.length}):`));
   if (nextUp.length === 0)
-    console.log(chalk.dim("    (none)"));
+    console.log(chalk2.dim("    (none)"));
   for (const t of nextUp) {
-    const pri = t.priority === "critical" ? chalk.bgRed.white(" CRIT ") : t.priority === "high" ? chalk.red("[high]") : "";
-    console.log(`    ${chalk.cyan(t.short_id || t.id.slice(0, 8))} ${t.title} ${pri}`);
+    const pri = t.priority === "critical" ? chalk2.bgRed.white(" CRIT ") : t.priority === "high" ? chalk2.red("[high]") : "";
+    console.log(`    ${chalk2.cyan(t.short_id || t.id.slice(0, 8))} ${t.title} ${pri}`);
   }
   if (blocked.length > 0) {
-    console.log(chalk.red(`
+    console.log(chalk2.red(`
   \u2298 Blocked (${blocked.length}):`));
     for (const { task, blockers } of blocked) {
-      console.log(`    ${chalk.cyan(task.short_id || task.id.slice(0, 8))} ${task.title}`);
+      console.log(`    ${chalk2.cyan(task.short_id || task.id.slice(0, 8))} ${task.title}`);
       for (const bl of blockers)
-        console.log(`      ${chalk.dim("\u2190 " + (bl.short_id || bl.id.slice(0, 8)) + " " + bl.title)} ${chalk.yellow(`[${bl.status}]`)}`);
+        console.log(`      ${chalk2.dim("\u2190 " + (bl.short_id || bl.id.slice(0, 8)) + " " + bl.title)} ${chalk2.yellow(`[${bl.status}]`)}`);
     }
   }
   if (overdue.length > 0) {
-    console.log(chalk.red(`
+    console.log(chalk2.red(`
   \u26A0 Overdue (${overdue.length}):`));
     for (const t of overdue) {
       const daysOver = Math.floor((Date.now() - new Date(t.due_at).getTime()) / 86400000);
-      console.log(`    ${chalk.red(`${daysOver}d`)} ${chalk.cyan(t.short_id || t.id.slice(0, 8))} ${t.title}`);
+      console.log(`    ${chalk2.red(`${daysOver}d`)} ${chalk2.cyan(t.short_id || t.id.slice(0, 8))} ${t.title}`);
     }
   }
-  console.log(chalk.dim(`
+  console.log(chalk2.dim(`
   ${inProgress.length} active \xB7 ${pending.length} pending \xB7 ${blocked.length} blocked \xB7 ${overdue.length} overdue`));
 });
 program2.command("handoff").description("Create or view agent session handoffs").option("--create", "Create a new handoff").option("--agent <name>", "Agent name").option("--summary <text>", "Handoff summary").option("--completed <items>", "Comma-separated completed items").option("--in-progress <items>", "Comma-separated in-progress items").option("--blockers <items>", "Comma-separated blockers").option("--next <items>", "Comma-separated next steps").option("--json", "Output as JSON").option("--limit <n>", "Number of handoffs to show", "5").action(async (opts) => {
@@ -20712,7 +21561,7 @@ program2.command("handoff").description("Create or view agent session handoffs")
   const projectId = autoProject(globalOpts) || undefined;
   if (opts.create || opts.summary) {
     if (!opts.summary) {
-      console.error(chalk.red("  --summary is required for creating a handoff"));
+      console.error(chalk2.red("  --summary is required for creating a handoff"));
       process.exit(1);
     }
     const handoff = createHandoff2({
@@ -20728,7 +21577,7 @@ program2.command("handoff").description("Create or view agent session handoffs")
       console.log(JSON.stringify(handoff));
       return;
     }
-    console.log(chalk.green(`  \u2713 Handoff created by ${handoff.agent_id || "unknown"}`));
+    console.log(chalk2.green(`  \u2713 Handoff created by ${handoff.agent_id || "unknown"}`));
     return;
   }
   const handoffs = listHandoffs2(projectId, parseInt(opts.limit, 10), db);
@@ -20737,31 +21586,31 @@ program2.command("handoff").description("Create or view agent session handoffs")
     return;
   }
   if (handoffs.length === 0) {
-    console.log(chalk.dim("  No handoffs yet."));
+    console.log(chalk2.dim("  No handoffs yet."));
     return;
   }
   for (const h of handoffs) {
     const time = h.created_at.slice(0, 16).replace("T", " ");
-    console.log(chalk.bold(`
+    console.log(chalk2.bold(`
   ${time} ${h.agent_id || "unknown"}`));
     console.log(`  ${h.summary}`);
     if (h.completed?.length) {
-      console.log(chalk.green(`  \u2713 Completed:`));
+      console.log(chalk2.green(`  \u2713 Completed:`));
       for (const c of h.completed)
         console.log(`    - ${c}`);
     }
     if (h.in_progress?.length) {
-      console.log(chalk.blue(`  \u25B6 In progress:`));
+      console.log(chalk2.blue(`  \u25B6 In progress:`));
       for (const c of h.in_progress)
         console.log(`    - ${c}`);
     }
     if (h.blockers?.length) {
-      console.log(chalk.red(`  \u2298 Blockers:`));
+      console.log(chalk2.red(`  \u2298 Blockers:`));
       for (const c of h.blockers)
         console.log(`    - ${c}`);
     }
     if (h.next_steps?.length) {
-      console.log(chalk.cyan(`  \u2192 Next steps:`));
+      console.log(chalk2.cyan(`  \u2192 Next steps:`));
       for (const c of h.next_steps)
         console.log(`    - ${c}`);
     }
@@ -20787,16 +21636,16 @@ program2.command("priorities").description("Show task counts grouped by priority
     console.log(JSON.stringify(counts));
     return;
   }
-  console.log(chalk.bold(`Priority Breakdown:
+  console.log(chalk2.bold(`Priority Breakdown:
 `));
-  const priColors = { critical: chalk.bgRed.white, high: chalk.red, medium: chalk.yellow, low: chalk.blue, none: chalk.dim };
+  const priColors = { critical: chalk2.bgRed.white, high: chalk2.red, medium: chalk2.yellow, low: chalk2.blue, none: chalk2.dim };
   for (const p of priorities) {
     const c = counts[p];
     if (!c || c.total === 0)
       continue;
-    const color = priColors[p] || chalk.white;
-    const bar = chalk.green("\u2588".repeat(Math.min(c.completed, 30))) + chalk.blue("\u2591".repeat(Math.min(c.in_progress, 10))) + chalk.dim("\xB7".repeat(Math.min(c.pending, 20)));
-    console.log(`  ${color(p.padEnd(9))} ${String(c.total).padStart(4)} total  ${chalk.green(String(c.completed).padStart(3))} done  ${chalk.blue(String(c.in_progress).padStart(3))} active  ${chalk.dim(String(c.pending).padStart(3))} pending  ${bar}`);
+    const color = priColors[p] || chalk2.white;
+    const bar = chalk2.green("\u2588".repeat(Math.min(c.completed, 30))) + chalk2.blue("\u2591".repeat(Math.min(c.in_progress, 10))) + chalk2.dim("\xB7".repeat(Math.min(c.pending, 20)));
+    console.log(`  ${color(p.padEnd(9))} ${String(c.total).padStart(4)} total  ${chalk2.green(String(c.completed).padStart(3))} done  ${chalk2.blue(String(c.in_progress).padStart(3))} active  ${chalk2.dim(String(c.pending).padStart(3))} pending  ${bar}`);
   }
 });
 program2.command("context").description("Session start context: status, latest handoff, next task, overdue").option("--agent <name>", "Agent name for handoff lookup").option("--json", "Output as JSON").action(async (opts) => {
@@ -20816,21 +21665,21 @@ program2.command("context").description("Session start context: status, latest h
     console.log(JSON.stringify({ status, next_task: nextTask, overdue_count: overdue.length, latest_handoff: handoff, as_of: new Date().toISOString() }));
     return;
   }
-  console.log(chalk.bold(`Session Context
+  console.log(chalk2.bold(`Session Context
 `));
   console.log(`  ${status.pending} pending \xB7 ${status.in_progress} active \xB7 ${status.completed} done \xB7 ${status.total} total`);
   if (status.stale_count > 0)
-    console.log(chalk.yellow(`  \u26A0 ${status.stale_count} stale tasks`));
+    console.log(chalk2.yellow(`  \u26A0 ${status.stale_count} stale tasks`));
   if (overdue.length > 0)
-    console.log(chalk.red(`  \u26A0 ${overdue.length} overdue tasks`));
+    console.log(chalk2.red(`  \u26A0 ${overdue.length} overdue tasks`));
   if (nextTask) {
-    const pri = nextTask.priority === "critical" || nextTask.priority === "high" ? chalk.red(` [${nextTask.priority}]`) : "";
-    console.log(chalk.bold(`
+    const pri = nextTask.priority === "critical" || nextTask.priority === "high" ? chalk2.red(` [${nextTask.priority}]`) : "";
+    console.log(chalk2.bold(`
   Next up:`));
-    console.log(`    ${chalk.cyan(nextTask.short_id || nextTask.id.slice(0, 8))} ${nextTask.title}${pri}`);
+    console.log(`    ${chalk2.cyan(nextTask.short_id || nextTask.id.slice(0, 8))} ${nextTask.title}${pri}`);
   }
   if (handoff) {
-    console.log(chalk.bold(`
+    console.log(chalk2.bold(`
   Last handoff (${handoff.agent_id || "unknown"}, ${handoff.created_at.slice(0, 16).replace("T", " ")}):`));
     console.log(`    ${handoff.summary}`);
     if (handoff.next_steps?.length) {
@@ -20838,7 +21687,7 @@ program2.command("context").description("Session start context: status, latest h
         console.log(`    \u2192 ${s}`);
     }
   }
-  console.log(chalk.dim(`
+  console.log(chalk2.dim(`
   as_of: ${new Date().toISOString()}`));
 });
 program2.command("report-failure").description("Create a task from a test/build/typecheck failure and auto-assign it").requiredOption("--error <message>", "Error message or summary").option("--type <type>", "Failure type: test, build, typecheck, runtime, other", "test").option("--file <path>", "File where failure occurred").option("--stack <trace>", "Stack trace or detailed output").option("--title <title>", "Custom task title (auto-generated if omitted)").option("--priority <p>", "Priority: low, medium, high, critical").option("--json", "Output as JSON").action(async (opts) => {
@@ -20877,11 +21726,11 @@ ${opts.stack.slice(0, 1500)}
     console.log(JSON.stringify({ task_id: task.id, short_id: task.short_id, title: task.title, assigned_to: assignResult.agent_name, method: assignResult.method }));
     return;
   }
-  console.log(chalk.green(`\u2713 Created task ${task.short_id || task.id.slice(0, 8)}: ${task.title}`));
+  console.log(chalk2.green(`\u2713 Created task ${task.short_id || task.id.slice(0, 8)}: ${task.title}`));
   if (assignResult.agent_name) {
-    console.log(chalk.cyan(`  Assigned to: ${assignResult.agent_name} (via ${assignResult.method})`));
+    console.log(chalk2.cyan(`  Assigned to: ${assignResult.agent_name} (via ${assignResult.method})`));
     if (assignResult.reason)
-      console.log(chalk.dim(`  Reason: ${assignResult.reason}`));
+      console.log(chalk2.dim(`  Reason: ${assignResult.reason}`));
   }
 });
 program2.action(async () => {
@@ -20898,4 +21747,5 @@ program2.action(async () => {
     program2.help();
   }
 });
+program2.addCommand(makeBrainsCommand());
 program2.parse();