@hasna/todos 0.10.22 → 0.11.2

package/dist/index.js

@@ -754,6 +754,58 @@ var MIGRATIONS = [
   `
   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);
   `
 ];
@@ -936,6 +988,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");
@@ -2252,6 +2313,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) {
@@ -2548,24 +2623,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 };
 }
@@ -2589,6 +2676,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);
@@ -3330,6 +3451,123 @@ function deleteSession(id, db) {
   const result = d.run("DELETE FROM sessions WHERE id = ?", [id]);
   return result.changes > 0;
 }
+// src/lib/gatherer.ts
+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 existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { homedir } from "os";
+import { join as join4 } from "path";
+var DEFAULT_MODEL = "gpt-4o-mini";
+var CONFIG_DIR = join4(homedir(), ".todos");
+var CONFIG_PATH = join4(CONFIG_DIR, "config.json");
+function readConfig() {
+  if (!existsSync4(CONFIG_PATH))
+    return {};
+  try {
+    const raw = readFileSync2(CONFIG_PATH, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+function writeConfig(config) {
+  if (!existsSync4(CONFIG_DIR)) {
+    mkdirSync3(CONFIG_DIR, { recursive: true });
+  }
+  writeFileSync2(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/db/handoffs.ts
 function createHandoff(input, db) {
   const d = db || getDatabase();
@@ -4161,16 +4399,16 @@ function searchTasks(options, projectId, taskListId, db) {
   return rows.map(rowToTask3);
 }
 // src/lib/claude-tasks.ts
-import { existsSync as existsSync4, readFileSync as readFileSync2, readdirSync as readdirSync2, writeFileSync as writeFileSync2 } from "fs";
-import { join as join4 } from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync3, readdirSync as readdirSync2, writeFileSync as writeFileSync3 } from "fs";
+import { join as join5 } from "path";
 function getTaskListDir(taskListId) {
-  return join4(HOME, ".claude", "tasks", taskListId);
+  return join5(HOME, ".claude", "tasks", taskListId);
 }
 function readClaudeTask(dir, filename) {
-  return readJsonFile(join4(dir, filename));
+  return readJsonFile(join5(dir, filename));
 }
 function writeClaudeTask(dir, task) {
-  writeJsonFile(join4(dir, `${task.id}.json`), task);
+  writeJsonFile(join5(dir, `${task.id}.json`), task);
 }
 function toClaudeStatus(status) {
   if (status === "pending" || status === "in_progress" || status === "completed") {
@@ -4182,14 +4420,14 @@ function toSqliteStatus(status) {
   return status;
 }
 function readPrefixCounter(dir) {
-  const path = join4(dir, ".prefix-counter");
-  if (!existsSync4(path))
+  const path = join5(dir, ".prefix-counter");
+  if (!existsSync5(path))
     return 0;
-  const val = parseInt(readFileSync2(path, "utf-8").trim(), 10);
+  const val = parseInt(readFileSync3(path, "utf-8").trim(), 10);
   return isNaN(val) ? 0 : val;
 }
 function writePrefixCounter(dir, value) {
-  writeFileSync2(join4(dir, ".prefix-counter"), String(value));
+  writeFileSync3(join5(dir, ".prefix-counter"), String(value));
 }
 function formatPrefixedSubject(title, prefix, counter) {
   const padded = String(counter).padStart(5, "0");
@@ -4216,7 +4454,7 @@ function taskToClaudeTask(task, claudeTaskId, existingMeta) {
 }
 function pushToClaudeTaskList(taskListId, projectId, options = {}) {
   const dir = getTaskListDir(taskListId);
-  if (!existsSync4(dir))
+  if (!existsSync5(dir))
     ensureDir2(dir);
   const filter = {};
   if (projectId)
@@ -4225,7 +4463,7 @@ function pushToClaudeTaskList(taskListId, projectId, options = {}) {
   const existingByTodosId = new Map;
   const files = listJsonFiles(dir);
   for (const f of files) {
-    const path = join4(dir, f);
+    const path = join5(dir, f);
     const ct = readClaudeTask(dir, f);
     if (ct?.metadata?.["todos_id"]) {
       existingByTodosId.set(ct.metadata["todos_id"], { task: ct, mtimeMs: getFileMtimeMs(path) });
@@ -4312,7 +4550,7 @@ function pushToClaudeTaskList(taskListId, projectId, options = {}) {
 }
 function pullFromClaudeTaskList(taskListId, projectId, options = {}) {
   const dir = getTaskListDir(taskListId);
-  if (!existsSync4(dir)) {
+  if (!existsSync5(dir)) {
     return { pushed: 0, pulled: 0, errors: [`Task list directory not found: ${dir}`] };
   }
   const files = readdirSync2(dir).filter((f) => f.endsWith(".json"));
@@ -4332,7 +4570,7 @@ function pullFromClaudeTaskList(taskListId, projectId, options = {}) {
   }
   for (const f of files) {
     try {
-      const filePath = join4(dir, f);
+      const filePath = join5(dir, f);
       const ct = readClaudeTask(dir, f);
       if (!ct)
         continue;
@@ -4400,20 +4638,20 @@ function syncClaudeTaskList(taskListId, projectId, options = {}) {
 }
 
 // src/lib/agent-tasks.ts
-import { existsSync as existsSync5 } from "fs";
-import { join as join5 } from "path";
+import { existsSync as existsSync6 } from "fs";
+import { join as join6 } from "path";
 function agentBaseDir(agent) {
   const key = `TODOS_${agent.toUpperCase()}_TASKS_DIR`;
-  return process.env[key] || getAgentTasksDir(agent) || process.env["TODOS_AGENT_TASKS_DIR"] || join5(HOME, ".todos", "agents");
+  return process.env[key] || getAgentTasksDir(agent) || process.env["TODOS_AGENT_TASKS_DIR"] || join6(HOME, ".todos", "agents");
 }
 function getTaskListDir2(agent, taskListId) {
-  return join5(agentBaseDir(agent), agent, taskListId);
+  return join6(agentBaseDir(agent), agent, taskListId);
 }
 function readAgentTask(dir, filename) {
-  return readJsonFile(join5(dir, filename));
+  return readJsonFile(join6(dir, filename));
 }
 function writeAgentTask(dir, task) {
-  writeJsonFile(join5(dir, `${task.id}.json`), task);
+  writeJsonFile(join6(dir, `${task.id}.json`), task);
 }
 function taskToAgentTask(task, externalId, existingMeta) {
   return {
@@ -4438,7 +4676,7 @@ function metadataKey(agent) {
 }
 function pushToAgentTaskList(agent, taskListId, projectId, options = {}) {
   const dir = getTaskListDir2(agent, taskListId);
-  if (!existsSync5(dir))
+  if (!existsSync6(dir))
     ensureDir2(dir);
   const filter = {};
   if (projectId)
@@ -4447,7 +4685,7 @@ function pushToAgentTaskList(agent, taskListId, projectId, options = {}) {
   const existingByTodosId = new Map;
   const files = listJsonFiles(dir);
   for (const f of files) {
-    const path = join5(dir, f);
+    const path = join6(dir, f);
     const at = readAgentTask(dir, f);
     if (at?.metadata?.["todos_id"]) {
       existingByTodosId.set(at.metadata["todos_id"], { task: at, mtimeMs: getFileMtimeMs(path) });
@@ -4521,7 +4759,7 @@ function pushToAgentTaskList(agent, taskListId, projectId, options = {}) {
 }
 function pullFromAgentTaskList(agent, taskListId, projectId, options = {}) {
   const dir = getTaskListDir2(agent, taskListId);
-  if (!existsSync5(dir)) {
+  if (!existsSync6(dir)) {
     return { pushed: 0, pulled: 0, errors: [`Task list directory not found: ${dir}`] };
   }
   const files = listJsonFiles(dir);
@@ -4540,7 +4778,7 @@ function pullFromAgentTaskList(agent, taskListId, projectId, options = {}) {
   }
   for (const f of files) {
     try {
-      const filePath = join5(dir, f);
+      const filePath = join6(dir, f);
       const at = readAgentTask(dir, f);
       if (!at)
         continue;
@@ -4677,8 +4915,8 @@ function syncWithAgents(agents, taskListIdByAgent, projectId, direction = "both"
   return { pushed, pulled, errors };
 }
 // src/lib/extract.ts
-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 join7 } from "path";
 var EXTRACT_TAGS = ["TODO", "FIXME", "HACK", "XXX", "BUG", "NOTE"];
 var DEFAULT_EXTENSIONS = new Set([
   ".ts",
@@ -4812,9 +5050,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 : join7(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);
@@ -4998,6 +5236,188 @@ function issueToTask(issue, opts) {
     agent_id: opts?.agent_id
   };
 }
+// src/db/traces.ts
+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;
+}
+// src/db/snapshots.ts
+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);
+}
+// src/db/budgets.ts
+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 };
+}
 export {
   uuid,
   updateTaskList,
@@ -5017,12 +5437,16 @@ export {
   syncWithAgents,
   syncWithAgent,
   syncKgEdges,
+  stealTask,
   startTask,
   slugify,
   setTaskStatus,
   setTaskPriority,
+  setBudget,
+  setActiveModel,
   searchTasks,
   scoreTask,
+  saveSnapshot,
   resolvePartialId,
   resetDatabase,
   removeTaskRelationshipByPair,
@@ -5044,8 +5468,10 @@ export {
   nextOccurrence,
   moveTask,
   matchCapabilities,
+  logTrace,
   logTaskChange,
   logProgress,
+  logCost,
   lockTask,
   loadConfig,
   listWebhooks,
@@ -5053,6 +5479,7 @@ export {
   listTasks,
   listTaskLists,
   listTaskFiles,
+  listSnapshots,
   listSessions,
   listProjects,
   listProjectSources,
@@ -5065,9 +5492,11 @@ export {
   isValidRecurrenceRule,
   isAgentConflict,
   getWebhook,
+  getTraceStats,
   getTemplate,
   getTasksChangedSince,
   getTaskWithRelations,
+  getTaskTraces,
   getTaskStats,
   getTaskRelationships,
   getTaskRelationship,
@@ -5096,6 +5525,7 @@ export {
   getOrg,
   getNextTask,
   getLeaderboard,
+  getLatestSnapshot,
   getLatestHandoff,
   getImpactAnalysis,
   getDirectReports,
@@ -5107,11 +5537,14 @@ export {
   getChecklist,
   getCapableAgents,
   getBurndown,
+  getBudget,
   getBlockingDeps,
   getAgentMetrics,
   getAgentByName,
   getAgent,
   getActiveWork,
+  getActiveModel,
+  gatherTrainingData,
   findTasksByFile,
   findRelatedTaskIds,
   findPath,
@@ -5149,11 +5582,14 @@ export {
   closeDatabase,
   cloneTask,
   clearChecklist,
+  clearActiveModel,
   cleanExpiredLocks,
+  claimOrSteal,
   claimNextTask,
   checkLock,
   checkCompletionGuard,
   checkChecklistItem,
+  checkBudget,
   bulkUpdateTasks,
   bulkCreateTasks,
   bulkAddTaskFiles,
@@ -5181,6 +5617,7 @@ export {
   LockError,
   EXTRACT_TAGS,
   DependencyCycleError,
+  DEFAULT_MODEL,
   CompletionGuardError,
   AgentNotFoundError
 };