@hasna/todos 0.16.0 → 0.17.0

package/dist/index.js

@@ -4117,20 +4117,17 @@ function ensureAgentIdentitySchema(db) {
         SELECT RAISE(ABORT, 'IDENTITY_SOURCE_LINEAGE_IMMUTABLE');
       END;
 
+      -- Drop first so an older definition is replaced rather than silently
+      -- retained (the upgrade path). AGENT_IDENTITY_HISTORY_TRIGGER_DDL then
+      -- re-creates them with CREATE TRIGGER IF NOT EXISTS. The two statements
+      -- do different jobs and both are kept: the DROP is what refreshes a
+      -- stale definition, and the IF NOT EXISTS is what keeps the CREATE safe
+      -- on its own \u2014 so a caller that reaches it without a preceding DROP, in
+      -- its own connection or transaction, gets a no-op instead of
+      -- "trigger ... already exists".
       DROP TRIGGER IF EXISTS trg_agent_identity_mapping_history_immutable;
-      CREATE TRIGGER trg_agent_identity_mapping_history_immutable
-      BEFORE UPDATE OF local_agent_id, observed_label, evidence, mapping_basis, status, revision, created_at
-        ON agent_identity_source_mappings
-      BEGIN
-        SELECT RAISE(ABORT, 'IDENTITY_MAPPING_HISTORY_IMMUTABLE');
-      END;
-
       DROP TRIGGER IF EXISTS trg_agent_identity_mapping_history_append_only;
-      CREATE TRIGGER trg_agent_identity_mapping_history_append_only
-      BEFORE DELETE ON agent_identity_source_mappings
-      BEGIN
-        SELECT RAISE(ABORT, 'IDENTITY_MAPPING_HISTORY_IMMUTABLE');
-      END;
+      ${AGENT_IDENTITY_HISTORY_TRIGGER_DDL}
     `);
     db.run("INSERT OR IGNORE INTO _migrations (id) VALUES (?)", [IDENTITY_MIGRATION_ID]);
   });
@@ -4170,7 +4167,20 @@ function storeAgentAlias(agentId, label, aliasKind, status, db) {
 function recordAgentAlias(agentId, label, db) {
   return storeAgentAlias(agentId, label, "historical", "active", db);
 }
-var IDENTITY_PROJECTION_CONTRACT, IDENTITY_MIGRATION_ID = 65;
+var IDENTITY_PROJECTION_CONTRACT, IDENTITY_MIGRATION_ID = 65, AGENT_IDENTITY_HISTORY_TRIGGER_DDL = `
+  CREATE TRIGGER IF NOT EXISTS trg_agent_identity_mapping_history_immutable
+  BEFORE UPDATE OF local_agent_id, observed_label, evidence, mapping_basis, status, revision, created_at
+    ON agent_identity_source_mappings
+  BEGIN
+    SELECT RAISE(ABORT, 'IDENTITY_MAPPING_HISTORY_IMMUTABLE');
+  END;
+
+  CREATE TRIGGER IF NOT EXISTS trg_agent_identity_mapping_history_append_only
+  BEFORE DELETE ON agent_identity_source_mappings
+  BEGIN
+    SELECT RAISE(ABORT, 'IDENTITY_MAPPING_HISTORY_IMMUTABLE');
+  END;
+`;
 var init_identity_mapping = __esm(() => {
   init_types();
   init_types();
@@ -4195,7 +4205,7 @@ var init_identity_mapping = __esm(() => {
 // src/lib/paths.ts
 import { existsSync as existsSync2 } from "fs";
 import { homedir } from "os";
-import { join, resolve as resolve2 } from "path";
+import { isAbsolute, join, resolve as resolve2 } from "path";
 import { homedir as pathsResolverHomedir } from "os";
 import { join as pathsResolverJoin } from "path";
 function pathsResolverAssertApp(app) {
@@ -4252,8 +4262,14 @@ function dataDir(options) {
 function effectiveHome(env2 = process.env) {
   return env2.HOME || env2.USERPROFILE || homedir();
 }
+function hasnaHomeRoot(env2 = process.env) {
+  const override = env2["HASNA_HOME"]?.trim();
+  if (override && isAbsolute(override))
+    return override;
+  return join(effectiveHome(env2), ".hasna");
+}
 function legacyHomeDir(env2 = process.env) {
-  return join(effectiveHome(env2), ".hasna", "todos");
+  return join(hasnaHomeRoot(env2), "todos");
 }
 function resolverHome(env2 = process.env) {
   return dataDir({ app: "todos", home: effectiveHome(env2), env: env2 });
@@ -4672,15 +4688,18 @@ __export(exports_database, {
   resolvePartialId: () => resolvePartialId,
   resolveAssignedToAliases: () => resolveAssignedToAliases,
   resetDatabase: () => resetDatabase,
+  refuseLocalStore: () => refuseLocalStore,
   now: () => now,
   lowerInClause: () => lowerInClause,
   lockExpiryCutoff: () => lockExpiryCutoff,
   isLockExpired: () => isLockExpired,
+  isLocalStoreRefused: () => isLocalStoreRefused,
   getDatabasePath: () => getDatabasePath,
   getDatabase: () => getDatabase,
   closeDatabase: () => closeDatabase,
   clearExpiredLocks: () => clearExpiredLocks,
   assignedToAliasSet: () => assignedToAliasSet,
+  allowLocalStore: () => allowLocalStore,
   LOCK_EXPIRY_MINUTES: () => LOCK_EXPIRY_MINUTES
 });
 import { Database } from "bun:sqlite";
@@ -4797,7 +4816,18 @@ function maybeInstallShadowCapture(db) {
     console.error(`[todos] shadow capture install failed: ${error instanceof Error ? error.message : String(error)}`);
   }
 }
+function refuseLocalStore(message) {
+  localStoreRefusal = message;
+}
+function allowLocalStore() {
+  localStoreRefusal = null;
+}
+function isLocalStoreRefused() {
+  return localStoreRefusal !== null;
+}
 function getDatabase(dbPath) {
+  if (localStoreRefusal !== null)
+    throw new Error(localStoreRefusal);
   if (dbPath === undefined && !selectsTodosLocalStore()) {
     throw new Error("API_DATABASE_FALLBACK_FORBIDDEN: this operation must use the shared Todos API; implicit SQLite access is unavailable");
   }
@@ -4938,7 +4968,7 @@ function lowerInClause(column, values, params) {
   params.push(...values.map((v) => v.toLowerCase()));
   return `LOWER(${column}) IN (${values.map(() => "?").join(",")})`;
 }
-var LOCK_EXPIRY_MINUTES = 30, _db = null, _dbPath = null, ALLOWED_TABLES;
+var LOCK_EXPIRY_MINUTES = 30, _db = null, _dbPath = null, localStoreRefusal = null, ALLOWED_TABLES;
 var init_database = __esm(() => {
   init_local_opt_in();
   init_schema();
@@ -10679,7 +10709,9 @@ function listTasks(filter = {}, db) {
       params.push(decoded.p, decoded.p, decoded.c, decoded.p, decoded.c, decoded.i);
     } catch {}
   }
-  if (!filter.include_archived) {
+  if (filter.archived_only) {
+    conditions.push("archived_at IS NOT NULL");
+  } else if (!filter.include_archived) {
     conditions.push("archived_at IS NULL");
   }
   const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
@@ -10692,7 +10724,8 @@ function listTasks(filter = {}, db) {
       params.push(filter.offset);
     }
   }
-  const rows = d.query(`SELECT * FROM tasks ${where} ORDER BY ${PRIORITY_RANK}, created_at DESC, id ASC${limitClause}`).all(...params);
+  const orderBy = filter.archived_only ? "archived_at DESC, id DESC" : `${PRIORITY_RANK}, created_at DESC, id ASC`;
+  const rows = d.query(`SELECT * FROM tasks ${where} ORDER BY ${orderBy}${limitClause}`).all(...params);
   return rows.map(rowToTask);
 }
 function getTaskByFingerprint(fingerprint, db) {
@@ -10835,7 +10868,9 @@ function countTasks(filter = {}, db) {
     }
   }
   addMetadataConditions(filter.metadata, conditions, params);
-  if (!filter.include_archived) {
+  if (filter.archived_only) {
+    conditions.push("archived_at IS NOT NULL");
+  } else if (!filter.include_archived) {
     conditions.push("archived_at IS NULL");
   }
   const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
@@ -10972,6 +11007,10 @@ function updateTaskStored(id, input, db) {
     sets.push("completed_at = ?");
     params.push(input.completed_at);
   }
+  if (input.archived_at !== undefined) {
+    sets.push("archived_at = ?");
+    params.push(input.archived_at);
+  }
   if (input.confidence !== undefined) {
     sets.push("confidence = ?");
     params.push(input.confidence);
@@ -11035,6 +11074,8 @@ function updateTaskStored(id, input, db) {
     logTaskChange(id, "update", "parent_id", task.parent_id, input.parent_id, agentId, d);
   if (input.assigned_to !== undefined && input.assigned_to !== task.assigned_to)
     logTaskChange(id, "update", "assigned_to", task.assigned_to, input.assigned_to, agentId, d);
+  if (input.archived_at !== undefined && input.archived_at !== task.archived_at)
+    logTaskChange(id, "update", "archived_at", task.archived_at, input.archived_at, agentId, d);
   if (input.working_dir !== undefined && input.working_dir !== task.working_dir)
     logTaskChange(id, "update", "working_dir", task.working_dir, input.working_dir, agentId, d);
   if (input.approved_by !== undefined)
@@ -13845,7 +13886,7 @@ var init_dispatches = __esm(() => {
 // package.json
 var package_default = {
   name: "@hasna/todos",
-  version: "0.16.0",
+  version: "0.17.0",
   description: "Universal task management for AI coding agents - CLI + MCP server + interactive TUI",
   type: "module",
   main: "dist/index.js",
@@ -13958,7 +13999,7 @@ var package_default = {
     url: "https://github.com/hasna/apps.git",
     directory: "apps/todos"
   },
-  homepage: "https://github.com/hasna/apps",
+  homepage: "https://github.com/hasna/apps/tree/main/apps/todos#readme",
   bugs: {
     url: "https://github.com/hasna/apps/issues"
   },
@@ -14381,7 +14422,7 @@ var MCP_TOOL_GROUPS = {
     "machines_topology",
     "machines_unarchive"
   ],
-  maintenance: ["extract_todos", "get_sla_breaches", "notify_upcoming_deadlines", "run_doctor", "score_task", "watch_source_todos"]
+  maintenance: ["get_sla_breaches", "notify_upcoming_deadlines", "run_doctor", "score_task"]
 };
 var MCP_PROFILE_GROUPS = {
   minimal: ["core", "loops"],
@@ -19806,17 +19847,23 @@ var TODOS_CLI_MCP_PARITY = [
       "todos extract",
       "todos extract-watch"
     ],
-    mcpTools: [
-      "extract_todos",
-      "watch_source_todos"
-    ],
+    mcpTools: [],
     jsonContracts: ["source_code_index", "source_todo_comment", "task", "structured_error", "api_error"],
     errorContracts: ["structured_error", "api_error"],
-    status: "matched",
-    intentionalGaps: [],
+    status: "intentional-gap",
+    intentionalGaps: [
+      {
+        cliCommand: "todos extract",
+        reason: "The source TODO index scans the local checkout the CLI runs in; the former extract_todos MCP tool read the agent host's filesystem behind a task-store tool surface and had no hosted arm, so it was removed (fleet alignment 2026-09-11)."
+      },
+      {
+        cliCommand: "todos extract-watch",
+        reason: "A polling filesystem watcher is a long-running local process, not an MCP tool call; the former watch_source_todos tool was removed with extract_todos \u2014 run `todos extract-watch` from the checkout instead."
+      }
+    ],
+    gapReason: "Source scanning and watching are local-filesystem CLI operations; no MCP tool mapping.",
     example: {
-      cli: "todos extract . --dry-run --index --json",
-      mcpTool: "extract_todos"
+      cli: "todos extract . --dry-run --index --json"
     }
   },
   {
@@ -26405,6 +26452,7 @@ function searchTasks(options, projectId, taskListId, db) {
 
 // src/storage/local-sqlite.ts
 init_tasks();
+init_task_graph();
 init_projects();
 init_plans();
 
@@ -26968,6 +27016,19 @@ function listAgents(opts, db) {
   }
   return d.query("SELECT * FROM agents WHERE status = 'active' ORDER BY name").all().map(rowToAgent);
 }
+function listAgentsPage(options, db) {
+  if (!Number.isSafeInteger(options.limit) || options.limit < 1 || options.limit > 500) {
+    throw new Error("Agent page limit must be an integer from 1 to 500");
+  }
+  if (!Number.isSafeInteger(options.offset) || options.offset < 0) {
+    throw new Error("Agent page offset must be a non-negative integer");
+  }
+  const d = db || getDatabase();
+  const where = options.include_archived ? "" : "WHERE status = 'active'";
+  const total = d.query(`SELECT COUNT(*) AS total FROM agents ${where}`).get().total;
+  const agents = d.query(`SELECT * FROM agents ${where} ORDER BY LOWER(name), id LIMIT ? OFFSET ?`).all(options.limit, options.offset).map(rowToAgent);
+  return { agents, total };
+}
 function updateAgentActivity(id, db) {
   const d = db || getDatabase();
   d.run("UPDATE agents SET last_seen_at = ? WHERE id = ?", [now(), id]);
@@ -28296,6 +28357,98 @@ function exportSqliteMachines(db) {
 }
 
 // src/storage/local-sqlite.ts
+function bulkCreateAtomicSqlite(db, inputs) {
+  return db.transaction(() => {
+    const tempIds = new Map;
+    const created = [];
+    const dependencies = [];
+    for (const input of inputs) {
+      const { temp_id, depends_on: _dependsOn, ...taskInput } = input;
+      const task2 = createTask(taskInput, db);
+      if (temp_id)
+        tempIds.set(temp_id, task2.id);
+      created.push({ temp_id: temp_id ?? null, id: task2.id, short_id: task2.short_id, title: task2.title });
+    }
+    for (let index = 0;index < inputs.length; index++) {
+      const input = inputs[index];
+      const taskId = created[index].id;
+      const seenDependencies = new Set;
+      for (const reference of input.depends_on ?? []) {
+        const dependencyId = tempIds.get(reference) ?? resolveTaskRefLocal(db, reference)?.id;
+        if (!dependencyId)
+          throw new TaskNotFoundError(reference);
+        if (seenDependencies.has(dependencyId)) {
+          throw new ResourceConflictError("BULK_CREATE_DUPLICATE_DEPENDENCY", `Multiple references resolve to dependency ${dependencyId}`);
+        }
+        seenDependencies.add(dependencyId);
+        addDependency(taskId, dependencyId, db);
+        dependencies.push({ task_id: taskId, depends_on: dependencyId });
+      }
+    }
+    return { schema_version: 1, atomic: true, created, dependencies };
+  })();
+}
+function deleteTaskHierarchySqlite(db, rootId) {
+  const rows = db.query(`WITH RECURSIVE tree(id, depth) AS (
+    SELECT id, 0 FROM tasks WHERE id = ?
+    UNION ALL
+    SELECT child.id, tree.depth + 1 FROM tasks child JOIN tree ON child.parent_id = tree.id
+  ) SELECT id FROM tree ORDER BY depth DESC, id`).all(rootId);
+  if (rows.length === 0)
+    throw new TaskNotFoundError(rootId);
+  for (const row of rows) {
+    if (!deleteTask(row.id, db))
+      throw new Error(`Atomic hierarchy delete lost task ${row.id}`);
+  }
+}
+function bulkDeleteAtomicSqlite(db, ids2, force) {
+  return db.transaction(() => {
+    const resolved = ids2.map((reference) => ({ reference, task: resolveTaskRefLocal(db, reference) }));
+    const seen = new Set;
+    for (const item of resolved) {
+      if (!item.task)
+        continue;
+      if (seen.has(item.task.id)) {
+        throw new ResourceConflictError("BULK_DELETE_DUPLICATE_TASK", `Multiple references resolve to task ${item.task.id}`);
+      }
+      seen.add(item.task.id);
+    }
+    const childState = new Map;
+    for (const item of resolved) {
+      if (!item.task)
+        continue;
+      childState.set(item.task.id, Boolean(db.query("SELECT id FROM tasks WHERE parent_id = ? LIMIT 1").get(item.task.id)));
+    }
+    const planned = resolved.filter((item) => item.task && (force || !childState.get(item.task.id)));
+    const plannedIds = new Set(planned.map((item) => item.task.id));
+    const roots = planned.filter((item) => {
+      if (!force)
+        return true;
+      let parentId = item.task.parent_id;
+      while (parentId) {
+        if (plannedIds.has(parentId))
+          return false;
+        parentId = getTask(parentId, db)?.parent_id ?? null;
+      }
+      return true;
+    });
+    for (const item of roots)
+      deleteTaskHierarchySqlite(db, item.task.id);
+    return {
+      schema_version: 1,
+      atomic: true,
+      force,
+      results: resolved.map((item) => {
+        if (!item.task)
+          return { requested_id: item.reference, task_id: null, outcome: "missing", reason: "not_found" };
+        if (!force && childState.get(item.task.id)) {
+          return { requested_id: item.reference, task_id: item.task.id, outcome: "skipped", reason: "has_children" };
+        }
+        return { requested_id: item.reference, task_id: item.task.id, outcome: "deleted", reason: null };
+      })
+    };
+  })();
+}
 var TASK_UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 function resolveTaskRefLocal(db, ref) {
   const raw = ref.trim().toLowerCase();
@@ -28392,6 +28545,8 @@ function createLocalSqliteTodosStorageAdapter(options = {}) {
       },
       handoffStaleLock: (input) => handoffStaleTaskLock(input, database()),
       delete: (id) => deleteTask(id, database()),
+      bulkCreateAtomic: (inputs, _context) => bulkCreateAtomicSqlite(database(), inputs),
+      bulkDeleteAtomic: (ids2, force, _context) => bulkDeleteAtomicSqlite(database(), ids2, force),
       start: (id, agentId) => startTask(id, agentId, database()),
       complete: (id, agentId, options2) => completeTask(id, agentId, database(), options2),
       fail: (id, agentId, reason, options2) => failTask(id, agentId, reason, options2, database()),
@@ -28400,6 +28555,30 @@ function createLocalSqliteTodosStorageAdapter(options = {}) {
       getActiveWork: (filters) => getActiveWork(filters, database()),
       getChangedSince: (since, filters) => getTasksChangedSince(since, filters, database())
     },
+    dependencies: {
+      add: (taskId, dependsOn) => {
+        addDependency(taskId, dependsOn, database());
+        return { task_id: taskId, depends_on: dependsOn };
+      },
+      remove: (taskId, dependsOn) => removeDependency(taskId, dependsOn, database()),
+      list: (taskId) => {
+        const dependencies = getTaskDependencies(taskId, database());
+        const blocks = getTaskDependents(taskId, database());
+        return { dependencies, blocks, blocked_by: blocks };
+      },
+      listPage: ({ limit, offset }) => {
+        if (!Number.isSafeInteger(limit) || limit < 1 || limit > 500) {
+          throw new Error("SQLite dependency page limit must be an integer from 1 to 500");
+        }
+        if (!Number.isSafeInteger(offset) || offset < 0) {
+          throw new Error("SQLite dependency page offset must be a non-negative integer");
+        }
+        const totalRow = database().query("SELECT COUNT(*) AS total FROM task_dependencies").get();
+        const dependencies = database().query("SELECT task_id, depends_on FROM task_dependencies ORDER BY task_id, depends_on LIMIT ? OFFSET ?").all(limit, offset);
+        return { dependencies, total: totalRow.total };
+      },
+      listAll: () => database().query("SELECT task_id, depends_on FROM task_dependencies ORDER BY task_id, depends_on").all()
+    },
     projects: {
       create: (input) => createProject(input, database()),
       get: (id) => getProject(id, database()),
@@ -28443,6 +28622,7 @@ function createLocalSqliteTodosStorageAdapter(options = {}) {
       get: (id) => getAgent(id, database()),
       getByName: (name) => getAgentByName(name, database()),
       list: (options2) => listAgents(options2, database()),
+      listPage: (options2) => listAgentsPage(options2, database()),
       update: (id, input) => updateAgent(id, input, database())
     },
     taskLists: {
@@ -28481,6 +28661,29 @@ function createLocalSqliteTodosStorageAdapter(options = {}) {
         return comments;
       },
       getTaskHistory: (taskId) => getTaskHistory(taskId, database()),
+      getTaskHistoryPage: (taskId, options2) => {
+        if (!Number.isSafeInteger(options2.limit) || options2.limit < 1 || options2.limit > 500) {
+          throw new Error("Task history limit must be an integer from 1 to 500");
+        }
+        if (!Number.isSafeInteger(options2.offset) || options2.offset < 0) {
+          throw new Error("Task history offset must be a non-negative integer");
+        }
+        const conditions = ["task_id = ?"];
+        const values = [taskId];
+        if (options2.since) {
+          conditions.push("created_at >= ?");
+          values.push(options2.since);
+        }
+        if (options2.until) {
+          conditions.push("created_at <= ?");
+          values.push(options2.until);
+        }
+        const where = conditions.join(" AND ");
+        const total = database().query(`SELECT COUNT(*) AS total FROM task_history WHERE ${where}`).get(...values).total;
+        const direction = options2.order === "asc" ? "ASC" : "DESC";
+        const history = database().query(`SELECT * FROM task_history WHERE ${where} ORDER BY created_at ${direction}, id ${direction} LIMIT ? OFFSET ?`).all(...values, options2.limit, options2.offset);
+        return { history, total };
+      },
       getRecentActivity: (limit) => getRecentActivity(limit, database())
     },
     sync: {
@@ -30247,6 +30450,8 @@ function createPostgresTodosStorageAdapter(options) {
       count: (filter = {}) => store.countTasks(filter),
       update: (id, input, context) => updateTask2(id, input, store, context),
       delete: (id, context) => store.deleteTaskHierarchy(id, context),
+      bulkCreateAtomic: (inputs, context) => bulkCreateTasksAtomic(inputs, store, context),
+      bulkDeleteAtomic: (ids2, force, context) => bulkDeleteTasksAtomic(ids2, force, store, context),
       start: (id, agentId) => startTask2(id, agentId, store),
       complete: (id, agentId, options2) => completeTask2(id, agentId, options2, store),
       fail: (id, agentId, reason, options2) => failTask2(id, agentId, reason, options2, store),
@@ -30263,6 +30468,7 @@ function createPostgresTodosStorageAdapter(options) {
       add: (taskId, dependsOn, context) => addDependency2(taskId, dependsOn, store, context),
       remove: (taskId, dependsOn) => removeDependency2(taskId, dependsOn, store),
       list: (taskId) => listDependencies(taskId, store),
+      listPage: (page) => store.listDependencyPage(page),
       listAll: () => store.list("dependencies")
     },
     verifications: {
@@ -30328,6 +30534,7 @@ function createPostgresTodosStorageAdapter(options) {
       get: (id) => store.get("agents", id),
       getByName: async (name) => matchAgentByName(await store.list("agents"), name),
       list: async (options2) => (await store.list("agents")).filter((agent) => options2?.include_archived || agent.status !== "archived").sort((a, b) => a.name.localeCompare(b.name)),
+      listPage: (options2) => store.listAgentPage(options2),
       update: (id, input) => updateAgent2(id, input, store),
       heartbeat: (idOrName, context) => heartbeatAgent(idOrName, store, context),
       release: (idOrName, sessionId, context) => releaseAgent2(idOrName, sessionId, store, context)
@@ -30385,8 +30592,9 @@ function createPostgresTodosStorageAdapter(options) {
       getCommentsPage: async (taskId, options2) => {
         return (await store.listComments(taskId, options2)).map(redactComment).sort((a, b) => a.created_at.localeCompare(b.created_at) || a.id.localeCompare(b.id));
       },
-      getTaskHistory: async (taskId) => (await store.list("audit_history")).filter((entry2) => entry2.task_id === taskId).sort((a, b) => a.created_at.localeCompare(b.created_at)),
-      getRecentActivity: async (limit = 20) => (await store.list("audit_history")).sort((a, b) => b.created_at.localeCompare(a.created_at)).slice(0, limit)
+      getTaskHistory: async (taskId) => (await store.list("audit_history")).filter((entry2) => entry2.task_id === taskId).sort((a, b) => b.created_at.localeCompare(a.created_at) || b.id.localeCompare(a.id)),
+      getTaskHistoryPage: (taskId, options2) => store.listTaskHistoryPage(taskId, options2),
+      getRecentActivity: (limit = 20) => store.listRecentActivity(limit)
     },
     machines: createPostgresMachineRegistry(options.client, options.service ?? "todos", options.tableName ?? DEFAULT_TODOS_POSTGRES_SYNC_TABLE, () => store.ensureSchema()),
     atomicProjectMigration: createAtomicProjectMigration({ client: options.client, table: options.tableName ?? DEFAULT_TODOS_POSTGRES_SYNC_TABLE, service: options.service ?? "todos", ensureSchema: () => store.ensureSchema() }),
@@ -30423,6 +30631,8 @@ class PostgresJsonRecordStore {
   }
   async withDependencyGraphTransaction(fn) {
     await this.ensureSchema();
+    if (this.projectIntegrityLocked)
+      return fn(this);
     return this.withTaskParentIntegrityTransaction(async (client) => {
       const scoped = new PostgresJsonRecordStore({ ...this.options, client });
       scoped.schemaReady = Promise.resolve();
@@ -30569,6 +30779,128 @@ class PostgresJsonRecordStore {
   async list(type) {
     return (await this.listRecords(type)).map((record) => record.payload);
   }
+  async listAgentPage(options) {
+    const { limit, offset } = options;
+    if (!Number.isSafeInteger(limit) || limit < 1 || limit > 500) {
+      throw new Error("Postgres agent page limit must be an integer from 1 to 500");
+    }
+    if (!Number.isSafeInteger(offset) || offset < 0) {
+      throw new Error("Postgres agent page offset must be a non-negative integer");
+    }
+    await this.ensureSchema();
+    const result = await this.options.client.query(`/* todos:list-agent-page */ WITH filtered AS (
+         SELECT object_id, payload
+         FROM ${this.tableName}
+         WHERE service = $1 AND object_type = 'agents' AND deleted_at IS NULL
+           AND ($2::boolean OR COALESCE(payload->>'status', 'active') <> 'archived')
+       ), page AS (
+         SELECT object_id, payload FROM filtered
+         ORDER BY LOWER(payload->>'name'), object_id
+         LIMIT $3 OFFSET $4
+       )
+       SELECT (SELECT count(*) FROM filtered) AS total,
+              COALESCE((SELECT jsonb_agg(payload ORDER BY LOWER(payload->>'name'), object_id) FROM page), '[]'::jsonb) AS agents`, [this.service, options.include_archived === true, limit, offset]);
+    const row = result.rows[0];
+    const total = Number(row?.total);
+    if (!Number.isSafeInteger(total) || total < 0 || !Array.isArray(row?.agents)) {
+      throw new Error("Postgres agent page returned invalid count or agents");
+    }
+    if (row.agents.length > limit || row.agents.length > 0 && offset + row.agents.length > total) {
+      throw new Error("Postgres agent page exceeded its requested bounds");
+    }
+    return { agents: row.agents.map((value) => payloadRecord2(value)), total };
+  }
+  async listRecentActivity(limit) {
+    if (!Number.isSafeInteger(limit) || limit < 1 || limit > 1e4) {
+      throw new Error("Postgres recent activity limit must be an integer from 1 to 10000");
+    }
+    await this.ensureSchema();
+    const result = await this.options.client.query(`/* todos:list-recent-activity */ SELECT payload
+       FROM ${this.tableName}
+       WHERE service = $1 AND object_type = 'audit_history' AND deleted_at IS NULL
+       ORDER BY payload->>'created_at' DESC, object_id DESC
+       LIMIT $2`, [this.service, limit]);
+    return result.rows.map((row) => payloadRecord2(row.payload));
+  }
+  async listTaskHistoryPage(taskId, options) {
+    const { limit, offset } = options;
+    if (!Number.isSafeInteger(limit) || limit < 1 || limit > 500) {
+      throw new Error("Postgres task history limit must be an integer from 1 to 500");
+    }
+    if (!Number.isSafeInteger(offset) || offset < 0) {
+      throw new Error("Postgres task history offset must be a non-negative integer");
+    }
+    await this.ensureSchema();
+    const direction = options.order === "asc" ? "ASC" : "DESC";
+    const result = await this.options.client.query(`/* todos:list-task-history-page */ WITH filtered AS (
+         SELECT object_id, payload, payload->>'created_at' AS created_at
+         FROM ${this.tableName}
+         WHERE service = $1 AND object_type = 'audit_history' AND deleted_at IS NULL
+           AND payload->>'task_id' = $2
+           AND ($3::text IS NULL OR payload->>'created_at' >= $3)
+           AND ($4::text IS NULL OR payload->>'created_at' <= $4)
+       ), page AS (
+         SELECT object_id, payload, created_at FROM filtered
+         ORDER BY created_at ${direction}, object_id ${direction}
+         LIMIT $5 OFFSET $6
+       )
+       SELECT (SELECT count(*) FROM filtered) AS total,
+              COALESCE((SELECT jsonb_agg(payload ORDER BY created_at ${direction}, object_id ${direction}) FROM page), '[]'::jsonb) AS history`, [this.service, taskId, options.since ?? null, options.until ?? null, limit, offset]);
+    const row = result.rows[0];
+    const total = Number(row?.total);
+    if (!Number.isSafeInteger(total) || total < 0 || !Array.isArray(row?.history)) {
+      throw new Error("Postgres task history page returned invalid count or history");
+    }
+    if (row.history.length > limit || row.history.length > 0 && offset + row.history.length > total) {
+      throw new Error("Postgres task history page exceeded its requested bounds");
+    }
+    return { history: row.history.map((value) => payloadRecord2(value)), total };
+  }
+  async listDependencyPage(options) {
+    const { limit, offset } = options;
+    if (!Number.isSafeInteger(limit) || limit < 1 || limit > 500) {
+      throw new Error("Postgres dependency page limit must be an integer from 1 to 500");
+    }
+    if (!Number.isSafeInteger(offset) || offset < 0) {
+      throw new Error("Postgres dependency page offset must be a non-negative integer");
+    }
+    await this.ensureSchema();
+    const result = await this.options.client.query(`/* todos:list-dependencies-page */ WITH page AS (
+         SELECT payload, updated_at, object_id
+         FROM ${this.tableName}
+         WHERE service = $1 AND object_type = 'dependencies' AND deleted_at IS NULL
+         ORDER BY updated_at ASC, object_id ASC
+         LIMIT $2 OFFSET $3
+       )
+       SELECT
+         (SELECT COUNT(*)::text FROM ${this.tableName}
+          WHERE service = $1 AND object_type = 'dependencies' AND deleted_at IS NULL) AS total,
+         COALESCE(
+           jsonb_agg(page.payload ORDER BY page.updated_at ASC, page.object_id ASC)
+             FILTER (WHERE page.payload IS NOT NULL),
+           '[]'::jsonb
+         ) AS dependencies
+       FROM page`, [this.service, limit, offset]);
+    const row = result.rows[0];
+    const totalText = typeof row?.total === "string" ? row.total : typeof row?.total === "number" && Number.isSafeInteger(row.total) ? String(row.total) : null;
+    if (totalText === null || !/^\d+$/.test(totalText)) {
+      throw new Error("Postgres dependency page returned an invalid total");
+    }
+    const total = Number(totalText);
+    if (!Number.isSafeInteger(total)) {
+      throw new Error("Postgres dependency page total exceeds the safe integer range");
+    }
+    if (!Array.isArray(row?.dependencies)) {
+      throw new Error("Postgres dependency page returned an invalid dependencies array");
+    }
+    if (row.dependencies.length > limit || offset + row.dependencies.length > total) {
+      throw new Error("Postgres dependency page returned rows outside the requested bound");
+    }
+    return {
+      dependencies: row.dependencies.map((value) => payloadRecord2(value)),
+      total
+    };
+  }
   async listComments(taskId, options = {}) {
     await this.ensureSchema();
     const limit = options.limit ?? 100;
@@ -30644,7 +30976,9 @@ class PostgresJsonRecordStore {
         return "1=0";
       return `${column} IN (${values.map((v) => p(v)).join(", ")})`;
     };
-    if (filter.include_archived === false)
+    if (filter.archived_only === true)
+      conds.push(`(payload->>'archived_at' IS NOT NULL)`);
+    else if (filter.include_archived === false)
       conds.push(`(payload->>'archived_at' IS NULL)`);
     if (filter.ids)
       conds.push(inClause("payload->>'id'", filter.ids));
@@ -30701,7 +31035,7 @@ class PostgresJsonRecordStore {
   async listTasks(filter) {
     await this.ensureSchema();
     const { where, params, queryRef } = await this.buildTaskFilterSql(filter);
-    const orderBy = queryRef ? `ORDER BY ts_rank_cd(task_search_tsv, websearch_to_tsquery('simple', todos_immutable_unaccent(${queryRef}))) DESC, ${TASK_ORDER_TIEBREAK}` : TASK_ORDER_BY;
+    const orderBy = filter.archived_only ? `ORDER BY payload->>'archived_at' DESC, object_id DESC` : queryRef ? `ORDER BY ts_rank_cd(task_search_tsv, websearch_to_tsquery('simple', todos_immutable_unaccent(${queryRef}))) DESC, ${TASK_ORDER_TIEBREAK}` : TASK_ORDER_BY;
     let sql = `/* todos:list-tasks */ SELECT payload FROM ${this.tableName} WHERE ${where} ${orderBy}`;
     if (filter.limit !== undefined) {
       params.push(filter.limit);
@@ -30921,6 +31255,8 @@ class PostgresJsonRecordStore {
     if (planIds.length === 0 && !parentGuard)
       return this.upsert("tasks", value, context);
     await this.ensureSchema();
+    if (!queryClient && this.projectIntegrityLocked)
+      queryClient = this.options.client;
     if (!queryClient) {
       return this.withTaskParentIntegrityTransaction((client2) => this.upsertTaskWithPlanMembershipGuard(value, guardedPlanIds, explicitProject, context, parentGuard, client2));
     }
@@ -31458,9 +31794,11 @@ class PostgresJsonRecordStore {
   }
   async deleteTaskHierarchy(id, context = {}) {
     await this.ensureSchema();
-    return this.withTaskParentIntegrityTransaction(async (client) => {
-      const timestamp3 = new Date().toISOString();
-      const result = await client.query(`/* todos:task-parent-integrity-delete */ WITH RECURSIVE
+    if (!this.projectIntegrityLocked) {
+      return this.withDependencyGraphTransaction((scoped) => scoped.deleteTaskHierarchy(id, context));
+    }
+    const timestamp3 = new Date().toISOString();
+    const result = await this.options.client.query(`/* todos:task-parent-integrity-delete */ WITH RECURSIVE
        task_tree(object_id, path, cycle) AS (
          SELECT task.object_id, ARRAY[task.object_id], false
          FROM ${this.tableName} AS task
@@ -31522,13 +31860,12 @@ class PostgresJsonRecordStore {
        SELECT EXISTS (SELECT 1 FROM task_tree WHERE object_id = $2) AS found,
               (SELECT count(*) FROM tombstoned) AS deleted_count,
               (SELECT count(*) FROM tombstoned_related) AS related_deleted_count`, [
-        this.service,
-        id,
-        timestamp3,
-        context.requestId ?? this.sourceMachineId ?? null
-      ]);
-      return Boolean(result.rows[0]?.found);
-    });
+      this.service,
+      id,
+      timestamp3,
+      context.requestId ?? this.sourceMachineId ?? null
+    ]);
+    return Boolean(result.rows[0]?.found);
   }
   async getPlanProjectLinkReceipt(receiptId) {
     const value = await this.get("plan_project_link_receipts", receiptId);
@@ -31984,6 +32321,102 @@ class PostgresJsonRecordStore {
          updated_at = EXCLUDED.updated_at`, [this.service, name, value]);
   }
 }
+async function bulkCreateTasksAtomic(inputs, store, context) {
+  return store.withDependencyGraphTransaction(async (scoped) => {
+    const tempIds = new Map;
+    const created = [];
+    const dependencies = [];
+    for (const input of inputs) {
+      const { temp_id, depends_on: _dependsOn, ...taskInput } = input;
+      const task2 = await createTask2(taskInput, scoped, context);
+      if (temp_id)
+        tempIds.set(temp_id, task2.id);
+      created.push({ temp_id: temp_id ?? null, id: task2.id, short_id: task2.short_id, title: task2.title });
+    }
+    for (let index = 0;index < inputs.length; index++) {
+      const input = inputs[index];
+      const taskId = created[index].id;
+      const seenDependencies = new Set;
+      for (const reference of input.depends_on ?? []) {
+        const exact = tempIds.get(reference) ?? (await scoped.get("tasks", reference))?.id;
+        const dependencyId = exact ?? (await scoped.resolveTaskRef(reference))?.id;
+        if (!dependencyId)
+          throw new TaskNotFoundError(reference);
+        if (seenDependencies.has(dependencyId)) {
+          throw new ResourceConflictError("BULK_CREATE_DUPLICATE_DEPENDENCY", `Multiple references resolve to dependency ${dependencyId}`);
+        }
+        seenDependencies.add(dependencyId);
+        dependencies.push(await addDependency2(taskId, dependencyId, scoped, context));
+      }
+    }
+    return { schema_version: 1, atomic: true, created, dependencies };
+  });
+}
+async function bulkDeleteTasksAtomic(ids2, force, store, context) {
+  return store.withDependencyGraphTransaction(async (scoped) => {
+    const resolved = [];
+    for (const reference of ids2) {
+      resolved.push({
+        reference,
+        task: await scoped.get("tasks", reference) ?? await scoped.resolveTaskRef(reference)
+      });
+    }
+    const seen = new Set;
+    for (const item of resolved) {
+      if (!item.task)
+        continue;
+      if (seen.has(item.task.id)) {
+        throw new ResourceConflictError("BULK_DELETE_DUPLICATE_TASK", `Multiple references resolve to task ${item.task.id}`);
+      }
+      seen.add(item.task.id);
+    }
+    const childState = new Map;
+    for (const item of resolved) {
+      if (!item.task)
+        continue;
+      const children = await scoped.listTasks({ parent_id: item.task.id, include_subtasks: true, limit: 1 });
+      childState.set(item.task.id, children.length > 0);
+    }
+    const planned = resolved.filter((item) => item.task && (force || !childState.get(item.task.id)));
+    const plannedIds = new Set(planned.map((item) => item.task.id));
+    const roots = [];
+    for (const item of planned) {
+      if (!force) {
+        roots.push(item);
+        continue;
+      }
+      let parentId = item.task.parent_id;
+      let covered = false;
+      while (parentId) {
+        if (plannedIds.has(parentId)) {
+          covered = true;
+          break;
+        }
+        parentId = (await scoped.get("tasks", parentId))?.parent_id ?? null;
+      }
+      if (!covered)
+        roots.push(item);
+    }
+    for (const item of roots) {
+      if (!await scoped.deleteTaskHierarchy(item.task.id, context)) {
+        throw new Error(`Atomic bulk delete lost task ${item.task.id}`);
+      }
+    }
+    return {
+      schema_version: 1,
+      atomic: true,
+      force,
+      results: resolved.map((item) => {
+        if (!item.task)
+          return { requested_id: item.reference, task_id: null, outcome: "missing", reason: "not_found" };
+        if (!force && childState.get(item.task.id)) {
+          return { requested_id: item.reference, task_id: item.task.id, outcome: "skipped", reason: "has_children" };
+        }
+        return { requested_id: item.reference, task_id: item.task.id, outcome: "deleted", reason: null };
+      })
+    };
+  });
+}
 async function createTask2(input, store, context) {
   const timestamp3 = new Date().toISOString();
   const taskId = randomUUID4();
@@ -32074,12 +32507,16 @@ async function updateTask2(id, input, store, context) {
       }
     }
   }
+  const patchTouchesPlacement = input.project_id !== undefined || input.task_list_id !== undefined;
+  const effectiveProjectIdForShortId = input.project_id !== undefined ? input.project_id : existing.project_id;
+  const backfilledShortId = existing.short_id === null && patchTouchesPlacement && effectiveProjectIdForShortId ? await nextTaskShortId2(effectiveProjectIdForShortId, store, context) : null;
   const reopened = existing.status === "completed" && input.status !== undefined && input.status !== "completed" && input.completed_at === undefined;
   const terminalNow = input.status !== undefined && isTerminalStatus(input.status);
   const task2 = {
     ...existing,
     ...definedPatch(input),
     ...terminalNow ? { locked_by: null, locked_at: null } : {},
+    short_id: backfilledShortId ?? existing.short_id,
     version: existing.version + 1,
     updated_at: new Date().toISOString(),
     tags: input.tags ?? existing.tags,
@@ -34730,15 +35167,16 @@ function assertTodosPriorRegistrationAdoptionValidationEnvelope(value, input) {
 // src/sdk/resolve.ts
 init_local_opt_in();
 var TODOS_LOCAL_SERVE_URL = "http://localhost:19427";
+var TODOS_CREDENTIAL_MISSING_MESSAGE = "TODOS_CREDENTIAL_MISSING: no Hasna Todos credential resolved. Looked at " + "HASNA_TODOS_API_KEY_OVERRIDE / HASNA_PROFILE / HASNA_TODOS_API_KEY_REF, the Keychain item " + "hasna.credentials.todos.api-key, ~/.hasna/todos/config/credentials, then HASNA_TODOS_API_KEY. " + "There is no local fallback: the on-box todos-serve is opt-in only (HASNA_TODOS_LOCAL=1, alias " + "TODOS_LOCAL=1) and is disabled by default \u2014 failing closed.";
 var localNoticePrinted = false;
 function stripV1(baseUrl) {
   return baseUrl.replace(/\/+$/, "").replace(/\/v1$/, "");
 }
-function announceLocal(notice, reason) {
+function announceLocal(notice) {
   if (localNoticePrinted)
     return;
   localNoticePrinted = true;
-  const line = `todos: LOCAL mode \u2014 no Hasna credential resolved (${reason}); reading and writing the local ` + `todos-serve at ${TODOS_LOCAL_SERVE_URL}, not the hosted fleet. Set HASNA_TODOS_API_KEY, add the ` + `Keychain item hasna.credentials.todos.api-key, or write ~/.hasna/todos/config/credentials to go hosted.`;
+  const line = `todos: LOCAL mode \u2014 HASNA_TODOS_LOCAL is set and nothing configures a Todos authority; reading and ` + `writing the local todos-serve at ${TODOS_LOCAL_SERVE_URL}, not the hosted fleet. Unset it, and ` + `provide a credential via the Keychain item hasna.credentials.todos.api-key, ` + `~/.hasna/todos/config/credentials, or HASNA_TODOS_API_KEY, to work against https://api.hasna.com/todos.`;
   if (notice)
     notice(line);
   else if (typeof process !== "undefined")
@@ -34762,7 +35200,7 @@ function resolveTodosSdkTransport(options = {}) {
     };
   }
   if (selectsTodosLocalStore(env2)) {
-    announceLocal(options.notice, "HASNA_TODOS_LOCAL is set and nothing configures an authority");
+    announceLocal(options.notice);
     return {
       mode: "local-serve",
       baseUrl: TODOS_LOCAL_SERVE_URL,
@@ -34780,14 +35218,7 @@ function resolveTodosSdkTransport(options = {}) {
     resolution = resolveClientTransport("todos", env2, chainOptions);
   } catch (error) {
     if (error instanceof ClientTransportConfigurationError && /is not set and no API key could be resolved/.test(error.message)) {
-      announceLocal(options.notice, "nothing configured a Hasna Todos credential");
-      return {
-        mode: "local-serve",
-        baseUrl: TODOS_LOCAL_SERVE_URL,
-        apiKey: null,
-        apiKeySource: null,
-        apiUrlSource: "local-serve"
-      };
+      throw new Error(`${TODOS_CREDENTIAL_MISSING_MESSAGE} ${error.message}`, { cause: error });
     }
     throw error;
   }
@@ -48211,6 +48642,10 @@ function rethrowAuthorityFailure(error) {
   throw new Error(`REMOTE_API_URL_INVALID: ${message} local SQLite fallback is disabled`, { cause: error });
 }
 function classifyRemoteRequestError(baseUrl, route, error) {
+  const errorName = error instanceof Error ? error.name : "";
+  if (errorName === "CredentialResolutionError" || errorName === "CredentialFileUnsafeError") {
+    rethrowAuthorityFailure(error);
+  }
   const status3 = error && typeof error === "object" ? error.status : undefined;
   if (status3 === 401) {
     throw new Error(`REMOTE_API_UNAUTHORIZED: configured Todos authority ${baseUrl} rejected HASNA_TODOS_API_KEY for ${route}; ` + "local SQLite fallback is disabled", { cause: error });
@@ -48359,6 +48794,10 @@ function toListQuery(filter = {}) {
     query["parent_id"] = filter.parent_id ?? "";
   if (filter.include_subtasks !== undefined)
     query["include_subtasks"] = filter.include_subtasks ? "true" : "false";
+  if (filter.include_archived !== undefined)
+    query["include_archived"] = filter.include_archived ? "true" : "false";
+  if (filter.archived_only !== undefined)
+    query["archived_only"] = filter.archived_only ? "true" : "false";
   if (filter.plan_id)
     query["plan_id"] = filter.plan_id;
   if (filter.task_list_id)
@@ -54871,7 +55310,7 @@ function formatTraceabilityReport(report) {
 }
 // src/lib/mention-resolver.ts
 import { existsSync as existsSync17, readdirSync as readdirSync3, readFileSync as readFileSync13, statSync as statSync6 } from "fs";
-import { basename as basename4, isAbsolute, join as join15, relative as relative4, resolve as resolve17, sep as sep2 } from "path";
+import { basename as basename4, isAbsolute as isAbsolute2, join as join15, relative as relative4, resolve as resolve17, sep as sep2 } from "path";
 init_database();
 init_plans();
 init_task_runs();
@@ -54954,7 +55393,7 @@ function normalizeWorkspace(workspace) {
 }
 function isInside(root, absolutePath) {
   const rel = relative4(root, absolutePath);
-  return rel === "" || !rel.startsWith("..") && !rel.includes(`..${sep2}`) && !isAbsolute(rel);
+  return rel === "" || !rel.startsWith("..") && !rel.includes(`..${sep2}`) && !isAbsolute2(rel);
 }
 function normalizeRelativePath(value) {
   const normalized2 = value.trim().replace(/^\.?\//, "").replace(/\\/g, "/");
@@ -64038,7 +64477,6 @@ var ALL_MCP_TOOLS = [
   "export_todos_md",
   "export_verification_evidence",
   "extend_task",
-  "extract_todos",
   "fail_agent_run",
   "fail_task",
   "find_duplicate_tasks",