@hasna/todos 0.10.22 → 0.11.1

package/dist/cli/index.js

@@ -6,60 +6,39 @@ var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-function __accessProp(key) {
-  return this[key];
-}
-var __toESMCache_node;
-var __toESMCache_esm;
 var __toESM = (mod, isNodeMode, target) => {
-  var canCache = mod != null && typeof mod === "object";
-  if (canCache) {
-    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
-    var cached = cache.get(mod);
-    if (cached)
-      return cached;
-  }
   target = mod != null ? __create(__getProtoOf(mod)) : {};
   const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
   for (let key of __getOwnPropNames(mod))
     if (!__hasOwnProp.call(to, key))
       __defProp(to, key, {
-        get: __accessProp.bind(mod, key),
+        get: () => mod[key],
         enumerable: true
       });
-  if (canCache)
-    cache.set(mod, to);
   return to;
 };
+var __moduleCache = /* @__PURE__ */ new WeakMap;
 var __toCommonJS = (from) => {
-  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  var entry = __moduleCache.get(from), desc;
   if (entry)
     return entry;
   entry = __defProp({}, "__esModule", { value: true });
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (var key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(entry, key))
-        __defProp(entry, key, {
-          get: __accessProp.bind(from, key),
-          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-        });
-  }
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
   __moduleCache.set(from, entry);
   return entry;
 };
-var __moduleCache;
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
-var __returnValue = (v) => v;
-function __exportSetter(name, newValue) {
-  this[name] = __returnValue.bind(null, newValue);
-}
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
-      set: __exportSetter.bind(all, name)
+      set: (newValue) => all[name] = () => newValue
     });
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
@@ -2347,6 +2326,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 +2948,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 +3795,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 +3825,7 @@ __export(exports_tasks, {
   countTasks: () => countTasks,
   completeTask: () => completeTask,
   cloneTask: () => cloneTask,
+  claimOrSteal: () => claimOrSteal,
   claimNextTask: () => claimNextTask,
   bulkUpdateTasks: () => bulkUpdateTasks,
   bulkCreateTasks: () => bulkCreateTasks,
@@ -4264,6 +4307,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 +4617,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 +4670,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);
@@ -10363,6 +10466,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, {
@@ -13037,6 +13353,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 +14192,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(),
@@ -19758,6 +20253,20 @@ program2.command("claim <agent>").description("Atomically claim the best pending
   }
   console.log(chalk.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(chalk.dim("No stale tasks available to steal."));
+    return;
+  }
+  if (globalOpts.json) {
+    output(task, true);
+    return;
+  }
+  console.log(chalk.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();
   const filters = {};