@hasna/todos 0.16.0 → 0.17.0

package/dist/storage.js

@@ -4324,20 +4324,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]);
   });
@@ -4377,7 +4374,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();
@@ -4402,7 +4412,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) {
@@ -4459,8 +4469,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(rowToTask2);
 }
 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)
@@ -13891,6 +13932,7 @@ function searchTasks(options, projectId, taskListId, db) {
 
 // src/storage/local-sqlite.ts
 init_tasks();
+init_task_graph();
 init_projects();
 init_plans();
 
@@ -14454,6 +14496,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]);
@@ -15782,6 +15837,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 task = createTask(taskInput, db);
+      if (temp_id)
+        tempIds.set(temp_id, task.id);
+      created.push({ temp_id: temp_id ?? null, id: task.id, short_id: task.short_id, title: task.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, ids, force) {
+  return db.transaction(() => {
+    const resolved = ids.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();
@@ -15878,6 +16025,8 @@ function createLocalSqliteTodosStorageAdapter(options = {}) {
       },
       handoffStaleLock: (input) => handoffStaleTaskLock(input, database()),
       delete: (id) => deleteTask(id, database()),
+      bulkCreateAtomic: (inputs, _context) => bulkCreateAtomicSqlite(database(), inputs),
+      bulkDeleteAtomic: (ids, force, _context) => bulkDeleteAtomicSqlite(database(), ids, 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()),
@@ -15886,6 +16035,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()),
@@ -15929,6 +16102,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: {
@@ -15967,6 +16141,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: {
@@ -17733,6 +17930,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: (ids, force, context) => bulkDeleteTasksAtomic(ids, 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),
@@ -17749,6 +17948,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: {
@@ -17814,6 +18014,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)
@@ -17871,8 +18072,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() }),
@@ -17909,6 +18111,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();
@@ -18055,6 +18259,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;
@@ -18130,7 +18456,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));
@@ -18187,7 +18515,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);
@@ -18407,6 +18735,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));
     }
@@ -18944,9 +19274,11 @@ class PostgresJsonRecordStore {
   }
   async deleteTaskHierarchy(id, context = {}) {
     await this.ensureSchema();
-    return this.withTaskParentIntegrityTransaction(async (client) => {
-      const timestamp2 = 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 timestamp2 = 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
@@ -19008,13 +19340,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,
-        timestamp2,
-        context.requestId ?? this.sourceMachineId ?? null
-      ]);
-      return Boolean(result.rows[0]?.found);
-    });
+      this.service,
+      id,
+      timestamp2,
+      context.requestId ?? this.sourceMachineId ?? null
+    ]);
+    return Boolean(result.rows[0]?.found);
   }
   async getPlanProjectLinkReceipt(receiptId) {
     const value = await this.get("plan_project_link_receipts", receiptId);
@@ -19470,6 +19801,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 task = await createTask2(taskInput, scoped, context);
+      if (temp_id)
+        tempIds.set(temp_id, task.id);
+      created.push({ temp_id: temp_id ?? null, id: task.id, short_id: task.short_id, title: task.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(ids, force, store, context) {
+  return store.withDependencyGraphTransaction(async (scoped) => {
+    const resolved = [];
+    for (const reference of ids) {
+      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 timestamp2 = new Date().toISOString();
   const taskId = randomUUID4();
@@ -19560,12 +19987,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 task = {
     ...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,