@hasna/todos 0.11.43 → 0.11.45

package/dist/storage.js

@@ -1122,6 +1122,152 @@ var init_migrations = __esm(() => {
   );
   CREATE INDEX IF NOT EXISTS idx_saved_search_views_scope ON saved_search_views(scope);
   INSERT OR IGNORE INTO _migrations (id) VALUES (55);
+  `,
+    `
+  ALTER TABLE task_time_logs ADD COLUMN run_id TEXT;
+  ALTER TABLE task_time_logs ADD COLUMN focus_session_id TEXT;
+  CREATE INDEX IF NOT EXISTS idx_task_time_logs_run ON task_time_logs(run_id);
+  CREATE INDEX IF NOT EXISTS idx_task_time_logs_focus_session ON task_time_logs(focus_session_id);
+  CREATE TABLE IF NOT EXISTS focus_sessions (
+    id TEXT PRIMARY KEY,
+    task_id TEXT REFERENCES tasks(id) ON DELETE SET NULL,
+    plan_id TEXT REFERENCES plans(id) ON DELETE SET NULL,
+    run_id TEXT,
+    agent_id TEXT,
+    title TEXT,
+    status TEXT NOT NULL DEFAULT 'active' CHECK(status IN ('active', 'paused', 'completed', 'cancelled')),
+    started_at TEXT NOT NULL,
+    last_resumed_at TEXT,
+    paused_at TEXT,
+    ended_at TEXT,
+    actual_minutes INTEGER NOT NULL DEFAULT 0,
+    idle_after_minutes INTEGER,
+    notes TEXT,
+    metadata TEXT DEFAULT '{}',
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+  CREATE INDEX IF NOT EXISTS idx_focus_sessions_task ON focus_sessions(task_id);
+  CREATE INDEX IF NOT EXISTS idx_focus_sessions_plan ON focus_sessions(plan_id);
+  CREATE INDEX IF NOT EXISTS idx_focus_sessions_run ON focus_sessions(run_id);
+  CREATE INDEX IF NOT EXISTS idx_focus_sessions_agent ON focus_sessions(agent_id);
+  CREATE INDEX IF NOT EXISTS idx_focus_sessions_status ON focus_sessions(status);
+  INSERT OR IGNORE INTO _migrations (id) VALUES (56);
+  `,
+    `
+  CREATE TABLE IF NOT EXISTS task_boards (
+    id TEXT PRIMARY KEY,
+    name TEXT NOT NULL UNIQUE,
+    scope TEXT NOT NULL DEFAULT 'tasks' CHECK(scope IN ('tasks', 'plans')),
+    project_id TEXT REFERENCES projects(id) ON DELETE SET NULL,
+    task_list_id TEXT REFERENCES task_lists(id) ON DELETE SET NULL,
+    plan_id TEXT REFERENCES plans(id) ON DELETE SET NULL,
+    agent_id TEXT,
+    lanes TEXT NOT NULL DEFAULT '[]',
+    filters TEXT NOT NULL DEFAULT '{}',
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+  CREATE INDEX IF NOT EXISTS idx_task_boards_scope ON task_boards(scope);
+  CREATE INDEX IF NOT EXISTS idx_task_boards_project ON task_boards(project_id);
+  CREATE INDEX IF NOT EXISTS idx_task_boards_plan ON task_boards(plan_id);
+  INSERT OR IGNORE INTO _migrations (id) VALUES (57);
+  `,
+    `
+  CREATE TABLE IF NOT EXISTS local_calendar_items (
+    id TEXT PRIMARY KEY,
+    kind TEXT NOT NULL CHECK(kind IN ('task_due', 'task_sla', 'task_reminder', 'milestone', 'work_block', 'run', 'imported')),
+    title TEXT NOT NULL,
+    description TEXT,
+    starts_at TEXT NOT NULL,
+    ends_at TEXT,
+    timezone TEXT,
+    project_id TEXT REFERENCES projects(id) ON DELETE SET NULL,
+    task_id TEXT REFERENCES tasks(id) ON DELETE SET NULL,
+    plan_id TEXT REFERENCES plans(id) ON DELETE SET NULL,
+    run_id TEXT,
+    recurrence_rule TEXT,
+    metadata TEXT DEFAULT '{}',
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+  CREATE INDEX IF NOT EXISTS idx_local_calendar_items_time ON local_calendar_items(starts_at, ends_at);
+  CREATE INDEX IF NOT EXISTS idx_local_calendar_items_task ON local_calendar_items(task_id);
+  CREATE INDEX IF NOT EXISTS idx_local_calendar_items_project ON local_calendar_items(project_id);
+  CREATE INDEX IF NOT EXISTS idx_local_calendar_items_kind ON local_calendar_items(kind);
+  INSERT OR IGNORE INTO _migrations (id) VALUES (58);
+  `,
+    `
+  CREATE TABLE IF NOT EXISTS project_knowledge_records (
+    id TEXT PRIMARY KEY,
+    record_type TEXT NOT NULL CHECK(record_type IN ('decision','architecture_note','tradeoff','context_snapshot')),
+    title TEXT NOT NULL,
+    content TEXT,
+    decision TEXT,
+    rationale TEXT,
+    alternatives TEXT DEFAULT '[]',
+    task_id TEXT REFERENCES tasks(id) ON DELETE SET NULL,
+    project_id TEXT REFERENCES projects(id) ON DELETE SET NULL,
+    plan_id TEXT REFERENCES plans(id) ON DELETE SET NULL,
+    agent_id TEXT,
+    snapshot_id TEXT REFERENCES context_snapshots(id) ON DELETE SET NULL,
+    tags TEXT DEFAULT '[]',
+    metadata TEXT DEFAULT '{}',
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+  CREATE INDEX IF NOT EXISTS idx_project_knowledge_type ON project_knowledge_records(record_type);
+  CREATE INDEX IF NOT EXISTS idx_project_knowledge_project ON project_knowledge_records(project_id);
+  CREATE INDEX IF NOT EXISTS idx_project_knowledge_task ON project_knowledge_records(task_id);
+  CREATE INDEX IF NOT EXISTS idx_project_knowledge_plan ON project_knowledge_records(plan_id);
+  CREATE INDEX IF NOT EXISTS idx_project_knowledge_agent ON project_knowledge_records(agent_id);
+  CREATE INDEX IF NOT EXISTS idx_project_knowledge_snapshot ON project_knowledge_records(snapshot_id);
+  INSERT OR IGNORE INTO _migrations (id) VALUES (59);
+  `,
+    `
+  CREATE TABLE IF NOT EXISTS project_risks (
+    id TEXT PRIMARY KEY,
+    title TEXT NOT NULL,
+    description TEXT,
+    status TEXT NOT NULL DEFAULT 'open' CHECK(status IN ('open','mitigating','resolved','accepted')),
+    severity TEXT NOT NULL DEFAULT 'medium' CHECK(severity IN ('low','medium','high','critical')),
+    probability TEXT NOT NULL DEFAULT 'medium' CHECK(probability IN ('low','medium','high')),
+    owner TEXT,
+    mitigation TEXT,
+    due_at TEXT,
+    project_id TEXT REFERENCES projects(id) ON DELETE SET NULL,
+    plan_id TEXT REFERENCES plans(id) ON DELETE SET NULL,
+    task_id TEXT REFERENCES tasks(id) ON DELETE SET NULL,
+    tags TEXT DEFAULT '[]',
+    metadata TEXT DEFAULT '{}',
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+    closed_at TEXT
+  );
+  CREATE INDEX IF NOT EXISTS idx_project_risks_status ON project_risks(status);
+  CREATE INDEX IF NOT EXISTS idx_project_risks_severity ON project_risks(severity);
+  CREATE INDEX IF NOT EXISTS idx_project_risks_project ON project_risks(project_id);
+  CREATE INDEX IF NOT EXISTS idx_project_risks_plan ON project_risks(plan_id);
+  CREATE INDEX IF NOT EXISTS idx_project_risks_task ON project_risks(task_id);
+  CREATE INDEX IF NOT EXISTS idx_project_risks_due ON project_risks(due_at);
+  INSERT OR IGNORE INTO _migrations (id) VALUES (60);
+  `,
+    `
+  CREATE TABLE IF NOT EXISTS local_retrospectives (
+    id TEXT PRIMARY KEY,
+    title TEXT NOT NULL,
+    scope TEXT NOT NULL CHECK(scope IN ('project','plan')),
+    project_id TEXT REFERENCES projects(id) ON DELETE SET NULL,
+    plan_id TEXT REFERENCES plans(id) ON DELETE SET NULL,
+    agent_id TEXT,
+    report_json TEXT NOT NULL,
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+  CREATE INDEX IF NOT EXISTS idx_local_retrospectives_project ON local_retrospectives(project_id);
+  CREATE INDEX IF NOT EXISTS idx_local_retrospectives_plan ON local_retrospectives(plan_id);
+  CREATE INDEX IF NOT EXISTS idx_local_retrospectives_agent ON local_retrospectives(agent_id);
+  INSERT OR IGNORE INTO _migrations (id) VALUES (61);
   `
   ];
 });
@@ -1309,6 +1455,89 @@ function ensureSchema(db) {
       updated_at TEXT NOT NULL DEFAULT (datetime('now'))
     )`);
   ensureIndex("CREATE INDEX IF NOT EXISTS idx_saved_search_views_scope ON saved_search_views(scope)");
+  ensureTable("context_snapshots", `
+    CREATE TABLE 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'))
+    )`);
+  ensureIndex("CREATE INDEX IF NOT EXISTS idx_snapshots_agent ON context_snapshots(agent_id)");
+  ensureIndex("CREATE INDEX IF NOT EXISTS idx_snapshots_task ON context_snapshots(task_id)");
+  ensureTable("project_knowledge_records", `
+    CREATE TABLE project_knowledge_records (
+      id TEXT PRIMARY KEY,
+      record_type TEXT NOT NULL CHECK(record_type IN ('decision','architecture_note','tradeoff','context_snapshot')),
+      title TEXT NOT NULL,
+      content TEXT,
+      decision TEXT,
+      rationale TEXT,
+      alternatives TEXT DEFAULT '[]',
+      task_id TEXT REFERENCES tasks(id) ON DELETE SET NULL,
+      project_id TEXT REFERENCES projects(id) ON DELETE SET NULL,
+      plan_id TEXT REFERENCES plans(id) ON DELETE SET NULL,
+      agent_id TEXT,
+      snapshot_id TEXT REFERENCES context_snapshots(id) ON DELETE SET NULL,
+      tags TEXT DEFAULT '[]',
+      metadata TEXT DEFAULT '{}',
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+    )`);
+  ensureIndex("CREATE INDEX IF NOT EXISTS idx_project_knowledge_type ON project_knowledge_records(record_type)");
+  ensureIndex("CREATE INDEX IF NOT EXISTS idx_project_knowledge_project ON project_knowledge_records(project_id)");
+  ensureIndex("CREATE INDEX IF NOT EXISTS idx_project_knowledge_task ON project_knowledge_records(task_id)");
+  ensureIndex("CREATE INDEX IF NOT EXISTS idx_project_knowledge_plan ON project_knowledge_records(plan_id)");
+  ensureIndex("CREATE INDEX IF NOT EXISTS idx_project_knowledge_agent ON project_knowledge_records(agent_id)");
+  ensureIndex("CREATE INDEX IF NOT EXISTS idx_project_knowledge_snapshot ON project_knowledge_records(snapshot_id)");
+  ensureTable("project_risks", `
+    CREATE TABLE project_risks (
+      id TEXT PRIMARY KEY,
+      title TEXT NOT NULL,
+      description TEXT,
+      status TEXT NOT NULL DEFAULT 'open' CHECK(status IN ('open','mitigating','resolved','accepted')),
+      severity TEXT NOT NULL DEFAULT 'medium' CHECK(severity IN ('low','medium','high','critical')),
+      probability TEXT NOT NULL DEFAULT 'medium' CHECK(probability IN ('low','medium','high')),
+      owner TEXT,
+      mitigation TEXT,
+      due_at TEXT,
+      project_id TEXT REFERENCES projects(id) ON DELETE SET NULL,
+      plan_id TEXT REFERENCES plans(id) ON DELETE SET NULL,
+      task_id TEXT REFERENCES tasks(id) ON DELETE SET NULL,
+      tags TEXT DEFAULT '[]',
+      metadata TEXT DEFAULT '{}',
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+      closed_at TEXT
+    )`);
+  ensureIndex("CREATE INDEX IF NOT EXISTS idx_project_risks_status ON project_risks(status)");
+  ensureIndex("CREATE INDEX IF NOT EXISTS idx_project_risks_severity ON project_risks(severity)");
+  ensureIndex("CREATE INDEX IF NOT EXISTS idx_project_risks_project ON project_risks(project_id)");
+  ensureIndex("CREATE INDEX IF NOT EXISTS idx_project_risks_plan ON project_risks(plan_id)");
+  ensureIndex("CREATE INDEX IF NOT EXISTS idx_project_risks_task ON project_risks(task_id)");
+  ensureIndex("CREATE INDEX IF NOT EXISTS idx_project_risks_due ON project_risks(due_at)");
+  ensureTable("local_retrospectives", `
+    CREATE TABLE local_retrospectives (
+      id TEXT PRIMARY KEY,
+      title TEXT NOT NULL,
+      scope TEXT NOT NULL CHECK(scope IN ('project','plan')),
+      project_id TEXT REFERENCES projects(id) ON DELETE SET NULL,
+      plan_id TEXT REFERENCES plans(id) ON DELETE SET NULL,
+      agent_id TEXT,
+      report_json TEXT NOT NULL,
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+    )`);
+  ensureIndex("CREATE INDEX IF NOT EXISTS idx_local_retrospectives_project ON local_retrospectives(project_id)");
+  ensureIndex("CREATE INDEX IF NOT EXISTS idx_local_retrospectives_plan ON local_retrospectives(plan_id)");
+  ensureIndex("CREATE INDEX IF NOT EXISTS idx_local_retrospectives_agent ON local_retrospectives(agent_id)");
   ensureTable("task_relationships", `
     CREATE TABLE task_relationships (
       id TEXT PRIMARY KEY,
@@ -1645,6 +1874,8 @@ function ensureSchema(db) {
     CREATE TABLE task_time_logs (
       id TEXT PRIMARY KEY,
       task_id TEXT NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+      run_id TEXT,
+      focus_session_id TEXT,
       agent_id TEXT,
       started_at TEXT,
       ended_at TEXT,
@@ -1652,9 +1883,77 @@ function ensureSchema(db) {
       notes TEXT,
       created_at TEXT NOT NULL DEFAULT (datetime('now'))
     )`);
+  ensureColumn("task_time_logs", "run_id", "TEXT");
+  ensureColumn("task_time_logs", "focus_session_id", "TEXT");
   ensureIndex("CREATE INDEX IF NOT EXISTS idx_task_time_logs_task ON task_time_logs(task_id)");
   ensureIndex("CREATE INDEX IF NOT EXISTS idx_task_time_logs_agent ON task_time_logs(agent_id)");
+  ensureIndex("CREATE INDEX IF NOT EXISTS idx_task_time_logs_run ON task_time_logs(run_id)");
+  ensureIndex("CREATE INDEX IF NOT EXISTS idx_task_time_logs_focus_session ON task_time_logs(focus_session_id)");
   ensureColumn("tasks", "actual_minutes", "INTEGER");
+  ensureTable("focus_sessions", `
+    CREATE TABLE focus_sessions (
+      id TEXT PRIMARY KEY,
+      task_id TEXT REFERENCES tasks(id) ON DELETE SET NULL,
+      plan_id TEXT REFERENCES plans(id) ON DELETE SET NULL,
+      run_id TEXT,
+      agent_id TEXT,
+      title TEXT,
+      status TEXT NOT NULL DEFAULT 'active' CHECK(status IN ('active', 'paused', 'completed', 'cancelled')),
+      started_at TEXT NOT NULL,
+      last_resumed_at TEXT,
+      paused_at TEXT,
+      ended_at TEXT,
+      actual_minutes INTEGER NOT NULL DEFAULT 0,
+      idle_after_minutes INTEGER,
+      notes TEXT,
+      metadata TEXT DEFAULT '{}',
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+    )`);
+  ensureIndex("CREATE INDEX IF NOT EXISTS idx_focus_sessions_task ON focus_sessions(task_id)");
+  ensureIndex("CREATE INDEX IF NOT EXISTS idx_focus_sessions_plan ON focus_sessions(plan_id)");
+  ensureIndex("CREATE INDEX IF NOT EXISTS idx_focus_sessions_run ON focus_sessions(run_id)");
+  ensureIndex("CREATE INDEX IF NOT EXISTS idx_focus_sessions_agent ON focus_sessions(agent_id)");
+  ensureIndex("CREATE INDEX IF NOT EXISTS idx_focus_sessions_status ON focus_sessions(status)");
+  ensureTable("task_boards", `
+    CREATE TABLE task_boards (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL UNIQUE,
+      scope TEXT NOT NULL DEFAULT 'tasks' CHECK(scope IN ('tasks', 'plans')),
+      project_id TEXT REFERENCES projects(id) ON DELETE SET NULL,
+      task_list_id TEXT REFERENCES task_lists(id) ON DELETE SET NULL,
+      plan_id TEXT REFERENCES plans(id) ON DELETE SET NULL,
+      agent_id TEXT,
+      lanes TEXT NOT NULL DEFAULT '[]',
+      filters TEXT NOT NULL DEFAULT '{}',
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+    )`);
+  ensureIndex("CREATE INDEX IF NOT EXISTS idx_task_boards_scope ON task_boards(scope)");
+  ensureIndex("CREATE INDEX IF NOT EXISTS idx_task_boards_project ON task_boards(project_id)");
+  ensureIndex("CREATE INDEX IF NOT EXISTS idx_task_boards_plan ON task_boards(plan_id)");
+  ensureTable("local_calendar_items", `
+    CREATE TABLE local_calendar_items (
+      id TEXT PRIMARY KEY,
+      kind TEXT NOT NULL CHECK(kind IN ('task_due', 'task_sla', 'task_reminder', 'milestone', 'work_block', 'run', 'imported')),
+      title TEXT NOT NULL,
+      description TEXT,
+      starts_at TEXT NOT NULL,
+      ends_at TEXT,
+      timezone TEXT,
+      project_id TEXT REFERENCES projects(id) ON DELETE SET NULL,
+      task_id TEXT REFERENCES tasks(id) ON DELETE SET NULL,
+      plan_id TEXT REFERENCES plans(id) ON DELETE SET NULL,
+      run_id TEXT,
+      recurrence_rule TEXT,
+      metadata TEXT DEFAULT '{}',
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+    )`);
+  ensureIndex("CREATE INDEX IF NOT EXISTS idx_local_calendar_items_time ON local_calendar_items(starts_at, ends_at)");
+  ensureIndex("CREATE INDEX IF NOT EXISTS idx_local_calendar_items_task ON local_calendar_items(task_id)");
+  ensureIndex("CREATE INDEX IF NOT EXISTS idx_local_calendar_items_project ON local_calendar_items(project_id)");
+  ensureIndex("CREATE INDEX IF NOT EXISTS idx_local_calendar_items_kind ON local_calendar_items(kind)");
   ensureTable("task_watchers", `
     CREATE TABLE task_watchers (
       id TEXT PRIMARY KEY,
@@ -1734,12 +2033,63 @@ var init_schema = __esm(() => {
 });
 
 // src/db/machines.ts
-import { hostname as osHostname, platform as osPlatform } from "os";
+import { existsSync } from "fs";
+import { hostname as osHostname, platform as osPlatform, arch as osArch } from "os";
+import { resolve } from "path";
+import { spawnSync } from "child_process";
+function parseMetadata(value) {
+  if (!value)
+    return {};
+  try {
+    const parsed = JSON.parse(value);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
 function rowToMachine(row) {
   return {
     ...row,
     is_primary: !!row.is_primary,
-    metadata: row.metadata ? JSON.parse(row.metadata) : {}
+    metadata: parseMetadata(row.metadata)
+  };
+}
+function discoverGitRoot(workspacePath) {
+  const result = spawnSync("git", ["-C", workspacePath, "rev-parse", "--show-toplevel"], {
+    encoding: "utf-8",
+    timeout: 2000
+  });
+  if (result.status !== 0)
+    return;
+  const root = result.stdout.trim();
+  return root || undefined;
+}
+function topologyMetadata(input, existing = {}) {
+  const next = { ...existing };
+  const workspacePath = input.workspace_path ? resolve(input.workspace_path) : undefined;
+  const entries = {
+    tailscale_name: input.tailscale_name,
+    tailscale_ip: input.tailscale_ip,
+    lan_address: input.lan_address,
+    workspace_path: workspacePath,
+    git_root: input.git_root ?? (workspacePath ? discoverGitRoot(workspacePath) : undefined),
+    arch: input.arch
+  };
+  for (const [key, value] of Object.entries(entries)) {
+    if (value !== undefined && value !== "")
+      next[key] = value;
+  }
+  return next;
+}
+function extractTopology(machine) {
+  const metadata = machine.metadata;
+  return {
+    tailscale_name: typeof metadata["tailscale_name"] === "string" ? metadata["tailscale_name"] : undefined,
+    tailscale_ip: typeof metadata["tailscale_ip"] === "string" ? metadata["tailscale_ip"] : undefined,
+    lan_address: typeof metadata["lan_address"] === "string" ? metadata["lan_address"] : undefined,
+    workspace_path: typeof metadata["workspace_path"] === "string" ? metadata["workspace_path"] : undefined,
+    git_root: typeof metadata["git_root"] === "string" ? metadata["git_root"] : undefined,
+    arch: typeof metadata["arch"] === "string" ? metadata["arch"] : undefined
   };
 }
 function getOrCreateLocalMachine(db) {
@@ -1783,6 +2133,159 @@ function listMachines(db, includeArchived = false) {
   const rows = d.query(query).all();
   return rows.map(rowToMachine);
 }
+function registerMachine(name, opts, db) {
+  const d = db || getDatabase();
+  const existing = d.query("SELECT * FROM machines WHERE name = ?").get(name);
+  const metadata = topologyMetadata(opts, parseMetadata(existing?.metadata ?? null));
+  if (existing) {
+    d.run("UPDATE machines SET hostname = ?, platform = ?, ssh_address = ?, last_seen_at = ?, metadata = ? WHERE id = ?", [
+      opts.hostname ?? existing.hostname,
+      opts.platform ?? existing.platform,
+      opts.ssh_address ?? existing.ssh_address,
+      now(),
+      JSON.stringify(metadata),
+      existing.id
+    ]);
+    if (opts.primary) {
+      setPrimaryMachine(name, d);
+    }
+    return getMachine(existing.id, d);
+  }
+  const id = uuid();
+  const ts = now();
+  const host = opts.hostname || osHostname();
+  const plat = opts.platform || osPlatform();
+  d.run("INSERT INTO machines (id, name, hostname, platform, ssh_address, last_seen_at, is_primary, metadata, created_at) VALUES (?, ?, ?, ?, ?, ?, 0, ?, ?)", [id, name, host, plat, opts.ssh_address ?? null, ts, JSON.stringify(metadata), ts]);
+  if (opts.primary) {
+    setPrimaryMachine(name, d);
+  }
+  return getMachine(id, d);
+}
+function updateMachineHeartbeat(idOrName, opts = {}, db) {
+  const d = db || getDatabase();
+  const key = idOrName || process.env["TODOS_MACHINE_NAME"] || osHostname();
+  const row = d.query("SELECT * FROM machines WHERE id = ? OR name = ?").get(key, key);
+  if (!row) {
+    return registerMachine(key, {
+      hostname: opts.hostname ?? osHostname(),
+      platform: opts.platform ?? osPlatform(),
+      arch: opts.arch ?? osArch(),
+      ...opts
+    }, d);
+  }
+  const metadata = topologyMetadata({ arch: osArch(), ...opts }, parseMetadata(row.metadata));
+  const ts = now();
+  d.run("UPDATE machines SET hostname = ?, platform = ?, ssh_address = ?, last_seen_at = ?, metadata = ? WHERE id = ?", [
+    opts.hostname ?? row.hostname ?? osHostname(),
+    opts.platform ?? row.platform ?? osPlatform(),
+    opts.ssh_address ?? row.ssh_address,
+    ts,
+    JSON.stringify(metadata),
+    row.id
+  ]);
+  return getMachine(row.id, d);
+}
+function getMachineTopologyDiagnostics(opts = {}, db, at = new Date) {
+  const d = db || getDatabase();
+  const staleAfter = opts.stale_minutes ?? 30;
+  const generatedAt = at.toISOString();
+  const localMachine = getOrCreateLocalMachine(d);
+  const machines = listMachines(d, opts.include_archived ?? true);
+  const machineById = new Map(machines.map((machine) => [machine.id, machine]));
+  const summaries = machines.map((machine) => {
+    const lastSeenMs = Date.parse(machine.last_seen_at);
+    const staleMinutes = Number.isFinite(lastSeenMs) ? Math.max(0, Math.floor((at.getTime() - lastSeenMs) / 60000)) : Number.POSITIVE_INFINITY;
+    return {
+      id: machine.id,
+      name: machine.name,
+      hostname: machine.hostname,
+      platform: machine.platform,
+      ssh_address: machine.ssh_address,
+      is_primary: machine.is_primary,
+      archived_at: machine.archived_at,
+      last_seen_at: machine.last_seen_at,
+      stale: !machine.archived_at && staleMinutes > staleAfter,
+      stale_minutes: Number.isFinite(staleMinutes) ? staleMinutes : staleAfter + 1,
+      topology: extractTopology(machine)
+    };
+  });
+  const pathRows = d.query(`SELECT p.id AS project_id, p.name AS project_name, pmp.machine_id, m.name AS machine_name, pmp.path
+     FROM project_machine_paths pmp
+     JOIN projects p ON p.id = pmp.project_id
+     LEFT JOIN machines m ON m.id = pmp.machine_id
+     ORDER BY p.name, pmp.machine_id`).all();
+  const projectRows = d.query("SELECT id, name, path FROM projects ORDER BY name").all();
+  const rowsByProject = new Map;
+  for (const row of pathRows) {
+    const rows = rowsByProject.get(row.project_id) ?? [];
+    rows.push({ ...row, machine_name: row.machine_name ?? row.machine_id });
+    rowsByProject.set(row.project_id, rows);
+  }
+  const pathIssues = [];
+  for (const project of projectRows) {
+    const rows = rowsByProject.get(project.id) ?? [];
+    const localRow = rows.find((row) => row.machine_id === localMachine.id);
+    if (!localRow) {
+      pathIssues.push({
+        type: "missing_local_path",
+        project_id: project.id,
+        project_name: project.name,
+        message: `No machine-local path override is registered for ${project.name} on ${localMachine.name}`
+      });
+    }
+    const distinctPaths = [...new Set(rows.map((row) => row.path))];
+    if (distinctPaths.length > 1) {
+      pathIssues.push({
+        type: "path_mismatch",
+        project_id: project.id,
+        project_name: project.name,
+        paths: rows.map((row) => ({ machine_id: row.machine_id, machine_name: row.machine_name, path: row.path })),
+        message: `${project.name} has ${distinctPaths.length} different machine-local paths`
+      });
+    }
+    if (localRow && !existsSync(localRow.path)) {
+      pathIssues.push({
+        type: "path_missing",
+        project_id: project.id,
+        project_name: project.name,
+        machine_id: localMachine.id,
+        machine_name: localMachine.name,
+        path: localRow.path,
+        message: `Local path does not exist on this machine: ${localRow.path}`
+      });
+    }
+    if (!localRow && project.path && machineById.has(localMachine.id) && !existsSync(project.path)) {
+      pathIssues.push({
+        type: "path_missing",
+        project_id: project.id,
+        project_name: project.name,
+        machine_id: localMachine.id,
+        machine_name: localMachine.name,
+        path: project.path,
+        message: `Project path does not exist on this machine: ${project.path}`
+      });
+    }
+  }
+  return {
+    generated_at: generatedAt,
+    stale_after_minutes: staleAfter,
+    local_machine: localMachine,
+    machines: summaries,
+    stale_machines: summaries.filter((summary) => summary.stale),
+    path_issues: pathIssues
+  };
+}
+function setPrimaryMachine(name, db) {
+  const d = db || getDatabase();
+  const row = d.query("SELECT * FROM machines WHERE name = ?").get(name);
+  if (!row)
+    throw new Error(`Machine '${name}' not found`);
+  if (row.archived_at)
+    throw new Error(`Cannot set archived machine '${name}' as primary`);
+  d.run("UPDATE machines SET is_primary = 0 WHERE archived_at IS NULL");
+  d.run("UPDATE machines SET is_primary = 1 WHERE id = ?", [row.id]);
+  return rowToMachine({ ...row, is_primary: 1 });
+}
 function deleteMachine(id, db) {
   const d = db || getDatabase();
   const row = d.query("SELECT * FROM machines WHERE id = ?").get(id);
@@ -1851,16 +2354,16 @@ __export(exports_database, {
   LOCK_EXPIRY_MINUTES: () => LOCK_EXPIRY_MINUTES
 });
 import { Database } from "bun:sqlite";
-import { existsSync, mkdirSync } from "fs";
-import { dirname, join, resolve } from "path";
+import { existsSync as existsSync2, mkdirSync } from "fs";
+import { dirname, join, resolve as resolve2 } from "path";
 function isInMemoryDb(path) {
   return path === ":memory:" || path.startsWith("file::memory:");
 }
 function findNearestTodosDb(startDir) {
-  let dir = resolve(startDir);
+  let dir = resolve2(startDir);
   while (true) {
     const candidate = join(dir, ".todos", "todos.db");
-    if (existsSync(candidate))
+    if (existsSync2(candidate))
       return candidate;
     const parent = dirname(dir);
     if (parent === dir)
@@ -1870,9 +2373,9 @@ function findNearestTodosDb(startDir) {
   return null;
 }
 function findGitRoot(startDir) {
-  let dir = resolve(startDir);
+  let dir = resolve2(startDir);
   while (true) {
-    if (existsSync(join(dir, ".git")))
+    if (existsSync2(join(dir, ".git")))
       return dir;
     const parent = dirname(dir);
     if (parent === dir)
@@ -1901,7 +2404,7 @@ function getDbPath() {
   const home = process.env["HOME"] || process.env["USERPROFILE"] || "~";
   const newPath = join(home, ".hasna", "todos", "todos.db");
   const legacyPath = join(home, ".todos", "todos.db");
-  if (!existsSync(newPath) && existsSync(legacyPath)) {
+  if (!existsSync2(newPath) && existsSync2(legacyPath)) {
     return legacyPath;
   }
   return newPath;
@@ -1912,8 +2415,8 @@ function getDatabasePath() {
 function ensureDir(filePath) {
   if (isInMemoryDb(filePath))
     return;
-  const dir = dirname(resolve(filePath));
-  if (!existsSync(dir)) {
+  const dir = dirname(resolve2(filePath));
+  if (!existsSync2(dir)) {
     mkdirSync(dir, { recursive: true });
   }
 }
@@ -1998,7 +2501,7 @@ var LOCK_EXPIRY_MINUTES = 30, _db = null, ALLOWED_TABLES;
 var init_database = __esm(() => {
   init_schema();
   init_machines();
-  ALLOWED_TABLES = new Set(["tasks", "projects", "agents", "plans", "task_lists", "task_templates"]);
+  ALLOWED_TABLES = new Set(["tasks", "projects", "agents", "plans", "task_lists", "task_templates", "project_knowledge_records", "project_risks", "local_retrospectives"]);
 });
 
 // src/db/task-crud.ts
@@ -2009,19 +2512,19 @@ init_database();
 init_types();
 
 // src/lib/config.ts
-import { existsSync as existsSync3 } from "fs";
+import { existsSync as existsSync4 } from "fs";
 import { dirname as dirname2, join as join3 } from "path";
 
 // src/lib/sync-utils.ts
-import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync, readdirSync, statSync, writeFileSync } from "fs";
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync, readdirSync, statSync, writeFileSync } from "fs";
 import { join as join2 } from "path";
 var HOME = process.env["HOME"] || process.env["USERPROFILE"] || "~";
 function ensureDir2(dir) {
-  if (!existsSync2(dir))
+  if (!existsSync3(dir))
     mkdirSync2(dir, { recursive: true });
 }
 function listJsonFiles(dir) {
-  if (!existsSync2(dir))
+  if (!existsSync3(dir))
     return [];
   return readdirSync(dir).filter((f) => f.endsWith(".json"));
 }
@@ -2038,7 +2541,7 @@ function writeJsonFile(path, data) {
 }
 function readHighWaterMark(dir) {
   const path = join2(dir, ".highwatermark");
-  if (!existsSync2(path))
+  if (!existsSync3(path))
     return 1;
   const val = parseInt(readFileSync(path, "utf-8").trim(), 10);
   return isNaN(val) ? 1 : val;
@@ -2072,7 +2575,7 @@ function getTodosGlobalDir() {
   const legacyDir = join3(home, ".todos");
   const newConfig = join3(newDir, "config.json");
   const legacyConfig = join3(legacyDir, "config.json");
-  if (!existsSync3(newConfig) && existsSync3(legacyConfig))
+  if (!existsSync4(newConfig) && existsSync4(legacyConfig))
     return legacyDir;
   return newDir;
 }
@@ -2086,7 +2589,7 @@ function normalizeAgent(agent) {
 function loadConfig() {
   if (cached)
     return cached;
-  if (!existsSync3(getConfigPath())) {
+  if (!existsSync4(getConfigPath())) {
     cached = {};
     return cached;
   }
@@ -2428,12 +2931,49 @@ function checkCompletionGuard(task, agentId, db, configOverride) {
 // src/lib/event-hooks.ts
 import { createHash, randomUUID } from "crypto";
 import { appendFileSync, mkdirSync as mkdirSync3 } from "fs";
-import { dirname as dirname3, resolve as resolve4 } from "path";
+import { dirname as dirname3, resolve as resolve5 } from "path";
 import { createConnection } from "net";
 
 // src/lib/redaction.ts
+var DEFAULT_SECRET_PATTERNS = [
+  { name: "aws-access-key", regex: /\b(AKIA|ASIA)[0-9A-Z]{16}\b/g, replacement: "[REDACTED_AWS_KEY]" },
+  { name: "private-key", regex: /-----BEGIN (?:RSA |EC |OPENSSH |)PRIVATE KEY-----[\s\S]*?-----END (?:RSA |EC |OPENSSH |)PRIVATE KEY-----/g, replacement: "[REDACTED_PRIVATE_KEY]" },
+  { name: "openai-token", regex: /\bsk-[A-Za-z0-9_-]{12,}\b/g, replacement: "[REDACTED_TOKEN]" },
+  { name: "env-secret-assignment", regex: /\b([A-Za-z0-9_]*(?:API_KEY|TOKEN|SECRET|PASSWORD)[A-Za-z0-9_]*)\s*=\s*['"]?[^'"\s]{8,}/gi, replacement: "$1=[REDACTED]" },
+  { name: "bearer-token", regex: /\b(bearer)\s+[A-Za-z0-9._~+/=-]{12,}/gi, replacement: "$1 [REDACTED]" }
+];
+var DEFAULT_SECRET_KEY_PATTERN = /api[_-]?key|token|secret|password/i;
+function unique(values) {
+  return Array.from(new Set((values || []).map((value) => value.trim()).filter(Boolean)));
+}
+function cloneRegex(regex) {
+  return new RegExp(regex.source, regex.flags.includes("g") ? regex.flags : `${regex.flags}g`);
+}
+function customPatterns() {
+  return unique(loadConfig().secret_safety?.redaction_patterns).flatMap((pattern) => {
+    try {
+      return [{ name: `custom:${pattern}`, regex: new RegExp(pattern, "g") }];
+    } catch {
+      return [];
+    }
+  });
+}
+function secretPatterns() {
+  return [...customPatterns(), ...DEFAULT_SECRET_PATTERNS];
+}
+function isSecretKey(key) {
+  if (DEFAULT_SECRET_KEY_PATTERN.test(key))
+    return true;
+  return unique(loadConfig().secret_safety?.redaction_keys).some((pattern) => key.toLowerCase().includes(pattern.toLowerCase()));
+}
 function redactEvidenceText(value) {
-  return value.replace(/\b(AKIA|ASIA)[0-9A-Z]{16}\b/g, "[REDACTED_AWS_KEY]").replace(/-----BEGIN (?:RSA |EC |OPENSSH |)PRIVATE KEY-----[\s\S]*?-----END (?:RSA |EC |OPENSSH |)PRIVATE KEY-----/g, "[REDACTED_PRIVATE_KEY]").replace(/\bsk-[A-Za-z0-9_-]{12,}\b/g, "[REDACTED_TOKEN]").replace(/\b([A-Za-z0-9_]*(?:API_KEY|TOKEN|SECRET|PASSWORD)[A-Za-z0-9_]*)\s*=\s*['"]?[^'"\s]{8,}/gi, "$1=[REDACTED]").replace(/\b(bearer)\s+[A-Za-z0-9._~+/=-]{12,}/gi, "$1 [REDACTED]");
+  let redacted = value;
+  for (const pattern of secretPatterns()) {
+    const regex = cloneRegex(pattern.regex);
+    const replacement = pattern.replacement ?? "[REDACTED]";
+    redacted = typeof replacement === "string" ? redacted.replace(regex, replacement) : redacted.replace(regex, replacement);
+  }
+  return redacted;
 }
 function redactValue(value) {
   if (typeof value === "string")
@@ -2443,7 +2983,7 @@ function redactValue(value) {
   if (value && typeof value === "object") {
     const redacted = {};
     for (const [key, child] of Object.entries(value)) {
-      if (/api[_-]?key|token|secret|password/i.test(key)) {
+      if (isSecretKey(key)) {
         redacted[key] = "[REDACTED]";
       } else {
         redacted[key] = redactValue(child);
@@ -2453,12 +2993,39 @@ function redactValue(value) {
   }
   return value;
 }
+function listSecretFindings(value) {
+  const findings = [];
+  for (const pattern of secretPatterns()) {
+    const matches = value.match(cloneRegex(pattern.regex));
+    if (matches?.length)
+      findings.push({ pattern: pattern.name, count: matches.length });
+  }
+  return findings;
+}
+function hasSecretFindings(value) {
+  return listSecretFindings(value).length > 0;
+}
+function getSecretSafetyConfig() {
+  return {
+    redaction_patterns: unique(loadConfig().secret_safety?.redaction_patterns),
+    redaction_keys: unique(loadConfig().secret_safety?.redaction_keys)
+  };
+}
+function upsertSecretSafetyConfig(input) {
+  const config = loadConfig();
+  const next = {
+    redaction_patterns: unique([...config.secret_safety?.redaction_patterns || [], ...input.redaction_patterns || []]),
+    redaction_keys: unique([...config.secret_safety?.redaction_keys || [], ...input.redaction_keys || []])
+  };
+  saveConfig({ ...config, secret_safety: next });
+  return next;
+}
 
 // src/lib/runner-sandbox.ts
-import { relative as relative2, resolve as resolve3 } from "path";
+import { relative as relative2, resolve as resolve4 } from "path";
 
 // src/lib/workspace-trust.ts
-import { relative, resolve as resolve2 } from "path";
+import { relative, resolve as resolve3 } from "path";
 var DEFAULT_DENYLIST = ["rm -rf", "mkfs", "dd if=", "curl | sh", "wget | sh"];
 var DEFAULT_ENV_REDACTIONS = ["API_KEY", "TOKEN", "SECRET", "PASSWORD", "AUTH"];
 var PRESET_DEFAULTS = {
@@ -2504,9 +3071,9 @@ var PRESET_DEFAULTS = {
   }
 };
 function normalizePath(path) {
-  return resolve2(path);
+  return resolve3(path);
 }
-function unique(values) {
+function unique2(values) {
   return Array.from(new Set((values || []).map((value) => value.trim()).filter(Boolean)));
 }
 function defaultProfile(root, preset) {
@@ -2566,11 +3133,11 @@ function upsertWorkspaceTrustProfile(input) {
     root,
     preset,
     trusted: input.trusted ?? base.trusted ?? PRESET_DEFAULTS[preset].trusted,
-    command_allowlist: unique(input.command_allowlist ?? base.command_allowlist ?? PRESET_DEFAULTS[preset].command_allowlist),
-    command_denylist: unique(input.command_denylist ?? base.command_denylist ?? PRESET_DEFAULTS[preset].command_denylist),
-    tool_permissions: unique(input.tool_permissions ?? base.tool_permissions ?? PRESET_DEFAULTS[preset].tool_permissions),
-    write_scopes: unique(input.write_scopes ?? base.write_scopes ?? PRESET_DEFAULTS[preset].write_scopes),
-    env_redactions: unique(input.env_redactions ?? base.env_redactions ?? PRESET_DEFAULTS[preset].env_redactions),
+    command_allowlist: unique2(input.command_allowlist ?? base.command_allowlist ?? PRESET_DEFAULTS[preset].command_allowlist),
+    command_denylist: unique2(input.command_denylist ?? base.command_denylist ?? PRESET_DEFAULTS[preset].command_denylist),
+    tool_permissions: unique2(input.tool_permissions ?? base.tool_permissions ?? PRESET_DEFAULTS[preset].tool_permissions),
+    write_scopes: unique2(input.write_scopes ?? base.write_scopes ?? PRESET_DEFAULTS[preset].write_scopes),
+    env_redactions: unique2(input.env_redactions ?? base.env_redactions ?? PRESET_DEFAULTS[preset].env_redactions),
     require_prompt_for_unsafe: input.require_prompt_for_unsafe ?? base.require_prompt_for_unsafe ?? PRESET_DEFAULTS[preset].require_prompt_for_unsafe,
     created_at: existing?.created_at || timestamp,
     updated_at: timestamp
@@ -2604,7 +3171,7 @@ function writeAllowed(profile, root, writePath) {
 function redactedEnvKeys(profile, env) {
   if (!env)
     return [];
-  const patterns = unique([...DEFAULT_ENV_REDACTIONS, ...profile.env_redactions]).map((item) => item.toUpperCase());
+  const patterns = unique2([...DEFAULT_ENV_REDACTIONS, ...profile.env_redactions]).map((item) => item.toUpperCase());
   return Object.keys(env).filter((key) => patterns.some((pattern) => key.toUpperCase().includes(pattern)));
 }
 function checkWorkspacePermission(input = {}) {
@@ -2641,9 +3208,9 @@ function checkWorkspacePermission(input = {}) {
 var DEFAULT_COMMAND_DENYLIST = ["rm -rf", "mkfs", "dd if=", "curl | sh", "wget | sh"];
 var DEFAULT_ENV_REDACTIONS2 = ["API_KEY", "TOKEN", "SECRET", "PASSWORD", "AUTH"];
 function normalizePath2(path) {
-  return resolve3(path);
+  return resolve4(path);
 }
-function unique2(values) {
+function unique3(values) {
   return Array.from(new Set((values || []).map((value) => value.trim()).filter(Boolean)));
 }
 function configuredProfiles2(config = loadConfig()) {
@@ -2699,7 +3266,7 @@ function profileByName(name, path) {
 function redactedEnvKeys2(profile, env) {
   if (!env)
     return [];
-  const patterns = unique2([...DEFAULT_ENV_REDACTIONS2, ...profile.env_redactions]).map((item) => item.toUpperCase());
+  const patterns = unique3([...DEFAULT_ENV_REDACTIONS2, ...profile.env_redactions]).map((item) => item.toUpperCase());
   return Object.keys(env).filter((key) => patterns.some((pattern) => key.toUpperCase().includes(pattern)));
 }
 function omittedEnvKeys(profile, env) {
@@ -2732,12 +3299,12 @@ function upsertRunnerSandboxProfile(input) {
     ...base,
     name: input.name,
     root,
-    command_allowlist: unique2(input.command_allowlist ?? base.command_allowlist),
-    command_denylist: unique2(input.command_denylist ?? base.command_denylist),
+    command_allowlist: unique3(input.command_allowlist ?? base.command_allowlist),
+    command_denylist: unique3(input.command_denylist ?? base.command_denylist),
     cwd_boundary: normalizePath2(input.cwd_boundary || base.cwd_boundary || root),
-    write_scopes: unique2(input.write_scopes ?? base.write_scopes),
-    env_allowlist: unique2(input.env_allowlist ?? base.env_allowlist),
-    env_redactions: unique2(input.env_redactions ?? base.env_redactions),
+    write_scopes: unique3(input.write_scopes ?? base.write_scopes),
+    env_allowlist: unique3(input.env_allowlist ?? base.env_allowlist),
+    env_redactions: unique3(input.env_redactions ?? base.env_redactions),
     network_policy: input.network_policy || base.network_policy,
     require_approval: input.require_approval ?? base.require_approval,
     audit_evidence: input.audit_evidence ?? base.audit_evidence,
@@ -2797,7 +3364,7 @@ function checkRunnerSandbox(input = {}) {
   const redacted = redactedEnvKeys2(profile, input.env);
   const omitted = omittedEnvKeys(profile, input.env);
   const effective = Object.keys(input.env || {}).filter((key) => !omitted.includes(key));
-  const uniqueReasons = unique2(reasons);
+  const uniqueReasons = unique3(reasons);
   const allowed = uniqueReasons.length === 0;
   return {
     allowed,
@@ -2830,9 +3397,14 @@ var LOCAL_EVENT_TYPES = [
   "task.blocked",
   "task.started",
   "task.completed",
+  "task.due",
+  "task.due_soon",
   "task.failed",
+  "task.sla_breached",
+  "task.stale",
   "task.unblocked",
   "task.status_changed",
+  "calendar.reminder",
   "plan.updated",
   "run.started",
   "run.completed",
@@ -2979,7 +3551,7 @@ async function deliverHook(hook, envelope) {
       if (hook.target === "stdout") {
         output = line.trim();
       } else if (hook.target === "file") {
-        const filePath = resolve4(hook.file_path);
+        const filePath = resolve5(hook.file_path);
         mkdirSync3(dirname3(filePath), { recursive: true });
         appendFileSync(filePath, line);
       } else if (hook.target === "socket") {
@@ -3414,8 +3986,8 @@ function createTask(input, db) {
   let id = uuid();
   for (let attempt = 0;attempt < 3; attempt++) {
     try {
-      d.run(`INSERT INTO tasks (id, short_id, project_id, parent_id, plan_id, task_list_id, cycle_id, title, description, status, priority, agent_id, assigned_to, session_id, working_dir, tags, metadata, version, created_at, updated_at, due_at, estimated_minutes, confidence, retry_count, max_retries, retry_after, requires_approval, approved_by, approved_at, recurrence_rule, recurrence_parent_id, spawns_template_id, reason, spawned_from_session, assigned_by, assigned_from_project, task_type)
-         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+      d.run(`INSERT INTO tasks (id, short_id, project_id, parent_id, plan_id, task_list_id, cycle_id, title, description, status, priority, agent_id, assigned_to, session_id, working_dir, tags, metadata, version, created_at, updated_at, due_at, estimated_minutes, sla_minutes, confidence, retry_count, max_retries, retry_after, requires_approval, approved_by, approved_at, recurrence_rule, recurrence_parent_id, spawns_template_id, reason, spawned_from_session, assigned_by, assigned_from_project, task_type)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
         id,
         null,
         input.project_id || null,
@@ -3437,6 +4009,7 @@ function createTask(input, db) {
         timestamp,
         input.due_at || null,
         input.estimated_minutes || null,
+        input.sla_minutes ?? null,
         input.confidence ?? null,
         input.retry_count ?? 0,
         input.max_retries ?? 3,
@@ -3744,6 +4317,10 @@ function updateTask(id, input, db) {
     sets.push("estimated_minutes = ?");
     params.push(input.estimated_minutes);
   }
+  if (input.sla_minutes !== undefined) {
+    sets.push("sla_minutes = ?");
+    params.push(input.sla_minutes);
+  }
   if (input.actual_minutes !== undefined) {
     sets.push("actual_minutes = ?");
     params.push(input.actual_minutes);
@@ -3825,6 +4402,7 @@ function updateTask(id, input, db) {
     version: task.version + 1,
     updated_at: timestamp,
     completed_at: input.status === "completed" ? completionTimestamp : input.completed_at !== undefined ? input.completed_at : task.completed_at,
+    sla_minutes: input.sla_minutes !== undefined ? input.sla_minutes : task.sla_minutes,
     actual_minutes: input.actual_minutes ?? task.actual_minutes,
     confidence: input.confidence !== undefined ? input.confidence : task.confidence,
     retry_count: input.retry_count ?? task.retry_count,
@@ -4608,7 +5186,7 @@ function completeTask(id, agentId, db, options) {
   emitLocalEventHooksQuiet({ type: "task.completed", payload: { id, agent_id: agentId, title: task.title, completed_at: timestamp } });
   let spawnedTask = null;
   if (task.recurrence_rule && !options?.skip_recurrence) {
-    spawnedTask = spawnNextRecurrence(task, d);
+    spawnedTask = spawnNextRecurrence(task, d, timestamp);
   }
   let spawnedFromTemplate = null;
   if (task.spawns_template_id) {
@@ -4938,8 +5516,9 @@ function claimOrSteal(agentId, filters, db) {
   });
   return tx();
 }
-function spawnNextRecurrence(completedTask, db) {
-  const dueAt = nextOccurrence(completedTask.recurrence_rule, new Date);
+function spawnNextRecurrence(completedTask, db, completedAt) {
+  const recurrenceBase = completedTask.due_at ? new Date(completedTask.due_at) : new Date(completedAt);
+  const dueAt = nextOccurrence(completedTask.recurrence_rule, recurrenceBase);
   let title = completedTask.title;
   if (completedTask.short_id && title.startsWith(completedTask.short_id + ": ")) {
     title = title.slice(completedTask.short_id.length + 2);
@@ -4956,6 +5535,7 @@ function spawnNextRecurrence(completedTask, db) {
     tags: completedTask.tags,
     metadata: completedTask.metadata,
     estimated_minutes: completedTask.estimated_minutes ?? undefined,
+    sla_minutes: completedTask.sla_minutes ?? undefined,
     recurrence_rule: completedTask.recurrence_rule,
     recurrence_parent_id: recurrenceParentId,
     due_at: dueAt
@@ -5208,10 +5788,10 @@ function unarchiveTask(id, db) {
   d.run("UPDATE tasks SET archived_at = NULL WHERE id = ?", [id]);
   return getTask(id, d);
 }
-function getOverdueTasks(projectId, db) {
+function getOverdueTasks(projectId, db, at = new Date) {
   const d = db || getDatabase();
-  const nowStr = new Date().toISOString();
-  let query = `SELECT * FROM tasks WHERE due_at IS NOT NULL AND due_at < ? AND status NOT IN ('completed', 'cancelled', 'failed')`;
+  const nowStr = at.toISOString();
+  let query = `SELECT * FROM tasks WHERE archived_at IS NULL AND due_at IS NOT NULL AND due_at < ? AND status NOT IN ('completed', 'cancelled', 'failed')`;
   const params = [nowStr];
   if (projectId) {
     query += ` AND project_id = ?`;
@@ -5221,21 +5801,298 @@ function getOverdueTasks(projectId, db) {
   const rows = d.query(query).all(...params);
   return rows.map(rowToTask);
 }
-function logCost(taskId, tokens, usd, db) {
+function getEscalatedTasks(opts = {}, db, at = new Date) {
   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]);
+  const nowMs = at.getTime();
+  const conditions = [
+    "archived_at IS NULL",
+    "status NOT IN ('completed', 'cancelled', 'failed')",
+    "(due_at IS NOT NULL OR sla_minutes IS NOT NULL)"
+  ];
+  const params = [];
+  if (opts.project_id) {
+    conditions.push("project_id = ?");
+    params.push(opts.project_id);
+  }
+  if (opts.agent_id) {
+    conditions.push("assigned_to = ?");
+    params.push(opts.agent_id);
+  }
+  const rows = d.query(`SELECT * FROM tasks WHERE ${conditions.join(" AND ")} ORDER BY due_at ASC, created_at ASC`).all(...params);
+  return rows.map(rowToTask).map((task) => {
+    const reasons = [];
+    const breachedTimes = [];
+    if (task.due_at) {
+      const dueMs = new Date(task.due_at).getTime();
+      if (Number.isFinite(dueMs) && dueMs < nowMs) {
+        reasons.push("overdue");
+        breachedTimes.push(dueMs);
+      }
+    }
+    if (task.sla_minutes != null) {
+      const startMs = new Date(task.started_at ?? task.created_at).getTime();
+      const breachedMs = startMs + task.sla_minutes * 60000;
+      if (Number.isFinite(breachedMs) && breachedMs < nowMs) {
+        reasons.push("sla_breached");
+        breachedTimes.push(breachedMs);
+      }
+    }
+    if (reasons.length === 0)
+      return null;
+    return {
+      task,
+      reasons,
+      breached_at: new Date(Math.min(...breachedTimes)).toISOString()
+    };
+  }).filter((item) => item !== null);
 }
-// src/db/plans.ts
-init_types();
-init_database();
-function createPlan(input, db) {
+function rowToFocusSession(row) {
+  return {
+    ...row,
+    metadata: JSON.parse(row.metadata || "{}")
+  };
+}
+function minutesBetween(start, end) {
+  if (!start || !end)
+    return 0;
+  const startMs = Date.parse(start);
+  const endMs = Date.parse(end);
+  if (!Number.isFinite(startMs) || !Number.isFinite(endMs) || endMs <= startMs)
+    return 0;
+  return Math.max(1, Math.ceil((endMs - startMs) / 60000));
+}
+function assertPositiveMinutes(minutes) {
+  if (!Number.isFinite(minutes) || minutes < 1)
+    throw new Error("minutes must be a positive integer");
+  return Math.floor(minutes);
+}
+function recalculateTaskActualMinutes(taskId, db) {
+  const row = db.query("SELECT COALESCE(SUM(minutes), 0) as total FROM task_time_logs WHERE task_id = ?").get(taskId);
+  const total = Number(row.total || 0);
+  db.run("UPDATE tasks SET actual_minutes = ?, updated_at = ? WHERE id = ?", [total, now(), taskId]);
+  return total;
+}
+function logTime(input, db) {
   const d = db || getDatabase();
+  if (!getTask(input.task_id, d))
+    throw new Error(`Task not found: ${input.task_id}`);
   const id = uuid();
-  const timestamp = now();
-  d.run(`INSERT INTO plans (id, project_id, task_list_id, agent_id, name, description, status, created_at, updated_at)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+  const ts = now();
+  const minutes = assertPositiveMinutes(input.minutes);
+  d.run(`INSERT INTO task_time_logs (id, task_id, run_id, focus_session_id, agent_id, minutes, started_at, ended_at, notes, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [id, input.task_id, input.run_id || null, input.focus_session_id || null, input.agent_id || null, minutes, input.started_at || null, input.ended_at || null, input.notes || null, ts]);
+  recalculateTaskActualMinutes(input.task_id, d);
+  return {
     id,
-    input.project_id || null,
+    task_id: input.task_id,
+    run_id: input.run_id || null,
+    focus_session_id: input.focus_session_id || null,
+    agent_id: input.agent_id || null,
+    minutes,
+    started_at: input.started_at || null,
+    ended_at: input.ended_at || null,
+    notes: input.notes || null,
+    created_at: ts
+  };
+}
+function getTimeLogs(taskId, db) {
+  const d = db || getDatabase();
+  return d.query(`SELECT * FROM task_time_logs WHERE task_id = ? ORDER BY created_at DESC`).all(taskId);
+}
+function startFocusSession(input, db) {
+  const d = db || getDatabase();
+  if (input.task_id && !getTask(input.task_id, d))
+    throw new Error(`Task not found: ${input.task_id}`);
+  const id = uuid();
+  const ts = now();
+  const startedAt = input.started_at || ts;
+  d.run(`INSERT INTO focus_sessions (
+      id, task_id, plan_id, run_id, agent_id, title, status, started_at, last_resumed_at,
+      actual_minutes, idle_after_minutes, notes, metadata, created_at, updated_at
+    ) VALUES (?, ?, ?, ?, ?, ?, 'active', ?, ?, 0, ?, ?, ?, ?, ?)`, [
+    id,
+    input.task_id || null,
+    input.plan_id || null,
+    input.run_id || null,
+    input.agent_id || null,
+    input.title || null,
+    startedAt,
+    startedAt,
+    input.idle_after_minutes ?? null,
+    input.notes || null,
+    JSON.stringify(input.metadata || {}),
+    ts,
+    ts
+  ]);
+  return getFocusSession(id, d);
+}
+function getFocusSession(id, db) {
+  const d = db || getDatabase();
+  const row = d.query("SELECT * FROM focus_sessions WHERE id = ?").get(id);
+  return row ? rowToFocusSession(row) : null;
+}
+function listFocusSessions(query = {}, db) {
+  const d = db || getDatabase();
+  const conditions = [];
+  const params = [];
+  if (query.task_id) {
+    conditions.push("task_id = ?");
+    params.push(query.task_id);
+  }
+  if (query.plan_id) {
+    conditions.push("plan_id = ?");
+    params.push(query.plan_id);
+  }
+  if (query.run_id) {
+    conditions.push("run_id = ?");
+    params.push(query.run_id);
+  }
+  if (query.agent_id) {
+    conditions.push("agent_id = ?");
+    params.push(query.agent_id);
+  }
+  if (query.status) {
+    conditions.push("status = ?");
+    params.push(query.status);
+  } else if (!query.include_completed) {
+    conditions.push("status IN ('active', 'paused')");
+  }
+  let sql = "SELECT * FROM focus_sessions";
+  if (conditions.length > 0)
+    sql += ` WHERE ${conditions.join(" AND ")}`;
+  sql += " ORDER BY updated_at DESC";
+  if (query.limit) {
+    sql += " LIMIT ?";
+    params.push(query.limit);
+  }
+  return d.query(sql).all(...params).map(rowToFocusSession);
+}
+function pauseFocusSession(id, pausedAt, db) {
+  const d = db || getDatabase();
+  const session = getFocusSession(id, d);
+  if (!session)
+    throw new Error(`Focus session not found: ${id}`);
+  if (session.status !== "active")
+    throw new Error(`Focus session is ${session.status}, not active`);
+  const ts = now();
+  const pauseAt = pausedAt || ts;
+  const minutes = session.actual_minutes + minutesBetween(session.last_resumed_at, pauseAt);
+  d.run("UPDATE focus_sessions SET status = 'paused', actual_minutes = ?, paused_at = ?, last_resumed_at = NULL, updated_at = ? WHERE id = ?", [minutes, pauseAt, ts, id]);
+  return getFocusSession(id, d);
+}
+function resumeFocusSession(id, resumedAt, db) {
+  const d = db || getDatabase();
+  const session = getFocusSession(id, d);
+  if (!session)
+    throw new Error(`Focus session not found: ${id}`);
+  if (session.status !== "paused")
+    throw new Error(`Focus session is ${session.status}, not paused`);
+  const ts = now();
+  const resumed = resumedAt || ts;
+  d.run("UPDATE focus_sessions SET status = 'active', paused_at = NULL, last_resumed_at = ?, updated_at = ? WHERE id = ?", [resumed, ts, id]);
+  return getFocusSession(id, d);
+}
+function stopFocusSession(input, db) {
+  const d = db || getDatabase();
+  const session = getFocusSession(input.id, d);
+  if (!session)
+    throw new Error(`Focus session not found: ${input.id}`);
+  if (session.status === "completed" || session.status === "cancelled")
+    return session;
+  const ts = now();
+  const endedAt = input.ended_at || ts;
+  const finalMinutes = session.status === "active" ? session.actual_minutes + minutesBetween(session.last_resumed_at, endedAt) : session.actual_minutes;
+  const finalStatus = input.status || "completed";
+  d.run("UPDATE focus_sessions SET status = ?, actual_minutes = ?, ended_at = ?, last_resumed_at = NULL, paused_at = NULL, notes = COALESCE(?, notes), updated_at = ? WHERE id = ?", [finalStatus, finalMinutes, endedAt, input.notes || null, ts, input.id]);
+  const stopped = getFocusSession(input.id, d);
+  if (stopped.task_id && finalStatus === "completed" && finalMinutes > 0) {
+    logTime({
+      task_id: stopped.task_id,
+      run_id: stopped.run_id || undefined,
+      focus_session_id: stopped.id,
+      agent_id: stopped.agent_id || undefined,
+      minutes: finalMinutes,
+      started_at: stopped.started_at,
+      ended_at: stopped.ended_at || endedAt,
+      notes: input.notes || stopped.notes || undefined
+    }, d);
+  }
+  return stopped;
+}
+function getIdleFocusSessionPrompts(opts = {}, db) {
+  const d = db || getDatabase();
+  const nowDate = opts.now ? new Date(opts.now) : new Date;
+  const sessions = listFocusSessions({ agent_id: opts.agent_id, status: "active", include_completed: false }, d);
+  return sessions.flatMap((session) => {
+    if (!session.idle_after_minutes || !session.last_resumed_at)
+      return [];
+    const idleMinutes = Math.floor((nowDate.getTime() - Date.parse(session.last_resumed_at)) / 60000);
+    if (!Number.isFinite(idleMinutes) || idleMinutes < session.idle_after_minutes)
+      return [];
+    return [{
+      session,
+      idle_minutes: idleMinutes,
+      message: `Focus session ${session.id.slice(0, 8)} has been active for ${idleMinutes} minutes. Pause, stop, or continue it.`
+    }];
+  });
+}
+function getTimeReport(opts, db) {
+  const d = db || getDatabase();
+  const conditions = opts?.include_open ? ["1 = 1"] : ["t.status = 'completed'"];
+  const params = [];
+  if (opts?.project_id) {
+    conditions.push("t.project_id = ?");
+    params.push(opts.project_id);
+  }
+  if (opts?.plan_id) {
+    conditions.push("t.plan_id = ?");
+    params.push(opts.plan_id);
+  }
+  if (opts?.agent_id) {
+    conditions.push(`(
+      t.assigned_to = ?
+      OR t.agent_id = ?
+      OR EXISTS (SELECT 1 FROM task_time_logs ttl WHERE ttl.task_id = t.id AND ttl.agent_id = ?)
+      OR EXISTS (SELECT 1 FROM focus_sessions fs WHERE fs.task_id = t.id AND fs.agent_id = ?)
+    )`);
+    params.push(opts.agent_id, opts.agent_id, opts.agent_id, opts.agent_id);
+  }
+  if (opts?.since) {
+    conditions.push("(t.completed_at >= ? OR t.updated_at >= ?)");
+    params.push(opts.since, opts.since);
+  }
+  const rows = d.query(`
+    SELECT t.id as task_id, t.title, t.project_id, t.plan_id, t.estimated_minutes, t.actual_minutes
+    FROM tasks t
+    WHERE ${conditions.join(" AND ")}
+    ORDER BY t.completed_at DESC, t.updated_at DESC
+  `).all(...params);
+  return rows.map((row) => {
+    const timeLogs = getTimeLogs(row.task_id, d);
+    const focusSessions = listFocusSessions({ task_id: row.task_id, include_completed: true }, d);
+    const loggedMinutes = timeLogs.reduce((acc, log) => acc + log.minutes, 0);
+    const focusMinutes = focusSessions.reduce((acc, session) => acc + session.actual_minutes, 0);
+    return { ...row, logged_minutes: loggedMinutes, focus_minutes: focusMinutes, time_logs: timeLogs, focus_sessions: focusSessions };
+  });
+}
+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]);
+}
+// src/db/boards.ts
+init_database();
+
+// src/db/plans.ts
+init_types();
+init_database();
+function createPlan(input, db) {
+  const d = db || getDatabase();
+  const id = uuid();
+  const timestamp = now();
+  d.run(`INSERT INTO plans (id, project_id, task_list_id, agent_id, name, description, status, created_at, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+    id,
+    input.project_id || null,
     input.task_list_id || null,
     input.agent_id || null,
     input.name,
@@ -5244,62 +6101,1459 @@ function createPlan(input, db) {
     timestamp,
     timestamp
   ]);
-  return getPlan(id, d);
+  return getPlan(id, d);
+}
+function getPlan(id, db) {
+  const d = db || getDatabase();
+  const row = d.query("SELECT * FROM plans WHERE id = ?").get(id);
+  return row;
+}
+function listPlans(projectId, db) {
+  const d = db || getDatabase();
+  if (projectId) {
+    return d.query("SELECT * FROM plans WHERE project_id = ? ORDER BY created_at DESC").all(projectId);
+  }
+  return d.query("SELECT * FROM plans ORDER BY created_at DESC").all();
+}
+function updatePlan(id, input, db) {
+  const d = db || getDatabase();
+  const plan = getPlan(id, d);
+  if (!plan)
+    throw new PlanNotFoundError(id);
+  const sets = ["updated_at = ?"];
+  const params = [now()];
+  if (input.name !== undefined) {
+    sets.push("name = ?");
+    params.push(input.name);
+  }
+  if (input.description !== undefined) {
+    sets.push("description = ?");
+    params.push(input.description);
+  }
+  if (input.status !== undefined) {
+    sets.push("status = ?");
+    params.push(input.status);
+  }
+  if (input.task_list_id !== undefined) {
+    sets.push("task_list_id = ?");
+    params.push(input.task_list_id);
+  }
+  if (input.agent_id !== undefined) {
+    sets.push("agent_id = ?");
+    params.push(input.agent_id);
+  }
+  params.push(id);
+  d.run(`UPDATE plans SET ${sets.join(", ")} WHERE id = ?`, params);
+  const updated = getPlan(id, d);
+  emitLocalEventHooksQuiet({
+    type: "plan.updated",
+    payload: { id, old_status: plan.status, new_status: updated.status, name: updated.name, project_id: updated.project_id }
+  });
+  return updated;
+}
+function deletePlan(id, db) {
+  const d = db || getDatabase();
+  const result = d.run("DELETE FROM plans WHERE id = ?", [id]);
+  return result.changes > 0;
+}
+
+// src/db/boards.ts
+var TASK_LANES = [
+  { id: "ready", name: "Ready", statuses: ["pending"], wip_limit: null, position: 0 },
+  { id: "doing", name: "Doing", statuses: ["in_progress"], wip_limit: 3, position: 1 },
+  { id: "review", name: "Review", statuses: ["failed"], wip_limit: 5, position: 2 },
+  { id: "done", name: "Done", statuses: ["completed"], wip_limit: null, position: 3 },
+  { id: "cancelled", name: "Cancelled", statuses: ["cancelled"], wip_limit: null, position: 4 }
+];
+var PLAN_LANES = [
+  { id: "active", name: "Active", statuses: ["active"], wip_limit: 3, position: 0 },
+  { id: "completed", name: "Completed", statuses: ["completed"], wip_limit: null, position: 1 },
+  { id: "archived", name: "Archived", statuses: ["archived"], wip_limit: null, position: 2 }
+];
+function parseJsonObject(value) {
+  if (!value)
+    return {};
+  if (typeof value === "object" && !Array.isArray(value))
+    return value;
+  if (typeof value !== "string")
+    return {};
+  try {
+    const parsed = JSON.parse(value);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function parseJsonArray(value) {
+  if (Array.isArray(value))
+    return value;
+  if (typeof value !== "string")
+    return [];
+  try {
+    const parsed = JSON.parse(value);
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+function defaultLanes(scope) {
+  return (scope === "plans" ? PLAN_LANES : TASK_LANES).map((lane) => ({ ...lane, statuses: [...lane.statuses] }));
+}
+function normalizeLanes(scope, lanes) {
+  const source = lanes && lanes.length > 0 ? lanes : defaultLanes(scope);
+  return source.map((lane, index) => ({
+    id: lane.id || lane.name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") || `lane-${index + 1}`,
+    name: lane.name || lane.id || `Lane ${index + 1}`,
+    statuses: Array.from(new Set((lane.statuses || []).map(String).filter(Boolean))),
+    wip_limit: lane.wip_limit === undefined ? null : lane.wip_limit,
+    position: lane.position ?? index
+  })).filter((lane) => lane.statuses.length > 0).sort((a, b) => a.position - b.position);
+}
+function rowToTaskBoard(row) {
+  return {
+    ...row,
+    lanes: normalizeLanes(row.scope, parseJsonArray(row.lanes)),
+    filters: parseJsonObject(row.filters)
+  };
+}
+function maybeFilter(value) {
+  return value === undefined || value === null || value === "" ? undefined : value;
+}
+function createTaskBoard(input, db) {
+  const d = db || getDatabase();
+  const id = uuid();
+  const timestamp = now();
+  const scope = input.scope || "tasks";
+  const lanes = normalizeLanes(scope, input.lanes);
+  d.run(`INSERT INTO task_boards (id, name, scope, project_id, task_list_id, plan_id, agent_id, lanes, filters, created_at, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+    id,
+    input.name,
+    scope,
+    input.project_id || null,
+    input.task_list_id || null,
+    input.plan_id || null,
+    input.agent_id || null,
+    JSON.stringify(lanes),
+    JSON.stringify(input.filters || {}),
+    timestamp,
+    timestamp
+  ]);
+  return getTaskBoard(id, d);
+}
+function getTaskBoard(idOrName, db) {
+  const d = db || getDatabase();
+  const row = d.query("SELECT * FROM task_boards WHERE id = ? OR name = ?").get(idOrName, idOrName);
+  return row ? rowToTaskBoard(row) : null;
+}
+function listTaskBoards(query = {}, db) {
+  const d = db || getDatabase();
+  const conditions = [];
+  const params = [];
+  if (query.scope) {
+    conditions.push("scope = ?");
+    params.push(query.scope);
+  }
+  if (query.project_id) {
+    conditions.push("project_id = ?");
+    params.push(query.project_id);
+  }
+  if (query.task_list_id) {
+    conditions.push("task_list_id = ?");
+    params.push(query.task_list_id);
+  }
+  if (query.plan_id) {
+    conditions.push("plan_id = ?");
+    params.push(query.plan_id);
+  }
+  if (query.agent_id) {
+    conditions.push("agent_id = ?");
+    params.push(query.agent_id);
+  }
+  let sql = "SELECT * FROM task_boards";
+  if (conditions.length > 0)
+    sql += ` WHERE ${conditions.join(" AND ")}`;
+  sql += " ORDER BY updated_at DESC, name";
+  if (query.limit) {
+    sql += " LIMIT ?";
+    params.push(query.limit);
+  }
+  return d.query(sql).all(...params).map(rowToTaskBoard);
+}
+function updateTaskBoard(idOrName, input, db) {
+  const d = db || getDatabase();
+  const board = getTaskBoard(idOrName, d);
+  if (!board)
+    throw new Error(`Board not found: ${idOrName}`);
+  const sets = ["updated_at = ?"];
+  const params = [now()];
+  if (input.name !== undefined) {
+    sets.push("name = ?");
+    params.push(input.name);
+  }
+  if (input.project_id !== undefined) {
+    sets.push("project_id = ?");
+    params.push(input.project_id);
+  }
+  if (input.task_list_id !== undefined) {
+    sets.push("task_list_id = ?");
+    params.push(input.task_list_id);
+  }
+  if (input.plan_id !== undefined) {
+    sets.push("plan_id = ?");
+    params.push(input.plan_id);
+  }
+  if (input.agent_id !== undefined) {
+    sets.push("agent_id = ?");
+    params.push(input.agent_id);
+  }
+  if (input.lanes !== undefined) {
+    sets.push("lanes = ?");
+    params.push(JSON.stringify(normalizeLanes(board.scope, input.lanes)));
+  }
+  if (input.filters !== undefined) {
+    sets.push("filters = ?");
+    params.push(JSON.stringify(input.filters));
+  }
+  params.push(board.id);
+  d.run(`UPDATE task_boards SET ${sets.join(", ")} WHERE id = ?`, params);
+  return getTaskBoard(board.id, d);
+}
+function deleteTaskBoard(idOrName, db) {
+  const d = db || getDatabase();
+  const board = getTaskBoard(idOrName, d);
+  if (!board)
+    return false;
+  return d.run("DELETE FROM task_boards WHERE id = ?", [board.id]).changes > 0;
+}
+function incompleteDependencyCount(taskId, db) {
+  const row = db.query(`SELECT COUNT(*) as count
+      FROM task_dependencies td
+      JOIN tasks dep ON dep.id = td.depends_on
+      WHERE td.task_id = ? AND dep.status NOT IN ('completed', 'cancelled')`).get(taskId);
+  return row.count;
+}
+function taskToCard(task, db) {
+  const blockedCount = incompleteDependencyCount(task.id, db);
+  const blocked = blockedCount > 0;
+  const badges = [task.priority];
+  if (blocked)
+    badges.push("blocked");
+  if (!blocked && task.status === "pending")
+    badges.push("ready");
+  if (task.assigned_to)
+    badges.push(`@${task.assigned_to}`);
+  if (task.due_at && Date.parse(task.due_at) < Date.now() && !["completed", "cancelled", "failed"].includes(task.status)) {
+    badges.push("overdue");
+  }
+  return {
+    id: task.id,
+    short_id: task.short_id,
+    title: task.title,
+    status: task.status,
+    priority: task.priority,
+    project_id: task.project_id,
+    plan_id: task.plan_id,
+    task_list_id: task.task_list_id,
+    assigned_to: task.assigned_to,
+    blocked,
+    ready: !blocked && task.status === "pending",
+    badges,
+    updated_at: task.updated_at
+  };
+}
+function planTaskStats(planId, db) {
+  const tasks = listTasks({ plan_id: planId, include_archived: true }, db);
+  let blocked = 0;
+  let ready = 0;
+  for (const task of tasks) {
+    const isBlocked = incompleteDependencyCount(task.id, db) > 0;
+    if (isBlocked)
+      blocked++;
+    if (!isBlocked && task.status === "pending")
+      ready++;
+  }
+  return {
+    total: tasks.length,
+    active: tasks.filter((task) => !["completed", "cancelled", "failed"].includes(task.status)).length,
+    blocked,
+    ready
+  };
+}
+function planToCard(plan, db) {
+  const stats = planTaskStats(plan.id, db);
+  const badges = [`tasks:${stats.total}`, `active:${stats.active}`];
+  if (stats.blocked > 0)
+    badges.push(`blocked:${stats.blocked}`);
+  if (stats.ready > 0)
+    badges.push(`ready:${stats.ready}`);
+  return {
+    id: plan.id,
+    short_id: null,
+    title: plan.name,
+    status: plan.status,
+    priority: null,
+    project_id: plan.project_id,
+    plan_id: plan.id,
+    task_list_id: plan.task_list_id,
+    assigned_to: plan.agent_id,
+    blocked: stats.blocked > 0,
+    ready: stats.ready > 0,
+    badges,
+    updated_at: plan.updated_at
+  };
+}
+function filteredTasks(board, db) {
+  const filters = board.filters;
+  return listTasks({
+    project_id: board.project_id || maybeFilter(filters.project_id),
+    task_list_id: board.task_list_id || maybeFilter(filters.task_list_id),
+    plan_id: board.plan_id || maybeFilter(filters.plan_id),
+    assigned_to: board.agent_id || maybeFilter(filters.assigned_to),
+    agent_id: maybeFilter(filters.agent_id),
+    priority: maybeFilter(filters.priority),
+    tags: Array.isArray(filters.tags) ? filters.tags.map(String) : undefined,
+    task_type: maybeFilter(filters.task_type),
+    include_archived: Boolean(filters.include_archived)
+  }, db);
+}
+function filteredPlans(board, db) {
+  return listPlans(board.project_id || undefined, db).filter((plan) => !board.task_list_id || plan.task_list_id === board.task_list_id).filter((plan) => !board.agent_id || plan.agent_id === board.agent_id);
+}
+function buildLaneSnapshots(board, cards) {
+  return board.lanes.map((lane) => {
+    const laneCards = cards.filter((card) => lane.statuses.includes(card.status));
+    return {
+      lane,
+      count: laneCards.length,
+      wip_limit: lane.wip_limit,
+      wip_exceeded: lane.wip_limit !== null && laneCards.length > lane.wip_limit,
+      cards: laneCards
+    };
+  });
+}
+function buildTaskBoardSnapshot(idOrBoard, db) {
+  const d = db || getDatabase();
+  const board = typeof idOrBoard === "string" ? getTaskBoard(idOrBoard, d) : idOrBoard;
+  if (!board)
+    throw new Error(`Board not found: ${idOrBoard}`);
+  const cards = board.scope === "plans" ? filteredPlans(board, d).map((plan) => planToCard(plan, d)) : filteredTasks(board, d).map((task) => taskToCard(task, d));
+  const lanes = buildLaneSnapshots(board, cards);
+  return {
+    board,
+    generated_at: now(),
+    lanes,
+    totals: {
+      cards: cards.length,
+      blocked: cards.filter((card) => card.blocked).length,
+      ready: cards.filter((card) => card.ready).length,
+      wip_exceeded_lanes: lanes.filter((lane) => lane.wip_exceeded).length
+    },
+    keyboard: {
+      move_left: "h",
+      move_right: "l",
+      move_up: "k",
+      move_down: "j",
+      open: "enter",
+      quit: "q"
+    }
+  };
+}
+function moveBoardCard(input, db) {
+  const d = db || getDatabase();
+  const board = getTaskBoard(input.board_id, d);
+  if (!board)
+    throw new Error(`Board not found: ${input.board_id}`);
+  const lane = input.lane_id ? board.lanes.find((candidate) => candidate.id === input.lane_id || candidate.name === input.lane_id) : null;
+  const status = input.status || lane?.statuses[0];
+  if (!status)
+    throw new Error("Target lane or status is required");
+  if (board.scope === "plans") {
+    const planId = resolvePartialId(d, "plans", input.card_id) || input.card_id;
+    const plan = updatePlan(planId, { status }, d);
+    return planToCard(plan, d);
+  }
+  const taskId = resolvePartialId(d, "tasks", input.card_id) || input.card_id;
+  const task = getTask(taskId, d);
+  if (!task)
+    throw new Error(`Task not found: ${input.card_id}`);
+  const updated = updateTask(task.id, { status, version: task.version }, d);
+  return taskToCard(updated, d);
+}
+function renderTaskBoard(snapshot) {
+  const lines = [
+    `${snapshot.board.name} (${snapshot.board.scope})`,
+    `cards:${snapshot.totals.cards} ready:${snapshot.totals.ready} blocked:${snapshot.totals.blocked} wip_exceeded:${snapshot.totals.wip_exceeded_lanes}`,
+    `keys: ${snapshot.keyboard.move_left}/${snapshot.keyboard.move_right} lane, ${snapshot.keyboard.move_up}/${snapshot.keyboard.move_down} card, ${snapshot.keyboard.open} open, ${snapshot.keyboard.quit} quit`,
+    ""
+  ];
+  for (const lane of snapshot.lanes) {
+    const limit = lane.wip_limit === null ? "" : ` / ${lane.wip_limit}`;
+    const marker = lane.wip_exceeded ? " !" : "";
+    lines.push(`${lane.lane.name} (${lane.count}${limit})${marker}`);
+    for (const card of lane.cards) {
+      const id = card.short_id || card.id.slice(0, 8);
+      lines.push(`  ${id} ${card.title} [${card.badges.join(", ")}]`);
+    }
+    if (lane.cards.length === 0)
+      lines.push("  (empty)");
+    lines.push("");
+  }
+  return lines.join(`
+`).trimEnd();
+}
+function exportTaskBoardBundle(idOrName, db) {
+  const d = db || getDatabase();
+  const boards = idOrName ? [getTaskBoard(idOrName, d)].filter(Boolean) : listTaskBoards({}, d);
+  return {
+    kind: "hasna.todos.task-board",
+    schemaVersion: 1,
+    exportedAt: now(),
+    boards
+  };
+}
+function importTaskBoardBundle(bundle, db) {
+  const d = db || getDatabase();
+  if (bundle.kind !== "hasna.todos.task-board" || bundle.schemaVersion !== 1 || !Array.isArray(bundle.boards)) {
+    throw new Error("Invalid task board bundle");
+  }
+  let inserted = 0;
+  let updated = 0;
+  let skipped = 0;
+  for (const board of bundle.boards) {
+    const existing = getTaskBoard(board.id, d) || getTaskBoard(board.name, d);
+    if (existing) {
+      updateTaskBoard(existing.id, {
+        name: board.name,
+        project_id: board.project_id,
+        task_list_id: board.task_list_id,
+        plan_id: board.plan_id,
+        agent_id: board.agent_id,
+        lanes: board.lanes,
+        filters: board.filters
+      }, d);
+      updated++;
+    } else if (board.name && board.scope) {
+      createTaskBoard({
+        name: board.name,
+        scope: board.scope,
+        project_id: board.project_id || undefined,
+        task_list_id: board.task_list_id || undefined,
+        plan_id: board.plan_id || undefined,
+        agent_id: board.agent_id || undefined,
+        lanes: board.lanes,
+        filters: board.filters
+      }, d);
+      inserted++;
+    } else {
+      skipped++;
+    }
+  }
+  return { inserted, updated, skipped };
+}
+// src/db/calendar.ts
+init_database();
+
+// src/lib/artifact-store.ts
+init_database();
+import { createHash as createHash2 } from "crypto";
+import { existsSync as existsSync5, mkdirSync as mkdirSync4, readFileSync as readFileSync2, statSync as statSync2, writeFileSync as writeFileSync2 } from "fs";
+import { dirname as dirname4, join as join4, resolve as resolve6 } from "path";
+import { tmpdir } from "os";
+function isInMemoryDb2(path) {
+  return path === ":memory:" || path.startsWith("file::memory:");
+}
+function artifactStoreRoot() {
+  if (process.env["HASNA_TODOS_ARTIFACTS_DIR"])
+    return resolve6(process.env["HASNA_TODOS_ARTIFACTS_DIR"]);
+  if (process.env["TODOS_ARTIFACTS_DIR"])
+    return resolve6(process.env["TODOS_ARTIFACTS_DIR"]);
+  const dbPath = getDatabasePath();
+  if (isInMemoryDb2(dbPath))
+    return join4(tmpdir(), "hasna-todos-artifacts");
+  return join4(dirname4(resolve6(dbPath)), "artifacts");
+}
+function artifactStorePath(relativePath) {
+  const normalized = relativePath.replace(/\\/g, "/");
+  if (normalized.includes("..") || normalized.startsWith("/") || normalized.length === 0) {
+    throw new Error("Invalid artifact store path");
+  }
+  return join4(artifactStoreRoot(), normalized);
+}
+function sha256(buffer) {
+  return createHash2("sha256").update(buffer).digest("hex");
+}
+function isTextLike(buffer, path) {
+  if (buffer.includes(0))
+    return false;
+  if (/\.(txt|log|json|jsonl|md|csv|yaml|yml|xml|html|css|js|ts|tsx|jsx|patch|diff)$/i.test(path))
+    return true;
+  const sample = buffer.subarray(0, Math.min(buffer.length, 4096)).toString("utf8");
+  return !sample.includes("\uFFFD");
+}
+function retentionExpiresAt(createdAt, retentionDays) {
+  if (retentionDays === undefined)
+    return null;
+  if (!Number.isFinite(retentionDays) || retentionDays < 0)
+    throw new Error("retention_days must be a non-negative number");
+  const expires = new Date(createdAt);
+  expires.setUTCDate(expires.getUTCDate() + retentionDays);
+  return expires.toISOString();
+}
+function mediaTypeFor(path, textLike) {
+  if (/\.(png)$/i.test(path))
+    return "image/png";
+  if (/\.(jpe?g)$/i.test(path))
+    return "image/jpeg";
+  if (/\.(gif)$/i.test(path))
+    return "image/gif";
+  if (/\.(webp)$/i.test(path))
+    return "image/webp";
+  if (/\.(json)$/i.test(path))
+    return "application/json";
+  if (/\.(md)$/i.test(path))
+    return "text/markdown";
+  if (textLike)
+    return "text/plain";
+  return "application/octet-stream";
+}
+function storeArtifactContent(input) {
+  const sourcePath = resolve6(input.path);
+  if (!existsSync5(sourcePath))
+    return null;
+  const sourceStat = statSync2(sourcePath);
+  if (!sourceStat.isFile())
+    throw new Error(`Artifact path is not a file: ${input.path}`);
+  const sourceBuffer = readFileSync2(sourcePath);
+  const sourceSha = sha256(sourceBuffer);
+  const textLike = isTextLike(sourceBuffer, input.path);
+  let storedBuffer = sourceBuffer;
+  let redactionStatus = textLike ? "clean" : "binary_or_unknown";
+  if (textLike) {
+    const redactedText = redactEvidenceText(sourceBuffer.toString("utf8"));
+    storedBuffer = Buffer.from(redactedText);
+    if (!storedBuffer.equals(sourceBuffer))
+      redactionStatus = "redacted";
+  }
+  const storedSha = sha256(storedBuffer);
+  const relativePath = join4("sha256", storedSha.slice(0, 2), storedSha).replace(/\\/g, "/");
+  const destination = artifactStorePath(relativePath);
+  if (!existsSync5(destination)) {
+    mkdirSync4(dirname4(destination), { recursive: true });
+    writeFileSync2(destination, storedBuffer);
+  }
+  const createdAt = input.created_at || new Date().toISOString();
+  const retentionDays = input.retention_days ?? null;
+  return {
+    size_bytes: storedBuffer.length,
+    sha256: storedSha,
+    store: {
+      stored: true,
+      algorithm: "sha256",
+      sha256: storedSha,
+      size_bytes: storedBuffer.length,
+      relative_path: relativePath,
+      content_address: `sha256:${storedSha}`,
+      media_type: mediaTypeFor(input.path, textLike),
+      redaction: {
+        checked: textLike,
+        status: redactionStatus
+      },
+      retention: {
+        days: retentionDays,
+        expires_at: retentionDays === null ? null : retentionExpiresAt(createdAt, retentionDays)
+      },
+      source: {
+        path: input.path,
+        size_bytes: sourceBuffer.length,
+        sha256: sourceSha
+      }
+    }
+  };
+}
+function storeMetadata(metadata) {
+  const value = metadata["artifact_store"];
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return null;
+  const record = value;
+  if (record.stored !== true)
+    return null;
+  if (typeof record.sha256 !== "string" || typeof record.relative_path !== "string" || typeof record.size_bytes !== "number")
+    return null;
+  return record;
+}
+function verifyStoredArtifact(input) {
+  const store = storeMetadata(input.metadata);
+  if (!store) {
+    return {
+      id: input.id,
+      path: input.path,
+      status: "metadata_only",
+      expected_sha256: input.sha256,
+      actual_sha256: null,
+      expected_size_bytes: input.size_bytes,
+      actual_size_bytes: null,
+      relative_path: null,
+      message: "artifact has metadata only and no local stored content"
+    };
+  }
+  const storedPath = artifactStorePath(store.relative_path);
+  if (!existsSync5(storedPath)) {
+    return {
+      id: input.id,
+      path: input.path,
+      status: "missing",
+      expected_sha256: store.sha256,
+      actual_sha256: null,
+      expected_size_bytes: store.size_bytes,
+      actual_size_bytes: null,
+      relative_path: store.relative_path,
+      message: "stored artifact content is missing"
+    };
+  }
+  const buffer = readFileSync2(storedPath);
+  const actualSha = sha256(buffer);
+  const actualSize = buffer.length;
+  const ok = actualSha === store.sha256 && actualSize === store.size_bytes;
+  return {
+    id: input.id,
+    path: input.path,
+    status: ok ? "ok" : "mismatch",
+    expected_sha256: store.sha256,
+    actual_sha256: actualSha,
+    expected_size_bytes: store.size_bytes,
+    actual_size_bytes: actualSize,
+    relative_path: store.relative_path,
+    message: ok ? "stored artifact content matches metadata" : "stored artifact content does not match metadata"
+  };
+}
+function exportStoredArtifactContent(input) {
+  const report = verifyStoredArtifact(input);
+  if (report.status !== "ok" || !report.relative_path || !report.actual_sha256 || report.actual_size_bytes === null)
+    return null;
+  const content = readFileSync2(artifactStorePath(report.relative_path));
+  return {
+    artifact_id: input.id,
+    sha256: report.actual_sha256,
+    size_bytes: report.actual_size_bytes,
+    relative_path: report.relative_path,
+    base64: content.toString("base64")
+  };
+}
+function importStoredArtifactContent(content) {
+  const buffer = Buffer.from(content.base64, "base64");
+  const actualSha = sha256(buffer);
+  if (actualSha !== content.sha256 || buffer.length !== content.size_bytes) {
+    return {
+      id: content.artifact_id,
+      path: content.relative_path,
+      status: "mismatch",
+      expected_sha256: content.sha256,
+      actual_sha256: actualSha,
+      expected_size_bytes: content.size_bytes,
+      actual_size_bytes: buffer.length,
+      relative_path: content.relative_path,
+      message: "exported artifact content checksum does not match manifest"
+    };
+  }
+  const destination = artifactStorePath(content.relative_path);
+  mkdirSync4(dirname4(destination), { recursive: true });
+  writeFileSync2(destination, buffer);
+  return {
+    id: content.artifact_id,
+    path: content.relative_path,
+    status: "ok",
+    expected_sha256: content.sha256,
+    actual_sha256: actualSha,
+    expected_size_bytes: content.size_bytes,
+    actual_size_bytes: buffer.length,
+    relative_path: content.relative_path,
+    message: "stored artifact content imported"
+  };
+}
+
+// src/db/task-runs.ts
+init_types();
+
+// src/db/comments.ts
+init_types();
+init_database();
+function addComment(input, db) {
+  const d = db || getDatabase();
+  if (!getTask(input.task_id, d)) {
+    throw new TaskNotFoundError(input.task_id);
+  }
+  const id = uuid();
+  const timestamp = now();
+  d.run(`INSERT INTO task_comments (id, task_id, agent_id, session_id, content, type, progress_pct, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?)`, [
+    id,
+    input.task_id,
+    input.agent_id || null,
+    input.session_id || null,
+    redactEvidenceText(input.content),
+    input.type || "comment",
+    input.progress_pct ?? null,
+    timestamp
+  ]);
+  return getComment(id, d);
+}
+function logProgress(taskId, message, pct, agentId, db) {
+  return addComment({ task_id: taskId, content: message, type: "progress", progress_pct: pct, agent_id: agentId }, db);
+}
+function getComment(id, db) {
+  const d = db || getDatabase();
+  return d.query("SELECT * FROM task_comments WHERE id = ?").get(id);
+}
+function listComments(taskId, db) {
+  const d = db || getDatabase();
+  return d.query("SELECT * FROM task_comments WHERE task_id = ? ORDER BY created_at").all(taskId);
+}
+function deleteComment(id, db) {
+  const d = db || getDatabase();
+  const result = d.run("DELETE FROM task_comments WHERE id = ?", [id]);
+  return result.changes > 0;
+}
+
+// src/db/task-runs.ts
+init_database();
+
+// src/db/task-files.ts
+init_database();
+function addTaskFile(input, db) {
+  const d = db || getDatabase();
+  const id = uuid();
+  const timestamp = now();
+  const existing = d.query("SELECT id FROM task_files WHERE task_id = ? AND path = ?").get(input.task_id, input.path);
+  if (existing) {
+    d.run("UPDATE task_files SET status = ?, agent_id = ?, note = ?, updated_at = ? WHERE id = ?", [input.status || "active", input.agent_id || null, input.note || null, timestamp, existing.id]);
+    return getTaskFile(existing.id, d);
+  }
+  d.run(`INSERT INTO task_files (id, task_id, path, status, agent_id, note, created_at, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?)`, [id, input.task_id, input.path, input.status || "active", input.agent_id || null, input.note || null, timestamp, timestamp]);
+  return getTaskFile(id, d);
+}
+function getTaskFile(id, db) {
+  const d = db || getDatabase();
+  return d.query("SELECT * FROM task_files WHERE id = ?").get(id);
+}
+function listTaskFiles(taskId, db) {
+  const d = db || getDatabase();
+  return d.query("SELECT * FROM task_files WHERE task_id = ? ORDER BY path").all(taskId);
+}
+function findTasksByFile(path, db) {
+  const d = db || getDatabase();
+  return d.query("SELECT * FROM task_files WHERE path = ? AND status != 'removed' ORDER BY updated_at DESC").all(path);
+}
+function updateTaskFileStatus(taskId, path, status, agentId, db) {
+  const d = db || getDatabase();
+  const timestamp = now();
+  d.run("UPDATE task_files SET status = ?, agent_id = COALESCE(?, agent_id), updated_at = ? WHERE task_id = ? AND path = ?", [status, agentId || null, timestamp, taskId, path]);
+  const row = d.query("SELECT * FROM task_files WHERE task_id = ? AND path = ?").get(taskId, path);
+  return row;
+}
+function removeTaskFile(taskId, path, db) {
+  const d = db || getDatabase();
+  const result = d.run("DELETE FROM task_files WHERE task_id = ? AND path = ?", [taskId, path]);
+  return result.changes > 0;
+}
+function bulkAddTaskFiles(taskId, paths, agentId, db) {
+  const d = db || getDatabase();
+  const results = [];
+  const tx = d.transaction(() => {
+    for (const path of paths) {
+      results.push(addTaskFile({ task_id: taskId, path, agent_id: agentId }, d));
+    }
+  });
+  tx();
+  return results;
+}
+
+// src/db/task-commits.ts
+init_database();
+function rowToCommit(row) {
+  return {
+    ...row,
+    files_changed: row.files_changed ? JSON.parse(row.files_changed) : null
+  };
+}
+function rowToGitRef(row) {
+  return {
+    ...row,
+    metadata: row.metadata ? JSON.parse(row.metadata) : {}
+  };
+}
+function rowToVerification(row) {
+  return row;
+}
+function getTaskCommits(taskId, db) {
+  const d = db || getDatabase();
+  return d.query("SELECT * FROM task_commits WHERE task_id = ? ORDER BY committed_at DESC, created_at DESC").all(taskId).map(rowToCommit);
+}
+function getTaskGitRefs(taskId, db) {
+  const d = db || getDatabase();
+  return d.query("SELECT * FROM task_git_refs WHERE task_id = ? ORDER BY ref_type, updated_at DESC").all(taskId).map(rowToGitRef);
+}
+function addTaskVerification(input, db) {
+  const d = db || getDatabase();
+  const id = uuid();
+  const runAt = input.run_at || now();
+  d.run("INSERT INTO task_verifications (id, task_id, command, status, output_summary, artifact_path, agent_id, run_at, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)", [
+    id,
+    input.task_id,
+    input.command,
+    input.status || "unknown",
+    input.output_summary ?? null,
+    input.artifact_path ?? null,
+    input.agent_id ?? null,
+    runAt,
+    now()
+  ]);
+  return rowToVerification(d.query("SELECT * FROM task_verifications WHERE id = ?").get(id));
 }
-function getPlan(id, db) {
+function getTaskVerifications(taskId, db) {
   const d = db || getDatabase();
-  const row = d.query("SELECT * FROM plans WHERE id = ?").get(id);
-  return row;
+  return d.query("SELECT * FROM task_verifications WHERE task_id = ? ORDER BY run_at DESC, created_at DESC").all(taskId).map(rowToVerification);
 }
-function listPlans(projectId, db) {
+function getTaskTraceability(taskId, db) {
   const d = db || getDatabase();
-  if (projectId) {
-    return d.query("SELECT * FROM plans WHERE project_id = ? ORDER BY created_at DESC").all(projectId);
+  return {
+    task_id: taskId,
+    commits: getTaskCommits(taskId, d),
+    git_refs: getTaskGitRefs(taskId, d),
+    verifications: getTaskVerifications(taskId, d)
+  };
+}
+
+// src/db/task-runs.ts
+function parseObject(value) {
+  if (!value)
+    return {};
+  try {
+    const parsed = JSON.parse(value);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
   }
-  return d.query("SELECT * FROM plans ORDER BY created_at DESC").all();
 }
-function updatePlan(id, input, db) {
+function rowToRun(row) {
+  return { ...row, metadata: parseObject(row.metadata) };
+}
+function rowToEvent(row) {
+  return { ...row, data: parseObject(row.data) };
+}
+function rowToArtifact(row) {
+  return { ...row, metadata: parseObject(row.metadata) };
+}
+function getRunRow(runId, db) {
+  return db.query("SELECT * FROM task_runs WHERE id = ?").get(runId);
+}
+function resolveTaskRunId(idOrPrefix, db) {
   const d = db || getDatabase();
-  const plan = getPlan(id, d);
-  if (!plan)
-    throw new PlanNotFoundError(id);
-  const sets = ["updated_at = ?"];
-  const params = [now()];
-  if (input.name !== undefined) {
-    sets.push("name = ?");
-    params.push(input.name);
-  }
-  if (input.description !== undefined) {
-    sets.push("description = ?");
-    params.push(input.description);
-  }
-  if (input.status !== undefined) {
-    sets.push("status = ?");
-    params.push(input.status);
+  const rows = d.query("SELECT id FROM task_runs WHERE id = ? OR id LIKE ? ORDER BY created_at DESC LIMIT 2").all(idOrPrefix, `${idOrPrefix}%`);
+  if (rows.length === 0)
+    throw new Error(`Run not found: ${idOrPrefix}`);
+  if (rows.length > 1)
+    throw new Error(`Run ID is ambiguous: ${idOrPrefix}`);
+  return rows[0].id;
+}
+function getTaskRun(runId, db) {
+  const d = db || getDatabase();
+  const row = getRunRow(runId, d);
+  return row ? rowToRun(row) : null;
+}
+function startTaskRun(input, db) {
+  const d = db || getDatabase();
+  if (!getTask(input.task_id, d))
+    throw new TaskNotFoundError(input.task_id);
+  const id = uuid();
+  const timestamp = input.started_at || now();
+  if (input.claim && input.agent_id) {
+    startTask(input.task_id, input.agent_id, d);
   }
-  if (input.task_list_id !== undefined) {
-    sets.push("task_list_id = ?");
-    params.push(input.task_list_id);
+  d.run("INSERT INTO task_runs (id, task_id, agent_id, title, status, summary, metadata, started_at, created_at, updated_at) VALUES (?, ?, ?, ?, 'running', ?, ?, ?, ?, ?)", [
+    id,
+    input.task_id,
+    input.agent_id ?? null,
+    input.title ? redactEvidenceText(input.title) : null,
+    input.summary ? redactEvidenceText(input.summary) : null,
+    JSON.stringify(redactValue(input.metadata || {})),
+    timestamp,
+    timestamp,
+    timestamp
+  ]);
+  addTaskRunEvent({
+    run_id: id,
+    event_type: "started",
+    message: input.summary || input.title || "run started",
+    data: { title: input.title, claim: Boolean(input.claim) },
+    agent_id: input.agent_id,
+    created_at: timestamp
+  }, d);
+  if (input.claim && input.agent_id) {
+    addTaskRunEvent({
+      run_id: id,
+      event_type: "claim",
+      message: `claimed by ${input.agent_id}`,
+      data: { agent_id: input.agent_id },
+      agent_id: input.agent_id,
+      created_at: timestamp
+    }, d);
   }
-  if (input.agent_id !== undefined) {
-    sets.push("agent_id = ?");
-    params.push(input.agent_id);
+  const run = getTaskRun(id, d);
+  emitLocalEventHooksQuiet({ type: "run.started", payload: { id: run.id, task_id: run.task_id, agent_id: run.agent_id, title: run.title } });
+  return run;
+}
+function addTaskRunEvent(input, db) {
+  const d = db || getDatabase();
+  const runId = resolveTaskRunId(input.run_id, d);
+  const run = getTaskRun(runId, d);
+  if (!run)
+    throw new Error(`Run not found: ${input.run_id}`);
+  const id = uuid();
+  const timestamp = input.created_at || now();
+  d.run("INSERT INTO task_run_events (id, run_id, task_id, event_type, message, data, agent_id, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)", [
+    id,
+    run.id,
+    run.task_id,
+    input.event_type,
+    input.message ? redactEvidenceText(input.message) : null,
+    JSON.stringify(redactValue(input.data || {})),
+    input.agent_id ?? run.agent_id,
+    timestamp
+  ]);
+  if (input.event_type === "comment" && input.message) {
+    addComment({ task_id: run.task_id, content: redactEvidenceText(input.message), type: "comment", agent_id: input.agent_id ?? run.agent_id ?? undefined }, d);
   }
-  params.push(id);
-  d.run(`UPDATE plans SET ${sets.join(", ")} WHERE id = ?`, params);
-  const updated = getPlan(id, d);
+  return rowToEvent(d.query("SELECT * FROM task_run_events WHERE id = ?").get(id));
+}
+function addTaskRunCommand(input, db) {
+  const d = db || getDatabase();
+  const runId = resolveTaskRunId(input.run_id, d);
+  const run = getTaskRun(runId, d);
+  if (!run)
+    throw new Error(`Run not found: ${input.run_id}`);
+  const id = uuid();
+  const status = input.status || "unknown";
+  const timestamp = now();
+  const command = redactEvidenceText(input.command);
+  const outputSummary = input.output_summary ? redactEvidenceText(input.output_summary) : null;
+  const artifactPath = input.artifact_path ? redactEvidenceText(input.artifact_path) : null;
+  d.run("INSERT INTO task_run_commands (id, run_id, task_id, command, status, exit_code, output_summary, artifact_path, agent_id, started_at, completed_at, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)", [
+    id,
+    run.id,
+    run.task_id,
+    command,
+    status,
+    input.exit_code ?? null,
+    outputSummary,
+    artifactPath,
+    input.agent_id ?? run.agent_id,
+    input.started_at ?? null,
+    input.completed_at ?? timestamp,
+    timestamp
+  ]);
+  addTaskVerification({
+    task_id: run.task_id,
+    command,
+    status,
+    output_summary: outputSummary ?? undefined,
+    artifact_path: artifactPath ?? undefined,
+    agent_id: input.agent_id ?? run.agent_id ?? undefined,
+    run_at: input.completed_at ?? timestamp
+  }, d);
+  addTaskRunEvent({
+    run_id: run.id,
+    event_type: "command",
+    message: `${status}: ${command}`,
+    data: { command, status, exit_code: input.exit_code ?? null, output_summary: outputSummary, artifact_path: artifactPath },
+    agent_id: input.agent_id ?? run.agent_id ?? undefined,
+    created_at: timestamp
+  }, d);
+  return d.query("SELECT * FROM task_run_commands WHERE id = ?").get(id);
+}
+function addTaskRunFile(input, db) {
+  const d = db || getDatabase();
+  const runId = resolveTaskRunId(input.run_id, d);
+  const run = getTaskRun(runId, d);
+  if (!run)
+    throw new Error(`Run not found: ${input.run_id}`);
+  const file = addTaskFile({
+    task_id: run.task_id,
+    path: input.path,
+    status: input.status || "modified",
+    note: input.note ? redactEvidenceText(input.note) : undefined,
+    agent_id: input.agent_id ?? run.agent_id ?? undefined
+  }, d);
+  addTaskRunEvent({
+    run_id: run.id,
+    event_type: "file",
+    message: `${file.status}: ${file.path}`,
+    data: { path: file.path, status: file.status, note: file.note },
+    agent_id: input.agent_id ?? run.agent_id ?? undefined
+  }, d);
+  return file;
+}
+function addTaskRunArtifact(input, db) {
+  const d = db || getDatabase();
+  const runId = resolveTaskRunId(input.run_id, d);
+  const run = getTaskRun(runId, d);
+  if (!run)
+    throw new Error(`Run not found: ${input.run_id}`);
+  const id = uuid();
+  const timestamp = now();
+  const path = redactEvidenceText(input.path);
+  const description = input.description ? redactEvidenceText(input.description) : null;
+  const metadata = redactValue(input.metadata || {});
+  let sizeBytes = input.size_bytes ?? null;
+  let digest = input.sha256 ?? null;
+  const stored = input.store_content !== false ? storeArtifactContent({ path: input.path, metadata, retention_days: input.retention_days, created_at: timestamp }) : null;
+  if (stored) {
+    sizeBytes = stored.size_bytes;
+    digest = stored.sha256;
+    metadata["artifact_store"] = stored.store;
+  } else if (input.store_content === true) {
+    throw new Error(`Artifact file not found: ${input.path}`);
+  }
+  d.run("INSERT INTO task_run_artifacts (id, run_id, task_id, path, artifact_type, description, size_bytes, sha256, metadata, agent_id, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)", [
+    id,
+    run.id,
+    run.task_id,
+    path,
+    input.artifact_type ?? null,
+    description,
+    sizeBytes,
+    digest,
+    JSON.stringify(metadata),
+    input.agent_id ?? run.agent_id,
+    timestamp
+  ]);
+  addTaskRunEvent({
+    run_id: run.id,
+    event_type: "artifact",
+    message: description || path,
+    data: { path, artifact_type: input.artifact_type, size_bytes: sizeBytes, sha256: digest, stored: Boolean(stored) },
+    agent_id: input.agent_id ?? run.agent_id ?? undefined,
+    created_at: timestamp
+  }, d);
+  return rowToArtifact(d.query("SELECT * FROM task_run_artifacts WHERE id = ?").get(id));
+}
+function verifyTaskRunArtifacts(runId, db) {
+  const ledger = getTaskRunLedger(runId, db);
+  return ledger.artifacts.map((artifact) => verifyStoredArtifact({
+    id: artifact.id,
+    path: artifact.path,
+    size_bytes: artifact.size_bytes,
+    sha256: artifact.sha256,
+    metadata: artifact.metadata
+  }));
+}
+function finishTaskRun(input, db) {
+  const d = db || getDatabase();
+  const runId = resolveTaskRunId(input.run_id, d);
+  const run = getTaskRun(runId, d);
+  if (!run)
+    throw new Error(`Run not found: ${input.run_id}`);
+  const timestamp = input.completed_at || now();
+  const summary = input.summary ? redactEvidenceText(input.summary) : null;
+  d.run("UPDATE task_runs SET status = ?, summary = COALESCE(?, summary), completed_at = ?, updated_at = ? WHERE id = ?", [input.status, summary, timestamp, timestamp, run.id]);
+  addTaskRunEvent({
+    run_id: run.id,
+    event_type: input.status,
+    message: summary || `run ${input.status}`,
+    data: { status: input.status },
+    agent_id: input.agent_id ?? run.agent_id ?? undefined,
+    created_at: timestamp
+  }, d);
+  const updated = getTaskRun(run.id, d);
   emitLocalEventHooksQuiet({
-    type: "plan.updated",
-    payload: { id, old_status: plan.status, new_status: updated.status, name: updated.name, project_id: updated.project_id }
+    type: `run.${input.status}`,
+    payload: { id: updated.id, task_id: updated.task_id, agent_id: updated.agent_id, status: updated.status, summary: updated.summary, completed_at: timestamp }
   });
   return updated;
 }
-function deletePlan(id, db) {
+function listTaskRuns(taskId, db) {
   const d = db || getDatabase();
-  const result = d.run("DELETE FROM plans WHERE id = ?", [id]);
-  return result.changes > 0;
+  const rows = taskId ? d.query("SELECT * FROM task_runs WHERE task_id = ? ORDER BY started_at DESC, created_at DESC").all(taskId) : d.query("SELECT * FROM task_runs ORDER BY started_at DESC, created_at DESC LIMIT 100").all();
+  return rows.map(rowToRun);
+}
+function getTaskRunLedger(runId, db) {
+  const d = db || getDatabase();
+  const resolved = resolveTaskRunId(runId, d);
+  const run = getTaskRun(resolved, d);
+  if (!run)
+    throw new Error(`Run not found: ${runId}`);
+  const events = d.query("SELECT * FROM task_run_events WHERE run_id = ? ORDER BY created_at, rowid").all(run.id).map(rowToEvent);
+  const commands = d.query("SELECT * FROM task_run_commands WHERE run_id = ? ORDER BY created_at, rowid").all(run.id);
+  const artifacts = d.query("SELECT * FROM task_run_artifacts WHERE run_id = ? ORDER BY created_at, rowid").all(run.id).map(rowToArtifact);
+  const files = d.query("SELECT * FROM task_files WHERE task_id = ? ORDER BY updated_at DESC, path").all(run.task_id);
+  return { run, events, commands, artifacts, files };
 }
 
+// src/db/calendar.ts
+function parseJsonObject2(value) {
+  if (!value)
+    return {};
+  if (typeof value === "object" && !Array.isArray(value))
+    return value;
+  if (typeof value !== "string")
+    return {};
+  try {
+    const parsed = JSON.parse(value);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function rowToCalendarItem(row) {
+  return { ...row, metadata: parseJsonObject2(row.metadata) };
+}
+function eventFromLocal(item) {
+  return {
+    ...item,
+    source: "local",
+    badges: [item.kind, item.timezone || "floating"]
+  };
+}
+function addMinutes(iso, minutes) {
+  const ms = Date.parse(iso);
+  if (!Number.isFinite(ms))
+    return iso;
+  return new Date(ms + minutes * 60000).toISOString();
+}
+function eventFromTaskDue(task) {
+  if (!task.due_at)
+    return null;
+  return {
+    id: `task-due-${task.id}`,
+    kind: "task_due",
+    title: `Due: ${task.title}`,
+    description: task.description,
+    starts_at: task.due_at,
+    ends_at: null,
+    timezone: null,
+    project_id: task.project_id,
+    task_id: task.id,
+    plan_id: task.plan_id,
+    run_id: null,
+    recurrence_rule: task.recurrence_rule,
+    source: "task",
+    badges: ["due", task.priority, task.status],
+    metadata: { priority: task.priority, status: task.status, short_id: task.short_id }
+  };
+}
+function eventFromTaskSla(task) {
+  if (!task.sla_minutes || ["completed", "cancelled", "failed"].includes(task.status))
+    return null;
+  const base = task.started_at || task.created_at;
+  if (!base)
+    return null;
+  const startsAt = addMinutes(base, task.sla_minutes);
+  return {
+    id: `task-sla-${task.id}`,
+    kind: "task_sla",
+    title: `SLA: ${task.title}`,
+    description: task.description,
+    starts_at: startsAt,
+    ends_at: null,
+    timezone: null,
+    project_id: task.project_id,
+    task_id: task.id,
+    plan_id: task.plan_id,
+    run_id: null,
+    recurrence_rule: null,
+    source: "task",
+    badges: ["sla", task.priority, task.status],
+    metadata: { sla_minutes: task.sla_minutes, status: task.status, short_id: task.short_id }
+  };
+}
+function eventFromRun(run, task) {
+  return {
+    id: `run-${run.id}`,
+    kind: "run",
+    title: `Run: ${run.title || task?.title || run.id.slice(0, 8)}`,
+    description: run.summary,
+    starts_at: run.started_at,
+    ends_at: run.completed_at,
+    timezone: null,
+    project_id: task?.project_id || null,
+    task_id: run.task_id,
+    plan_id: task?.plan_id || null,
+    run_id: run.id,
+    recurrence_rule: null,
+    source: "run",
+    badges: ["run", run.status],
+    metadata: { status: run.status, agent_id: run.agent_id }
+  };
+}
+function inWindow(event, query) {
+  const start = Date.parse(event.starts_at);
+  if (query.from && Number.isFinite(start) && start < Date.parse(query.from))
+    return false;
+  if (query.to && Number.isFinite(start) && start > Date.parse(query.to))
+    return false;
+  if (query.kind && event.kind !== query.kind)
+    return false;
+  if (query.project_id && event.project_id !== query.project_id)
+    return false;
+  if (query.task_id && event.task_id !== query.task_id)
+    return false;
+  if (query.plan_id && event.plan_id !== query.plan_id)
+    return false;
+  if (query.run_id && event.run_id !== query.run_id)
+    return false;
+  return true;
+}
+function createCalendarItem(input, db) {
+  const d = db || getDatabase();
+  const id = uuid();
+  const timestamp = now();
+  const kind = input.kind || "work_block";
+  d.run(`INSERT INTO local_calendar_items (
+      id, kind, title, description, starts_at, ends_at, timezone, project_id, task_id, plan_id, run_id,
+      recurrence_rule, metadata, created_at, updated_at
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+    id,
+    kind,
+    input.title,
+    input.description || null,
+    input.starts_at,
+    input.ends_at || null,
+    input.timezone || null,
+    input.project_id || null,
+    input.task_id || null,
+    input.plan_id || null,
+    input.run_id || null,
+    input.recurrence_rule || null,
+    JSON.stringify(input.metadata || {}),
+    timestamp,
+    timestamp
+  ]);
+  return getCalendarItem(id, d);
+}
+function getCalendarItem(id, db) {
+  const d = db || getDatabase();
+  const resolved = id.length >= 36 ? id : d.query("SELECT id FROM local_calendar_items WHERE id LIKE ?").all(`${id}%`).length === 1 ? d.query("SELECT id FROM local_calendar_items WHERE id LIKE ?").get(`${id}%`).id : id;
+  const row = d.query("SELECT * FROM local_calendar_items WHERE id = ?").get(resolved);
+  return row ? rowToCalendarItem(row) : null;
+}
+function listCalendarItems(query = {}, db) {
+  const d = db || getDatabase();
+  const conditions = [];
+  const params = [];
+  if (query.project_id) {
+    conditions.push("project_id = ?");
+    params.push(query.project_id);
+  }
+  if (query.task_id) {
+    conditions.push("task_id = ?");
+    params.push(query.task_id);
+  }
+  if (query.plan_id) {
+    conditions.push("plan_id = ?");
+    params.push(query.plan_id);
+  }
+  if (query.run_id) {
+    conditions.push("run_id = ?");
+    params.push(query.run_id);
+  }
+  if (query.kind) {
+    conditions.push("kind = ?");
+    params.push(query.kind);
+  }
+  if (query.from) {
+    conditions.push("starts_at >= ?");
+    params.push(query.from);
+  }
+  if (query.to) {
+    conditions.push("starts_at <= ?");
+    params.push(query.to);
+  }
+  let sql = "SELECT * FROM local_calendar_items";
+  if (conditions.length > 0)
+    sql += ` WHERE ${conditions.join(" AND ")}`;
+  sql += " ORDER BY starts_at ASC, created_at ASC";
+  if (query.limit) {
+    sql += " LIMIT ?";
+    params.push(query.limit);
+  }
+  return d.query(sql).all(...params).map(rowToCalendarItem);
+}
+function listCalendarEvents(query = {}, db) {
+  const d = db || getDatabase();
+  const taskFilter = {
+    project_id: query.project_id,
+    plan_id: query.plan_id,
+    ids: query.task_id ? [query.task_id] : undefined,
+    include_archived: true
+  };
+  const tasks = listTasks(taskFilter, d).filter((task) => query.include_completed || !["completed", "cancelled"].includes(task.status));
+  const events = [];
+  for (const task of tasks) {
+    const due = eventFromTaskDue(task);
+    if (due)
+      events.push(due);
+    if (query.include_sla !== false) {
+      const sla = eventFromTaskSla(task);
+      if (sla)
+        events.push(sla);
+    }
+  }
+  if (query.include_runs !== false) {
+    const runs = query.task_id ? listTaskRuns(query.task_id, d) : listTaskRuns(undefined, d);
+    for (const run of runs) {
+      const task = getTask(run.task_id, d);
+      events.push(eventFromRun(run, task));
+    }
+  }
+  if (query.include_local !== false) {
+    events.push(...listCalendarItems(query, d).map(eventFromLocal));
+  }
+  return events.filter((event) => inWindow(event, query)).sort((left, right) => left.starts_at.localeCompare(right.starts_at) || left.id.localeCompare(right.id)).slice(0, query.limit || undefined);
+}
+function pad(value) {
+  return value < 10 ? `0${value}` : String(value);
+}
+function icsDate(iso) {
+  const date = new Date(iso);
+  if (Number.isNaN(date.getTime()))
+    return iso.replace(/[-:]/g, "").replace(/\.\d{3}/, "");
+  return `${date.getUTCFullYear()}${pad(date.getUTCMonth() + 1)}${pad(date.getUTCDate())}T${pad(date.getUTCHours())}${pad(date.getUTCMinutes())}${pad(date.getUTCSeconds())}Z`;
+}
+function escapeIcs(value) {
+  return String(value || "").replace(/\\/g, "\\\\").replace(/\n/g, "\\n").replace(/,/g, "\\,").replace(/;/g, "\\;");
+}
+function foldLine(line) {
+  if (line.length <= 75)
+    return line;
+  const chunks = [];
+  let rest = line;
+  while (rest.length > 75) {
+    chunks.push(rest.slice(0, 75));
+    rest = rest.slice(75);
+  }
+  chunks.push(rest);
+  return chunks.map((chunk, index) => index === 0 ? chunk : ` ${chunk}`).join(`\r
+`);
+}
+function recurrenceToRrule(rule) {
+  if (!rule)
+    return null;
+  const normalized = rule.trim().toLowerCase();
+  if (normalized === "daily" || normalized === "every day")
+    return "FREQ=DAILY";
+  if (normalized === "weekly" || normalized === "every week")
+    return "FREQ=WEEKLY";
+  if (normalized === "monthly" || normalized === "every month")
+    return "FREQ=MONTHLY";
+  if (normalized === "every weekday")
+    return "FREQ=WEEKLY;BYDAY=MO,TU,WE,TH,FR";
+  const everyN = normalized.match(/^every (\d+) (day|days|week|weeks|month|months)$/);
+  if (everyN) {
+    const freq = everyN[2].startsWith("day") ? "DAILY" : everyN[2].startsWith("week") ? "WEEKLY" : "MONTHLY";
+    return `FREQ=${freq};INTERVAL=${everyN[1]}`;
+  }
+  const days = normalized.match(/^every (mon|monday|tue|tuesday|wed|wednesday|thu|thursday|fri|friday|sat|saturday|sun|sunday)(,(mon|monday|tue|tuesday|wed|wednesday|thu|thursday|fri|friday|sat|saturday|sun|sunday))*$/);
+  if (days) {
+    const map = { mon: "MO", monday: "MO", tue: "TU", tuesday: "TU", wed: "WE", wednesday: "WE", thu: "TH", thursday: "TH", fri: "FR", friday: "FR", sat: "SA", saturday: "SA", sun: "SU", sunday: "SU" };
+    const byday = normalized.replace("every ", "").split(",").map((day) => map[day] || "").filter(Boolean).join(",");
+    if (byday)
+      return `FREQ=WEEKLY;BYDAY=${byday}`;
+  }
+  if (normalized.startsWith("freq="))
+    return rule.toUpperCase();
+  return null;
+}
+function exportCalendarIcs(options = {}, db) {
+  const events = listCalendarEvents(options, db);
+  const generatedAt = options.generated_at || now();
+  const lines = [
+    "BEGIN:VCALENDAR",
+    "VERSION:2.0",
+    `PRODID:${options.product_id || "-//hasna//todos local calendar//EN"}`,
+    "CALSCALE:GREGORIAN",
+    `X-WR-CALNAME:${escapeIcs(options.calendar_name || "Hasna Todos")}`
+  ];
+  for (const event of events) {
+    const title = options.redact ? `${event.kind} ${event.id.slice(0, 8)}` : event.title;
+    const description = options.redact ? null : event.description;
+    lines.push("BEGIN:VEVENT");
+    lines.push(`UID:${escapeIcs(event.id)}@hasna-todos.local`);
+    lines.push(`DTSTAMP:${icsDate(generatedAt)}`);
+    lines.push(`DTSTART:${icsDate(event.starts_at)}`);
+    if (event.ends_at)
+      lines.push(`DTEND:${icsDate(event.ends_at)}`);
+    else
+      lines.push(`DUE:${icsDate(event.starts_at)}`);
+    lines.push(`SUMMARY:${escapeIcs(title)}`);
+    if (description)
+      lines.push(`DESCRIPTION:${escapeIcs(description)}`);
+    lines.push(`CATEGORIES:${escapeIcs(event.badges.join(","))}`);
+    const rrule = recurrenceToRrule(event.recurrence_rule);
+    if (rrule)
+      lines.push(`RRULE:${rrule}`);
+    lines.push(`X-HASNA-TODOS-KIND:${event.kind}`);
+    if (event.task_id)
+      lines.push(`X-HASNA-TODOS-TASK:${event.task_id}`);
+    if (event.plan_id)
+      lines.push(`X-HASNA-TODOS-PLAN:${event.plan_id}`);
+    if (event.run_id)
+      lines.push(`X-HASNA-TODOS-RUN:${event.run_id}`);
+    lines.push("END:VEVENT");
+  }
+  lines.push("END:VCALENDAR");
+  return {
+    filename: "todos-calendar.ics",
+    content: lines.map(foldLine).join(`\r
+`) + `\r
+`,
+    events
+  };
+}
+function unescapeIcs(value) {
+  return value.replace(/\\n/g, `
+`).replace(/\\,/g, ",").replace(/\\;/g, ";").replace(/\\\\/g, "\\");
+}
+function parseIcsDate(value) {
+  const match = value.match(/^(\d{4})(\d{2})(\d{2})T?(\d{2})?(\d{2})?(\d{2})?Z?$/);
+  if (!match)
+    return value;
+  return new Date(Date.UTC(Number(match[1]), Number(match[2]) - 1, Number(match[3]), Number(match[4] || "0"), Number(match[5] || "0"), Number(match[6] || "0"))).toISOString();
+}
+function importCalendarIcs(content, db) {
+  const d = db || getDatabase();
+  const unfolded = content.replace(/\r?\n[ \t]/g, "");
+  const blocks = unfolded.match(/BEGIN:VEVENT[\s\S]*?END:VEVENT/g) || [];
+  const items = [];
+  let skipped = 0;
+  for (const block of blocks) {
+    const fields = new Map;
+    for (const rawLine of block.split(/\r?\n/)) {
+      const index = rawLine.indexOf(":");
+      if (index <= 0)
+        continue;
+      const key = rawLine.slice(0, index).split(";")[0].toUpperCase();
+      fields.set(key, rawLine.slice(index + 1));
+    }
+    const title = unescapeIcs(fields.get("SUMMARY") || "");
+    const startsAt = fields.get("DTSTART") || fields.get("DUE");
+    if (!title || !startsAt) {
+      skipped++;
+      continue;
+    }
+    const item = createCalendarItem({
+      kind: "imported",
+      title,
+      description: fields.has("DESCRIPTION") ? unescapeIcs(fields.get("DESCRIPTION")) : undefined,
+      starts_at: parseIcsDate(startsAt),
+      ends_at: fields.has("DTEND") ? parseIcsDate(fields.get("DTEND")) : undefined,
+      recurrence_rule: fields.get("RRULE"),
+      metadata: { uid: fields.get("UID") || null, imported_from: "ics" }
+    }, d);
+    items.push(item);
+  }
+  return { imported: items.length, skipped, items };
+}
 // src/db/agents.ts
 init_database();
 
@@ -5895,46 +8149,6 @@ function ensureTaskList(name, slug, projectId, db) {
   return createTaskList({ name, slug, project_id: projectId }, d);
 }
 
-// src/db/comments.ts
-init_types();
-init_database();
-function addComment(input, db) {
-  const d = db || getDatabase();
-  if (!getTask(input.task_id, d)) {
-    throw new TaskNotFoundError(input.task_id);
-  }
-  const id = uuid();
-  const timestamp = now();
-  d.run(`INSERT INTO task_comments (id, task_id, agent_id, session_id, content, type, progress_pct, created_at)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?)`, [
-    id,
-    input.task_id,
-    input.agent_id || null,
-    input.session_id || null,
-    input.content,
-    input.type || "comment",
-    input.progress_pct ?? null,
-    timestamp
-  ]);
-  return getComment(id, d);
-}
-function logProgress(taskId, message, pct, agentId, db) {
-  return addComment({ task_id: taskId, content: message, type: "progress", progress_pct: pct, agent_id: agentId }, db);
-}
-function getComment(id, db) {
-  const d = db || getDatabase();
-  return d.query("SELECT * FROM task_comments WHERE id = ?").get(id);
-}
-function listComments(taskId, db) {
-  const d = db || getDatabase();
-  return d.query("SELECT * FROM task_comments WHERE task_id = ? ORDER BY created_at").all(taskId);
-}
-function deleteComment(id, db) {
-  const d = db || getDatabase();
-  const result = d.run("DELETE FROM task_comments WHERE id = ?", [id]);
-  return result.changes > 0;
-}
-
 // src/storage/local-sqlite.ts
 init_database();
 function createLocalSqliteTodosStorageAdapter(options = {}) {