@hasna/todos 0.13.6 → 0.13.8

package/dist/server/index.js

@@ -70,7 +70,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@hasna/todos",
-    version: "0.13.6",
+    version: "0.13.8",
     description: "Universal task management for AI coding agents - CLI + MCP server + interactive TUI",
     type: "module",
     main: "dist/index.js",
@@ -11956,6 +11956,50 @@ var init_checklists = __esm(() => {
   init_database();
 });
 
+// src/lib/creator-identity.ts
+import { existsSync as existsSync6, rmSync } from "fs";
+import { join as join5 } from "path";
+function identityFilePath() {
+  return join5(getTodosGlobalDir(), "identity.json");
+}
+function readPersistedIdentity() {
+  const path = identityFilePath();
+  if (!existsSync6(path))
+    return null;
+  const parsed = readJsonFile(path);
+  if (!parsed || typeof parsed.agent_id !== "string" || !parsed.agent_id.trim())
+    return null;
+  return parsed;
+}
+function canonicalAgentRef(value) {
+  return value.trim().toLowerCase();
+}
+function isProcessBoundSource(source) {
+  return source === "explicit" || source === "env";
+}
+function resolveWritableIdentity(explicit) {
+  const resolved = resolveCreatorIdentity(explicit);
+  if (!isProcessBoundSource(resolved.source))
+    return { agent_id: null, source: "none" };
+  return resolved;
+}
+function resolveCreatorIdentity(explicit) {
+  const fromExplicit = explicit?.trim();
+  if (fromExplicit)
+    return { agent_id: canonicalAgentRef(fromExplicit), source: "explicit" };
+  const fromEnv = (process.env["TODOS_AGENT_ID"] || process.env["HASNA_TODOS_AGENT_ID"] || "").trim();
+  if (fromEnv)
+    return { agent_id: canonicalAgentRef(fromEnv), source: "env" };
+  const persisted = readPersistedIdentity();
+  if (persisted) {
+    return { agent_id: canonicalAgentRef(persisted.agent_name || persisted.agent_id), source: "persisted" };
+  }
+  return { agent_id: null, source: "none" };
+}
+var init_creator_identity = __esm(() => {
+  init_sync_utils();
+});
+
 // src/lib/recurrence.ts
 function parseRecurrenceRule(rule) {
   const normalized = rule.trim().toLowerCase();
@@ -12682,6 +12726,11 @@ __export(exports_task_lifecycle, {
   claimOrSteal: () => claimOrSteal,
   claimNextTask: () => claimNextTask2
 });
+function sameHolder(stored, incoming) {
+  if (!stored || !incoming)
+    return false;
+  return canonicalAgentRef(stored) === canonicalAgentRef(incoming);
+}
 function lockExpiresAt(lockedAt) {
   if (!lockedAt)
     return null;
@@ -12732,13 +12781,13 @@ function startTask2(id, agentId, db) {
   const cutoff = lockExpiryCutoff();
   const timestamp2 = now();
   const result = d.run(`UPDATE tasks SET status = 'in_progress', assigned_to = ?, locked_by = ?, locked_at = ?, started_at = COALESCE(started_at, ?), version = version + 1, updated_at = ?
-     WHERE id = ? AND status IN ('pending', 'in_progress') AND (locked_by IS NULL OR locked_by = ? OR locked_at < ?)`, [agentId, agentId, timestamp2, timestamp2, timestamp2, id, agentId, cutoff]);
+     WHERE id = ? AND status IN ('pending', 'in_progress') AND (locked_by IS NULL OR LOWER(TRIM(locked_by)) = LOWER(TRIM(?)) OR locked_at < ?)`, [agentId, agentId, timestamp2, timestamp2, timestamp2, id, agentId, cutoff]);
   if (result.changes === 0) {
     const current = getTask(id, d);
     if (!current)
       throw new TaskNotFoundError(id);
     assertStartable(current, agentId);
-    if (current.locked_by && current.locked_by !== agentId && !isLockExpired(current.locked_at)) {
+    if (current.locked_by && !sameHolder(current.locked_by, agentId) && !isLockExpired(current.locked_at)) {
       throw new LockError(id, current.locked_by);
     }
     throw new Error(`Task ${id} could not be started because it changed during claim`);
@@ -12763,7 +12812,7 @@ function completeTask2(id, agentId, db, options) {
   if (task.status === "cancelled") {
     throw new Error(`Task ${id} is cancelled and cannot be completed`);
   }
-  if (agentId && task.locked_by && task.locked_by !== agentId && !isLockExpired(task.locked_at)) {
+  if (agentId && task.locked_by && !sameHolder(task.locked_by, agentId) && !isLockExpired(task.locked_at)) {
     throw new LockError(id, task.locked_by);
   }
   checkCompletionGuard(task, agentId || null, d);
@@ -12885,16 +12934,16 @@ function lockTask2(id, agentId, db) {
       error: `Task is ${task.status} and cannot be locked`
     };
   }
-  if (task.locked_by === agentId && !isLockExpired(task.locked_at)) {
+  if (sameHolder(task.locked_by, agentId) && !isLockExpired(task.locked_at)) {
     const timestamp3 = now();
-    d.run(`UPDATE tasks SET locked_at = ?, updated_at = ?, version = version + 1 WHERE id = ? AND locked_by = ?`, [timestamp3, timestamp3, id, agentId]);
+    d.run(`UPDATE tasks SET locked_at = ?, updated_at = ?, version = version + 1 WHERE id = ? AND LOWER(TRIM(locked_by)) = LOWER(TRIM(?))`, [timestamp3, timestamp3, id, agentId]);
     logTaskChange2(id, "lock_renew", "locked_by", agentId, agentId, agentId, d);
     return { success: true, locked_by: agentId, locked_at: timestamp3, expires_at: lockExpiresAt(timestamp3) };
   }
   const cutoff = lockExpiryCutoff();
   const timestamp2 = now();
   const result = d.run(`UPDATE tasks SET locked_by = ?, locked_at = ?, version = version + 1, updated_at = ?
-     WHERE id = ? AND status NOT IN ('completed', 'cancelled') AND (locked_by IS NULL OR locked_by = ? OR locked_at < ?)`, [agentId, timestamp2, timestamp2, id, agentId, cutoff]);
+     WHERE id = ? AND status NOT IN ('completed', 'cancelled') AND (locked_by IS NULL OR LOWER(TRIM(locked_by)) = LOWER(TRIM(?)) OR locked_at < ?)`, [agentId, timestamp2, timestamp2, id, agentId, cutoff]);
   if (result.changes === 0) {
     const current = getTask(id, d);
     if (!current)
@@ -12926,7 +12975,7 @@ function unlockTask2(id, agentId, db) {
   const task = getTask(id, d);
   if (!task)
     throw new TaskNotFoundError(id);
-  if (agentId && task.locked_by && task.locked_by !== agentId) {
+  if (agentId && task.locked_by && !sameHolder(task.locked_by, agentId)) {
     throw new LockError(id, task.locked_by);
   }
   const timestamp2 = now();
@@ -13219,6 +13268,7 @@ var MAX_SPAWN_DEPTH = 10;
 var init_task_lifecycle = __esm(() => {
   init_types();
   init_database();
+  init_creator_identity();
   init_completion_guard();
   init_event_emission_safety();
   init_event_hooks();
@@ -13674,6 +13724,10 @@ function updateTask2(id, input, db) {
     sets.push("description = ?");
     params.push(input.description);
   }
+  if (input.agent_id !== undefined) {
+    sets.push("agent_id = ?");
+    params.push(input.agent_id);
+  }
   if (input.status !== undefined) {
     if (input.status === "completed") {
       checkCompletionGuard(task, task.assigned_to || task.agent_id || null, d);
@@ -15126,8 +15180,8 @@ var init_boards = __esm(() => {
 
 // src/lib/artifact-store.ts
 import { createHash as createHash4 } from "crypto";
-import { existsSync as existsSync6, mkdirSync as mkdirSync4, readFileSync as readFileSync2, rmSync, statSync as statSync2, writeFileSync as writeFileSync2 } from "fs";
-import { basename, dirname as dirname4, join as join5, resolve as resolve7 } from "path";
+import { existsSync as existsSync7, mkdirSync as mkdirSync4, readFileSync as readFileSync2, rmSync as rmSync2, statSync as statSync2, writeFileSync as writeFileSync2 } from "fs";
+import { basename, dirname as dirname4, join as join6, resolve as resolve7 } from "path";
 import { tmpdir as tmpdir2 } from "os";
 function isInMemoryDb2(path) {
   return path === ":memory:" || path.startsWith("file::memory:");
@@ -15139,15 +15193,15 @@ function artifactStoreRoot() {
     return resolve7(process.env["TODOS_ARTIFACTS_DIR"]);
   const dbPath = getDatabasePath();
   if (isInMemoryDb2(dbPath))
-    return join5(tmpdir2(), "hasna-todos-artifacts");
-  return join5(dirname4(resolve7(dbPath)), "artifacts");
+    return join6(tmpdir2(), "hasna-todos-artifacts");
+  return join6(dirname4(resolve7(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 join5(artifactStoreRoot(), normalized);
+  return join6(artifactStoreRoot(), normalized);
 }
 function sha2562(buffer) {
   return createHash4("sha256").update(buffer).digest("hex");
@@ -15188,7 +15242,7 @@ function mediaTypeFor(path, textLike) {
 }
 function storeArtifactContent(input) {
   const sourcePath = resolve7(input.path);
-  if (!existsSync6(sourcePath))
+  if (!existsSync7(sourcePath))
     return null;
   const sourceStat = statSync2(sourcePath);
   if (!sourceStat.isFile())
@@ -15205,9 +15259,9 @@ function storeArtifactContent(input) {
       redactionStatus = "redacted";
   }
   const storedSha = sha2562(storedBuffer);
-  const relativePath = join5("sha256", storedSha.slice(0, 2), storedSha).replace(/\\/g, "/");
+  const relativePath = join6("sha256", storedSha.slice(0, 2), storedSha).replace(/\\/g, "/");
   const destination = artifactStorePath(relativePath);
-  if (!existsSync6(destination)) {
+  if (!existsSync7(destination)) {
     mkdirSync4(dirname4(destination), { recursive: true });
     writeFileSync2(destination, storedBuffer);
   }
@@ -15267,7 +15321,7 @@ function verifyStoredArtifact(input) {
     };
   }
   const storedPath = artifactStorePath(store.relative_path);
-  if (!existsSync6(storedPath)) {
+  if (!existsSync7(storedPath)) {
     return {
       id: input.id,
       path: input.path,
@@ -17580,8 +17634,8 @@ var exports_doctor = {};
 __export(exports_doctor, {
   runTodosDoctor: () => runTodosDoctor
 });
-import { chmodSync, copyFileSync, existsSync as existsSync7, mkdirSync as mkdirSync5, statSync as statSync3 } from "fs";
-import { basename as basename2, dirname as dirname5, join as join6 } from "path";
+import { chmodSync, copyFileSync, existsSync as existsSync8, mkdirSync as mkdirSync5, statSync as statSync3 } from "fs";
+import { basename as basename2, dirname as dirname5, join as join7 } from "path";
 function tableExists2(db, table) {
   return Boolean(db.query("SELECT name FROM sqlite_master WHERE type='table' AND name=?").get(table));
 }
@@ -17675,7 +17729,7 @@ function findMissingProjectRoots(db) {
       continue;
     if (!row.path.startsWith("/"))
       continue;
-    if (!existsSync7(row.path))
+    if (!existsSync8(row.path))
       missing++;
   }
   return missing;
@@ -17735,16 +17789,16 @@ function databasePermissionsAreUnsafe(dbPath) {
 function createBackup(dbPath) {
   if (dbPath === ":memory:" || dbPath.startsWith("file::memory:"))
     return;
-  if (!existsSync7(dbPath))
+  if (!existsSync8(dbPath))
     return;
   const stamp = now().replace(/[:.]/g, "-");
-  const backupDir = join6(dirname5(dbPath), `${basename2(dbPath)}.backup-${stamp}`);
+  const backupDir = join7(dirname5(dbPath), `${basename2(dbPath)}.backup-${stamp}`);
   const files = [];
   mkdirSync5(backupDir, { recursive: true });
   for (const source of [dbPath, `${dbPath}-wal`, `${dbPath}-shm`]) {
-    if (!existsSync7(source))
+    if (!existsSync8(source))
       continue;
-    const target = join6(backupDir, basename2(source));
+    const target = join7(backupDir, basename2(source));
     copyFileSync(source, target);
     files.push(target);
   }
@@ -18003,7 +18057,7 @@ var init_doctor = __esm(() => {
 });
 
 // src/server/routes.ts
-import { join as join7, resolve as resolve8, sep as sep2 } from "path";
+import { join as join8, resolve as resolve8, sep as sep2 } from "path";
 function parseFieldsParam(url) {
   const fieldsParam = url.searchParams.get("fields");
   return fieldsParam ? fieldsParam.split(",").map((f) => f.trim()).filter(Boolean) : undefined;
@@ -18798,7 +18852,7 @@ function handleStaticFiles(path, method, ctx, json2, serveStaticFile2) {
   if (!ctx.dashboardExists || method !== "GET" && method !== "HEAD")
     return null;
   if (path !== "/") {
-    const filePath = join7(ctx.dashboardDir, path);
+    const filePath = join8(ctx.dashboardDir, path);
     const resolvedFile = resolve8(filePath);
     const resolvedBase = resolve8(ctx.dashboardDir);
     if (!resolvedFile.startsWith(resolvedBase + sep2) && resolvedFile !== resolvedBase) {
@@ -18808,7 +18862,7 @@ function handleStaticFiles(path, method, ctx, json2, serveStaticFile2) {
     if (res2)
       return res2;
   }
-  const indexPath = join7(ctx.dashboardDir, "index.html");
+  const indexPath = join8(ctx.dashboardDir, "index.html");
   const res = serveStaticFile2(indexPath);
   if (res)
     return res;
@@ -44242,39 +44296,98 @@ var init_token_utils = __esm(() => {
   };
 });
 
-// src/lib/creator-identity.ts
-import { existsSync as existsSync8, rmSync as rmSync2 } from "fs";
-import { join as join8 } from "path";
-function identityFilePath() {
-  return join8(getTodosGlobalDir(), "identity.json");
+// src/lib/assignee-validation.ts
+import { readFileSync as readFileSync3 } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join9 } from "path";
+function defaultSeatRosterPath() {
+  return process.env["TODOS_SEAT_ROSTER_PATH"] || join9(homedir2(), ".hasna", "identities", "hasna-seats.roster.json");
 }
-function readPersistedIdentity() {
-  const path = identityFilePath();
-  if (!existsSync8(path))
-    return null;
-  const parsed = readJsonFile(path);
-  if (!parsed || typeof parsed.agent_id !== "string" || !parsed.agent_id.trim())
-    return null;
-  return parsed;
+function loadSeatSlugs(path = defaultSeatRosterPath()) {
+  try {
+    const parsed = JSON.parse(readFileSync3(path, "utf8"));
+    const slugs = new Set;
+    for (const agent of parsed.agents ?? []) {
+      if (typeof agent?.slug === "string" && agent.slug.trim()) {
+        slugs.add(normalizeAgentNameInput(agent.slug));
+      }
+    }
+    return slugs;
+  } catch {
+    return new Set;
+  }
 }
-function canonicalAgentRef(value) {
-  return value.trim().toLowerCase();
+function validateAssignee(input, ctx) {
+  const raw = input.trim();
+  const normalized = normalizeAgentNameInput(raw);
+  if (!normalized) {
+    return {
+      ok: true,
+      assignee: raw,
+      isSeat: false,
+      warning: "Assignee is empty. Use --unassigned to file this deliberately with no owner."
+    };
+  }
+  const byId = ctx.agents.find((a) => a.id.toLowerCase() === normalized);
+  const byName = ctx.agents.filter((a) => normalizeAgentNameInput(a.name) === normalized);
+  const effectiveName = byId ? normalizeAgentNameInput(byId.name) : normalized;
+  if (ctx.seats.has(effectiveName)) {
+    if (ctx.allowSeat) {
+      return { ok: true, assignee: byId ? byId.name : raw, agentId: byId?.id, isSeat: true };
+    }
+    return {
+      ok: false,
+      reason: "seat",
+      message: `'${raw}' is a durable SEAT, and a task assigned to a seat is assigned to nobody \u2014 no session is watching that queue. ` + `Assign a specific agent, use --unassigned to file it with no owner on purpose, or pass --assign-seat if filing at the seat is what you mean.`
+    };
+  }
+  if (byId) {
+    return { ok: true, assignee: byId.name, agentId: byId.id, isSeat: false };
+  }
+  if (byName.length === 0) {
+    return {
+      ok: true,
+      assignee: raw,
+      isSeat: false,
+      warning: `No agent named '${raw}' is registered yet. If that is a typo the task is now routed to nobody \u2014 ` + `check with 'todos agents'.`
+    };
+  }
+  if (byName.length > 1) {
+    const ids = byName.map((a) => a.id).sort();
+    return {
+      ok: false,
+      reason: "ambiguous",
+      message: `'${raw}' names ${byName.length} registered agents (${ids.join(", ")}), so assigning by name would pick one at random \u2014 ` + `which is how a task lands on a stranger. Pass the agent ID instead.`,
+      candidates: byName
+    };
+  }
+  return { ok: true, assignee: byName[0].name, agentId: byName[0].id, isSeat: false };
 }
-function resolveCreatorIdentity(explicit) {
-  const fromExplicit = explicit?.trim();
-  if (fromExplicit)
-    return { agent_id: canonicalAgentRef(fromExplicit), source: "explicit" };
-  const fromEnv = (process.env["TODOS_AGENT_ID"] || process.env["HASNA_TODOS_AGENT_ID"] || "").trim();
-  if (fromEnv)
-    return { agent_id: canonicalAgentRef(fromEnv), source: "env" };
-  const persisted = readPersistedIdentity();
-  if (persisted) {
-    return { agent_id: canonicalAgentRef(persisted.agent_name || persisted.agent_id), source: "persisted" };
+var init_assignee_validation = () => {};
+
+// src/lib/assignee-context.ts
+async function loadAssigneeContext(listAgentsFn, allowSeat, nowMs = Date.now()) {
+  if (!cache || nowMs - cache.at >= ROSTER_TTL_MS) {
+    let agents;
+    let degraded = false;
+    try {
+      agents = await listAgentsFn();
+    } catch {
+      agents = [];
+      degraded = true;
+    }
+    cache = {
+      at: nowMs,
+      agents: agents.map((a) => ({ id: a.id, name: a.name })),
+      seats: loadSeatSlugs(),
+      degraded
+    };
   }
-  return { agent_id: null, source: "none" };
+  return { agents: cache.agents, seats: cache.seats, allowSeat, degraded: cache.degraded };
 }
-var init_creator_identity = __esm(() => {
-  init_sync_utils();
+var ROSTER_TTL_MS = 15000, cache;
+var init_assignee_context = __esm(() => {
+  init_assignee_validation();
 });
 
 // src/pr-groups/http-client.ts
@@ -45592,6 +45705,14 @@ var init_cloud_router = __esm(() => {
 });
 
 // src/mcp/tools/task-crud.ts
+async function validateMcpAssignee(value, allowSeat) {
+  const cloud = getTodosCloudClient();
+  const ctx = await loadAssigneeContext(() => cloud ? cloudListAgents(cloud) : listAgents(), allowSeat);
+  const verdict = validateAssignee(value, ctx);
+  if (!verdict.ok)
+    throw new Error(`Cannot assign to '${value}'. ${verdict.message}`);
+  return verdict.assignee;
+}
 function registerTaskCrudTools(server, ctx) {
   const { shouldRegisterTool, resolveId, formatError: formatError2, formatTask } = ctx;
   function mutationTaskResponse(task) {
@@ -45628,6 +45749,7 @@ function registerTaskCrudTools(server, ctx) {
       assigned_to: exports_external.string().optional().describe("Agent ID or name to assign to"),
       created_by: exports_external.string().optional().describe("Agent who FILED this task. Defaults to the ambient agent identity (todos init / TODOS_AGENT_ID)."),
       unassigned: exports_external.boolean().optional().describe("Deliberately file with no assignee. Without it, the task defaults to the filer."),
+      allow_seat: exports_external.boolean().optional().describe("Allow assigned_to to name a durable seat. A seat queue has no session watching it, so this must be deliberate."),
       depends_on: exports_external.array(exports_external.string()).optional().describe("Array of task IDs this task depends on"),
       short_id: exports_external.string().nullable().optional().describe("Short ID (auto-generated if not provided, disabled if null)"),
       tags: exports_external.array(exports_external.string()).optional().describe("Tags for the task"),
@@ -45638,16 +45760,18 @@ function registerTaskCrudTools(server, ctx) {
       retry_count: exports_external.number().optional().describe("Max retry count for agent failures")
     }, async (params) => {
       try {
-        const { depends_on, assigned_to, project_id, task_list_id, tags, estimate, confidence, retry_count, deadline, created_by, unassigned, ...rest } = params;
+        const { depends_on, assigned_to, project_id, task_list_id, tags, estimate, confidence, retry_count, deadline, created_by, unassigned, allow_seat, ...rest } = params;
+        const requestedAssignee = assigned_to ? await validateMcpAssignee(assigned_to, Boolean(allow_seat)) : undefined;
         const creator = resolveCreatorIdentity(created_by);
-        const assignee = assigned_to || (unassigned ? undefined : creator.agent_id || undefined);
+        const router = resolveWritableIdentity(created_by);
+        const assignee = requestedAssignee || (unassigned ? undefined : router.agent_id || undefined);
         const cloud = getTodosCloudClient();
         if (cloud) {
           const payload = { ...rest };
-          if (creator.agent_id) {
+          if (creator.agent_id)
             payload.created_by = creator.agent_id;
-            payload.agent_id = payload.agent_id ?? creator.agent_id;
-          }
+          if (router.agent_id)
+            payload.agent_id = payload.agent_id ?? router.agent_id;
           if (assignee)
             payload.assigned_to = assignee;
           if (project_id)
@@ -45670,10 +45794,10 @@ function registerTaskCrudTools(server, ctx) {
           return { content: [{ type: "text", text: mutationTaskResponse(created) }] };
         }
         const resolved = { ...rest };
-        if (creator.agent_id) {
+        if (creator.agent_id)
           resolved.created_by = creator.agent_id;
-          resolved.agent_id = resolved.agent_id ?? creator.agent_id;
-        }
+        if (router.agent_id)
+          resolved.agent_id = resolved.agent_id ?? router.agent_id;
         if (assignee)
           resolved.assigned_to = resolveAssignee(assignee);
         if (project_id)
@@ -45709,6 +45833,7 @@ function registerTaskCrudTools(server, ctx) {
       project_id: exports_external.string().optional().describe("Project ID"),
       task_list_id: exports_external.string().optional().describe("Task list ID"),
       assigned_to: exports_external.string().optional().describe("Agent ID or name to assign to"),
+      allow_seat: exports_external.boolean().optional().describe("Allow assigned_to to name a durable seat. A seat queue has no session watching it, so this must be deliberate."),
       tags: exports_external.array(exports_external.string()).optional().describe("Tags for the task"),
       working_dir: exports_external.string().optional().describe("Working directory associated with the task"),
       metadata: exports_external.record(exports_external.unknown()).optional().describe("Metadata object to shallow-merge"),
@@ -45722,7 +45847,7 @@ function registerTaskCrudTools(server, ctx) {
       acceptance: exports_external.unknown().optional()
     }, async (params) => {
       try {
-        const { assigned_to, project_id, task_list_id, metadata, expectation_id, expectation_fingerprint, evidence_paths, origin_loop_id, origin_run_id, expected, observed, acceptance, ...rest } = params;
+        const { assigned_to, allow_seat: _allowSeatUpsert, project_id, task_list_id, metadata, expectation_id, expectation_fingerprint, evidence_paths, origin_loop_id, origin_run_id, expected, observed, acceptance, ...rest } = params;
         const mergedMetadata = { ...metadata ?? {} };
         if (expectation_id !== undefined)
           mergedMetadata["expectation_id"] = expectation_id;
@@ -45741,8 +45866,9 @@ function registerTaskCrudTools(server, ctx) {
         if (acceptance !== undefined)
           mergedMetadata["acceptance"] = acceptance;
         const resolved = { ...rest, metadata: mergedMetadata };
-        if (assigned_to)
-          resolved.assigned_to = resolveAssignee(assigned_to);
+        if (assigned_to) {
+          resolved.assigned_to = resolveAssignee(await validateMcpAssignee(assigned_to, Boolean(params.allow_seat)));
+        }
         if (project_id)
           resolved.project_id = resolveId(project_id, "projects");
         if (task_list_id)
@@ -45873,12 +45999,16 @@ ${task.description}` : null
       completed_at: exports_external.string().optional().describe("ISO timestamp for backdating completion"),
       deadline: exports_external.string().nullable().optional(),
       retry_count: exports_external.number().optional(),
+      allow_seat: exports_external.boolean().optional().describe("Allow assigned_to to name a durable seat. A seat queue has no session watching it, so this must be deliberate."),
       version: exports_external.number().optional().describe("Expected version for optimistic locking")
     }, async (params) => {
       try {
+        if (typeof params.assigned_to === "string" && params.assigned_to !== "") {
+          params.assigned_to = await validateMcpAssignee(params.assigned_to, Boolean(params.allow_seat));
+        }
         const cloud = getTodosCloudClient();
         if (cloud) {
-          const { task_id: task_id2, version: version3, estimate, deadline, ...updates2 } = params;
+          const { task_id: task_id2, version: version3, estimate, deadline, allow_seat: _allowSeatCloud, ...updates2 } = params;
           const patch = { ...updates2 };
           if (patch.assigned_to === "")
             patch.assigned_to = null;
@@ -45903,7 +46033,7 @@ ${task.description}` : null
           return { content: [{ type: "text", text: mutationTaskResponse(updated) }] };
         }
         const resolvedId = resolveId(params.task_id);
-        const { task_id, version: version2, ...updates } = params;
+        const { task_id, version: version2, allow_seat: _allowSeatLocal, ...updates } = params;
         const resolved = { ...updates };
         if (resolved.assigned_to === "")
           resolved.assigned_to = null;
@@ -45956,11 +46086,14 @@ var init_task_crud2 = __esm(() => {
   init_types();
   init_token_utils();
   init_creator_identity();
+  init_assignee_validation();
+  init_assignee_context();
+  init_agents();
   init_cloud_router();
 });
 
 // src/lib/project-bootstrap.ts
-import { existsSync as existsSync9, readFileSync as readFileSync3, statSync as statSync4 } from "fs";
+import { existsSync as existsSync9, readFileSync as readFileSync4, statSync as statSync4 } from "fs";
 import { basename as basename3, dirname as dirname6, resolve as resolve9 } from "path";
 function safeStat(path) {
   try {
@@ -45994,7 +46127,7 @@ function readPackageJson(path) {
   if (!existsSync9(file))
     return null;
   try {
-    const parsed = JSON.parse(readFileSync3(file, "utf-8"));
+    const parsed = JSON.parse(readFileSync4(file, "utf-8"));
     return parsed && typeof parsed === "object" ? parsed : null;
   } catch {
     return null;
@@ -46556,8 +46689,8 @@ var init_retention_cleanup = __esm(() => {
 });
 
 // src/lib/mention-resolver.ts
-import { existsSync as existsSync11, readdirSync as readdirSync2, readFileSync as readFileSync4, statSync as statSync5 } from "fs";
-import { basename as basename4, isAbsolute, join as join9, relative as relative3, resolve as resolve10, sep as sep3 } from "path";
+import { existsSync as existsSync11, readdirSync as readdirSync2, readFileSync as readFileSync5, statSync as statSync5 } from "fs";
+import { basename as basename4, isAbsolute, join as join10, relative as relative3, resolve as resolve10, sep as sep3 } from "path";
 function blankResolution(parsed) {
   return {
     input: parsed.input,
@@ -46665,7 +46798,7 @@ function resolveFile(parsed, workspace) {
     return resolution;
   }
   if (parsed.line !== undefined) {
-    const lineCount = readFileSync4(absolutePath, "utf-8").split(/\r?\n/).length;
+    const lineCount = readFileSync5(absolutePath, "utf-8").split(/\r?\n/).length;
     if (parsed.line < 1 || parsed.line > lineCount) {
       resolution.warnings.push(`line ${parsed.line} is outside the file range 1-${lineCount}`);
       return resolution;
@@ -46688,7 +46821,7 @@ function walkSourceFiles(root, current = root, files = []) {
       if (SKIP_DIRS.has(entry2.name))
         continue;
     }
-    const absolutePath = join9(current, entry2.name);
+    const absolutePath = join10(current, entry2.name);
     if (entry2.isDirectory()) {
       if (!SKIP_DIRS.has(entry2.name))
         walkSourceFiles(root, absolutePath, files);
@@ -46718,7 +46851,7 @@ function resolveSymbol(parsed, workspace, maxMatches) {
   const pattern = symbolPattern(name);
   const matches = [];
   for (const file of walkSourceFiles(workspace)) {
-    const lines = readFileSync4(file, "utf-8").split(/\r?\n/);
+    const lines = readFileSync5(file, "utf-8").split(/\r?\n/);
     for (let index = 0;index < lines.length; index += 1) {
       const line = lines[index];
       const found = pattern.exec(line);
@@ -50379,8 +50512,8 @@ var init_audit_ledger = __esm(() => {
 });
 
 // src/lib/release-compatibility.ts
-import { readFileSync as readFileSync5 } from "fs";
-import { join as join10, resolve as resolve12 } from "path";
+import { readFileSync as readFileSync6 } from "fs";
+import { join as join11, resolve as resolve12 } from "path";
 import { Database as Database2 } from "bun:sqlite";
 function pass(id, message, details) {
   return { id, status: "passed", message, details };
@@ -50392,7 +50525,7 @@ function warn(id, message, details) {
   return { id, status: "warning", message, details };
 }
 function readPackageJson2(root) {
-  return JSON.parse(readFileSync5(join10(root, "package.json"), "utf8"));
+  return JSON.parse(readFileSync6(join11(root, "package.json"), "utf8"));
 }
 function sortedKeys(value) {
   return Object.keys(value ?? {}).sort((left, right) => left.localeCompare(right));
@@ -80287,7 +80420,7 @@ var init_agent_run_dispatcher = __esm(() => {
 });
 
 // src/lib/verification-providers.ts
-import { existsSync as existsSync12, readFileSync as readFileSync6 } from "fs";
+import { existsSync as existsSync12, readFileSync as readFileSync7 } from "fs";
 function normalizeName5(name) {
   const normalized = name.trim().toLowerCase();
   if (!/^[a-z0-9][a-z0-9_-]{0,63}$/.test(normalized)) {
@@ -80439,7 +80572,7 @@ Timed out after ${provider.timeout_ms}ms`);
   };
 }
 function runCiLogProvider(input) {
-  const text = input.log_text ?? (input.log_path && existsSync12(input.log_path) ? readFileSync6(input.log_path, "utf-8") : "");
+  const text = input.log_text ?? (input.log_path && existsSync12(input.log_path) ? readFileSync7(input.log_path, "utf-8") : "");
   return {
     status: classifyLog(text),
     attempts: 1,
@@ -83171,7 +83304,7 @@ var init_local_bridge = __esm(() => {
 
 // src/lib/local-backups.ts
 import { createHash as createHash7 } from "crypto";
-import { readFileSync as readFileSync7, writeFileSync as writeFileSync3 } from "fs";
+import { readFileSync as readFileSync8, writeFileSync as writeFileSync3 } from "fs";
 import { dirname as dirname7, resolve as resolve13 } from "path";
 import { mkdirSync as mkdirSync6 } from "fs";
 function stableJson2(value) {
@@ -83281,7 +83414,7 @@ function writeLocalBackupFile(backup, outputPath) {
   return path;
 }
 function readLocalBackupFile(path) {
-  return JSON.parse(readFileSync7(resolve13(path), "utf-8"));
+  return JSON.parse(readFileSync8(resolve13(path), "utf-8"));
 }
 function verifyLocalBackup(value, options = {}, db) {
   const verifiedAt = options.verified_at ?? now();
@@ -84732,8 +84865,8 @@ __export(exports_local_extensions, {
   discoverLocalExtensions: () => discoverLocalExtensions
 });
 import { createHash as createHash10, createVerify } from "crypto";
-import { existsSync as existsSync13, readdirSync as readdirSync3, readFileSync as readFileSync8, statSync as statSync6 } from "fs";
-import { basename as basename5, join as join11, resolve as resolve14 } from "path";
+import { existsSync as existsSync13, readdirSync as readdirSync3, readFileSync as readFileSync9, statSync as statSync6 } from "fs";
+import { basename as basename5, join as join12, resolve as resolve14 } from "path";
 function isObject3(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
@@ -84814,7 +84947,7 @@ function normalizeManifest(input) {
   };
 }
 function parseJson(path) {
-  return JSON.parse(readFileSync8(path, "utf8"));
+  return JSON.parse(readFileSync9(path, "utf8"));
 }
 function sha2566(bytes) {
   return `sha256:${createHash10("sha256").update(bytes).digest("hex")}`;
@@ -84995,10 +85128,10 @@ function inspectExtensionSource(source3) {
   if (!existsSync13(resolved))
     throw new Error(`extension source not found: ${source3}`);
   const stat = statSync6(resolved);
-  const manifestPath = stat.isDirectory() ? [join11(resolved, "todos.extension.json"), join11(resolved, "extension.json")].find(existsSync13) : resolved;
+  const manifestPath = stat.isDirectory() ? [join12(resolved, "todos.extension.json"), join12(resolved, "extension.json")].find(existsSync13) : resolved;
   if (!manifestPath)
     throw new Error(`extension directory ${source3} is missing todos.extension.json`);
-  const raw = readFileSync8(manifestPath);
+  const raw = readFileSync9(manifestPath);
   const parsed = parseJson(manifestPath);
   const bundle = isObject3(parsed) && isObject3(parsed["manifest"]);
   const manifest = normalizeManifest(bundle ? parsed["manifest"] : parsed);
@@ -85091,15 +85224,15 @@ function projectExtensionSources(projectPath) {
     return [];
   const root = resolve14(projectPath);
   const candidates = [
-    join11(root, "todos.extension.json"),
-    join11(root, ".todos", "todos.extension.json")
+    join12(root, "todos.extension.json"),
+    join12(root, ".todos", "todos.extension.json")
   ];
-  const extensionDir = join11(root, ".todos", "extensions");
+  const extensionDir = join12(root, ".todos", "extensions");
   if (existsSync13(extensionDir)) {
     for (const entry2 of readdirSync3(extensionDir)) {
       if (entry2.startsWith("."))
         continue;
-      const full = join11(extensionDir, entry2);
+      const full = join12(extensionDir, entry2);
       if (statSync6(full).isDirectory() || entry2.endsWith(".json"))
         candidates.push(full);
     }
@@ -89511,9 +89644,9 @@ __export(exports_extract, {
   buildCodebaseIndex: () => buildCodebaseIndex,
   EXTRACT_TAGS: () => EXTRACT_TAGS
 });
-import { existsSync as existsSync14, readFileSync as readFileSync9, statSync as statSync7 } from "fs";
+import { existsSync as existsSync14, readFileSync as readFileSync10, statSync as statSync7 } from "fs";
 import { createHash as createHash12 } from "crypto";
-import { relative as relative5, resolve as resolve15, join as join12 } from "path";
+import { relative as relative5, resolve as resolve15, join as join13 } from "path";
 function stableHash(value) {
   return createHash12("sha256").update(value).digest("hex");
 }
@@ -89522,11 +89655,11 @@ function normalizePathForMatch(value) {
 }
 function readGitignorePatterns(basePath) {
   const root = statSync7(basePath).isFile() ? resolve15(basePath, "..") : basePath;
-  const gitignorePath = join12(root, ".gitignore");
+  const gitignorePath = join13(root, ".gitignore");
   if (!existsSync14(gitignorePath))
     return [];
   try {
-    return readFileSync9(gitignorePath, "utf-8").split(`
+    return readFileSync10(gitignorePath, "utf-8").split(`
 `).map((line) => line.trim()).filter((line) => line && !line.startsWith("#") && !line.startsWith("!"));
   } catch {
     return [];
@@ -89665,9 +89798,9 @@ function buildCodebaseIndex(options) {
   const files = collectFiles(basePath, extensions, excludes, respectGitignore);
   const indexed = [];
   for (const file of files) {
-    const fullPath = statSync7(basePath).isFile() ? basePath : join12(basePath, file);
+    const fullPath = statSync7(basePath).isFile() ? basePath : join13(basePath, file);
     try {
-      const source3 = readFileSync9(fullPath, "utf-8");
+      const source3 = readFileSync10(fullPath, "utf-8");
       const relPath = statSync7(basePath).isFile() ? relative5(resolve15(basePath, ".."), fullPath) : file;
       indexed.push({
         file: relPath,
@@ -89696,9 +89829,9 @@ function extractTodos(options, db) {
   const files = collectFiles(basePath, extensions, excludes, respectGitignore);
   const allComments = [];
   for (const file of files) {
-    const fullPath = statSync7(basePath).isFile() ? basePath : join12(basePath, file);
+    const fullPath = statSync7(basePath).isFile() ? basePath : join13(basePath, file);
     try {
-      const source3 = readFileSync9(fullPath, "utf-8");
+      const source3 = readFileSync10(fullPath, "utf-8");
       const relPath = statSync7(basePath).isFile() ? relative5(resolve15(basePath, ".."), fullPath) : file;
       const comments = extractFromSource(source3, relPath, tags);
       allComments.push(...comments);
@@ -90647,7 +90780,7 @@ __export(exports_builtin_templates, {
   BUILTIN_TEMPLATES: () => BUILTIN_TEMPLATES
 });
 import { mkdirSync as mkdirSync7, writeFileSync as writeFileSync4 } from "fs";
-import { join as join13 } from "path";
+import { join as join14 } from "path";
 function templateMetadata(template) {
   return {
     source: BUILTIN_TEMPLATE_LIBRARY_SOURCE,
@@ -90706,7 +90839,7 @@ function writeBuiltinTemplateFiles(directory) {
   mkdirSync7(directory, { recursive: true });
   const files = [];
   for (const entry2 of exportBuiltinTemplateFiles()) {
-    const path = join13(directory, entry2.filename);
+    const path = join14(directory, entry2.filename);
     writeFileSync4(path, `${JSON.stringify(entry2.template, null, 2)}
 `, "utf-8");
     files.push(path);
@@ -91232,28 +91365,28 @@ __export(exports_environment_snapshots, {
   captureEnvironmentSnapshot: () => captureEnvironmentSnapshot
 });
 import { createHash as createHash13 } from "crypto";
-import { existsSync as existsSync15, readFileSync as readFileSync10, statSync as statSync8 } from "fs";
+import { existsSync as existsSync15, readFileSync as readFileSync11, statSync as statSync8 } from "fs";
 import { hostname as hostname3, platform, arch } from "os";
-import { dirname as dirname8, join as join14, resolve as resolve16 } from "path";
+import { dirname as dirname8, join as join15, resolve as resolve16 } from "path";
 import { tmpdir as tmpdir3 } from "os";
 function sha2567(value) {
   return createHash13("sha256").update(value).digest("hex");
 }
 function fileRecord(root, relativePath) {
-  const path = join14(root, relativePath);
+  const path = join15(root, relativePath);
   if (!existsSync15(path))
     return null;
   const stat = statSync8(path);
   if (!stat.isFile())
     return null;
-  const content = readFileSync10(path);
+  const content = readFileSync11(path);
   return { path: relativePath, sha256: sha2567(content), size_bytes: content.length };
 }
 function manifestRecord(root, relativePath) {
   const base = fileRecord(root, relativePath);
   if (!base)
     return null;
-  const parsed = readJsonFile(join14(root, relativePath));
+  const parsed = readJsonFile(join15(root, relativePath));
   if (!parsed)
     return { ...base, redacted: {} };
   const redacted = redactValue({
@@ -91348,8 +91481,8 @@ function commandEnv(env, includeValues) {
 function defaultSnapshotDir() {
   const dbPath = getDatabasePath();
   if (dbPath === ":memory:" || dbPath.startsWith("file::memory:"))
-    return join14(tmpdir3(), "hasna-todos", "environment-snapshots");
-  return join14(dirname8(resolve16(dbPath)), "environment-snapshots");
+    return join15(tmpdir3(), "hasna-todos", "environment-snapshots");
+  return join15(dirname8(resolve16(dbPath)), "environment-snapshots");
 }
 function snapshotWithId(snapshot) {
   const digest = sha2567(JSON.stringify(snapshot)).slice(0, 24);
@@ -91396,7 +91529,7 @@ function captureEnvironmentSnapshot(input = {}) {
   });
 }
 function writeEnvironmentSnapshot(snapshot, outputPath) {
-  const path = outputPath ? resolve16(outputPath) : join14(defaultSnapshotDir(), `${snapshot.id}.json`);
+  const path = outputPath ? resolve16(outputPath) : join15(defaultSnapshotDir(), `${snapshot.id}.json`);
   ensureDir(dirname8(path));
   writeJsonFile(path, snapshot);
   return path;
@@ -92320,26 +92453,26 @@ __export(exports_serve, {
   MIME_TYPES: () => MIME_TYPES
 });
 import { existsSync as existsSync16 } from "fs";
-import { join as join15, dirname as dirname9, extname } from "path";
+import { join as join16, dirname as dirname9, extname } from "path";
 import { fileURLToPath } from "url";
 function resolveDashboardDir() {
   const candidates = [];
   try {
     const scriptDir = dirname9(fileURLToPath(import.meta.url));
-    candidates.push(join15(scriptDir, "..", "dashboard", "dist"));
-    candidates.push(join15(scriptDir, "..", "..", "dashboard", "dist"));
+    candidates.push(join16(scriptDir, "..", "dashboard", "dist"));
+    candidates.push(join16(scriptDir, "..", "..", "dashboard", "dist"));
   } catch {}
   if (process.argv[1]) {
     const mainDir = dirname9(process.argv[1]);
-    candidates.push(join15(mainDir, "..", "dashboard", "dist"));
-    candidates.push(join15(mainDir, "..", "..", "dashboard", "dist"));
+    candidates.push(join16(mainDir, "..", "dashboard", "dist"));
+    candidates.push(join16(mainDir, "..", "..", "dashboard", "dist"));
   }
-  candidates.push(join15(process.cwd(), "dashboard", "dist"));
+  candidates.push(join16(process.cwd(), "dashboard", "dist"));
   for (const candidate of candidates) {
     if (existsSync16(candidate))
       return candidate;
   }
-  return join15(process.cwd(), "dashboard", "dist");
+  return join16(process.cwd(), "dashboard", "dist");
 }
 function getProvidedApiKey(req) {
   const headerKey = req.headers.get("x-api-key");