@hasna/todos 0.10.22 → 0.11.2

package/dist/mcp/index.js

@@ -392,6 +392,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");
@@ -1005,6 +1014,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);
   `
   ];
@@ -1601,12 +1662,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,
@@ -1629,6 +1692,7 @@ __export(exports_tasks, {
   countTasks: () => countTasks,
   completeTask: () => completeTask,
   cloneTask: () => cloneTask,
+  claimOrSteal: () => claimOrSteal,
   claimNextTask: () => claimNextTask,
   bulkUpdateTasks: () => bulkUpdateTasks,
   bulkCreateTasks: () => bulkCreateTasks,
@@ -2110,6 +2174,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) {
@@ -2406,24 +2484,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 };
 }
@@ -2447,6 +2537,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);
@@ -3042,6 +3166,219 @@ var init_task_commits = __esm(() => {
   init_database();
 });
 
+// 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, {
@@ -9398,7 +9735,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) });
 }
@@ -10849,6 +11202,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)"),
@@ -11559,6 +12041,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(),