@hasna/todos 0.15.20 → 0.15.24

package/dist/cli/index.js

@@ -2123,7 +2123,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@hasna/todos",
-    version: "0.15.20",
+    version: "0.15.24",
     description: "Universal task management for AI coding agents - CLI + MCP server + interactive TUI",
     type: "module",
     main: "dist/index.js",
@@ -2600,6 +2600,7 @@ __export(exports_config, {
   resetConfig: () => resetConfig,
   normalizeApiUrl: () => normalizeApiUrl,
   loadConfig: () => loadConfig,
+  getTodosAiConfig: () => getTodosAiConfig,
   getTaskPrefixConfig: () => getTaskPrefixConfig,
   getSyncAgentsFromConfig: () => getSyncAgentsFromConfig,
   getLocalApiConfig: () => getLocalApiConfig,
@@ -2609,7 +2610,7 @@ __export(exports_config, {
   getAgentTaskListId: () => getAgentTaskListId,
   getAgentPoolForProject: () => getAgentPoolForProject
 });
-import { existsSync as existsSync2 } from "fs";
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
 import { dirname, join as join2 } from "path";
 function getConfigPath() {
   return join2(getTodosGlobalDir(), "config.json");
@@ -2644,6 +2645,22 @@ function saveConfig(config) {
 function updateConfig(patch) {
   return saveConfig({ ...loadConfig(), ...patch });
 }
+function getTodosAiConfig() {
+  const configPath = getConfigPath();
+  if (!existsSync2(configPath))
+    return {};
+  const parsed = JSON.parse(readFileSync2(configPath, "utf8"));
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error("Todos config must be a JSON object");
+  }
+  const ai = parsed["ai"];
+  if (ai === undefined)
+    return {};
+  if (ai === null || typeof ai !== "object" || Array.isArray(ai)) {
+    throw new Error("Todos AI configuration must be an object");
+  }
+  return { ...ai };
+}
 function normalizeApiUrl(value) {
   const trimmed = value?.trim();
   if (!trimmed)
@@ -5998,8 +6015,12 @@ async function cloudGetTask(client, id) {
   const raw = await client.get("tasks", id);
   return raw == null ? null : unwrapTask(raw);
 }
-async function cloudCreateTask(client, input) {
+async function cloudCreateTask(client, input, verification = {}) {
   const expectedParentId = typeof input["parent_id"] === "string" ? input["parent_id"] : null;
+  const expectedCreatedBy = typeof verification.expectedCreatedBy === "string" && verification.expectedCreatedBy.trim() ? verification.expectedCreatedBy : null;
+  if (expectedCreatedBy !== null) {
+    await requireTaskCreatorCapability(client);
+  }
   const created = unwrapTask(await requiredRemoteRoute(client, "/v1/tasks", () => client.transport.post("/tasks", input, {
     idempotencyKey: randomUUID(),
     retry: false
@@ -6008,8 +6029,9 @@ async function cloudCreateTask(client, input) {
     throw new Error(`REMOTE_API_INCOMPATIBLE: configured Todos authority ${remoteAuthorityBase(client)} returned a task create ` + "response without a stored task id; no success row or local SQLite fallback is permitted");
   }
   const persisted = await cloudGetTask(client, created.id);
-  if (!persisted || persisted.id !== created.id || (persisted.parent_id ?? null) !== expectedParentId) {
-    throw new Error(`TASK_CREATE_PERSISTENCE_UNVERIFIED: configured Todos authority ${remoteAuthorityBase(client)} accepted ` + `POST /v1/tasks but authoritative GET /v1/tasks/${encodeURIComponent(created.id)} did not return the same ` + "stored task id and parent_id; no success row or local SQLite fallback is permitted");
+  if (!persisted || persisted.id !== created.id || (persisted.parent_id ?? null) !== expectedParentId || expectedCreatedBy !== null && persisted.created_by !== expectedCreatedBy) {
+    const creatorDetail = expectedCreatedBy === null ? "" : ` and explicit created_by=${JSON.stringify(expectedCreatedBy)} ` + `(readback ${JSON.stringify(persisted?.created_by ?? null)})`;
+    throw new Error(`TASK_CREATE_PERSISTENCE_UNVERIFIED: configured Todos authority ${remoteAuthorityBase(client)} accepted ` + `POST /v1/tasks but authoritative GET /v1/tasks/${encodeURIComponent(created.id)} did not return the same ` + `stored task id and parent_id${creatorDetail}; no success row or local SQLite fallback is permitted`);
   }
   return persisted;
 }
@@ -6115,6 +6137,33 @@ function resolveOpenApiSchema(document, schema) {
   }
   return current && typeof current === "object" && !Array.isArray(current) ? current : null;
 }
+function openApiSchemaProperty(document, schemaName, propertyName) {
+  const schema = resolveOpenApiSchema(document, {
+    $ref: `#/components/schemas/${schemaName}`
+  });
+  const properties = schema?.["properties"];
+  if (!properties || typeof properties !== "object" || Array.isArray(properties))
+    return null;
+  const property = properties[propertyName];
+  return property && typeof property === "object" && !Array.isArray(property) ? property : null;
+}
+async function fetchTaskCreatorCapability(client) {
+  const document = await requiredRemoteRoute(client, "/v1/openapi.json", () => client.transport.get("/openapi.json"));
+  const inputProperty = openApiSchemaProperty(document, "CreateTaskInput", "created_by");
+  const outputProperty = openApiSchemaProperty(document, "Task", "created_by");
+  return inputProperty?.["type"] === "string" && outputProperty?.["type"] === "string" && outputProperty?.["nullable"] === true;
+}
+async function requireTaskCreatorCapability(client) {
+  const authority = remoteAuthorityBase(client);
+  let capability = taskCreatorCapabilityCache.get(authority);
+  if (!capability) {
+    capability = fetchTaskCreatorCapability(client);
+    taskCreatorCapabilityCache.set(authority, capability);
+  }
+  if (!await capability) {
+    throw new Error(`REMOTE_CREATED_BY_UNSUPPORTED: configured Todos authority ${authority} does not advertise created_by ` + "on both CreateTaskInput and Task in /v1/openapi.json; no task mutation was sent; deploy a compatible " + "@hasna/todos /v1 server before retrying; local SQLite fallback is disabled");
+  }
+}
 async function fetchRetryCapability(client) {
   const document = await requiredRemoteRoute(client, "/v1/openapi.json", () => client.transport.get("/openapi.json"));
   if (!document || typeof document !== "object" || Array.isArray(document))
@@ -6667,6 +6716,30 @@ function openApiHasOperation(document, path, method) {
   const route = paths[path];
   return Boolean(route && typeof route === "object" && !Array.isArray(route) && route[method] && typeof route[method] === "object");
 }
+async function fetchTodosRemoteCommandCapabilities(client) {
+  const document = await requiredRemoteRoute(client, "/v1/openapi.json", () => client.transport.get("/openapi.json"));
+  const supported = new Set;
+  if (openApiHasOperation(document, "/v1/tasks/{id}/stale-lock-handoff", "post")) {
+    supported.add("stale-lock-handoff");
+  }
+  return supported;
+}
+async function getTodosRemoteCommandCapabilities(client) {
+  const authority = remoteAuthorityBase(client);
+  let capabilities = remoteCommandCapabilityCache.get(authority);
+  if (!capabilities) {
+    capabilities = fetchTodosRemoteCommandCapabilities(client);
+    remoteCommandCapabilityCache.set(authority, capabilities);
+  }
+  return capabilities;
+}
+async function requireStaleLockHandoffCapability(client) {
+  const authority = remoteAuthorityBase(client);
+  const capabilities = await getTodosRemoteCommandCapabilities(client);
+  if (!capabilities.has("stale-lock-handoff")) {
+    throw new Error(`REMOTE_STALE_LOCK_HANDOFF_UNSUPPORTED: configured Todos authority ${authority} does not advertise ` + "POST /v1/tasks/{id}/stale-lock-handoff; no lock mutation was sent; deploy a compatible " + "@hasna/todos /v1 server before retrying; local SQLite fallback is disabled");
+  }
+}
 async function fetchGitRefCapabilities(client) {
   const document = await requiredRemoteRoute(client, "/v1/openapi.json", () => client.transport.get("/openapi.json"));
   const supported = new Set;
@@ -6766,6 +6839,7 @@ async function cloudUnlockTask(client, id, agentId, force = false) {
   return true;
 }
 async function cloudHandoffStaleTaskLock(client, input) {
+  await requireStaleLockHandoffCapability(client);
   const raw = await client.transport.post(`/tasks/${encodeURIComponent(input.task_id)}/stale-lock-handoff`, {
     expected_holder: input.expected_holder,
     expected_lock_version: input.expected_lock_version,
@@ -7213,7 +7287,7 @@ async function cloudTimeline(client, options = {}) {
   const limit = options.limit ?? 50;
   return { entries: entries.slice(offset, offset + limit), total, limit, offset };
 }
-var UUID_RE, TRANSPORT_TOKENS, COMPLETION_EVIDENCE_FIELDS, completionCapabilityCache, retryCapabilityCache, gitRefCapabilityCache, SERVER_MODE_CANDIDATES, cachedServerMode = null, PRIORITY_RANK, listTagsCapabilityCache, PLAN_COMPLETION_PROTECTED_FIELDS, RELATION_HYDRATION_CONCURRENCY = 6;
+var UUID_RE, TRANSPORT_TOKENS, COMPLETION_EVIDENCE_FIELDS, completionCapabilityCache, retryCapabilityCache, taskCreatorCapabilityCache, gitRefCapabilityCache, remoteCommandCapabilityCache, SERVER_MODE_CANDIDATES, cachedServerMode = null, PRIORITY_RANK, listTagsCapabilityCache, PLAN_COMPLETION_PROTECTED_FIELDS, RELATION_HYDRATION_CONCURRENCY = 6;
 var init_cloud_router = __esm(() => {
   init_types();
   init_redaction();
@@ -7239,7 +7313,9 @@ var init_cloud_router = __esm(() => {
   ];
   completionCapabilityCache = new Map;
   retryCapabilityCache = new Map;
+  taskCreatorCapabilityCache = new Map;
   gitRefCapabilityCache = new Map;
+  remoteCommandCapabilityCache = new Map;
   SERVER_MODE_CANDIDATES = ["postgres", "cloud", "self_hosted"];
   PRIORITY_RANK = { critical: 0, high: 1, medium: 2, low: 3 };
   listTagsCapabilityCache = new Map;
@@ -7264,23 +7340,38 @@ function applyTodosCliAuthorityEnvironment(authority, env = process.env) {
   env.HASNA_TODOS_STORAGE_MODE = "sqlite";
   env.TODOS_STORAGE_MODE = "sqlite";
 }
-function isTodosCliCommandVisibleForRoute(command, route) {
+function isTodosCliCommandVisibleForRoute(command, route, remoteCapabilities = new Set) {
   if (route === "local")
     return true;
   const owner = COMMAND_CAPABILITY_MATRIX.get(command);
   if (!owner)
     return true;
-  return owner !== "local-only";
+  if (owner === "local-only")
+    return false;
+  const requiredCapability = REMOTE_COMMAND_CAPABILITIES.get(command);
+  return requiredCapability ? remoteCapabilities.has(requiredCapability) : true;
 }
-function applyTodosCliHelpVisibility(program2, route) {
+function applyTodosCliHelpVisibility(program2, route, remoteCapabilities = new Set) {
   if (route === "local")
     return;
   program2.configureHelp({
     visibleCommands(command) {
-      return Help.prototype.visibleCommands.call(this, command).filter((subcommand) => isTodosCliCommandVisibleForRoute(subcommand.name(), route));
+      return Help.prototype.visibleCommands.call(this, command).filter((subcommand) => isTodosCliCommandVisibleForRoute(subcommand.name(), route, remoteCapabilities));
     }
   });
 }
+function getUnavailableTodosCliRemoteMetadataCommand(route, remoteCapabilities = new Set, args = []) {
+  if (route === "local")
+    return null;
+  const invocation = parseInvocation([...args]);
+  if (!isMetadataInvocation([...args], invocation))
+    return null;
+  const requestedCommand = invocation.command === "help" ? positionalArgs(invocation.commandArgs)[0] : invocation.command;
+  if (!requestedCommand)
+    return null;
+  const requiredCapability = REMOTE_COMMAND_CAPABILITIES.get(requestedCommand);
+  return requiredCapability && !remoteCapabilities.has(requiredCapability) ? requestedCommand : null;
+}
 function parseInvocation(args) {
   const localTokens = [];
   const globalOptions = new Set;
@@ -7337,6 +7428,12 @@ function hasOption(args, option) {
 function positionalArgs(args) {
   return args.filter((arg) => !arg.startsWith("-"));
 }
+function isHostedLocalInvocation(invocation) {
+  if (invocation.command !== "redaction")
+    return false;
+  const subcommand = positionalArgs(invocation.commandArgs)[0];
+  return subcommand === "status" || subcommand === "add" || subcommand === "scan";
+}
 function isBundledStaticInvocation(invocation) {
   const command = invocation.command;
   if (!command)
@@ -7492,7 +7589,7 @@ function assertInvocationRoutable(invocation) {
 function assertRemoteCommandSupported(invocation, owner) {
   const command = invocation.command;
   if (command && owner === "local-only") {
-    throw new Error(`LOCAL_COMMAND_ROUTING_INVARIANT: \`${command}\` must select the local command route before remote authority validation`);
+    throw new Error(`REMOTE_COMMAND_UNSUPPORTED: \`${command}\` is a local-only command and the Todos /v1 authority does not ` + "serve it; local SQLite fallback is disabled. Run `todos --help` to see the commands this route supports.");
   }
   if (!command || !commandSupportsRemote(invocation)) {
     const blame = command ? disqualifyingArgument(invocation) : null;
@@ -7511,7 +7608,7 @@ function initializeTodosCliAuthority(args = process.argv.slice(2), env = process
     return { route: "remote-diagnostic", v1_base_url: status.v1_base_url };
   }
   const owner = assertInvocationRoutable(invocation);
-  if (owner === "local-only") {
+  if (owner === "local-only" && isHostedLocalInvocation(invocation)) {
     return { route: "local", v1_base_url: null, selected_by: "local-only-command" };
   }
   assertRemoteCommandSupported(invocation, owner);
@@ -7521,7 +7618,7 @@ function initializeTodosCliAuthority(args = process.argv.slice(2), env = process
   }
   return { route: "remote-http", v1_base_url: client.baseUrl };
 }
-var REGISTERED_CANONICAL_COMMANDS, TODOS_CLI_COMMAND_ALIASES, BUNDLED_STATIC_COMMANDS, BUNDLED_STATIC_STORE_BACKED_OPTIONS, DIAGNOSTIC_COMMANDS, REMOTE_COMMANDS, COMMAND_CAPABILITY_MATRIX, GLOBAL_OPTIONS_WITH_VALUES, GLOBAL_FLAGS, HELP_FLAGS, VERSION_FLAGS, dropIt = (blame) => ({ blame, remedy: "re-run without it" });
+var REGISTERED_CANONICAL_COMMANDS, TODOS_CLI_COMMAND_ALIASES, BUNDLED_STATIC_COMMANDS, BUNDLED_STATIC_STORE_BACKED_OPTIONS, DIAGNOSTIC_COMMANDS, REMOTE_COMMANDS, REMOTE_COMMAND_CAPABILITIES, COMMAND_CAPABILITY_MATRIX, GLOBAL_OPTIONS_WITH_VALUES, GLOBAL_FLAGS, HELP_FLAGS, VERSION_FLAGS, dropIt = (blame) => ({ blame, remedy: "re-run without it" });
 var init_stage_a = __esm(() => {
   init_esm();
   init_cloud_router();
@@ -7533,6 +7630,7 @@ var init_stage_a = __esm(() => {
     "agent-update",
     "agents",
     "agents-normalize",
+    "ai",
     "api-keys",
     "approvals",
     "approve",
@@ -7740,6 +7838,7 @@ var init_stage_a = __esm(() => {
     "add",
     "agent",
     "agents",
+    "ai",
     "approve",
     "assign",
     "bulk",
@@ -7793,6 +7892,16 @@ var init_stage_a = __esm(() => {
     "untag",
     "update"
   ]);
+  REMOTE_COMMAND_CAPABILITIES = new Map([
+    ["stale-lock-handoff", "stale-lock-handoff"]
+  ]);
+  for (const [canonical, aliases] of Object.entries(TODOS_CLI_COMMAND_ALIASES)) {
+    const requiredCapability = REMOTE_COMMAND_CAPABILITIES.get(canonical);
+    if (!requiredCapability)
+      continue;
+    for (const alias of aliases)
+      REMOTE_COMMAND_CAPABILITIES.set(alias, requiredCapability);
+  }
   COMMAND_CAPABILITY_MATRIX = new Map;
   for (const command of REGISTERED_CANONICAL_COMMANDS)
     COMMAND_CAPABILITY_MATRIX.set(command, "local-only");
@@ -12804,7 +12913,7 @@ __export(exports_helpers, {
 });
 import chalk from "chalk";
 import { execSync } from "child_process";
-import { existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync2, writeFileSync as writeFileSync2, writeSync } from "fs";
+import { existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync2, writeSync } from "fs";
 import { tmpdir } from "os";
 import { dirname as dirname3, join as join4, resolve as resolve3, sep } from "path";
 function jsonModeRequested(argv = process.argv) {
@@ -12885,7 +12994,7 @@ function readCloudTaskIdCache() {
   if (!path || !existsSync5(path))
     return { version: 1, tasks: [] };
   try {
-    const parsed = JSON.parse(readFileSync2(path, "utf8"));
+    const parsed = JSON.parse(readFileSync3(path, "utf8"));
     if (parsed.version !== 1 || !Array.isArray(parsed.tasks))
       return { version: 1, tasks: [] };
     return {
@@ -16438,7 +16547,7 @@ function requireCanonicalLockVersion(value) {
     throw new StaleLockHandoffError("STALE_LOCK_HANDOFF_INVALID_INPUT", "expected_lock_version must be the exact canonical locked_at timestamp (YYYY-MM-DDTHH:mm:ss.sssZ)", { field: "expected_lock_version" });
   }
   const parsed = Date.parse(value);
-  if (Number.isNaN(parsed) || new Date(parsed).toISOString() !== value) {
+  if (value.startsWith("0000-") || Number.isNaN(parsed) || new Date(parsed).toISOString() !== value) {
     throw new StaleLockHandoffError("STALE_LOCK_HANDOFF_INVALID_INPUT", "expected_lock_version must name a real canonical UTC instant", { field: "expected_lock_version" });
   }
   return value;
@@ -16463,9 +16572,6 @@ function prepareStaleLockHandoff(input, options = {}) {
   if (canonicalAgentRef(actor) !== canonicalAgentRef(newHolder)) {
     throw new StaleLockHandoffError("STALE_LOCK_HANDOFF_ACTOR_MISMATCH", "new_holder must match the authenticated actor", { actor, new_holder: newHolder });
   }
-  if (canonicalAgentRef(expectedHolder) === canonicalAgentRef(newHolder)) {
-    throw new StaleLockHandoffError("STALE_LOCK_HANDOFF_INVALID_INPUT", "new_holder must differ from expected_holder", { field: "new_holder" });
-  }
   const operationTimestamp = options.now ?? new Date().toISOString();
   if (!CANONICAL_LOCK_VERSION_RE.test(operationTimestamp) || new Date(Date.parse(operationTimestamp)).toISOString() !== operationTimestamp) {
     throw new StaleLockHandoffError("STALE_LOCK_HANDOFF_INVALID_INPUT", "operation timestamp must be a canonical UTC instant");
@@ -19201,7 +19307,7 @@ var init_boards = __esm(() => {
 
 // src/lib/artifact-store.ts
 import { createHash as createHash5 } from "crypto";
-import { existsSync as existsSync8, mkdirSync as mkdirSync5, readFileSync as readFileSync3, rmSync as rmSync2, statSync as statSync2, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync8, mkdirSync as mkdirSync5, readFileSync as readFileSync4, rmSync as rmSync2, statSync as statSync2, writeFileSync as writeFileSync3 } from "fs";
 import { basename as basename2, dirname as dirname5, join as join7, resolve as resolve8 } from "path";
 import { tmpdir as tmpdir3 } from "os";
 function isInMemoryDb2(path) {
@@ -19268,7 +19374,7 @@ function storeArtifactContent(input) {
   const sourceStat = statSync2(sourcePath);
   if (!sourceStat.isFile())
     throw new Error(`Artifact path is not a file: ${sanitizePreWriteText(input.path, "artifact.path")}`);
-  const sourceBuffer = readFileSync3(sourcePath);
+  const sourceBuffer = readFileSync4(sourcePath);
   const sourceSha = sha2562(sourceBuffer);
   const textLike = isTextLike(sourceBuffer, input.path);
   let storedBuffer = sourceBuffer;
@@ -19355,7 +19461,7 @@ function verifyStoredArtifact(input) {
       message: "stored artifact content is missing"
     };
   }
-  const buffer = readFileSync3(storedPath);
+  const buffer = readFileSync4(storedPath);
   const actualSha = sha2562(buffer);
   const actualSize = buffer.length;
   const ok = actualSha === store.sha256 && actualSize === store.size_bytes;
@@ -19375,7 +19481,7 @@ function exportStoredArtifactContent(input) {
   const report = verifyStoredArtifact(input);
   if (report.status !== "ok" || !report.relative_path || !report.actual_sha256 || report.actual_size_bytes === null)
     return null;
-  const content = readFileSync3(artifactStorePath(report.relative_path));
+  const content = readFileSync4(artifactStorePath(report.relative_path));
   return {
     artifact_id: input.id,
     sha256: report.actual_sha256,
@@ -20934,7 +21040,7 @@ function normalizeAgentNameInput(name) {
 }
 
 // src/lib/assignee-validation.ts
-import { readFileSync as readFileSync4 } from "fs";
+import { readFileSync as readFileSync5 } from "fs";
 import { homedir as homedir3 } from "os";
 import { join as join8 } from "path";
 function describeAssigneeFilter(input, ctx) {
@@ -20959,7 +21065,7 @@ function defaultSeatRosterPath() {
 }
 function loadSeatSlugs(path = defaultSeatRosterPath()) {
   try {
-    const parsed = JSON.parse(readFileSync4(path, "utf8"));
+    const parsed = JSON.parse(readFileSync5(path, "utf8"));
     const slugs = new Set;
     for (const agent of parsed.agents ?? []) {
       if (typeof agent?.slug === "string" && agent.slug.trim()) {
@@ -22114,6 +22220,21 @@ function warnMissingProject(resolvedProjectId, optedOut) {
     return;
   console.error(chalk3.yellow("Warning: task filed with no project \u2014 it will not appear in any project list, per-seat report, or drain. " + "Pass --project <id-or-slug>, or --no-project if filing it globally is deliberate."));
 }
+function warnTaskRouting(task, deliberatelyUnassigned) {
+  const ownerless = !task.assigned_to && !deliberatelyUnassigned;
+  const unattributable = !task.created_by;
+  if (ownerless && unattributable) {
+    console.error(chalk3.yellow("Warning: task is ownerless and unattributable \u2014 export TODOS_AGENT_ID=<name> for this session, or pass --agent/--assign <agent> or --unassigned."));
+    return;
+  }
+  if (ownerless) {
+    console.error(chalk3.yellow("Warning: task is ownerless \u2014 export TODOS_AGENT_ID=<name> for this session, or pass --agent/--assign <agent> or --unassigned."));
+    return;
+  }
+  if (unattributable) {
+    console.error(chalk3.yellow("Warning: task is unattributable \u2014 created_by will be recorded as null. Export TODOS_AGENT_ID=<name> for this session, or pass --agent <agent>, to record who filed it."));
+  }
+}
 function parseStatus(value) {
   if (!value)
     return;
@@ -22287,6 +22408,27 @@ async function computeCloudReparent(cloud, current, opts) {
     patch.task_list_id = taskListId;
   return patch;
 }
+async function cloudUpdateTaskWithVerifiedReparent(cloud, taskId, updatePatch, reparent) {
+  const acknowledged = await cloudUpdateTask(cloud, taskId, updatePatch);
+  if (reparent.project_id === undefined && reparent.task_list_id === undefined) {
+    return acknowledged;
+  }
+  const persisted = await cloudGetTask(cloud, taskId);
+  if (!persisted) {
+    throw new Error(`TASK_REPARENT_PERSISTENCE_UNVERIFIED: PATCH /v1/tasks/${taskId} was acknowledged, ` + "but the authoritative read-back did not return the task.");
+  }
+  const mismatches = [];
+  if (reparent.project_id !== undefined && persisted.project_id !== reparent.project_id) {
+    mismatches.push(`project_id expected ${reparent.project_id}, received ${persisted.project_id ?? "null"}`);
+  }
+  if (reparent.task_list_id !== undefined && (persisted.task_list_id ?? null) !== reparent.task_list_id) {
+    mismatches.push(`task_list_id expected ${reparent.task_list_id ?? "null"}, received ${persisted.task_list_id ?? "null"}`);
+  }
+  if (mismatches.length > 0) {
+    throw new Error(`TASK_REPARENT_PERSISTENCE_UNVERIFIED: PATCH /v1/tasks/${taskId} was acknowledged, ` + `but authoritative read-back disagreed (${mismatches.join("; ")}).`);
+  }
+  return persisted;
+}
 function computeLocalReparent(current, opts) {
   const targetProjectId = opts.projectRef ? resolveProjectIdOrSlug(opts.projectRef) : undefined;
   const scope = targetProjectId ?? current.project_id ?? null;
@@ -22317,12 +22459,6 @@ function registerTaskCommands(program2) {
     const router = resolveWritableIdentity(opts.createdBy || globalOpts.agent);
     const requestedAssign = opts.assign ? await resolveValidatedAssignee(opts.assign, Boolean(opts.assignSeat), (v) => `--assign ${v} --assign-seat`) : undefined;
     const assignee = requestedAssign || (opts.unassigned ? undefined : router.agent_id || undefined);
-    const ownerless = !assignee && !opts.unassigned;
-    if (ownerless) {
-      console.error(chalk3.yellow("Warning: task is ownerless and unattributable \u2014 export TODOS_AGENT_ID=<name> for this session, or pass --agent/--assign <agent> or --unassigned."));
-    } else if (!router.agent_id) {
-      console.error(chalk3.yellow("Warning: task is unattributable \u2014 created_by will be recorded as null. Export TODOS_AGENT_ID=<name> for this session, or pass --agent <agent>, to record who filed it."));
-    }
     const cloud = getTodosCloudClient();
     if (cloud) {
       let task3;
@@ -22338,7 +22474,7 @@ function registerTaskCommands(program2) {
         if (opts.plan && !cloudPlan) {
           throw new Error(`Could not resolve plan ID or slug: ${opts.plan}`);
         }
-        task3 = await cloudCreateTask(cloud, {
+        const taskInput = {
           title,
           description: opts.description,
           priority: parsePriority(opts.priority),
@@ -22359,10 +22495,12 @@ function registerTaskCommands(program2) {
           recurrence_rule: opts.recurrence,
           due_at: opts.due ? opts.due.length === 10 ? opts.due + "T00:00:00.000Z" : opts.due : undefined,
           reason: opts.reason
-        });
+        };
+        task3 = await cloudCreateTask(cloud, taskInput, opts.createdBy && router.agent_id ? { expectedCreatedBy: router.agent_id } : undefined);
       } catch (e) {
         handleError(e);
       }
+      warnTaskRouting(task3, Boolean(opts.unassigned));
       if (globalOpts.json) {
         output(task3, true);
       } else {
@@ -22410,6 +22548,7 @@ function registerTaskCommands(program2) {
     } catch (e) {
       handleError(e);
     }
+    warnTaskRouting(task2, Boolean(opts.unassigned));
     if (globalOpts.json) {
       output(task2, true);
     } else {
@@ -22827,8 +22966,10 @@ function registerTaskCommands(program2) {
     } else {
       const resolvedId = resolveTaskId(id);
       task2 = applyLocalCommentPage(getTaskWithRelations(resolvedId), page);
-      const { getTaskGitRefs: getTaskGitRefs2 } = await Promise.resolve().then(() => (init_task_commits(), exports_task_commits));
-      task2.git_refs = getTaskGitRefs2(resolvedId);
+      if (task2) {
+        const { getTaskGitRefs: getTaskGitRefs2 } = await Promise.resolve().then(() => (init_task_commits(), exports_task_commits));
+        task2.git_refs = getTaskGitRefs2(resolvedId);
+      }
     }
     if (!task2) {
       handleError(new Error(`Task not found: ${id}`));
@@ -23170,7 +23311,7 @@ ${chalk3.cyan(sid)} ${statusColor(task2.status)} ${prioColor(task2.priority)} ${
           listRef: opts.list,
           clearList: opts.clearList
         });
-        task3 = await cloudUpdateTask(cloud, currentId, {
+        const updatePatch = {
           title: opts.title,
           description: opts.description,
           status: parseStatus(opts.status),
@@ -23186,7 +23327,8 @@ ${chalk3.cyan(sid)} ${statusColor(task2.status)} ${prioColor(task2.priority)} ${
           due_at: opts.due !== undefined ? opts.due === "" ? null : opts.due.length === 10 ? opts.due + "T00:00:00.000Z" : opts.due : undefined,
           recurrence_rule: opts.recurrence !== undefined ? opts.recurrence === "" ? null : opts.recurrence : undefined,
           requires_approval: opts.clearApproval ? false : opts.approval !== undefined ? true : undefined
-        });
+        };
+        task3 = await cloudUpdateTaskWithVerifiedReparent(cloud, currentId, updatePatch, reparent2);
       } catch (e) {
         handleError(e);
       }
@@ -23265,7 +23407,7 @@ ${chalk3.cyan(sid)} ${statusColor(task2.status)} ${prioColor(task2.priority)} ${
         if (reparent2.project_id === undefined && reparent2.task_list_id === undefined) {
           throw new Error("Nothing to move: the task is already in the requested project/list.");
         }
-        task3 = await cloudUpdateTask(cloud, currentId, reparent2);
+        task3 = await cloudUpdateTaskWithVerifiedReparent(cloud, currentId, reparent2, reparent2);
       } catch (e) {
         handleError(e);
       }
@@ -23704,7 +23846,7 @@ var init_task_commands = __esm(() => {
 });
 
 // src/lib/plan-artifacts.ts
-import { existsSync as existsSync10, mkdirSync as mkdirSync6, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "fs";
+import { existsSync as existsSync10, mkdirSync as mkdirSync6, readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "fs";
 import { join as join9, resolve as resolve10 } from "path";
 function assertSafePathSegment(value, label) {
   const trimmed = value.trim();
@@ -23943,7 +24085,7 @@ function readPlanArtifact(plan, db) {
   const path = existsSync10(paths.primary.file_path) ? paths.primary.file_path : existsSync10(paths.legacy.file_path) ? paths.legacy.file_path : null;
   if (!path)
     return null;
-  const markdown = readFileSync5(path, "utf8");
+  const markdown = readFileSync6(path, "utf8");
   return {
     path,
     markdown,
@@ -23967,7 +24109,7 @@ function inspectPlanArtifact(plan, db) {
     };
   }
   try {
-    const artifact = parsePlanArtifactMarkdown(readFileSync5(path, "utf8"));
+    const artifact = parsePlanArtifactMarkdown(readFileSync6(path, "utf8"));
     return {
       path,
       exists: true,
@@ -26543,13 +26685,13 @@ function registerPlanTemplateCommands(program2) {
   });
   program2.command("template-import [file]").alias("templates-import").description("Import a template from a JSON file").option("--file <path>", "Path to template JSON file (alternative to positional arg)").action(async (file, opts) => {
     const globalOpts = program2.opts();
-    const { readFileSync: readFileSync6 } = await import("fs");
+    const { readFileSync: readFileSync7 } = await import("fs");
     try {
       const filePath = file || opts.file;
       if (!filePath) {
         handleError(new Error("Provide a file path: todos template-import <file> or --file <path>"));
       }
-      const content = readFileSync6(filePath, "utf-8");
+      const content = readFileSync7(filePath, "utf-8");
       const json = JSON.parse(content);
       const cloud = getTodosCloudClient();
       const template = cloud ? await cloudCreateTemplate(cloud, json) : (await Promise.resolve().then(() => (init_templates(), exports_templates))).importTemplate(json);
@@ -26939,6 +27081,8 @@ function searchTaskEntities(filters, db) {
   return tasks.filter((task) => taskMatchesSavedFilters(task, filters, db)).slice(0, normalizeLimit(filters.limit));
 }
 function searchProjects(filters, db) {
+  if (filters.agent_id)
+    return [];
   const params = [];
   let sql = "SELECT * FROM projects WHERE 1=1";
   if (filters.project_id) {
@@ -27144,7 +27288,7 @@ var init_saved_search_views = __esm(() => {
 });
 
 // src/lib/claude-tasks.ts
-import { existsSync as existsSync11, readFileSync as readFileSync6, readdirSync as readdirSync2, writeFileSync as writeFileSync6 } from "fs";
+import { existsSync as existsSync11, readFileSync as readFileSync7, readdirSync as readdirSync2, writeFileSync as writeFileSync6 } from "fs";
 import { join as join11 } from "path";
 function getTaskListDir(taskListId) {
   return join11(HOME, ".claude", "tasks", taskListId);
@@ -27168,7 +27312,7 @@ function readPrefixCounter(dir) {
   const path = join11(dir, ".prefix-counter");
   if (!existsSync11(path))
     return 0;
-  const val = parseInt(readFileSync6(path, "utf-8").trim(), 10);
+  const val = parseInt(readFileSync7(path, "utf-8").trim(), 10);
   return isNaN(val) ? 0 : val;
 }
 function writePrefixCounter(dir, value) {
@@ -27940,7 +28084,7 @@ __export(exports_project_bootstrap, {
   discoverProjectWorkspace: () => discoverProjectWorkspace,
   bootstrapProject: () => bootstrapProject
 });
-import { existsSync as existsSync13, readFileSync as readFileSync7, statSync as statSync4 } from "fs";
+import { existsSync as existsSync13, readFileSync as readFileSync8, statSync as statSync4 } from "fs";
 import { basename as basename4, dirname as dirname6, resolve as resolve11 } from "path";
 function safeStat(path) {
   try {
@@ -27974,7 +28118,7 @@ function readPackageJson(path) {
   if (!existsSync13(file))
     return null;
   try {
-    const parsed = JSON.parse(readFileSync7(file, "utf-8"));
+    const parsed = JSON.parse(readFileSync8(file, "utf-8"));
     return parsed && typeof parsed === "object" ? parsed : null;
   } catch {
     return null;
@@ -28327,7 +28471,7 @@ __export(exports_extract, {
   buildCodebaseIndex: () => buildCodebaseIndex,
   EXTRACT_TAGS: () => EXTRACT_TAGS
 });
-import { existsSync as existsSync14, readFileSync as readFileSync8, statSync as statSync5 } from "fs";
+import { existsSync as existsSync14, readFileSync as readFileSync9, statSync as statSync5 } from "fs";
 import { createHash as createHash7 } from "crypto";
 import { relative as relative3, resolve as resolve12, join as join13 } from "path";
 function stableHash(value) {
@@ -28342,7 +28486,7 @@ function readGitignorePatterns(basePath) {
   if (!existsSync14(gitignorePath))
     return [];
   try {
-    return readFileSync8(gitignorePath, "utf-8").split(`
+    return readFileSync9(gitignorePath, "utf-8").split(`
 `).map((line) => line.trim()).filter((line) => line && !line.startsWith("#") && !line.startsWith("!"));
   } catch {
     return [];
@@ -28483,7 +28627,7 @@ function buildCodebaseIndex(options) {
   for (const file of files) {
     const fullPath = statSync5(basePath).isFile() ? basePath : join13(basePath, file);
     try {
-      const source = readFileSync8(fullPath, "utf-8");
+      const source = readFileSync9(fullPath, "utf-8");
       const relPath = statSync5(basePath).isFile() ? relative3(resolve12(basePath, ".."), fullPath) : file;
       indexed.push({
         file: relPath,
@@ -28514,7 +28658,7 @@ function extractTodos(options, db) {
   for (const file of files) {
     const fullPath = statSync5(basePath).isFile() ? basePath : join13(basePath, file);
     try {
-      const source = readFileSync8(fullPath, "utf-8");
+      const source = readFileSync9(fullPath, "utf-8");
       const relPath = statSync5(basePath).isFile() ? relative3(resolve12(basePath, ".."), fullPath) : file;
       const comments = extractFromSource(source, relPath, tags);
       allComments.push(...comments);
@@ -29844,7 +29988,7 @@ __export(exports_project_commands, {
   registerProjectCommands: () => registerProjectCommands
 });
 import chalk5 from "chalk";
-import { readFileSync as readFileSync9, statSync as statSync6 } from "fs";
+import { readFileSync as readFileSync10, statSync as statSync6 } from "fs";
 import { basename as basename5, resolve as resolve13, sep as sep3 } from "path";
 function collectOption(value, previous = []) {
   return [...previous, value];
@@ -30057,7 +30201,7 @@ function registerProjectCommands(program2) {
         handleError(new Error(`Comment file "${opts.file}" must be a regular file.`));
       }
       try {
-        content = readFileSync9(commentFilePath, "utf8");
+        content = readFileSync10(commentFilePath, "utf8");
       } catch (error) {
         handleError(new Error(`Unable to read comment file "${opts.file}".`, { cause: error }));
       }
@@ -30836,10 +30980,10 @@ Indexed ${result.index.files.length} file(s), ${result.index.total_symbols} symb
   program2.command("bridge-import <file>").description("Dry-run or apply a local hasna/todos bridge export bundle").option("--apply", "Apply the import. Defaults to dry-run.").option("--decrypt", "Decrypt an encrypted bridge export before importing").option("--resolve-conflicts", "Safely merge existing local tasks by filling blank fields, unioning tags, and recording unresolved divergences").action(async (file, opts) => {
     const globalOpts = program2.opts();
     try {
-      const { readFileSync: readFileSync10 } = await import("fs");
+      const { readFileSync: readFileSync11 } = await import("fs");
       const { importLocalBridgeBundle: importLocalBridgeBundle2 } = await Promise.resolve().then(() => (init_local_bridge(), exports_local_bridge));
       const { decryptBridgeBundle: decryptBridgeBundle2, isEncryptedBridgeBundle: isEncryptedBridgeBundle2 } = await Promise.resolve().then(() => (init_local_encryption(), exports_local_encryption));
-      const parsed = JSON.parse(readFileSync10(resolve13(file), "utf-8"));
+      const parsed = JSON.parse(readFileSync11(resolve13(file), "utf-8"));
       const bundle = isEncryptedBridgeBundle2(parsed) ? opts.decrypt ? decryptBridgeBundle2(parsed) : (() => {
         throw new Error("Bridge bundle is encrypted. Re-run with --decrypt and the configured key environment variable set.");
       })() : parsed;
@@ -30873,9 +31017,9 @@ Indexed ${result.index.files.length} file(s), ${result.index.total_symbols} symb
   program2.command("todos-md-import <file>").alias("markdown-import").alias("import-md").description("Dry-run or apply a local todos.md Markdown import").option("--apply", "Apply the import. Defaults to dry-run.").option("--resolve-conflicts", "Safely merge embedded bridge task conflicts while preserving local divergent fields").action(async (file, opts) => {
     const globalOpts = program2.opts();
     try {
-      const { readFileSync: readFileSync10 } = await import("fs");
+      const { readFileSync: readFileSync11 } = await import("fs");
       const { importTodosMarkdown: importTodosMarkdown2 } = await Promise.resolve().then(() => (init_todos_md(), exports_todos_md));
-      const result = importTodosMarkdown2(readFileSync10(resolve13(file), "utf-8"), { dryRun: !opts.apply, conflictStrategy: opts.resolveConflicts ? "safe_merge" : "skip" });
+      const result = importTodosMarkdown2(readFileSync11(resolve13(file), "utf-8"), { dryRun: !opts.apply, conflictStrategy: opts.resolveConflicts ? "safe_merge" : "skip" });
       const { emitLocalEventHooksQuiet: emitLocalEventHooksQuiet2 } = await Promise.resolve().then(() => (init_event_hooks(), exports_event_hooks));
       emitLocalEventHooksQuiet2({ type: "import.finished", payload: { file: resolve13(file), format: "todos.md", dry_run: result.dry_run, ok: result.ok, inserted: result.inserted, skipped: result.skipped, issues: result.issues.length } });
       if (globalOpts.json) {
@@ -31483,6 +31627,2449 @@ var init_agent_commands = __esm(() => {
   init_cloud_router();
 });
 
+// src/ai.ts
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isJsonObject(value) {
+  if (!isRecord(value))
+    return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function prototypeDefinesToJson(value) {
+  let prototype = Object.getPrototypeOf(value);
+  while (prototype !== null) {
+    if (Object.getOwnPropertyDescriptor(prototype, "toJSON") !== undefined)
+      return true;
+    prototype = Object.getPrototypeOf(prototype);
+  }
+  return false;
+}
+function isStableJsonArray(value, ancestors, depth) {
+  if (Object.getPrototypeOf(value) !== Array.prototype || prototypeDefinesToJson(value)) {
+    return false;
+  }
+  const keys = Reflect.ownKeys(value);
+  if (keys.length !== value.length + 1)
+    return false;
+  for (const key of keys) {
+    if (key === "length")
+      continue;
+    if (typeof key !== "string" || !/^(0|[1-9]\d*)$/.test(key))
+      return false;
+    const index = Number(key);
+    if (!Number.isSafeInteger(index) || index < 0 || index >= value.length)
+      return false;
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (!descriptor || !descriptor.enumerable || !("value" in descriptor))
+      return false;
+    if (!isTodosAiJsonValueInternal(descriptor.value, ancestors, depth + 1))
+      return false;
+  }
+  return true;
+}
+function isStableJsonObject(value, ancestors, depth) {
+  if (!isJsonObject(value) || prototypeDefinesToJson(value))
+    return false;
+  for (const key of Reflect.ownKeys(value)) {
+    if (typeof key !== "string")
+      return false;
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (!descriptor || !descriptor.enumerable || !("value" in descriptor))
+      return false;
+    if (!isTodosAiJsonValueInternal(descriptor.value, ancestors, depth + 1))
+      return false;
+  }
+  return true;
+}
+function isOneOf(value, values) {
+  return typeof value === "string" && values.includes(value);
+}
+function selectedString(...values) {
+  for (const value of values) {
+    if (value === undefined || value === null)
+      continue;
+    const trimmed = value.trim();
+    if (trimmed)
+      return trimmed;
+  }
+  return null;
+}
+function parseEnum(value, values, field, fallback) {
+  if (value === null)
+    return fallback;
+  if (isOneOf(value, values))
+    return value;
+  throw new TodosAiContractError("invalid_configuration", `${field} must be one of: ${values.join(", ")}`);
+}
+function parseBoundedInteger(value, field, fallback, min, max) {
+  if (value === undefined || value === null || value === "")
+    return fallback;
+  const parsed = typeof value === "number" ? value : Number(value);
+  if (!Number.isSafeInteger(parsed) || parsed < min || parsed > max) {
+    throw new TodosAiContractError("invalid_configuration", `${field} must be an integer between ${min} and ${max}`);
+  }
+  return parsed;
+}
+function normalizeApprovalRefs(values) {
+  const refs = [...new Set((values ?? []).map((value) => value.trim()).filter(Boolean))];
+  if (refs.length > TODOS_AI_LIMITS.max_approval_refs) {
+    throw new TodosAiContractError("invalid_configuration", `--approval may be repeated at most ${TODOS_AI_LIMITS.max_approval_refs} times`);
+  }
+  for (const ref of refs) {
+    if (new TextEncoder().encode(ref).byteLength > TODOS_AI_LIMITS.max_approval_ref_bytes) {
+      throw new TodosAiContractError("invalid_configuration", `--approval references may not exceed ${TODOS_AI_LIMITS.max_approval_ref_bytes} bytes`);
+    }
+  }
+  return refs;
+}
+function resolveTodosAiCommandOptions(input) {
+  const cli = input.cli ?? {};
+  const config = input.config ?? {};
+  const env = input.env ?? {};
+  const format = parseEnum(selectedString(cli.format, env["TODOS_AI_FORMAT"], config.format), TODOS_AI_FORMATS, "format", TODOS_AI_DEFAULTS.format);
+  const configuredWriteMode = parseEnum(selectedString(cli.writeMode, env["TODOS_AI_WRITE_MODE"], config.write_mode), TODOS_AI_WRITE_MODES, "write mode", TODOS_AI_DEFAULTS.write_mode);
+  if (cli.dryRun && cli.writeMode === "execute") {
+    throw new TodosAiContractError("invalid_configuration", "--dry-run cannot be combined with --write-mode execute");
+  }
+  const writeMode = cli.dryRun ? "plan" : configuredWriteMode;
+  const explicitApproval = cli.dryRun ? selectedString(cli.approvalMode) : selectedString(cli.approvalMode, env["TODOS_AI_APPROVAL_MODE"], config.approval_mode);
+  const defaultApproval = writeMode === "execute" ? input.interactive ? "prompt" : "required" : "deny";
+  const approvalMode = cli.dryRun ? parseEnum(explicitApproval, TODOS_AI_APPROVAL_MODES, "approval mode", "deny") : parseEnum(explicitApproval, TODOS_AI_APPROVAL_MODES, "approval mode", defaultApproval);
+  const approvalRefs = normalizeApprovalRefs(cli.approvalRefs);
+  if (cli.dryRun && approvalMode !== "deny") {
+    throw new TodosAiContractError("invalid_configuration", "--dry-run requires approval mode deny");
+  }
+  if (writeMode !== "execute" && approvalMode !== "deny") {
+    throw new TodosAiContractError("invalid_configuration", "approval modes other than deny require --write-mode execute");
+  }
+  if (writeMode === "execute" && approvalMode === "deny") {
+    throw new TodosAiContractError("invalid_configuration", "--write-mode execute requires approval mode required, prompt, or existing");
+  }
+  if (!input.interactive && approvalMode === "prompt") {
+    throw new TodosAiContractError("invalid_configuration", "approval mode prompt is unavailable in non-interactive mode");
+  }
+  if (approvalMode === "existing" && approvalRefs.length === 0) {
+    throw new TodosAiContractError("invalid_configuration", "approval mode existing requires at least one --approval reference");
+  }
+  if (approvalMode !== "existing" && approvalRefs.length > 0) {
+    throw new TodosAiContractError("invalid_configuration", "--approval references require --approval-mode existing");
+  }
+  return {
+    provider: selectedString(cli.provider, env["TODOS_AI_PROVIDER"], config.provider),
+    model: selectedString(cli.model, env["TODOS_AI_MODEL"], config.model),
+    profile: selectedString(cli.profile, env["TODOS_AI_PROFILE"], config.profile),
+    format,
+    max_steps: parseBoundedInteger(cli.maxSteps ?? env["TODOS_AI_MAX_STEPS"] ?? config.max_steps, "max steps", TODOS_AI_DEFAULTS.max_steps, TODOS_AI_LIMITS.min_steps, TODOS_AI_LIMITS.max_steps),
+    timeout_ms: parseBoundedInteger(cli.timeoutMs ?? env["TODOS_AI_TIMEOUT_MS"] ?? config.timeout_ms, "timeout", TODOS_AI_DEFAULTS.timeout_ms, TODOS_AI_LIMITS.min_timeout_ms, TODOS_AI_LIMITS.max_timeout_ms),
+    write_mode: writeMode,
+    approval_mode: approvalMode,
+    approval_refs: approvalRefs,
+    dry_run: cli.dryRun === true,
+    interactive: input.interactive
+  };
+}
+function normalizeTodosAiPrompt(value) {
+  const prompt = value.trim();
+  if (new TextEncoder().encode(prompt).byteLength > TODOS_AI_LIMITS.max_prompt_bytes) {
+    throw new TodosAiContractError("invalid_input", `prompt exceeds ${TODOS_AI_LIMITS.max_prompt_bytes} bytes`);
+  }
+  return prompt;
+}
+function parseTodosAiJson(value, field) {
+  if (new TextEncoder().encode(value).byteLength > TODOS_AI_LIMITS.max_json_bytes) {
+    throw new TodosAiContractError("invalid_input", `${field} exceeds ${TODOS_AI_LIMITS.max_json_bytes} bytes`);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(value);
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    throw new TodosAiContractError("invalid_input", `${field} must be valid JSON: ${detail}`);
+  }
+  if (!isTodosAiJsonValue(parsed)) {
+    throw new TodosAiContractError("invalid_input", `${field} must contain only stable JSON values`);
+  }
+  return parsed;
+}
+function parseTodosAiOutputSchema(value) {
+  const parsed = parseTodosAiJson(value, "output schema");
+  if (!isRecord(parsed)) {
+    throw new TodosAiContractError("invalid_input", "output schema must be a JSON object");
+  }
+  return parsed;
+}
+function parseTodosAiVariables(values) {
+  if (values.length > TODOS_AI_LIMITS.max_variable_count) {
+    throw new TodosAiContractError("invalid_input", `--var may be repeated at most ${TODOS_AI_LIMITS.max_variable_count} times`);
+  }
+  const variables = Object.create(null);
+  for (const entry of values) {
+    const separator = entry.indexOf("=");
+    const key = separator >= 0 ? entry.slice(0, separator).trim() : "";
+    const value = separator >= 0 ? entry.slice(separator + 1) : "";
+    if (!/^[A-Za-z_][A-Za-z0-9_.-]{0,63}$/.test(key)) {
+      throw new TodosAiContractError("invalid_input", `invalid --var entry ${JSON.stringify(entry)}; expected non-secret key=value`);
+    }
+    if (SENSITIVE_VARIABLE_KEY.test(key)) {
+      throw new TodosAiContractError("invalid_input", `--var ${key} is credential-shaped; provide credentials through the runtime's secret configuration`);
+    }
+    if (Object.hasOwn(variables, key)) {
+      throw new TodosAiContractError("invalid_input", `duplicate --var key: ${key}`);
+    }
+    if (new TextEncoder().encode(value).byteLength > TODOS_AI_LIMITS.max_variable_value_bytes) {
+      throw new TodosAiContractError("invalid_input", `--var ${key} exceeds ${TODOS_AI_LIMITS.max_variable_value_bytes} bytes`);
+    }
+    variables[key] = value;
+  }
+  return variables;
+}
+function isTodosAiJsonValue(value) {
+  return isTodosAiJsonValueInternal(value, new Set, 0);
+}
+function isTodosAiUpdateTaskResult(value) {
+  if (!isTodosAiJsonValue(value) || !isRecord(value) || !hasOnlyKeys(value, [
+    "schema",
+    "operation",
+    "mode",
+    "applied",
+    "readback_verified",
+    "source",
+    "target",
+    "changed_fields",
+    "approval_ref",
+    "payload_digest",
+    "idempotency"
+  ]) || value["schema"] !== TODOS_AI_UPDATE_TASK_RESULT_SCHEMA || value["operation"] !== "update_task" || value["mode"] !== "plan" && value["mode"] !== "execute" || value["source"] !== "sqlite" && value["source"] !== "http") {
+    return false;
+  }
+  const changedFields = value["changed_fields"];
+  const target = value["target"];
+  const idempotency = value["idempotency"];
+  const payloadDigest = value["payload_digest"];
+  const approvalRef = value["approval_ref"];
+  if (!Array.isArray(changedFields) || changedFields.length === 0 || changedFields.length > TODOS_AI_UPDATE_TASK_FIELDS.length || !changedFields.every((field) => typeof field === "string" && TODOS_AI_UPDATE_TASK_FIELDS.includes(field)) || new Set(changedFields).size !== changedFields.length || !TODOS_AI_UPDATE_TASK_FIELDS.filter((field) => changedFields.includes(field)).every((field, index) => changedFields[index] === field) || !isRecord(target) || !hasOnlyKeys(target, ["task_id", "expected_version", "result_version"]) || typeof target["task_id"] !== "string" || !/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(target["task_id"]) || !Number.isSafeInteger(target["expected_version"]) || target["expected_version"] < 0 || typeof payloadDigest !== "string" || !/^[0-9a-f]{64}$/.test(payloadDigest) || approvalRef !== `todos-ai:update_task:${payloadDigest}` || !isRecord(idempotency) || !hasOnlyKeys(idempotency, ["key", "scope", "replay"]) || !boundedUtf8String(idempotency["key"], TODOS_AI_UPDATE_TASK_LIMITS.max_idempotency_key_bytes) || new TextEncoder().encode(idempotency["key"]).byteLength < TODOS_AI_UPDATE_TASK_LIMITS.min_idempotency_key_bytes || !/^[A-Za-z0-9._:-]+$/.test(idempotency["key"]) || idempotency["scope"] !== "run" || typeof idempotency["replay"] !== "boolean" || new TextEncoder().encode(JSON.stringify(value)).byteLength > TODOS_AI_UPDATE_TASK_LIMITS.max_result_bytes) {
+    return false;
+  }
+  if (value["mode"] === "plan") {
+    return value["applied"] === false && value["readback_verified"] === false && target["result_version"] === null;
+  }
+  return value["applied"] === true && value["readback_verified"] === true && Number.isSafeInteger(target["result_version"]) && target["result_version"] === target["expected_version"] + 1;
+}
+function isTodosAiJsonValueInternal(value, ancestors, depth) {
+  if (depth > 64)
+    return false;
+  if (value === null || typeof value === "string" || typeof value === "boolean")
+    return true;
+  if (typeof value === "number")
+    return Number.isFinite(value);
+  if (typeof value !== "object")
+    return false;
+  if (ancestors.has(value))
+    return false;
+  ancestors.add(value);
+  try {
+    return Array.isArray(value) ? isStableJsonArray(value, ancestors, depth) : isStableJsonObject(value, ancestors, depth);
+  } catch {
+    return false;
+  } finally {
+    ancestors.delete(value);
+  }
+}
+function isUsage(value) {
+  if (!isRecord(value))
+    return false;
+  return ["input_tokens", "output_tokens", "total_tokens"].every((key) => Number.isSafeInteger(value[key]) && value[key] >= 0);
+}
+function hasOnlyKeys(value, keys) {
+  const allowed = new Set(keys);
+  return Reflect.ownKeys(value).every((key) => typeof key === "string" && allowed.has(key));
+}
+function boundedUtf8String(value, maximum, allowEmpty = false) {
+  return typeof value === "string" && (allowEmpty || value.length > 0) && new TextEncoder().encode(value).byteLength <= maximum;
+}
+function isPendingInput(value) {
+  if (!isRecord(value) || !hasOnlyKeys(value, ["prompt", "fields"]))
+    return false;
+  if (!boundedUtf8String(value["prompt"], TODOS_AI_LIMITS.max_pending_input_prompt_bytes)) {
+    return false;
+  }
+  if (!Array.isArray(value["fields"]) || value["fields"].length === 0 || value["fields"].length > TODOS_AI_LIMITS.max_pending_input_fields) {
+    return false;
+  }
+  const fields = value["fields"];
+  const unique4 = new Set;
+  for (const field of fields) {
+    if (!boundedUtf8String(field, TODOS_AI_LIMITS.max_pending_input_field_bytes) || !/^[A-Za-z_][A-Za-z0-9_.-]{0,127}$/.test(field) || unique4.has(field)) {
+      return false;
+    }
+    unique4.add(field);
+  }
+  return true;
+}
+function isPendingApproval(value) {
+  if (!isRecord(value) || !hasOnlyKeys(value, ["id", "summary", "operations"])) {
+    return false;
+  }
+  if (!boundedUtf8String(value["id"], TODOS_AI_LIMITS.max_pending_approval_id_bytes) || !boundedUtf8String(value["summary"], TODOS_AI_LIMITS.max_pending_approval_summary_bytes) || !Array.isArray(value["operations"]) || value["operations"].length === 0 || value["operations"].length > TODOS_AI_LIMITS.max_pending_approval_operations || !value["operations"].every(isRecord) || !value["operations"].every(isTodosAiJsonValue)) {
+    return false;
+  }
+  return new TextEncoder().encode(JSON.stringify(value)).byteLength <= TODOS_AI_LIMITS.max_pending_approval_bytes;
+}
+function isAiError(value) {
+  if (!isRecord(value))
+    return false;
+  const code = value["code"];
+  const validCode = [
+    "invalid_input",
+    "invalid_configuration",
+    "runtime_unavailable",
+    "runtime_incompatible",
+    "runtime_invalid_result",
+    "needs_input",
+    "needs_approval",
+    "timeout",
+    "interrupted",
+    "provider_error",
+    "tool_error",
+    "schema_error",
+    "internal_error"
+  ];
+  return typeof code === "string" && validCode.includes(code) && typeof value["message"] === "string" && typeof value["retryable"] === "boolean" && (value["details"] === null || isRecord(value["details"]) && isTodosAiJsonValue(value["details"]));
+}
+function isTodosAiRunResult(value) {
+  if (!isRecord(value) || !isTodosAiJsonValue(value))
+    return false;
+  const structurallyValid = value["schema_version"] === TODOS_AI_SCHEMA_VERSION && typeof value["run_id"] === "string" && Boolean(value["run_id"]) && isOneOf(value["status"], TODOS_AI_RUN_STATUSES) && (value["answer"] === null || typeof value["answer"] === "string") && isTodosAiJsonValue(value["data"]) && Number.isSafeInteger(value["steps"]) && value["steps"] >= 0 && (value["usage"] === null || isUsage(value["usage"])) && (value["pending_input"] === null || isPendingInput(value["pending_input"])) && (value["pending_approval"] === null || isPendingApproval(value["pending_approval"])) && (value["error"] === null || isAiError(value["error"]));
+  if (!structurallyValid)
+    return false;
+  switch (value["status"]) {
+    case "answered":
+      return typeof value["answer"] === "string" && value["pending_input"] === null && value["pending_approval"] === null && value["error"] === null;
+    case "completed":
+      return isTodosAiUpdateTaskResult(value["data"]) && value["data"]["mode"] === "execute" && value["data"]["applied"] === true && value["data"]["readback_verified"] === true && value["pending_input"] === null && value["pending_approval"] === null && value["error"] === null;
+    case "needs_input":
+      return value["pending_input"] !== null && value["pending_approval"] === null && value["error"] === null;
+    case "needs_approval":
+      return value["pending_input"] === null && value["pending_approval"] !== null && value["error"] === null;
+    case "failed":
+      return value["pending_input"] === null && value["pending_approval"] === null && value["error"] !== null;
+  }
+  return false;
+}
+function assertTodosAiRunResult(value) {
+  if (!isTodosAiRunResult(value)) {
+    throw new TodosAiContractError("runtime_invalid_result", "optional AI runtime returned a result that does not satisfy the Todos AI protocol", TODOS_AI_EXIT_CODES.failed);
+  }
+  return value;
+}
+function isTodosAiRuntimeEvent(value) {
+  if (!isRecord(value) || !isTodosAiJsonValue(value))
+    return false;
+  return value["schema_version"] === TODOS_AI_SCHEMA_VERSION && typeof value["run_id"] === "string" && Boolean(value["run_id"]) && Number.isSafeInteger(value["sequence"]) && value["sequence"] >= 0 && isOneOf(value["type"], TODOS_AI_RUNTIME_EVENT_TYPES) && typeof value["timestamp"] === "string" && isRecord(value["data"]) && isTodosAiJsonValue(value["data"]);
+}
+function assertTodosAiRuntimeModule(value) {
+  if (!isRecord(value) || value["TODOS_AI_RUNTIME_PROTOCOL_VERSION"] !== TODOS_AI_RUNTIME_PROTOCOL_VERSION || typeof value["createTodosAiRuntime"] !== "function") {
+    throw new TodosAiContractError("runtime_incompatible", `optional AI runtime must implement protocol ${TODOS_AI_RUNTIME_PROTOCOL_VERSION}`, TODOS_AI_EXIT_CODES.runtime_unavailable);
+  }
+  return value;
+}
+function assertTodosAiRuntime(value) {
+  if (!isRecord(value) || typeof value["run"] !== "function") {
+    throw new TodosAiContractError("runtime_incompatible", `optional AI runtime must implement protocol ${TODOS_AI_RUNTIME_PROTOCOL_VERSION}`, TODOS_AI_EXIT_CODES.runtime_unavailable);
+  }
+  return value;
+}
+async function loadTodosAiRuntime(context, importer = defaultTodosAiRuntimeImporter) {
+  let imported;
+  try {
+    imported = await importer(TODOS_AI_RUNTIME_SPECIFIER);
+  } catch (cause) {
+    throw new TodosAiContractError("runtime_unavailable", `optional AI runtime is unavailable; install a compatible ${TODOS_AI_RUNTIME_SPECIFIER}`, TODOS_AI_EXIT_CODES.runtime_unavailable, { cause });
+  }
+  const runtimeModule = assertTodosAiRuntimeModule(imported);
+  return assertTodosAiRuntime(await runtimeModule.createTodosAiRuntime(context));
+}
+function createTodosAiFailureResult(runId, code, message, retryable = false, details = null) {
+  return {
+    schema_version: TODOS_AI_SCHEMA_VERSION,
+    run_id: runId,
+    status: "failed",
+    answer: null,
+    data: null,
+    steps: 0,
+    usage: null,
+    pending_input: null,
+    pending_approval: null,
+    error: { code, message, retryable, details }
+  };
+}
+function createTodosAiNeedsInputResult(runId, message) {
+  return {
+    schema_version: TODOS_AI_SCHEMA_VERSION,
+    run_id: runId,
+    status: "needs_input",
+    answer: null,
+    data: null,
+    steps: 0,
+    usage: null,
+    pending_input: { prompt: message, fields: ["prompt"] },
+    pending_approval: null,
+    error: null
+  };
+}
+function todosAiExitCodeForResult(result) {
+  if (result.status === "answered" || result.status === "completed")
+    return TODOS_AI_EXIT_CODES.success;
+  if (result.status === "needs_input")
+    return TODOS_AI_EXIT_CODES.needs_input;
+  if (result.status === "needs_approval")
+    return TODOS_AI_EXIT_CODES.needs_approval;
+  switch (result.error?.code) {
+    case "invalid_input":
+    case "invalid_configuration":
+      return TODOS_AI_EXIT_CODES.usage;
+    case "runtime_unavailable":
+    case "runtime_incompatible":
+      return TODOS_AI_EXIT_CODES.runtime_unavailable;
+    case "timeout":
+      return TODOS_AI_EXIT_CODES.timeout;
+    case "interrupted":
+      return TODOS_AI_EXIT_CODES.interrupted;
+    default:
+      return TODOS_AI_EXIT_CODES.failed;
+  }
+}
+var TODOS_AI_SCHEMA_VERSION = 1, TODOS_AI_RUNTIME_PROTOCOL_VERSION = 1, TODOS_AI_RUNTIME_SPECIFIER = "@hasna/todos-ai/runtime", TODOS_AI_UPDATE_TASK_RESULT_SCHEMA = "todos.ai.update_task.v1", TODOS_AI_FORMATS, TODOS_AI_WRITE_MODES, TODOS_AI_APPROVAL_MODES, TODOS_AI_RUN_STATUSES, TODOS_AI_RUNTIME_EVENT_TYPES, TODOS_AI_UPDATE_TASK_FIELDS, TODOS_AI_UPDATE_TASK_LIMITS, TODOS_AI_DEFAULTS, TODOS_AI_LIMITS, TODOS_AI_EXIT_CODES, TodosAiContractError, TodosAiNeedsInputSignal, TodosAiNeedsApprovalSignal, SENSITIVE_VARIABLE_KEY, defaultTodosAiRuntimeImporter = async (specifier) => import(specifier);
+var init_ai = __esm(() => {
+  TODOS_AI_FORMATS = ["text", "json", "stream-json"];
+  TODOS_AI_WRITE_MODES = ["read-only", "plan", "execute"];
+  TODOS_AI_APPROVAL_MODES = ["deny", "required", "prompt", "existing"];
+  TODOS_AI_RUN_STATUSES = [
+    "answered",
+    "needs_input",
+    "needs_approval",
+    "completed",
+    "failed"
+  ];
+  TODOS_AI_RUNTIME_EVENT_TYPES = [
+    "run.started",
+    "run.progress",
+    "text.delta",
+    "tool.started",
+    "tool.completed",
+    "input.required",
+    "approval.required"
+  ];
+  TODOS_AI_UPDATE_TASK_FIELDS = [
+    "title",
+    "description",
+    "status",
+    "priority",
+    "assigned_to",
+    "tags",
+    "due_at"
+  ];
+  TODOS_AI_UPDATE_TASK_LIMITS = {
+    max_title_bytes: 1024,
+    max_description_bytes: 8192,
+    max_assignee_bytes: 256,
+    max_tags: 16,
+    max_tag_bytes: 128,
+    max_due_at_bytes: 128,
+    min_idempotency_key_bytes: 8,
+    max_idempotency_key_bytes: 128,
+    max_result_bytes: 65536
+  };
+  TODOS_AI_DEFAULTS = {
+    format: "text",
+    max_steps: 8,
+    timeout_ms: 60000,
+    write_mode: "read-only"
+  };
+  TODOS_AI_LIMITS = {
+    max_prompt_bytes: 1048576,
+    max_json_bytes: 1048576,
+    max_result_bytes: 4194304,
+    max_variable_count: 100,
+    max_variable_value_bytes: 65536,
+    max_approval_refs: 32,
+    max_approval_ref_bytes: 1024,
+    max_resume_run_id_bytes: 1024,
+    max_pending_input_prompt_bytes: 1024,
+    max_pending_input_fields: 16,
+    max_pending_input_field_bytes: 128,
+    max_pending_approval_id_bytes: 256,
+    max_pending_approval_summary_bytes: 1024,
+    max_pending_approval_operations: 4,
+    max_pending_approval_bytes: 8192,
+    max_stream_events: 1000,
+    max_stream_record_bytes: 262144,
+    max_stream_bytes: 8388608,
+    min_steps: 1,
+    max_steps: 20,
+    min_timeout_ms: 1000,
+    max_timeout_ms: 600000
+  };
+  TODOS_AI_EXIT_CODES = {
+    success: 0,
+    usage: 2,
+    needs_input: 3,
+    needs_approval: 4,
+    runtime_unavailable: 5,
+    failed: 6,
+    timeout: 124,
+    interrupted: 130
+  };
+  TodosAiContractError = class TodosAiContractError extends Error {
+    code;
+    exitCode;
+    constructor(code, message, exitCode = TODOS_AI_EXIT_CODES.usage, options) {
+      super(message, options);
+      this.code = code;
+      this.exitCode = exitCode;
+      this.name = "TodosAiContractError";
+    }
+  };
+  TodosAiNeedsInputSignal = class TodosAiNeedsInputSignal extends Error {
+    pending_input;
+    constructor(pendingInput) {
+      if (!isTodosAiJsonValue(pendingInput) || !isPendingInput(pendingInput)) {
+        throw new TodosAiContractError("invalid_input", "Todos AI pending input must be bounded stable control data");
+      }
+      super("Todos AI input required");
+      this.name = "TodosAiNeedsInputSignal";
+      this.pending_input = {
+        prompt: pendingInput.prompt,
+        fields: [...pendingInput.fields]
+      };
+    }
+  };
+  TodosAiNeedsApprovalSignal = class TodosAiNeedsApprovalSignal extends Error {
+    pending_approval;
+    constructor(pendingApproval) {
+      if (!isTodosAiJsonValue(pendingApproval) || !isPendingApproval(pendingApproval)) {
+        throw new TodosAiContractError("invalid_input", "Todos AI pending approval must be bounded stable control data");
+      }
+      super("Todos AI approval required");
+      this.name = "TodosAiNeedsApprovalSignal";
+      this.pending_approval = {
+        id: pendingApproval.id,
+        summary: pendingApproval.summary,
+        operations: pendingApproval.operations.map((operation) => JSON.parse(JSON.stringify(operation)))
+      };
+    }
+  };
+  SENSITIVE_VARIABLE_KEY = /(?:^|[_.-])(api[_-]?key|credential|password|secret|token)(?:$|[_.-])/i;
+});
+
+// src/lib/access-profiles.ts
+function resolveAccessProfile(envValue) {
+  const raw = (envValue ?? process.env["TODOS_PROFILE"] ?? "full").toLowerCase();
+  if (ACCESS_PROFILES.includes(raw))
+    return raw;
+  if (raw === "readonly")
+    return "read_only";
+  if (raw === "agent-safe")
+    return "agent_safe";
+  return "full";
+}
+function shouldRegisterToolForProfile(toolName, profile) {
+  const p = profile ?? resolveAccessProfile();
+  if (ADMIN_ONLY_TOOLS.has(toolName) && p !== "admin")
+    return false;
+  switch (p) {
+    case "read_only":
+      return READ_ONLY_TOOLS.has(toolName);
+    case "agent_safe":
+      return AGENT_SAFE_TOOLS.has(toolName);
+    case "minimal":
+      return MINIMAL_TOOLS.has(toolName);
+    case "standard":
+      return !STANDARD_EXCLUDED.has(toolName);
+    case "admin":
+    case "full":
+    default:
+      return true;
+  }
+}
+var ACCESS_PROFILES, READ_ONLY_TOOLS, MINIMAL_TOOLS, AGENT_SAFE_TOOLS, STANDARD_EXCLUDED, ADMIN_ONLY_TOOLS, DANGEROUS_TOOLS;
+var init_access_profiles = __esm(() => {
+  ACCESS_PROFILES = ["read_only", "agent_safe", "minimal", "standard", "full", "admin"];
+  READ_ONLY_TOOLS = new Set([
+    "get_task",
+    "list_tasks",
+    "get_status",
+    "get_context",
+    "search_tasks",
+    "list_projects",
+    "get_project",
+    "list_plans",
+    "get_plan",
+    "list_agents",
+    "get_agent",
+    "list_task_lists",
+    "get_task_list",
+    "get_task_commits",
+    "get_task_traceability",
+    "list_pending_approvals",
+    "get_task_gate_status",
+    "list_active_leases",
+    "list_agent_runs",
+    "list_agent_adapters",
+    "discover_workspace",
+    "get_bootstrap_status",
+    "get_agent_workflow_demo_docs",
+    "get_feature_manifest",
+    "get_capability_discovery",
+    "get_feature_manifest_docs",
+    "get_cli_mcp_parity",
+    "list_secret_patterns",
+    "list_sandbox_profiles",
+    "list_workspace_trust_profiles",
+    "list_verification_providers",
+    "list_verification_records",
+    "get_tasks_changed_since",
+    "get_stale_tasks",
+    "get_next_task",
+    "find_duplicate_tasks",
+    "describe_tools",
+    "search_tools",
+    "inspect_git_commit",
+    "list_task_findings",
+    "scan_text_for_secrets",
+    "check_workspace_permission",
+    "check_sandbox_command",
+    "parse_mentions",
+    "resolve_mention",
+    "resolve_mentions_in_text",
+    "generate_release_notes",
+    "format_release_notes_markdown",
+    "analyze_branch_work",
+    "generate_branch_work_plan",
+    "get_branch_work_plan_docs"
+  ]);
+  MINIMAL_TOOLS = new Set([
+    "claim_next_task",
+    "complete_task",
+    "fail_task",
+    "get_status",
+    "get_context",
+    "get_task",
+    "start_task",
+    "add_comment",
+    "get_next_task",
+    "bootstrap",
+    "get_tasks_changed_since",
+    "heartbeat",
+    "release_agent",
+    "begin_task_run_transaction",
+    "finish_task_run",
+    "upsert_task_finding",
+    "list_task_findings",
+    "resolve_missing_task_findings"
+  ]);
+  AGENT_SAFE_TOOLS = new Set([
+    ...READ_ONLY_TOOLS,
+    ...MINIMAL_TOOLS,
+    "create_task",
+    "update_task",
+    "lock_task",
+    "unlock_task",
+    "enqueue_agent_run",
+    "claim_next_agent_run",
+    "complete_agent_run",
+    "fail_agent_run",
+    "acquire_task_lease",
+    "renew_task_lease",
+    "release_task_lease",
+    "request_approval",
+    "run_verification",
+    "link_task_git_trace",
+    "assign_label_to_task",
+    "set_task_custom_field",
+    "log_progress"
+  ]);
+  STANDARD_EXCLUDED = new Set([
+    "rename_agent",
+    "delete_agent",
+    "unarchive_agent",
+    "create_webhook",
+    "list_webhooks",
+    "delete_webhook",
+    "create_template",
+    "list_templates",
+    "create_task_from_template",
+    "delete_template",
+    "update_template",
+    "init_templates",
+    "preview_template",
+    "export_template",
+    "import_template",
+    "template_history",
+    "approve_task",
+    "migrate_pg"
+  ]);
+  ADMIN_ONLY_TOOLS = new Set([
+    "migrate_pg",
+    "delete_task",
+    "delete_project",
+    "delete_agent",
+    "delete_plan",
+    "delete_task_list",
+    "delete_webhook",
+    "delete_template",
+    "steal_task_lease",
+    "recover_stale_leases"
+  ]);
+  DANGEROUS_TOOLS = new Set([
+    ...ADMIN_ONLY_TOOLS,
+    "bulk_update_tasks",
+    "merge_tasks",
+    "cancel_agent_run"
+  ]);
+});
+
+// src/db/checkpoints.ts
+function upsertCheckpoint(task_id, step, updates, db) {
+  const d = db || getDatabase();
+  const timestamp2 = now();
+  const existing = d.query("SELECT id FROM task_checkpoints WHERE task_id = ? AND step = ?").get(task_id, step);
+  const id = existing?.id ?? uuid();
+  const agentId = updates.agent_id ?? null;
+  const status = updates.status ?? "pending";
+  const data = updates.data ? JSON.stringify(updates.data) : JSON.stringify({});
+  const error = updates.error ?? null;
+  const attempt = updates.attempt ?? 1;
+  const maxAttempts = updates.max_attempts ?? 1;
+  const startedAt = updates.started_at ?? null;
+  const completedAt = updates.completed_at ?? null;
+  d.run(`INSERT INTO task_checkpoints (id, task_id, agent_id, step, status, data, error, attempt, max_attempts, started_at, completed_at, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+     ON CONFLICT(id) DO UPDATE SET status=?, data=?, error=?, attempt=?, max_attempts=?, started_at=COALESCE(started_at,?), completed_at=?, updated_at=?`, [
+    id,
+    task_id,
+    agentId,
+    step,
+    status,
+    data,
+    error,
+    attempt,
+    maxAttempts,
+    startedAt,
+    completedAt,
+    timestamp2,
+    status,
+    data,
+    error,
+    attempt,
+    maxAttempts,
+    startedAt,
+    completedAt,
+    timestamp2
+  ]);
+  return rowToCheckpoint(d.query("SELECT * FROM task_checkpoints WHERE id = ?").get(id));
+}
+function getCheckpoint(taskId, step, db) {
+  const d = db || getDatabase();
+  const row = d.query("SELECT * FROM task_checkpoints WHERE task_id = ? AND step = ?").get(taskId, step);
+  return row ? rowToCheckpoint(row) : null;
+}
+function getTaskCheckpoints(taskId, db) {
+  const d = db || getDatabase();
+  return d.query("SELECT * FROM task_checkpoints WHERE task_id = ? ORDER BY created_at ASC").all(taskId).map(rowToCheckpoint);
+}
+function rowToCheckpoint(row) {
+  if (!row)
+    return null;
+  return {
+    ...row,
+    data: JSON.parse(row.data || "{}"),
+    status: row.status,
+    agent_id: row.agent_id || null,
+    error: row.error || null,
+    started_at: row.started_at || null,
+    completed_at: row.completed_at || null
+  };
+}
+var init_checkpoints = __esm(() => {
+  init_database();
+});
+
+// src/lib/approval-gates.ts
+var exports_approval_gates = {};
+__export(exports_approval_gates, {
+  requestApprovalGate: () => requestApprovalGate,
+  rejectApprovalGate: () => rejectApprovalGate,
+  listApprovalGates: () => listApprovalGates,
+  expireApprovalGate: () => expireApprovalGate,
+  checkApprovalGate: () => checkApprovalGate,
+  assertApprovalGate: () => assertApprovalGate,
+  approveApprovalGate: () => approveApprovalGate
+});
+function stepForGate(gate) {
+  const trimmed = gate.trim();
+  if (!trimmed)
+    throw new Error("Approval gate name is required");
+  return `approval:${trimmed}`;
+}
+function approvalStatusToCheckpointStatus(status) {
+  if (status === "approved")
+    return "completed";
+  if (status === "pending")
+    return "pending";
+  return "failed";
+}
+function checkpointStatusToApprovalStatus(checkpoint) {
+  const value = checkpoint.data["approval_status"];
+  if (value === "approved" || value === "rejected" || value === "expired" || value === "pending")
+    return value;
+  if (checkpoint.status === "completed")
+    return "approved";
+  if (checkpoint.status === "failed")
+    return "rejected";
+  return "pending";
+}
+function ensureTask(taskId, db) {
+  if (!getTask(taskId, db))
+    throw new TaskNotFoundError(taskId);
+}
+function isExpired(expiresAt, at = new Date) {
+  return Boolean(expiresAt && new Date(expiresAt).getTime() <= at.getTime());
+}
+function gateFromCheckpoint(checkpoint) {
+  const status = checkpointStatusToApprovalStatus(checkpoint);
+  return {
+    id: checkpoint.id,
+    task_id: checkpoint.task_id,
+    gate: String(checkpoint.data["approval_gate_name"] || checkpoint.step.replace(/^approval:/, "")),
+    status,
+    reviewer: typeof checkpoint.data["reviewer"] === "string" ? checkpoint.data["reviewer"] : null,
+    requester: typeof checkpoint.data["requester"] === "string" ? checkpoint.data["requester"] : null,
+    reason: typeof checkpoint.data["reason"] === "string" ? checkpoint.data["reason"] : null,
+    note: typeof checkpoint.data["note"] === "string" ? checkpoint.data["note"] : null,
+    plan_id: typeof checkpoint.data["plan_id"] === "string" ? checkpoint.data["plan_id"] : null,
+    run_id: typeof checkpoint.data["run_id"] === "string" ? checkpoint.data["run_id"] : null,
+    expires_at: typeof checkpoint.data["expires_at"] === "string" ? checkpoint.data["expires_at"] : null,
+    decided_by: typeof checkpoint.data["decided_by"] === "string" ? checkpoint.data["decided_by"] : null,
+    decided_at: typeof checkpoint.data["decided_at"] === "string" ? checkpoint.data["decided_at"] : null,
+    created_at: checkpoint.created_at,
+    updated_at: checkpoint.updated_at,
+    checkpoint
+  };
+}
+function logApprovalEvent(taskId, action, gate, agentId, db) {
+  const payload = JSON.stringify({
+    gate: gate.gate,
+    status: gate.status,
+    reviewer: gate.reviewer,
+    requester: gate.requester,
+    plan_id: gate.plan_id,
+    run_id: gate.run_id,
+    expires_at: gate.expires_at,
+    decided_by: gate.decided_by,
+    decided_at: gate.decided_at
+  });
+  logTaskChange(taskId, `approval_gate.${action}`, "approval_gate", null, payload, agentId, db);
+  if (gate.run_id && getTaskRun(gate.run_id, db)) {
+    addTaskRunEvent({
+      run_id: gate.run_id,
+      event_type: "progress",
+      message: `approval gate ${action}: ${gate.gate}`,
+      data: JSON.parse(payload),
+      agent_id: agentId
+    }, db);
+  }
+  if (action === "approved" || action === "rejected" || action === "expired") {
+    emitLocalEventHooksQuiet({
+      type: "approval.decided",
+      payload: { task_id: taskId, gate: gate.gate, status: gate.status, reviewer: gate.reviewer, run_id: gate.run_id },
+      databasePath: databasePathFromDatabase(db)
+    });
+  }
+}
+function writeGate(input, status, decision, db) {
+  const d = db || getDatabase();
+  ensureTask(input.task_id, d);
+  const step = stepForGate(input.gate);
+  const existing = getCheckpoint(input.task_id, step, d);
+  const existingData = existing?.data || {};
+  const timestamp2 = decision?.decided_at || now();
+  const existingRunId = typeof existingData["run_id"] === "string" ? existingData["run_id"] : undefined;
+  const runId = input.run_id ? resolveTaskRunId(input.run_id, d) : existingRunId;
+  const data = {
+    ...existingData,
+    ...input.metadata || {},
+    approval_gate: true,
+    approval_gate_name: input.gate.trim(),
+    approval_status: status,
+    requester: input.requester ?? existingData["requester"] ?? null,
+    reviewer: input.reviewer ?? decision?.decided_by ?? existingData["reviewer"] ?? null,
+    reason: decision?.reason ?? input.reason ?? existingData["reason"] ?? null,
+    note: decision?.note ?? existingData["note"] ?? null,
+    plan_id: input.plan_id ?? existingData["plan_id"] ?? null,
+    run_id: runId ?? null,
+    expires_at: input.expires_at ?? existingData["expires_at"] ?? null,
+    decided_by: decision?.decided_by ?? existingData["decided_by"] ?? null,
+    decided_at: decision?.decided_at ?? existingData["decided_at"] ?? null
+  };
+  const checkpoint = upsertCheckpoint(input.task_id, step, {
+    agent_id: decision?.decided_by || input.requester || input.reviewer,
+    status: approvalStatusToCheckpointStatus(status),
+    data,
+    error: status === "rejected" || status === "expired" ? String(data.reason || status) : null,
+    started_at: existing?.started_at || timestamp2,
+    completed_at: status === "pending" ? null : timestamp2
+  }, d);
+  return gateFromCheckpoint(checkpoint);
+}
+function currentGate(taskId, gate, db) {
+  const checkpoint = getCheckpoint(taskId, stepForGate(gate), db);
+  return checkpoint ? gateFromCheckpoint(checkpoint) : null;
+}
+function requestApprovalGate(input, db) {
+  const d = db || getDatabase();
+  const existing = currentGate(input.task_id, input.gate, d);
+  if (existing && existing.status !== "pending") {
+    throw new Error(`Approval gate ${input.gate} is already ${existing.status}`);
+  }
+  const gate = writeGate(input, "pending", undefined, d);
+  logApprovalEvent(input.task_id, "requested", gate, input.requester || input.reviewer, d);
+  return gate;
+}
+function approveApprovalGate(input, db) {
+  const d = db || getDatabase();
+  const existing = currentGate(input.task_id, input.gate, d);
+  if (!existing)
+    throw new Error(`Approval gate not found: ${input.gate}`);
+  if (existing.status !== "pending")
+    throw new Error(`Approval gate ${input.gate} is already ${existing.status}`);
+  if (isExpired(existing.expires_at))
+    throw new Error(`Approval gate ${input.gate} is expired`);
+  const gate = writeGate({
+    task_id: input.task_id,
+    gate: input.gate,
+    requester: existing.requester || undefined,
+    reviewer: input.reviewer || existing.reviewer || undefined,
+    reason: existing.reason || undefined,
+    plan_id: existing.plan_id || undefined,
+    run_id: existing.run_id || undefined,
+    expires_at: existing.expires_at || undefined
+  }, "approved", { decided_by: input.reviewer, decided_at: now(), note: input.note }, d);
+  logApprovalEvent(input.task_id, "approved", gate, input.reviewer, d);
+  return gate;
+}
+function rejectApprovalGate(input, db) {
+  const d = db || getDatabase();
+  const existing = currentGate(input.task_id, input.gate, d);
+  if (!existing)
+    throw new Error(`Approval gate not found: ${input.gate}`);
+  if (existing.status !== "pending")
+    throw new Error(`Approval gate ${input.gate} is already ${existing.status}`);
+  const gate = writeGate({
+    task_id: input.task_id,
+    gate: input.gate,
+    requester: existing.requester || undefined,
+    reviewer: input.reviewer || existing.reviewer || undefined,
+    reason: existing.reason || undefined,
+    plan_id: existing.plan_id || undefined,
+    run_id: existing.run_id || undefined,
+    expires_at: existing.expires_at || undefined
+  }, "rejected", { decided_by: input.reviewer, decided_at: now(), note: input.note, reason: input.reason || input.note }, d);
+  logApprovalEvent(input.task_id, "rejected", gate, input.reviewer, d);
+  return gate;
+}
+function expireApprovalGate(input, db) {
+  const d = db || getDatabase();
+  const existing = currentGate(input.task_id, input.gate, d);
+  if (!existing)
+    throw new Error(`Approval gate not found: ${input.gate}`);
+  if (existing.status !== "pending")
+    throw new Error(`Approval gate ${input.gate} is already ${existing.status}`);
+  const gate = writeGate({
+    task_id: input.task_id,
+    gate: input.gate,
+    requester: existing.requester || undefined,
+    reviewer: existing.reviewer || undefined,
+    reason: existing.reason || undefined,
+    plan_id: existing.plan_id || undefined,
+    run_id: existing.run_id || undefined,
+    expires_at: existing.expires_at || undefined
+  }, "expired", { decided_by: input.reviewer, decided_at: now(), reason: input.reason || "expired" }, d);
+  logApprovalEvent(input.task_id, "expired", gate, input.reviewer, d);
+  return gate;
+}
+function listApprovalGates(taskId, db) {
+  const d = db || getDatabase();
+  ensureTask(taskId, d);
+  return getTaskCheckpoints(taskId, d).filter((checkpoint) => checkpoint.data["approval_gate"] === true || checkpoint.step.startsWith("approval:")).map(gateFromCheckpoint);
+}
+function checkApprovalGate(taskId, gateName, db) {
+  const d = db || getDatabase();
+  ensureTask(taskId, d);
+  const gate = currentGate(taskId, gateName, d);
+  const reasons = [];
+  if (!gate)
+    reasons.push(`approval gate is required: ${gateName}`);
+  else if (gate.status !== "approved")
+    reasons.push(`approval gate ${gateName} is ${gate.status}`);
+  if (gate && gate.status === "pending" && isExpired(gate.expires_at))
+    reasons.push(`approval gate ${gateName} is expired`);
+  return { allowed: reasons.length === 0, gate, reasons };
+}
+function assertApprovalGate(taskId, gateName, db) {
+  const result = checkApprovalGate(taskId, gateName, db);
+  if (!result.allowed)
+    throw new Error(result.reasons.join("; "));
+  return result.gate;
+}
+var init_approval_gates = __esm(() => {
+  init_audit();
+  init_checkpoints();
+  init_database();
+  init_task_runs();
+  init_tasks();
+  init_types();
+  init_event_emission_safety();
+  init_event_hooks();
+});
+
+// src/ai-tools.ts
+import { createHash as createHash9 } from "crypto";
+function createLocalTodosAiReadAdapter(database) {
+  return {
+    source: "sqlite",
+    getTask: (id) => getTask(id, database),
+    listTasks: (filter) => listTasks(filter, database),
+    listProjects: () => listProjects(database),
+    listPlans: (projectId) => listPlans(projectId, database),
+    updateTask: (id, patch) => updateTask(id, patch, database),
+    verifyApproval: (input) => {
+      const result = checkApprovalGate(input.task_id, input.ref, database);
+      if (!result.gate)
+        return null;
+      return {
+        ref: result.gate.gate,
+        task_id: result.gate.task_id,
+        operation: input.operation,
+        payload_digest: input.payload_digest,
+        status: result.gate.status,
+        expires_at: result.gate.expires_at
+      };
+    }
+  };
+}
+function createHttpTodosAiReadAdapter(client) {
+  return {
+    source: "http",
+    getTask: (id) => cloudGetTask(client, id),
+    listTasks: (filter) => cloudListTasks(client, filter),
+    listProjects: () => cloudListProjects(client),
+    listPlans: (projectId) => cloudListPlans(client, projectId),
+    updateTask: (id, patch) => cloudUpdateTask(client, id, patch)
+  };
+}
+function resolveAdapter(options) {
+  if (options.adapter)
+    return options.adapter;
+  const client = getTodosCloudClient(options.env);
+  return client ? createHttpTodosAiReadAdapter(client) : createLocalTodosAiReadAdapter(options.database);
+}
+function resolvePermission(options) {
+  if (options.workspacePermission)
+    return options.workspacePermission;
+  const path = options.workspacePath ?? process.cwd();
+  return (permission) => checkWorkspacePermission({ path, tool: permission }).allowed;
+}
+function configuredProfileIsKnown(value) {
+  if (value === undefined || value.trim() === "")
+    return true;
+  const normalized = value.trim().toLowerCase();
+  return ACCESS_PROFILES.includes(normalized) || normalized === "readonly" || normalized === "agent-safe";
+}
+function createTodosAiToolSource(options = {}) {
+  const adapter = resolveAdapter(options);
+  const configuredProfile = options.env ? options.env["TODOS_PROFILE"] : process.env["TODOS_PROFILE"];
+  const profile = options.accessProfile ?? resolveAccessProfile(configuredProfile ?? "minimal");
+  const permission = resolvePermission(options);
+  const enabled = new Set(TODOS_AI_READ_TOOL_NAMES.filter((name) => shouldRegisterToolForProfile(name, profile) && permission(name === "get_task" ? "read" : "list", name)));
+  const hostAllowsUpdate = (options.accessProfile !== undefined || configuredProfileIsKnown(configuredProfile)) && shouldRegisterToolForProfile("update_task", profile) && permission("write", "update_task");
+  const approvalVerifier = options.approvalVerifier ?? adapter.verifyApproval;
+  return ({ request }) => {
+    const state = {
+      calls: 0,
+      evidence: [],
+      idempotency: new Map,
+      now: options.now ?? (() => new Date)
+    };
+    return createTools(adapter, enabled, state, request, hostAllowsUpdate, approvalVerifier);
+  };
+}
+function createTools(adapter, enabled, state, request, hostAllowsUpdate, approvalVerifier) {
+  const tools = [];
+  if (enabled.has("get_task")) {
+    tools.push({
+      name: "get_task",
+      description: "Read one Todos task by its stable identifier.",
+      effect: "read",
+      inputSchema: {
+        type: "object",
+        properties: {
+          id: {
+            type: "string",
+            minLength: 1,
+            maxLength: TODOS_AI_READ_TOOL_LIMITS.max_identifier_bytes
+          }
+        },
+        required: ["id"],
+        additionalProperties: false
+      },
+      execute: (input) => executeGetTask(adapter, state, request, input)
+    });
+  }
+  if (enabled.has("list_tasks")) {
+    tools.push({
+      name: "list_tasks",
+      description: "List a bounded set of Todos tasks using read-only filters.",
+      effect: "read",
+      inputSchema: {
+        type: "object",
+        properties: {
+          project_id: boundedStringSchema(TODOS_AI_READ_TOOL_LIMITS.max_identifier_bytes),
+          plan_id: boundedStringSchema(TODOS_AI_READ_TOOL_LIMITS.max_identifier_bytes),
+          task_list_id: boundedStringSchema(TODOS_AI_READ_TOOL_LIMITS.max_identifier_bytes),
+          assigned_to: boundedStringSchema(TODOS_AI_READ_TOOL_LIMITS.max_filter_string_bytes),
+          status: { type: "string", enum: [...TASK_STATUSES] },
+          priority: { type: "string", enum: [...TASK_PRIORITIES] },
+          tags: {
+            type: "array",
+            maxItems: TODOS_AI_READ_TOOL_LIMITS.max_tags,
+            items: boundedStringSchema(TODOS_AI_READ_TOOL_LIMITS.max_filter_string_bytes)
+          },
+          limit: {
+            type: "integer",
+            minimum: 1,
+            maximum: TODOS_AI_READ_TOOL_LIMITS.max_list_items,
+            default: TODOS_AI_READ_TOOL_LIMITS.default_list_items
+          },
+          offset: {
+            type: "integer",
+            minimum: 0,
+            maximum: TODOS_AI_READ_TOOL_LIMITS.max_list_offset
+          }
+        },
+        additionalProperties: false
+      },
+      execute: (input) => executeListTasks(adapter, state, request, input)
+    });
+  }
+  if (enabled.has("list_projects")) {
+    tools.push({
+      name: "list_projects",
+      description: "List a bounded set of Todos projects.",
+      effect: "read",
+      inputSchema: listOnlySchema(),
+      execute: (input) => executeListProjects(adapter, state, request, input)
+    });
+  }
+  if (enabled.has("list_plans")) {
+    tools.push({
+      name: "list_plans",
+      description: "List a bounded set of Todos plans, optionally scoped to a project.",
+      effect: "read",
+      inputSchema: {
+        type: "object",
+        properties: {
+          project_id: boundedStringSchema(TODOS_AI_READ_TOOL_LIMITS.max_identifier_bytes),
+          limit: {
+            type: "integer",
+            minimum: 1,
+            maximum: TODOS_AI_READ_TOOL_LIMITS.max_list_items,
+            default: TODOS_AI_READ_TOOL_LIMITS.default_list_items
+          },
+          offset: {
+            type: "integer",
+            minimum: 0,
+            maximum: TODOS_AI_READ_TOOL_LIMITS.max_list_offset
+          }
+        },
+        additionalProperties: false
+      },
+      execute: (input) => executeListPlans(adapter, state, request, input)
+    });
+  }
+  tools.push({
+    name: "request_input",
+    description: "Stop without mutation and request bounded clarification fields.",
+    effect: "control",
+    inputSchema: {
+      type: "object",
+      properties: {
+        prompt: boundedStringSchema(TODOS_AI_CONTROL_TOOL_LIMITS.max_prompt_bytes),
+        fields: {
+          type: "array",
+          minItems: 1,
+          maxItems: TODOS_AI_CONTROL_TOOL_LIMITS.max_fields,
+          items: boundedStringSchema(TODOS_AI_CONTROL_TOOL_LIMITS.max_field_bytes)
+        }
+      },
+      required: ["prompt", "fields"],
+      additionalProperties: false
+    },
+    execute: (input) => executeRequestInput(state, input)
+  });
+  const authorityAllowsUpdate = request.authority.write_mode === "plan" || request.authority.write_mode === "execute" && request.authority.approval_mode !== "deny";
+  if (hostAllowsUpdate && authorityAllowsUpdate) {
+    tools.push({
+      name: "update_task",
+      description: "Plan or execute one approved, version-checked update of one exact Todos task.",
+      effect: "write",
+      inputSchema: updateTaskInputSchema(),
+      execute: (input, context) => executeUpdateTask(adapter, approvalVerifier, state, request, input, context.signal)
+    });
+  }
+  return tools;
+}
+function boundedStringSchema(maxLength) {
+  return {
+    type: "string",
+    minLength: 1,
+    maxLength
+  };
+}
+function listOnlySchema() {
+  return {
+    type: "object",
+    properties: {
+      limit: {
+        type: "integer",
+        minimum: 1,
+        maximum: TODOS_AI_READ_TOOL_LIMITS.max_list_items,
+        default: TODOS_AI_READ_TOOL_LIMITS.default_list_items
+      },
+      offset: {
+        type: "integer",
+        minimum: 0,
+        maximum: TODOS_AI_READ_TOOL_LIMITS.max_list_offset
+      }
+    },
+    additionalProperties: false
+  };
+}
+function updateTaskInputSchema() {
+  return {
+    type: "object",
+    properties: {
+      task_id: {
+        type: "string",
+        pattern: "^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$"
+      },
+      expected_version: {
+        type: "integer",
+        minimum: 0
+      },
+      patch: {
+        type: "object",
+        minProperties: 1,
+        properties: {
+          title: boundedStringSchema(TODOS_AI_UPDATE_TASK_LIMITS.max_title_bytes),
+          description: {
+            type: "string",
+            maxLength: TODOS_AI_UPDATE_TASK_LIMITS.max_description_bytes
+          },
+          status: { type: "string", enum: [...TASK_STATUSES] },
+          priority: { type: "string", enum: [...TASK_PRIORITIES] },
+          assigned_to: {
+            type: ["string", "null"],
+            maxLength: TODOS_AI_UPDATE_TASK_LIMITS.max_assignee_bytes
+          },
+          tags: {
+            type: "array",
+            maxItems: TODOS_AI_UPDATE_TASK_LIMITS.max_tags,
+            items: boundedStringSchema(TODOS_AI_UPDATE_TASK_LIMITS.max_tag_bytes)
+          },
+          due_at: {
+            type: ["string", "null"],
+            maxLength: TODOS_AI_UPDATE_TASK_LIMITS.max_due_at_bytes
+          }
+        },
+        additionalProperties: false
+      },
+      idempotency_key: {
+        type: "string",
+        minLength: TODOS_AI_UPDATE_TASK_LIMITS.min_idempotency_key_bytes,
+        maxLength: TODOS_AI_UPDATE_TASK_LIMITS.max_idempotency_key_bytes,
+        pattern: "^[A-Za-z0-9._:-]+$"
+      }
+    },
+    required: ["task_id", "expected_version", "patch", "idempotency_key"],
+    additionalProperties: false
+  };
+}
+function deriveTodosAiUpdateTaskApprovalIdentity(input) {
+  if (!UUID_RE2.test(input.task_id) || !Number.isSafeInteger(input.expected_version) || input.expected_version < 0) {
+    throw new Error("update_task approval identity requires an exact task UUID and version");
+  }
+  const patch = normalizeUpdatePatch(input.patch);
+  const canonical = JSON.stringify({
+    operation: "update_task",
+    task_id: input.task_id,
+    expected_version: input.expected_version,
+    patch
+  });
+  const payloadDigest = createHash9("sha256").update(canonical).digest("hex");
+  return {
+    ref: `todos-ai:update_task:${payloadDigest}`,
+    payload_digest: payloadDigest
+  };
+}
+function executeRequestInput(state, input) {
+  beginCall(state);
+  const record = assertInputObject(input, "request_input", ["prompt", "fields"]);
+  const prompt = boundedRequiredString(record, "prompt", TODOS_AI_CONTROL_TOOL_LIMITS.max_prompt_bytes);
+  const rawFields = record["fields"];
+  if (!Array.isArray(rawFields) || rawFields.length === 0 || rawFields.length > TODOS_AI_CONTROL_TOOL_LIMITS.max_fields) {
+    throw new Error(`fields must contain 1 to ${TODOS_AI_CONTROL_TOOL_LIMITS.max_fields} strings`);
+  }
+  const fields = [];
+  const seen = new Set;
+  for (const [index, field] of rawFields.entries()) {
+    if (typeof field !== "string" || !/^[A-Za-z_][A-Za-z0-9_.-]{0,127}$/.test(field) || ENCODER.encode(field).byteLength > TODOS_AI_CONTROL_TOOL_LIMITS.max_field_bytes || seen.has(field)) {
+      throw new Error(`fields[${index}] must be a unique bounded field name`);
+    }
+    seen.add(field);
+    fields.push(field);
+  }
+  const redactedPrompt = truncateUtf8(redactEvidenceText(prompt), TODOS_AI_CONTROL_TOOL_LIMITS.max_prompt_bytes);
+  throw new TodosAiNeedsInputSignal({
+    prompt: redactedPrompt || "Additional input is required.",
+    fields
+  });
+}
+async function executeUpdateTask(adapter, approvalVerifier, state, request, input, signal) {
+  beginCall(state);
+  const normalized = normalizeUpdateTaskInput(input);
+  const existing = state.idempotency.get(normalized.idempotency_key);
+  if (existing) {
+    if (existing.payload_digest !== normalized.payload_digest) {
+      throw new Error("update_task idempotency key was reused with a different payload");
+    }
+    return replayUpdateTaskResult(await existing.promise);
+  }
+  const claim = {
+    payload_digest: normalized.payload_digest,
+    mutation_started: false,
+    promise: Promise.resolve({})
+  };
+  claim.promise = performUpdateTask(adapter, approvalVerifier, state, request, normalized, signal, claim);
+  state.idempotency.set(normalized.idempotency_key, claim);
+  try {
+    return await claim.promise;
+  } catch (error) {
+    if (!claim.mutation_started) {
+      state.idempotency.delete(normalized.idempotency_key);
+    }
+    throw error;
+  }
+}
+async function performUpdateTask(adapter, approvalVerifier, state, request, normalized, signal, claim) {
+  throwIfToolAborted(signal);
+  const before = await adapter.getTask(normalized.task_id);
+  throwIfToolAborted(signal);
+  assertExactTaskVersion(before, normalized.task_id, normalized.expected_version);
+  if (taskMatchesPatch(before, normalized.patch)) {
+    throw new Error("update_task patch does not change the authoritative task");
+  }
+  if (request.authority.write_mode === "plan") {
+    return updateTaskResult(normalized, {
+      mode: "plan",
+      applied: false,
+      readback_verified: false,
+      result_version: null,
+      replay: false,
+      source: adapter.source
+    });
+  }
+  if (request.authority.write_mode !== "execute") {
+    throw new Error("update_task is unavailable without plan or execute authority");
+  }
+  if (request.authority.approval_mode === "required" || request.authority.approval_mode === "prompt") {
+    throw new TodosAiNeedsApprovalSignal({
+      id: normalized.approval_ref,
+      summary: "Approve one exact version-checked task update.",
+      operations: [approvalOperation(normalized)]
+    });
+  }
+  if (request.authority.approval_mode !== "existing") {
+    throw new Error("update_task execution requires a verified existing approval");
+  }
+  await verifyExistingApproval(approvalVerifier, request, normalized, state.now());
+  if (!adapter.updateTask) {
+    throw new Error("update_task is unavailable for the selected authority");
+  }
+  throwIfToolAborted(signal);
+  claim.mutation_started = true;
+  let updateFailure = null;
+  try {
+    await adapter.updateTask(normalized.task_id, {
+      ...normalized.patch,
+      version: normalized.expected_version
+    });
+  } catch (error) {
+    updateFailure = error;
+  }
+  const after = await adapter.getTask(normalized.task_id);
+  if (after && after.id === normalized.task_id && after.version === normalized.expected_version + 1 && taskMatchesPatch(after, normalized.patch)) {
+    return updateTaskResult(normalized, {
+      mode: "execute",
+      applied: true,
+      readback_verified: true,
+      result_version: after.version,
+      replay: false,
+      source: adapter.source
+    });
+  }
+  if (updateFailure !== null) {
+    throw new Error("update_task mutation could not be reconciled by authoritative readback");
+  }
+  throw new Error("update_task authoritative readback did not verify the applied patch");
+}
+async function verifyExistingApproval(approvalVerifier, request, normalized, at) {
+  if (request.authority.approval_refs.length !== 1 || request.authority.approval_refs[0] !== normalized.approval_ref) {
+    throw new Error("update_task approval reference does not match the exact operation");
+  }
+  if (!approvalVerifier) {
+    throw new Error("update_task approval cannot be verified for the selected authority");
+  }
+  const verification = await approvalVerifier({
+    ref: normalized.approval_ref,
+    task_id: normalized.task_id,
+    operation: "update_task",
+    payload_digest: normalized.payload_digest
+  });
+  if (!verification || verification.ref !== normalized.approval_ref || verification.task_id !== normalized.task_id || verification.operation !== "update_task" || verification.payload_digest !== normalized.payload_digest || verification.status !== "approved") {
+    throw new Error("update_task approval is missing, rejected, expired, or unverifiable");
+  }
+  if (verification.expires_at !== null) {
+    const expiry = Date.parse(verification.expires_at);
+    if (!Number.isFinite(expiry) || expiry <= at.getTime()) {
+      throw new Error("update_task approval is expired or unverifiable");
+    }
+  }
+}
+function normalizeUpdateTaskInput(input) {
+  const record = assertInputObject(input, "update_task", [
+    "task_id",
+    "expected_version",
+    "patch",
+    "idempotency_key"
+  ]);
+  const taskId = boundedRequiredString(record, "task_id", TODOS_AI_READ_TOOL_LIMITS.max_identifier_bytes);
+  if (!UUID_RE2.test(taskId)) {
+    throw new Error("task_id must be one exact task UUID");
+  }
+  const expectedVersion = boundedInteger(record, "expected_version", -1, 0, Number.MAX_SAFE_INTEGER);
+  if (!Object.hasOwn(record, "expected_version")) {
+    throw new Error("expected_version is required");
+  }
+  const idempotencyKey = boundedRequiredString(record, "idempotency_key", TODOS_AI_UPDATE_TASK_LIMITS.max_idempotency_key_bytes);
+  const idempotencyBytes = ENCODER.encode(idempotencyKey).byteLength;
+  if (idempotencyBytes < TODOS_AI_UPDATE_TASK_LIMITS.min_idempotency_key_bytes || !/^[A-Za-z0-9._:-]+$/.test(idempotencyKey)) {
+    throw new Error("idempotency_key must be a bounded stable identifier");
+  }
+  const patchValue = record["patch"];
+  if (!isTodosAiJsonValue(patchValue) || patchValue === null || typeof patchValue !== "object" || Array.isArray(patchValue)) {
+    throw new Error("patch must be a stable JSON object");
+  }
+  const patch = normalizeUpdatePatch(patchValue);
+  const changedFields = Object.keys(patch);
+  const identity = deriveTodosAiUpdateTaskApprovalIdentity({
+    task_id: taskId,
+    expected_version: expectedVersion,
+    patch
+  });
+  return {
+    task_id: taskId,
+    expected_version: expectedVersion,
+    patch,
+    changed_fields: changedFields,
+    idempotency_key: idempotencyKey,
+    payload_digest: identity.payload_digest,
+    approval_ref: identity.ref
+  };
+}
+function normalizeUpdatePatch(value) {
+  if (!isTodosAiJsonValue(value) || value === null || Array.isArray(value)) {
+    throw new Error("patch must be a stable JSON object");
+  }
+  const allowed = new Set(TODOS_AI_UPDATE_TASK_FIELDS);
+  const supplied = Object.keys(value);
+  if (supplied.length === 0)
+    throw new Error("patch must contain at least one field");
+  for (const key of supplied) {
+    if (!allowed.has(key)) {
+      throw new Error(`update_task patch contains unsupported field: ${key}`);
+    }
+  }
+  const patch = {};
+  for (const field of TODOS_AI_UPDATE_TASK_FIELDS) {
+    if (!Object.hasOwn(value, field))
+      continue;
+    const candidate = value[field];
+    switch (field) {
+      case "title":
+        if (typeof candidate !== "string" || candidate.trim().length === 0 || ENCODER.encode(candidate).byteLength > TODOS_AI_UPDATE_TASK_LIMITS.max_title_bytes) {
+          throw new Error("patch.title must be a bounded non-empty string");
+        }
+        patch[field] = candidate;
+        break;
+      case "description":
+        if (typeof candidate !== "string" || ENCODER.encode(candidate).byteLength > TODOS_AI_UPDATE_TASK_LIMITS.max_description_bytes) {
+          throw new Error("patch.description must be a bounded string");
+        }
+        patch[field] = candidate;
+        break;
+      case "status":
+        if (typeof candidate !== "string" || !TASK_STATUSES.includes(candidate)) {
+          throw new Error(`patch.status must be one of: ${TASK_STATUSES.join(", ")}`);
+        }
+        patch[field] = candidate;
+        break;
+      case "priority":
+        if (typeof candidate !== "string" || !TASK_PRIORITIES.includes(candidate)) {
+          throw new Error(`patch.priority must be one of: ${TASK_PRIORITIES.join(", ")}`);
+        }
+        patch[field] = candidate;
+        break;
+      case "assigned_to":
+        if (candidate !== null && (typeof candidate !== "string" || ENCODER.encode(candidate).byteLength > TODOS_AI_UPDATE_TASK_LIMITS.max_assignee_bytes)) {
+          throw new Error("patch.assigned_to must be null or a bounded string");
+        }
+        patch[field] = candidate;
+        break;
+      case "tags": {
+        if (!Array.isArray(candidate) || candidate.length > TODOS_AI_UPDATE_TASK_LIMITS.max_tags) {
+          throw new Error(`patch.tags must contain at most ${TODOS_AI_UPDATE_TASK_LIMITS.max_tags} strings`);
+        }
+        const tags = [];
+        const seen = new Set;
+        for (const [index, tag] of candidate.entries()) {
+          if (typeof tag !== "string" || tag.length === 0 || ENCODER.encode(tag).byteLength > TODOS_AI_UPDATE_TASK_LIMITS.max_tag_bytes || seen.has(tag)) {
+            throw new Error(`patch.tags[${index}] must be a unique bounded string`);
+          }
+          seen.add(tag);
+          tags.push(tag);
+        }
+        patch[field] = tags;
+        break;
+      }
+      case "due_at":
+        if (candidate !== null && (typeof candidate !== "string" || ENCODER.encode(candidate).byteLength > TODOS_AI_UPDATE_TASK_LIMITS.max_due_at_bytes || !Number.isFinite(Date.parse(candidate)))) {
+          throw new Error("patch.due_at must be null or a bounded ISO date-time");
+        }
+        patch[field] = candidate;
+        break;
+    }
+  }
+  return patch;
+}
+function assertExactTaskVersion(task, taskId, expectedVersion) {
+  if (!task || task.id !== taskId) {
+    throw new Error("update_task exact target was not found");
+  }
+  if (task.version !== expectedVersion) {
+    throw new Error("update_task expected_version is stale");
+  }
+}
+function taskMatchesPatch(task, patch) {
+  return Object.entries(patch).every(([field, expected]) => {
+    const actual = task[field];
+    return Array.isArray(expected) ? Array.isArray(actual) && JSON.stringify(actual) === JSON.stringify(expected) : actual === expected;
+  });
+}
+function approvalOperation(normalized) {
+  return {
+    operation: "update_task",
+    task_id: normalized.task_id,
+    expected_version: normalized.expected_version,
+    fields: normalized.changed_fields,
+    payload_digest: normalized.payload_digest
+  };
+}
+function updateTaskResult(normalized, result) {
+  const value = {
+    schema: TODOS_AI_UPDATE_TASK_RESULT_SCHEMA,
+    operation: "update_task",
+    mode: result.mode,
+    applied: result.applied,
+    readback_verified: result.readback_verified,
+    source: result.source,
+    target: {
+      task_id: normalized.task_id,
+      expected_version: normalized.expected_version,
+      result_version: result.result_version
+    },
+    changed_fields: normalized.changed_fields,
+    approval_ref: normalized.approval_ref,
+    payload_digest: normalized.payload_digest,
+    idempotency: {
+      key: normalized.idempotency_key,
+      scope: "run",
+      replay: result.replay
+    }
+  };
+  if (!isTodosAiUpdateTaskResult(value)) {
+    throw new Error("update_task result does not satisfy its stable receipt contract");
+  }
+  return value;
+}
+function replayUpdateTaskResult(value) {
+  const idempotency = value["idempotency"];
+  if (!idempotency || typeof idempotency !== "object" || Array.isArray(idempotency)) {
+    throw new Error("update_task cached result is invalid");
+  }
+  const replayed = {
+    ...value,
+    idempotency: {
+      ...idempotency,
+      replay: true
+    }
+  };
+  if (!isTodosAiUpdateTaskResult(replayed)) {
+    throw new Error("update_task cached result is invalid");
+  }
+  return replayed;
+}
+function throwIfToolAborted(signal) {
+  if (signal.aborted)
+    throw new DOMException("Aborted", "AbortError");
+}
+function beginCall(state) {
+  if (state.calls >= TODOS_AI_READ_TOOL_LIMITS.max_tool_calls) {
+    throw new Error(`Todos AI tool-call limit of ${TODOS_AI_READ_TOOL_LIMITS.max_tool_calls} exceeded`);
+  }
+  state.calls += 1;
+}
+function assertInputObject(input, tool, allowed) {
+  if (!isTodosAiJsonValue(input) || input === null || Array.isArray(input)) {
+    throw new Error(`${tool} input must be a stable JSON object`);
+  }
+  const record = input;
+  const allowedKeys = new Set(allowed);
+  for (const key of Object.keys(record)) {
+    if (!allowedKeys.has(key))
+      throw new Error(`${tool} input contains unsupported field: ${key}`);
+  }
+  return record;
+}
+function boundedRequiredString(record, key, maximum) {
+  const value = record[key];
+  if (typeof value !== "string" || value.length === 0) {
+    throw new Error(`${key} must be a non-empty string`);
+  }
+  if (ENCODER.encode(value).byteLength > maximum) {
+    throw new Error(`${key} exceeds ${maximum} bytes`);
+  }
+  return value;
+}
+function boundedOptionalString(record, key, maximum) {
+  if (!Object.hasOwn(record, key))
+    return;
+  return boundedRequiredString(record, key, maximum);
+}
+function boundedInteger(record, key, fallback, minimum, maximum) {
+  if (!Object.hasOwn(record, key))
+    return fallback;
+  const value = record[key];
+  if (!Number.isSafeInteger(value) || value < minimum || value > maximum) {
+    throw new Error(`${key} must be an integer from ${minimum} to ${maximum}`);
+  }
+  return value;
+}
+function boundedEnum(record, key, values) {
+  if (!Object.hasOwn(record, key))
+    return;
+  const value = record[key];
+  if (typeof value !== "string" || !values.includes(value)) {
+    throw new Error(`${key} must be one of: ${values.join(", ")}`);
+  }
+  return value;
+}
+function boundedTags(record) {
+  if (!Object.hasOwn(record, "tags"))
+    return;
+  const value = record["tags"];
+  if (!Array.isArray(value) || value.length > TODOS_AI_READ_TOOL_LIMITS.max_tags) {
+    throw new Error(`tags must contain at most ${TODOS_AI_READ_TOOL_LIMITS.max_tags} strings`);
+  }
+  return value.map((tag, index) => {
+    if (typeof tag !== "string" || tag.length === 0) {
+      throw new Error(`tags[${index}] must be a non-empty string`);
+    }
+    if (ENCODER.encode(tag).byteLength > TODOS_AI_READ_TOOL_LIMITS.max_filter_string_bytes) {
+      throw new Error(`tags[${index}] exceeds ${TODOS_AI_READ_TOOL_LIMITS.max_filter_string_bytes} bytes`);
+    }
+    return tag;
+  });
+}
+async function executeGetTask(adapter, state, request, input) {
+  beginCall(state);
+  const record = assertInputObject(input, "get_task", ["id"]);
+  const id = boundedRequiredString(record, "id", TODOS_AI_READ_TOOL_LIMITS.max_identifier_bytes);
+  const task = await adapter.getTask(id);
+  const item = task ? compactTask(task) : null;
+  const evidence = task ? [taskEvidence(task)] : [];
+  return boundedSingleResult(adapter.source, "get_task", item, evidence, state, request);
+}
+async function executeListTasks(adapter, state, request, input) {
+  beginCall(state);
+  const record = assertInputObject(input, "list_tasks", [
+    "project_id",
+    "plan_id",
+    "task_list_id",
+    "assigned_to",
+    "status",
+    "priority",
+    "tags",
+    "limit",
+    "offset"
+  ]);
+  const { limit, offset } = listWindow(record);
+  const filter = {
+    limit: limit + 1,
+    offset
+  };
+  const projectId = boundedOptionalString(record, "project_id", TODOS_AI_READ_TOOL_LIMITS.max_identifier_bytes);
+  const planId = boundedOptionalString(record, "plan_id", TODOS_AI_READ_TOOL_LIMITS.max_identifier_bytes);
+  const taskListId = boundedOptionalString(record, "task_list_id", TODOS_AI_READ_TOOL_LIMITS.max_identifier_bytes);
+  const assignedTo = boundedOptionalString(record, "assigned_to", TODOS_AI_READ_TOOL_LIMITS.max_filter_string_bytes);
+  const status = boundedEnum(record, "status", TASK_STATUSES);
+  const priority = boundedEnum(record, "priority", TASK_PRIORITIES);
+  const tags = boundedTags(record);
+  if (projectId !== undefined)
+    filter.project_id = projectId;
+  if (planId !== undefined)
+    filter.plan_id = planId;
+  if (taskListId !== undefined)
+    filter.task_list_id = taskListId;
+  if (assignedTo !== undefined)
+    filter.assigned_to = assignedTo;
+  if (status !== undefined)
+    filter.status = status;
+  if (priority !== undefined)
+    filter.priority = priority;
+  if (tags !== undefined)
+    filter.tags = tags;
+  const rows = await adapter.listTasks(filter);
+  return boundedListResult(adapter.source, "list_tasks", rows.map(compactTask), rows.map(taskEvidence), limit, offset, state, request);
+}
+async function executeListProjects(adapter, state, request, input) {
+  beginCall(state);
+  const record = assertInputObject(input, "list_projects", ["limit", "offset"]);
+  const { limit, offset } = listWindow(record);
+  const rows = await adapter.listProjects();
+  const window = rows.slice(offset, offset + limit + 1);
+  return boundedListResult(adapter.source, "list_projects", window.map(compactProject), window.map(projectEvidence), limit, offset, state, request);
+}
+async function executeListPlans(adapter, state, request, input) {
+  beginCall(state);
+  const record = assertInputObject(input, "list_plans", [
+    "project_id",
+    "limit",
+    "offset"
+  ]);
+  const { limit, offset } = listWindow(record);
+  const projectId = boundedOptionalString(record, "project_id", TODOS_AI_READ_TOOL_LIMITS.max_identifier_bytes);
+  const rows = await adapter.listPlans(projectId);
+  const window = rows.slice(offset, offset + limit + 1);
+  return boundedListResult(adapter.source, "list_plans", window.map(compactPlan), window.map(planEvidence), limit, offset, state, request);
+}
+function listWindow(record) {
+  return {
+    limit: boundedInteger(record, "limit", TODOS_AI_READ_TOOL_LIMITS.default_list_items, 1, TODOS_AI_READ_TOOL_LIMITS.max_list_items),
+    offset: boundedInteger(record, "offset", 0, 0, TODOS_AI_READ_TOOL_LIMITS.max_list_offset)
+  };
+}
+function compactTask(task) {
+  if (!TASK_STATUSES.includes(task.status)) {
+    throw new Error("Todos AI task result has an invalid status");
+  }
+  if (!TASK_PRIORITIES.includes(task.priority)) {
+    throw new Error("Todos AI task result has an invalid priority");
+  }
+  return {
+    id: boundedOutputText(task.id),
+    short_id: boundedNullableOutputText(task.short_id),
+    version: requiredNonNegativeInteger(task.version, "task version"),
+    project_id: boundedNullableOutputText(task.project_id),
+    parent_id: boundedNullableOutputText(task.parent_id),
+    plan_id: boundedNullableOutputText(task.plan_id),
+    task_list_id: boundedNullableOutputText(task.task_list_id),
+    title: boundedOutputText(task.title),
+    description: boundedNullableOutputText(task.description),
+    status: task.status,
+    priority: task.priority,
+    assigned_to: boundedNullableOutputText(task.assigned_to),
+    agent_id: boundedNullableOutputText(task.agent_id),
+    tags: boundedOutputTags(task.tags),
+    task_type: boundedNullableOutputText(task.task_type),
+    created_by: boundedNullableOutputText(task.created_by),
+    assigned_by: boundedNullableOutputText(task.assigned_by),
+    created_at: boundedOutputText(task.created_at),
+    updated_at: boundedOutputText(task.updated_at),
+    started_at: boundedNullableOutputText(task.started_at),
+    completed_at: boundedNullableOutputText(task.completed_at),
+    due_at: boundedNullableOutputText(task.due_at)
+  };
+}
+function compactProject(project) {
+  return {
+    id: boundedOutputText(project.id),
+    name: boundedOutputText(project.name),
+    description: boundedNullableOutputText(project.description),
+    task_list_id: boundedNullableOutputText(project.task_list_id),
+    task_prefix: boundedNullableOutputText(project.task_prefix),
+    created_at: boundedOutputText(project.created_at),
+    updated_at: boundedOutputText(project.updated_at)
+  };
+}
+function compactPlan(plan) {
+  if (!PLAN_STATUSES.includes(plan.status)) {
+    throw new Error("Todos AI plan result has an invalid status");
+  }
+  return {
+    id: boundedOutputText(plan.id),
+    slug: boundedNullableOutputText(plan.slug),
+    project_id: boundedNullableOutputText(plan.project_id),
+    task_list_id: boundedNullableOutputText(plan.task_list_id),
+    agent_id: boundedNullableOutputText(plan.agent_id),
+    name: boundedOutputText(plan.name),
+    description: boundedNullableOutputText(plan.description),
+    status: plan.status,
+    created_at: boundedOutputText(plan.created_at),
+    updated_at: boundedOutputText(plan.updated_at)
+  };
+}
+function taskEvidence(task) {
+  return {
+    resource: "task",
+    id: boundedOutputText(task.id),
+    version: requiredNonNegativeInteger(task.version, "task version")
+  };
+}
+function projectEvidence(project) {
+  return {
+    resource: "project",
+    id: boundedOutputText(project.id),
+    version: boundedOutputText(project.updated_at)
+  };
+}
+function planEvidence(plan) {
+  return {
+    resource: "plan",
+    id: boundedOutputText(plan.id),
+    version: boundedOutputText(plan.updated_at)
+  };
+}
+function boundedOutputTags(tags) {
+  if (!Array.isArray(tags))
+    return [];
+  return tags.filter((tag) => typeof tag === "string").slice(0, TODOS_AI_READ_TOOL_LIMITS.max_output_tags).map(boundedOutputText);
+}
+function boundedNullableOutputText(value) {
+  return typeof value === "string" ? boundedOutputText(value) : null;
+}
+function boundedOutputText(value) {
+  return truncateUtf8(redactEvidenceText(value), TODOS_AI_READ_TOOL_LIMITS.max_output_string_bytes);
+}
+function requiredNonNegativeInteger(value, field) {
+  if (!Number.isSafeInteger(value) || value < 0) {
+    throw new Error(`Todos AI result has an invalid ${field}`);
+  }
+  return value;
+}
+function truncateUtf8(value, maximum) {
+  if (ENCODER.encode(value).byteLength <= maximum)
+    return value;
+  const suffix = "...";
+  const suffixBytes = ENCODER.encode(suffix).byteLength;
+  let output2 = "";
+  let bytes = 0;
+  for (const character of value) {
+    const characterBytes = ENCODER.encode(character).byteLength;
+    if (bytes + characterBytes + suffixBytes > maximum)
+      break;
+    output2 += character;
+    bytes += characterBytes;
+  }
+  return `${output2}${suffix}`;
+}
+function boundedSingleResult(source, tool, item, evidence, state, request) {
+  const mergedEvidence = mergeEvidence(state.evidence, evidence);
+  const result = redactValue({
+    source,
+    tool,
+    item,
+    evidence,
+    context: runContext(request, state.calls, mergedEvidence)
+  });
+  assertResultBound(result);
+  state.evidence = mergedEvidence;
+  return result;
+}
+function boundedListResult(source, tool, sourceItems, sourceEvidence, limit, offset, state, request) {
+  const available = Math.min(sourceItems.length, sourceEvidence.length);
+  let count = Math.min(limit, available);
+  let truncated = available > count;
+  while (count >= 0) {
+    const items = sourceItems.slice(0, count);
+    const evidence = sourceEvidence.slice(0, count);
+    const mergedEvidence = mergeEvidence(state.evidence, evidence);
+    const result = redactValue({
+      source,
+      tool,
+      items,
+      returned: items.length,
+      offset,
+      truncated,
+      evidence,
+      context: runContext(request, state.calls, mergedEvidence)
+    });
+    if (serializedBytes(result) <= TODOS_AI_READ_TOOL_LIMITS.max_result_bytes) {
+      state.evidence = mergedEvidence;
+      return result;
+    }
+    count -= 1;
+    truncated = true;
+  }
+  throw new Error("Todos AI read result could not be bounded");
+}
+function runContext(request, calls, evidence) {
+  return {
+    project: boundedNullableOutputText(request.context.project),
+    agent: boundedNullableOutputText(request.context.agent),
+    session: boundedNullableOutputText(request.context.session),
+    tool_calls: calls,
+    evidence
+  };
+}
+function mergeEvidence(existing, incoming) {
+  const merged = [];
+  const seen = new Set;
+  for (const pointer of [...existing, ...incoming]) {
+    const key = JSON.stringify(pointer);
+    if (seen.has(key))
+      continue;
+    seen.add(key);
+    merged.push(pointer);
+    if (merged.length >= TODOS_AI_READ_TOOL_LIMITS.max_evidence_pointers)
+      break;
+  }
+  return merged;
+}
+function assertResultBound(value) {
+  if (serializedBytes(value) > TODOS_AI_READ_TOOL_LIMITS.max_result_bytes) {
+    throw new Error(`Todos AI read result exceeds ${TODOS_AI_READ_TOOL_LIMITS.max_result_bytes} bytes`);
+  }
+}
+function serializedBytes(value) {
+  return ENCODER.encode(JSON.stringify(value)).byteLength;
+}
+var TODOS_AI_READ_TOOL_NAMES, TODOS_AI_READ_TOOL_LIMITS, TODOS_AI_CONTROL_TOOL_LIMITS, ENCODER, UUID_RE2;
+var init_ai_tools = __esm(() => {
+  init_ai();
+  init_ai();
+  init_cloud_router();
+  init_task_crud();
+  init_projects();
+  init_plans();
+  init_access_profiles();
+  init_approval_gates();
+  init_redaction();
+  init_workspace_trust();
+  init_types();
+  TODOS_AI_READ_TOOL_NAMES = [
+    "get_task",
+    "list_tasks",
+    "list_projects",
+    "list_plans"
+  ];
+  TODOS_AI_READ_TOOL_LIMITS = {
+    default_list_items: 20,
+    max_list_items: 50,
+    max_list_offset: 1e4,
+    max_identifier_bytes: 256,
+    max_filter_string_bytes: 256,
+    max_tags: 16,
+    max_output_tags: 16,
+    max_output_string_bytes: 2048,
+    max_result_bytes: 65536,
+    max_tool_calls: 32,
+    max_evidence_pointers: 32
+  };
+  TODOS_AI_CONTROL_TOOL_LIMITS = {
+    max_prompt_bytes: 1024,
+    max_fields: 16,
+    max_field_bytes: 128
+  };
+  ENCODER = new TextEncoder;
+  UUID_RE2 = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+});
+
+// src/cli/commands/ai-commands.ts
+var exports_ai_commands = {};
+__export(exports_ai_commands, {
+  registerAiCommands: () => registerAiCommands
+});
+import { randomUUID as randomUUID4 } from "crypto";
+import { writeSync as writeSync2 } from "fs";
+function appendOption(value, previous) {
+  return [...previous, value];
+}
+function globalOptions(program2) {
+  const command = program2;
+  return command.optsWithGlobals?.() ?? program2.opts();
+}
+function commandRawArgs(command) {
+  let root = command;
+  while (root.parent)
+    root = root.parent;
+  const rawArgs = root.rawArgs;
+  return rawArgs && rawArgs.length > 0 ? rawArgs : process.argv;
+}
+function commanderJsonRequested(command) {
+  const args = commandRawArgs(command);
+  let globalJson = false;
+  let format;
+  for (let index = 0;index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === undefined)
+      continue;
+    if (arg === "--")
+      break;
+    if (arg === "--json" || arg === "-j") {
+      globalJson = true;
+    } else if (arg.startsWith("--format=")) {
+      format = arg.slice("--format=".length);
+    } else if (arg === "--format") {
+      format = args[index + 1];
+      index += 1;
+    }
+  }
+  return format === undefined ? globalJson : format === "json";
+}
+function optionalString(value) {
+  if (typeof value !== "string")
+    return null;
+  const trimmed = value.trim();
+  return trimmed || null;
+}
+function requestedErrorFormat(options, globalOpts, configFormat) {
+  if (TODOS_AI_FORMATS.includes(options.format)) {
+    return options.format;
+  }
+  if (globalOpts["json"] === true)
+    return "json";
+  const envFormat = process.env["TODOS_AI_FORMAT"];
+  if (TODOS_AI_FORMATS.includes(envFormat))
+    return envFormat;
+  if (TODOS_AI_FORMATS.includes(configFormat)) {
+    return configFormat;
+  }
+  return TODOS_AI_DEFAULTS.format;
+}
+function loadTodosAiStoredConfig() {
+  let ai;
+  try {
+    ai = getTodosAiConfig();
+  } catch (cause) {
+    throw new TodosAiContractError("invalid_configuration", "Todos AI configuration could not be read", TODOS_AI_EXIT_CODES.usage, { cause });
+  }
+  if (ai !== undefined && (ai === null || typeof ai !== "object" || Array.isArray(ai))) {
+    throw new TodosAiContractError("invalid_configuration", "Todos AI configuration must be an object");
+  }
+  if (ai === undefined)
+    return;
+  const record = ai;
+  for (const field of [
+    "provider",
+    "model",
+    "profile",
+    "format",
+    "write_mode",
+    "approval_mode"
+  ]) {
+    if (record[field] !== undefined && typeof record[field] !== "string") {
+      throw new TodosAiContractError("invalid_configuration", `Todos AI configuration field ${field} must be a string`);
+    }
+  }
+  for (const field of ["max_steps", "timeout_ms"]) {
+    if (record[field] !== undefined && typeof record[field] !== "number") {
+      throw new TodosAiContractError("invalid_configuration", `Todos AI configuration field ${field} must be a number`);
+    }
+  }
+  return record;
+}
+async function readBoundedStdin() {
+  const chunks = [];
+  let bytes = 0;
+  for await (const chunk of process.stdin) {
+    const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    bytes += buffer.byteLength;
+    if (bytes > TODOS_AI_LIMITS.max_prompt_bytes) {
+      throw new TodosAiContractError("invalid_input", `stdin prompt exceeds ${TODOS_AI_LIMITS.max_prompt_bytes} bytes`);
+    }
+    chunks.push(buffer);
+  }
+  return Buffer.concat(chunks, bytes).toString("utf8");
+}
+function normalizeResumeRunId(value) {
+  const runId = optionalString(value);
+  if (!runId)
+    return null;
+  if (Buffer.byteLength(runId, "utf8") > TODOS_AI_LIMITS.max_resume_run_id_bytes) {
+    throw new TodosAiContractError("invalid_input", `--resume may not exceed ${TODOS_AI_LIMITS.max_resume_run_id_bytes} bytes`);
+  }
+  return runId;
+}
+function resultJson(result) {
+  const serialized = JSON.stringify(result);
+  if (Buffer.byteLength(serialized, "utf8") > TODOS_AI_LIMITS.max_result_bytes) {
+    throw new TodosAiContractError("runtime_invalid_result", `optional AI runtime result exceeds ${TODOS_AI_LIMITS.max_result_bytes} bytes`, TODOS_AI_EXIT_CODES.failed);
+  }
+  return serialized;
+}
+function renderTextResult(result) {
+  switch (result.status) {
+    case "answered":
+    case "completed":
+      if (result.answer) {
+        console.log(result.answer);
+      } else if (result.data !== null) {
+        console.log(JSON.stringify(result.data, null, 2));
+      } else {
+        console.log(`AI run ${result.run_id} completed.`);
+      }
+      return;
+    case "needs_input":
+      console.log(result.pending_input?.prompt ?? "The AI runtime needs additional input.");
+      return;
+    case "needs_approval":
+      console.log(result.pending_approval?.summary ?? "The AI runtime needs approval.");
+      if (result.pending_approval?.id)
+        console.log(`Approval: ${result.pending_approval.id}`);
+      return;
+    case "failed":
+      console.error(result.error?.message ?? "The AI runtime failed.");
+  }
+}
+function renderTerminalResult(result, format) {
+  const serialized = resultJson(result);
+  if (format === "json") {
+    console.log(serialized);
+    return;
+  }
+  if (format === "stream-json") {
+    const record = {
+      schema_version: TODOS_AI_SCHEMA_VERSION,
+      kind: "result",
+      result
+    };
+    console.log(JSON.stringify(record));
+    return;
+  }
+  renderTextResult(result);
+}
+function errorResult(runId, error) {
+  if (error instanceof TodosAiContractError) {
+    return createTodosAiFailureResult(runId, error.code, error.message);
+  }
+  return createTodosAiFailureResult(runId, "internal_error", "optional AI runtime failed");
+}
+async function withLoadDeadline(operation, controller, timeoutMs) {
+  return new Promise((resolve14, reject) => {
+    let settled = false;
+    const settle = (callback) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      callback();
+    };
+    const timer = setTimeout(() => {
+      const error = new TodosAiContractError("timeout", `AI run timed out after ${timeoutMs}ms`, TODOS_AI_EXIT_CODES.timeout);
+      controller.abort(error);
+      settle(() => reject(error));
+    }, timeoutMs);
+    Promise.resolve().then(operation).then((value) => settle(() => resolve14(value)), (error) => settle(() => reject(error)));
+  });
+}
+async function withInterrupt(operation, controller) {
+  return new Promise((resolve14, reject) => {
+    let settled = false;
+    const settle = (callback) => {
+      if (settled)
+        return;
+      settled = true;
+      process.removeListener("SIGINT", onInterrupt);
+      callback();
+    };
+    const onInterrupt = () => {
+      const error = new TodosAiContractError("interrupted", "AI run interrupted", TODOS_AI_EXIT_CODES.interrupted);
+      controller.abort(error);
+      settle(() => reject(error));
+    };
+    process.once("SIGINT", onInterrupt);
+    Promise.resolve().then(operation).then((value) => settle(() => resolve14(value)), (error) => settle(() => reject(error)));
+  });
+}
+function throwIfAborted(signal) {
+  if (!signal.aborted)
+    return;
+  if (signal.reason instanceof Error)
+    throw signal.reason;
+  throw new TodosAiContractError("interrupted", "AI run interrupted", TODOS_AI_EXIT_CODES.interrupted);
+}
+function createRuntimeEventSink(format, controller, expectedRunId) {
+  let eventCount = 0;
+  let streamBytes = 0;
+  let lastSequence = -1;
+  let runId = expectedRunId;
+  let failure = null;
+  let closed = false;
+  let rejectFailure;
+  const failurePromise = new Promise((_resolve, reject) => {
+    rejectFailure = reject;
+  });
+  failurePromise.catch(() => {
+    return;
+  });
+  const fail = (message) => {
+    if (failure)
+      return failure;
+    const error = new TodosAiContractError("runtime_invalid_result", message, TODOS_AI_EXIT_CODES.failed);
+    failure = error;
+    controller.abort(error);
+    rejectFailure(error);
+    return error;
+  };
+  return {
+    emit(event) {
+      if (closed)
+        return;
+      if (failure)
+        return;
+      if (!isTodosAiRuntimeEvent(event)) {
+        fail("optional AI runtime emitted an invalid event");
+        return;
+      }
+      if (runId !== null && event.run_id !== runId) {
+        fail("optional AI runtime changed run_id while streaming");
+        return;
+      }
+      if (event.sequence <= lastSequence) {
+        fail("optional AI runtime event sequence must increase");
+        return;
+      }
+      if (eventCount >= TODOS_AI_LIMITS.max_stream_events) {
+        fail(`optional AI runtime exceeded ${TODOS_AI_LIMITS.max_stream_events} events`);
+        return;
+      }
+      const record = {
+        schema_version: TODOS_AI_SCHEMA_VERSION,
+        kind: "event",
+        event
+      };
+      let serialized;
+      try {
+        serialized = JSON.stringify(record);
+      } catch {
+        fail("optional AI runtime emitted an event that could not be serialized");
+        return;
+      }
+      const recordBytes = Buffer.byteLength(serialized, "utf8");
+      if (recordBytes > TODOS_AI_LIMITS.max_stream_record_bytes) {
+        fail(`optional AI runtime event exceeds ${TODOS_AI_LIMITS.max_stream_record_bytes} bytes`);
+        return;
+      }
+      if (streamBytes + recordBytes + 1 > TODOS_AI_LIMITS.max_stream_bytes) {
+        fail(`optional AI runtime stream exceeds ${TODOS_AI_LIMITS.max_stream_bytes} bytes`);
+        return;
+      }
+      runId = event.run_id;
+      lastSequence = event.sequence;
+      eventCount += 1;
+      streamBytes += recordBytes + 1;
+      if (format === "stream-json")
+        process.stdout.write(`${serialized}
+`);
+    },
+    assertResult(result, maxSteps) {
+      if (failure)
+        throw failure;
+      if (runId !== null && result.run_id !== runId) {
+        throw fail("optional AI runtime result run_id does not match its streamed events");
+      }
+      if (result.steps > maxSteps) {
+        throw fail(`optional AI runtime exceeded the max step limit of ${maxSteps}`);
+      }
+    },
+    raceWithFailure(operation) {
+      return Promise.race([failurePromise, operation]);
+    },
+    failureRunId(fallback) {
+      return runId ?? fallback;
+    },
+    close() {
+      closed = true;
+    }
+  };
+}
+async function runTodosAi(promptParts, options, program2) {
+  const globalOpts = globalOptions(program2);
+  let format = requestedErrorFormat(options, globalOpts);
+  const hostRunId = randomUUID4();
+  let eventSink = null;
+  try {
+    const config = loadTodosAiStoredConfig();
+    format = requestedErrorFormat(options, globalOpts, config?.format);
+    const interactive = options.nonInteractive !== true && process.stdin.isTTY === true && process.stdout.isTTY === true;
+    const resolved = resolveTodosAiCommandOptions({
+      cli: {
+        provider: options.provider,
+        model: options.model,
+        profile: options.profile,
+        format: options.format ?? (globalOpts["json"] === true ? "json" : undefined),
+        maxSteps: options.maxSteps,
+        timeoutMs: options.timeoutMs,
+        writeMode: options.writeMode,
+        approvalMode: options.approvalMode,
+        approvalRefs: options.approval,
+        dryRun: options.dryRun
+      },
+      config,
+      env: process.env,
+      interactive
+    });
+    format = resolved.format;
+    const resumeRunId = normalizeResumeRunId(options.resume);
+    let rawPrompt = promptParts.join(" ");
+    if (!rawPrompt.trim() && process.stdin.isTTY !== true) {
+      rawPrompt = await readBoundedStdin();
+    }
+    const prompt = normalizeTodosAiPrompt(rawPrompt);
+    if (!prompt && !resumeRunId) {
+      if (!interactive) {
+        throw new TodosAiContractError("invalid_input", "Provide a prompt as arguments or non-TTY stdin.");
+      }
+      const result2 = createTodosAiNeedsInputResult(hostRunId, "Provide a prompt as arguments or non-TTY stdin.");
+      renderTerminalResult(result2, format);
+      process.exitCode = todosAiExitCodeForResult(result2);
+      return;
+    }
+    if (options.inputJson !== undefined && options.input !== undefined) {
+      throw new TodosAiContractError("invalid_input", "Pass either --input-json or --input, not both.");
+    }
+    const inputJson = options.inputJson ?? options.input;
+    const request = {
+      schema_version: TODOS_AI_SCHEMA_VERSION,
+      prompt,
+      input: inputJson === undefined ? null : parseTodosAiJson(inputJson, "input"),
+      variables: parseTodosAiVariables(options.var ?? []),
+      output_schema: options.outputSchema === undefined ? null : parseTodosAiOutputSchema(options.outputSchema),
+      provider: resolved.provider,
+      model: resolved.model,
+      profile: resolved.profile,
+      format: resolved.format,
+      interactive: resolved.interactive,
+      context: {
+        project: optionalString(globalOpts["project"]),
+        agent: optionalString(globalOpts["agent"]),
+        session: optionalString(globalOpts["session"])
+      },
+      authority: {
+        write_mode: resolved.write_mode,
+        approval_mode: resolved.approval_mode,
+        approval_refs: resolved.approval_refs,
+        dry_run: resolved.dry_run
+      },
+      limits: {
+        max_steps: resolved.max_steps,
+        timeout_ms: resolved.timeout_ms
+      },
+      resume_run_id: resumeRunId
+    };
+    const controller = new AbortController;
+    const sink = createRuntimeEventSink(format, controller, resumeRunId);
+    eventSink = sink;
+    const runtimeResult = await withInterrupt(async () => {
+      const runtime = await withLoadDeadline(() => loadTodosAiRuntime({
+        package_name: "@hasna/todos",
+        package_version: getPackageVersion(),
+        protocol_version: TODOS_AI_RUNTIME_PROTOCOL_VERSION,
+        tool_source: createTodosAiToolSource({
+          env: process.env,
+          workspacePath: process.cwd()
+        })
+      }), controller, resolved.timeout_ms);
+      throwIfAborted(controller.signal);
+      const runtimeOperation = Promise.resolve().then(() => {
+        throwIfAborted(controller.signal);
+        return runtime.run(request, {
+          signal: controller.signal,
+          emit: (event) => sink.emit(event)
+        });
+      });
+      return sink.raceWithFailure(runtimeOperation);
+    }, controller);
+    const result = assertTodosAiRunResult(runtimeResult);
+    eventSink.assertResult(result, resolved.max_steps);
+    eventSink.close();
+    renderTerminalResult(result, format);
+    process.exitCode = todosAiExitCodeForResult(result);
+  } catch (error) {
+    eventSink?.close();
+    const result = errorResult(eventSink?.failureRunId(hostRunId) ?? hostRunId, error);
+    renderTerminalResult(result, format);
+    process.exitCode = error instanceof TodosAiContractError ? error.exitCode : TODOS_AI_EXIT_CODES.failed;
+  }
+}
+function registerAiCommands(program2) {
+  const command = program2.command("ai [prompt...]").description("Run the optional provider-neutral Todos AI runtime").option("--format <format>", "Output format: text, json, or stream-json").option("--input-json <json>", "Structured JSON input supplied to the runtime").option("--input <json>", "Compatibility alias for --input-json").option("--var <key=value>", "Non-secret runtime variable; repeatable", appendOption, []).option("--output-schema <json>", "JSON Schema object for structured output").option("--provider <name>", "Runtime provider override").option("--model <name>", "Runtime model override").option("--profile <name>", "Runtime profile override").option("--write-mode <mode>", "Authority: read-only, plan, or execute").option("--approval-mode <mode>", "Approval handling: deny, required, prompt, or existing").option("--approval <reference>", "Existing approval reference; repeatable", appendOption, []).option("--dry-run", "Force plan-only authority without mutation").option("--max-steps <n>", `Maximum runtime steps (${TODOS_AI_LIMITS.min_steps}-${TODOS_AI_LIMITS.max_steps})`).option("--timeout-ms <ms>", `Timeout in milliseconds (${TODOS_AI_LIMITS.min_timeout_ms}-${TODOS_AI_LIMITS.max_timeout_ms})`).option("--resume <run-id>", "Resume a runtime run, optionally with a new prompt").option("--non-interactive", "Disable all runtime prompting");
+  const defaultOutputError = command.configureOutput().outputError;
+  command.configureOutput({
+    outputError: (message, write) => {
+      if (commanderJsonRequested(command))
+        return;
+      if (defaultOutputError) {
+        defaultOutputError(message, write);
+      } else {
+        write(message);
+      }
+    }
+  });
+  command.exitOverride((error) => {
+    if (error.exitCode === 0)
+      process.exit(0);
+    if (commanderJsonRequested(command)) {
+      const result = createTodosAiFailureResult(randomUUID4(), "invalid_input", error.message);
+      writeSync2(process.stdout.fd, `${resultJson(result)}
+`);
+    }
+    process.exit(TODOS_AI_EXIT_CODES.usage);
+  });
+  command.action(async (prompt, options) => {
+    await runTodosAi(prompt ?? [], options, program2);
+  });
+}
+var init_ai_commands = __esm(() => {
+  init_ai();
+  init_ai_tools();
+  init_config();
+  init_package_version();
+});
+
 // src/server/port.ts
 var exports_port = {};
 __export(exports_port, {
@@ -31522,7 +34109,7 @@ async function findFreePort(start) {
 var DEFAULT_PORT = 19427;
 
 // src/lib/db-backup.ts
-import { existsSync as existsSync15, copyFileSync, mkdirSync as mkdirSync8, readFileSync as readFileSync10, renameSync, statSync as statSync7, writeFileSync as writeFileSync7, unlinkSync } from "fs";
+import { existsSync as existsSync15, copyFileSync, mkdirSync as mkdirSync8, readFileSync as readFileSync11, renameSync, statSync as statSync7, writeFileSync as writeFileSync7, unlinkSync } from "fs";
 import { dirname as dirname7, join as join14, resolve as resolve14 } from "path";
 import { Database as Database2 } from "bun:sqlite";
 function resolveDbPath(dbPath) {
@@ -32250,7 +34837,7 @@ function addGroupTools(toolNames, groupName) {
     toolNames.add(tool);
   return true;
 }
-function shouldRegisterToolForProfile(name, profileValue = process.env["TODOS_PROFILE"], groupValue = process.env["TODOS_TOOL_GROUPS"]) {
+function shouldRegisterToolForProfile2(name, profileValue = process.env["TODOS_PROFILE"], groupValue = process.env["TODOS_TOOL_GROUPS"]) {
   const profileTokens = splitTokens(profileValue || "minimal");
   const groupTokens = splitTokens(groupValue);
   if (profileTokens.includes("full") || profileTokens.includes("all"))
@@ -32295,7 +34882,7 @@ function truncateText(value, maxChars = 240) {
     return value;
   return `${value.slice(0, Math.max(0, maxChars - 3))}...`;
 }
-function compactTask(task, maxDescriptionChars = 180) {
+function compactTask2(task, maxDescriptionChars = 180) {
   const summary = {
     id: task.id,
     short_id: task.short_id || task.id.slice(0, 8),
@@ -32838,7 +35425,7 @@ function profilesForTool(toolName) {
 function getMcpToolNames(options = {}) {
   const profile = options.profile ?? "minimal";
   const groups = options.groups ?? "";
-  return getAllMcpToolNames().filter((toolName) => shouldRegisterToolForProfile(toolName, profile, groups));
+  return getAllMcpToolNames().filter((toolName) => shouldRegisterToolForProfile2(toolName, profile, groups));
 }
 function createMcpManifest(options = {}) {
   const version = options.version ?? getPackageVersion(import.meta.url);
@@ -32887,8 +35474,8 @@ __export(exports_local_extensions, {
   getLocalExtension: () => getLocalExtension,
   discoverLocalExtensions: () => discoverLocalExtensions
 });
-import { createHash as createHash9, createVerify } from "crypto";
-import { existsSync as existsSync17, readdirSync as readdirSync3, readFileSync as readFileSync11, statSync as statSync8 } from "fs";
+import { createHash as createHash10, createVerify } from "crypto";
+import { existsSync as existsSync17, readdirSync as readdirSync3, readFileSync as readFileSync12, statSync as statSync8 } from "fs";
 import { basename as basename6, join as join16, resolve as resolve15 } from "path";
 function isObject(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
@@ -32970,10 +35557,10 @@ function normalizeManifest(input) {
   };
 }
 function parseJson(path) {
-  return JSON.parse(readFileSync11(path, "utf8"));
+  return JSON.parse(readFileSync12(path, "utf8"));
 }
 function sha2564(bytes) {
-  return `sha256:${createHash9("sha256").update(bytes).digest("hex")}`;
+  return `sha256:${createHash10("sha256").update(bytes).digest("hex")}`;
 }
 function compareVersions(a, b) {
   const left = a.split(".").map((part) => Number.parseInt(part, 10) || 0);
@@ -33154,7 +35741,7 @@ function inspectExtensionSource(source2) {
   const manifestPath = stat.isDirectory() ? [join16(resolved, "todos.extension.json"), join16(resolved, "extension.json")].find(existsSync17) : resolved;
   if (!manifestPath)
     throw new Error(`extension directory ${source2} is missing todos.extension.json`);
-  const raw = readFileSync11(manifestPath);
+  const raw = readFileSync12(manifestPath);
   const parsed = parseJson(manifestPath);
   const bundle = isObject(parsed) && isObject(parsed["manifest"]);
   const manifest = normalizeManifest(bundle ? parsed["manifest"] : parsed);
@@ -33793,310 +36380,6 @@ var init_policy_packs = __esm(() => {
   init_config();
 });
 
-// src/db/checkpoints.ts
-function upsertCheckpoint(task_id, step, updates, db) {
-  const d = db || getDatabase();
-  const timestamp2 = now();
-  const existing = d.query("SELECT id FROM task_checkpoints WHERE task_id = ? AND step = ?").get(task_id, step);
-  const id = existing?.id ?? uuid();
-  const agentId = updates.agent_id ?? null;
-  const status = updates.status ?? "pending";
-  const data = updates.data ? JSON.stringify(updates.data) : JSON.stringify({});
-  const error = updates.error ?? null;
-  const attempt = updates.attempt ?? 1;
-  const maxAttempts = updates.max_attempts ?? 1;
-  const startedAt = updates.started_at ?? null;
-  const completedAt = updates.completed_at ?? null;
-  d.run(`INSERT INTO task_checkpoints (id, task_id, agent_id, step, status, data, error, attempt, max_attempts, started_at, completed_at, updated_at)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-     ON CONFLICT(id) DO UPDATE SET status=?, data=?, error=?, attempt=?, max_attempts=?, started_at=COALESCE(started_at,?), completed_at=?, updated_at=?`, [
-    id,
-    task_id,
-    agentId,
-    step,
-    status,
-    data,
-    error,
-    attempt,
-    maxAttempts,
-    startedAt,
-    completedAt,
-    timestamp2,
-    status,
-    data,
-    error,
-    attempt,
-    maxAttempts,
-    startedAt,
-    completedAt,
-    timestamp2
-  ]);
-  return rowToCheckpoint(d.query("SELECT * FROM task_checkpoints WHERE id = ?").get(id));
-}
-function getCheckpoint(taskId, step, db) {
-  const d = db || getDatabase();
-  const row = d.query("SELECT * FROM task_checkpoints WHERE task_id = ? AND step = ?").get(taskId, step);
-  return row ? rowToCheckpoint(row) : null;
-}
-function getTaskCheckpoints(taskId, db) {
-  const d = db || getDatabase();
-  return d.query("SELECT * FROM task_checkpoints WHERE task_id = ? ORDER BY created_at ASC").all(taskId).map(rowToCheckpoint);
-}
-function rowToCheckpoint(row) {
-  if (!row)
-    return null;
-  return {
-    ...row,
-    data: JSON.parse(row.data || "{}"),
-    status: row.status,
-    agent_id: row.agent_id || null,
-    error: row.error || null,
-    started_at: row.started_at || null,
-    completed_at: row.completed_at || null
-  };
-}
-var init_checkpoints = __esm(() => {
-  init_database();
-});
-
-// src/lib/approval-gates.ts
-var exports_approval_gates = {};
-__export(exports_approval_gates, {
-  requestApprovalGate: () => requestApprovalGate,
-  rejectApprovalGate: () => rejectApprovalGate,
-  listApprovalGates: () => listApprovalGates,
-  expireApprovalGate: () => expireApprovalGate,
-  checkApprovalGate: () => checkApprovalGate,
-  assertApprovalGate: () => assertApprovalGate,
-  approveApprovalGate: () => approveApprovalGate
-});
-function stepForGate(gate) {
-  const trimmed = gate.trim();
-  if (!trimmed)
-    throw new Error("Approval gate name is required");
-  return `approval:${trimmed}`;
-}
-function approvalStatusToCheckpointStatus(status) {
-  if (status === "approved")
-    return "completed";
-  if (status === "pending")
-    return "pending";
-  return "failed";
-}
-function checkpointStatusToApprovalStatus(checkpoint) {
-  const value = checkpoint.data["approval_status"];
-  if (value === "approved" || value === "rejected" || value === "expired" || value === "pending")
-    return value;
-  if (checkpoint.status === "completed")
-    return "approved";
-  if (checkpoint.status === "failed")
-    return "rejected";
-  return "pending";
-}
-function ensureTask(taskId, db) {
-  if (!getTask(taskId, db))
-    throw new TaskNotFoundError(taskId);
-}
-function isExpired(expiresAt, at = new Date) {
-  return Boolean(expiresAt && new Date(expiresAt).getTime() <= at.getTime());
-}
-function gateFromCheckpoint(checkpoint) {
-  const status = checkpointStatusToApprovalStatus(checkpoint);
-  return {
-    id: checkpoint.id,
-    task_id: checkpoint.task_id,
-    gate: String(checkpoint.data["approval_gate_name"] || checkpoint.step.replace(/^approval:/, "")),
-    status,
-    reviewer: typeof checkpoint.data["reviewer"] === "string" ? checkpoint.data["reviewer"] : null,
-    requester: typeof checkpoint.data["requester"] === "string" ? checkpoint.data["requester"] : null,
-    reason: typeof checkpoint.data["reason"] === "string" ? checkpoint.data["reason"] : null,
-    note: typeof checkpoint.data["note"] === "string" ? checkpoint.data["note"] : null,
-    plan_id: typeof checkpoint.data["plan_id"] === "string" ? checkpoint.data["plan_id"] : null,
-    run_id: typeof checkpoint.data["run_id"] === "string" ? checkpoint.data["run_id"] : null,
-    expires_at: typeof checkpoint.data["expires_at"] === "string" ? checkpoint.data["expires_at"] : null,
-    decided_by: typeof checkpoint.data["decided_by"] === "string" ? checkpoint.data["decided_by"] : null,
-    decided_at: typeof checkpoint.data["decided_at"] === "string" ? checkpoint.data["decided_at"] : null,
-    created_at: checkpoint.created_at,
-    updated_at: checkpoint.updated_at,
-    checkpoint
-  };
-}
-function logApprovalEvent(taskId, action, gate, agentId, db) {
-  const payload = JSON.stringify({
-    gate: gate.gate,
-    status: gate.status,
-    reviewer: gate.reviewer,
-    requester: gate.requester,
-    plan_id: gate.plan_id,
-    run_id: gate.run_id,
-    expires_at: gate.expires_at,
-    decided_by: gate.decided_by,
-    decided_at: gate.decided_at
-  });
-  logTaskChange(taskId, `approval_gate.${action}`, "approval_gate", null, payload, agentId, db);
-  if (gate.run_id && getTaskRun(gate.run_id, db)) {
-    addTaskRunEvent({
-      run_id: gate.run_id,
-      event_type: "progress",
-      message: `approval gate ${action}: ${gate.gate}`,
-      data: JSON.parse(payload),
-      agent_id: agentId
-    }, db);
-  }
-  if (action === "approved" || action === "rejected" || action === "expired") {
-    emitLocalEventHooksQuiet({
-      type: "approval.decided",
-      payload: { task_id: taskId, gate: gate.gate, status: gate.status, reviewer: gate.reviewer, run_id: gate.run_id },
-      databasePath: databasePathFromDatabase(db)
-    });
-  }
-}
-function writeGate(input, status, decision, db) {
-  const d = db || getDatabase();
-  ensureTask(input.task_id, d);
-  const step = stepForGate(input.gate);
-  const existing = getCheckpoint(input.task_id, step, d);
-  const existingData = existing?.data || {};
-  const timestamp2 = decision?.decided_at || now();
-  const existingRunId = typeof existingData["run_id"] === "string" ? existingData["run_id"] : undefined;
-  const runId = input.run_id ? resolveTaskRunId(input.run_id, d) : existingRunId;
-  const data = {
-    ...existingData,
-    ...input.metadata || {},
-    approval_gate: true,
-    approval_gate_name: input.gate.trim(),
-    approval_status: status,
-    requester: input.requester ?? existingData["requester"] ?? null,
-    reviewer: input.reviewer ?? decision?.decided_by ?? existingData["reviewer"] ?? null,
-    reason: decision?.reason ?? input.reason ?? existingData["reason"] ?? null,
-    note: decision?.note ?? existingData["note"] ?? null,
-    plan_id: input.plan_id ?? existingData["plan_id"] ?? null,
-    run_id: runId ?? null,
-    expires_at: input.expires_at ?? existingData["expires_at"] ?? null,
-    decided_by: decision?.decided_by ?? existingData["decided_by"] ?? null,
-    decided_at: decision?.decided_at ?? existingData["decided_at"] ?? null
-  };
-  const checkpoint = upsertCheckpoint(input.task_id, step, {
-    agent_id: decision?.decided_by || input.requester || input.reviewer,
-    status: approvalStatusToCheckpointStatus(status),
-    data,
-    error: status === "rejected" || status === "expired" ? String(data.reason || status) : null,
-    started_at: existing?.started_at || timestamp2,
-    completed_at: status === "pending" ? null : timestamp2
-  }, d);
-  return gateFromCheckpoint(checkpoint);
-}
-function currentGate(taskId, gate, db) {
-  const checkpoint = getCheckpoint(taskId, stepForGate(gate), db);
-  return checkpoint ? gateFromCheckpoint(checkpoint) : null;
-}
-function requestApprovalGate(input, db) {
-  const d = db || getDatabase();
-  const existing = currentGate(input.task_id, input.gate, d);
-  if (existing && existing.status !== "pending") {
-    throw new Error(`Approval gate ${input.gate} is already ${existing.status}`);
-  }
-  const gate = writeGate(input, "pending", undefined, d);
-  logApprovalEvent(input.task_id, "requested", gate, input.requester || input.reviewer, d);
-  return gate;
-}
-function approveApprovalGate(input, db) {
-  const d = db || getDatabase();
-  const existing = currentGate(input.task_id, input.gate, d);
-  if (!existing)
-    throw new Error(`Approval gate not found: ${input.gate}`);
-  if (existing.status !== "pending")
-    throw new Error(`Approval gate ${input.gate} is already ${existing.status}`);
-  if (isExpired(existing.expires_at))
-    throw new Error(`Approval gate ${input.gate} is expired`);
-  const gate = writeGate({
-    task_id: input.task_id,
-    gate: input.gate,
-    requester: existing.requester || undefined,
-    reviewer: input.reviewer || existing.reviewer || undefined,
-    reason: existing.reason || undefined,
-    plan_id: existing.plan_id || undefined,
-    run_id: existing.run_id || undefined,
-    expires_at: existing.expires_at || undefined
-  }, "approved", { decided_by: input.reviewer, decided_at: now(), note: input.note }, d);
-  logApprovalEvent(input.task_id, "approved", gate, input.reviewer, d);
-  return gate;
-}
-function rejectApprovalGate(input, db) {
-  const d = db || getDatabase();
-  const existing = currentGate(input.task_id, input.gate, d);
-  if (!existing)
-    throw new Error(`Approval gate not found: ${input.gate}`);
-  if (existing.status !== "pending")
-    throw new Error(`Approval gate ${input.gate} is already ${existing.status}`);
-  const gate = writeGate({
-    task_id: input.task_id,
-    gate: input.gate,
-    requester: existing.requester || undefined,
-    reviewer: input.reviewer || existing.reviewer || undefined,
-    reason: existing.reason || undefined,
-    plan_id: existing.plan_id || undefined,
-    run_id: existing.run_id || undefined,
-    expires_at: existing.expires_at || undefined
-  }, "rejected", { decided_by: input.reviewer, decided_at: now(), note: input.note, reason: input.reason || input.note }, d);
-  logApprovalEvent(input.task_id, "rejected", gate, input.reviewer, d);
-  return gate;
-}
-function expireApprovalGate(input, db) {
-  const d = db || getDatabase();
-  const existing = currentGate(input.task_id, input.gate, d);
-  if (!existing)
-    throw new Error(`Approval gate not found: ${input.gate}`);
-  if (existing.status !== "pending")
-    throw new Error(`Approval gate ${input.gate} is already ${existing.status}`);
-  const gate = writeGate({
-    task_id: input.task_id,
-    gate: input.gate,
-    requester: existing.requester || undefined,
-    reviewer: existing.reviewer || undefined,
-    reason: existing.reason || undefined,
-    plan_id: existing.plan_id || undefined,
-    run_id: existing.run_id || undefined,
-    expires_at: existing.expires_at || undefined
-  }, "expired", { decided_by: input.reviewer, decided_at: now(), reason: input.reason || "expired" }, d);
-  logApprovalEvent(input.task_id, "expired", gate, input.reviewer, d);
-  return gate;
-}
-function listApprovalGates(taskId, db) {
-  const d = db || getDatabase();
-  ensureTask(taskId, d);
-  return getTaskCheckpoints(taskId, d).filter((checkpoint) => checkpoint.data["approval_gate"] === true || checkpoint.step.startsWith("approval:")).map(gateFromCheckpoint);
-}
-function checkApprovalGate(taskId, gateName, db) {
-  const d = db || getDatabase();
-  ensureTask(taskId, d);
-  const gate = currentGate(taskId, gateName, d);
-  const reasons = [];
-  if (!gate)
-    reasons.push(`approval gate is required: ${gateName}`);
-  else if (gate.status !== "approved")
-    reasons.push(`approval gate ${gateName} is ${gate.status}`);
-  if (gate && gate.status === "pending" && isExpired(gate.expires_at))
-    reasons.push(`approval gate ${gateName} is expired`);
-  return { allowed: reasons.length === 0, gate, reasons };
-}
-function assertApprovalGate(taskId, gateName, db) {
-  const result = checkApprovalGate(taskId, gateName, db);
-  if (!result.allowed)
-    throw new Error(result.reasons.join("; "));
-  return result.gate;
-}
-var init_approval_gates = __esm(() => {
-  init_audit();
-  init_checkpoints();
-  init_database();
-  init_task_runs();
-  init_tasks();
-  init_types();
-  init_event_emission_safety();
-  init_event_hooks();
-});
-
 // src/lib/terminal-notifications.ts
 var exports_terminal_notifications = {};
 __export(exports_terminal_notifications, {
@@ -34330,7 +36613,7 @@ var init_terminal_notifications = __esm(() => {
 });
 
 // src/db/api-keys.ts
-import { createHash as createHash10, randomBytes as randomBytes2, timingSafeEqual as timingSafeEqual3 } from "crypto";
+import { createHash as createHash11, randomBytes as randomBytes2, timingSafeEqual as timingSafeEqual3 } from "crypto";
 function rowToRecord(row) {
   return {
     id: row.id,
@@ -34344,7 +36627,7 @@ function rowToRecord(row) {
   };
 }
 function hashApiKey(key) {
-  return createHash10("sha256").update(key).digest("hex");
+  return createHash11("sha256").update(key).digest("hex");
 }
 function safeEqualHex(a, b) {
   if (a.length !== b.length)
@@ -34352,8 +36635,8 @@ function safeEqualHex(a, b) {
   return timingSafeEqual3(Buffer.from(a, "hex"), Buffer.from(b, "hex"));
 }
 function safeEqualStrings(a, b) {
-  const ah = createHash10("sha256").update(a, "utf8").digest();
-  const bh = createHash10("sha256").update(b, "utf8").digest();
+  const ah = createHash11("sha256").update(a, "utf8").digest();
+  const bh = createHash11("sha256").update(b, "utf8").digest();
   return timingSafeEqual3(ah, bh);
 }
 function generatePlaintextKey() {
@@ -34895,8 +37178,33 @@ var init_postgres_sync = __esm(() => {
   };
 });
 
+// src/task-manifest/canonical.ts
+import { createHash as createHash12 } from "crypto";
+function canonicalize2(value) {
+  if (Array.isArray(value))
+    return value.map(canonicalize2);
+  if (value !== null && typeof value === "object") {
+    return Object.fromEntries(Object.entries(value).filter(([, entry2]) => entry2 !== undefined).sort(([left], [right]) => left.localeCompare(right)).map(([key, entry2]) => [key, canonicalize2(entry2)]));
+  }
+  return value;
+}
+function canonicalJson2(value) {
+  return JSON.stringify(canonicalize2(value));
+}
+function canonicalDigest(value) {
+  return createHash12("sha256").update(canonicalJson2(value)).digest("hex");
+}
+function deterministicUuid(namespace, ...parts) {
+  const bytes = createHash12("sha256").update([namespace, ...parts].join("\x1F")).digest().subarray(0, 16);
+  bytes[6] = bytes[6] & 15 | 80;
+  bytes[8] = bytes[8] & 63 | 128;
+  const hex = bytes.toString("hex");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+var init_canonical = () => {};
+
 // src/storage/postgres-adapter.ts
-import { randomUUID as randomUUID4 } from "crypto";
+import { randomUUID as randomUUID5 } from "crypto";
 function createPostgresTodosStorageAdapter(options) {
   const store = new PostgresJsonRecordStore(options);
   const adapter = {
@@ -35120,7 +37428,7 @@ class PostgresJsonRecordStore {
            AND task_record.deleted_at IS NULL
            AND target.payload->>'locked_by' = $3
            AND target.payload->>'locked_at' = $4
-           AND todos_try_timestamptz(target.payload->>'locked_at') < $5::timestamptz
+           AND $4::timestamptz < $5::timestamptz
            AND COALESCE(target.payload->>'status', '') NOT IN ('completed', 'failed', 'cancelled')
          RETURNING task_record.payload
        ),
@@ -36274,7 +38582,7 @@ async function createTask2(input, store, context) {
   const effectiveProjectId = linkedPlan?.project_id ?? requestedProjectId;
   const shortId = effectiveProjectId ? await nextTaskShortId2(effectiveProjectId, store, context) : null;
   const task = {
-    id: randomUUID4(),
+    id: randomUUID5(),
     short_id: shortId,
     project_id: effectiveProjectId,
     parent_id: input.parent_id ?? null,
@@ -36520,7 +38828,7 @@ async function addVerification(input, store, context) {
     throw new Error(`Task not found: ${input.task_id}`);
   const timestamp2 = new Date().toISOString();
   const verification = {
-    id: randomUUID4(),
+    id: randomUUID5(),
     task_id: input.task_id,
     command: input.command,
     status: input.status ?? "unknown",
@@ -36541,7 +38849,7 @@ async function addCommit(input, store, context) {
     throw new Error(`Task not found: ${input.task_id}`);
   const timestamp2 = new Date().toISOString();
   const commit = {
-    id: randomUUID4(),
+    id: randomUUID5(),
     task_id: input.task_id,
     sha: input.sha,
     message: input.message ?? null,
@@ -36562,16 +38870,17 @@ async function findCommit(sha, store) {
 async function addGitRef(input, store, context) {
   if (!await store.get("tasks", input.task_id))
     throw new Error(`Task not found: ${input.task_id}`);
+  const existing = (await store.list("refs")).filter((ref) => ref.task_id === input.task_id && ref.ref_type === input.ref_type && ref.name === input.name).sort((left, right) => left.created_at.localeCompare(right.created_at) || left.id.localeCompare(right.id))[0];
   const timestamp2 = new Date().toISOString();
   const gitRef = {
-    id: randomUUID4(),
+    id: existing?.id ?? deterministicUuid("todos:git-ref:v1", input.task_id, input.ref_type, input.name),
     task_id: input.task_id,
     ref_type: input.ref_type,
     name: input.name,
-    url: input.url ?? null,
-    provider: input.provider ?? null,
+    url: input.url ?? existing?.url ?? null,
+    provider: input.provider ?? existing?.provider ?? null,
     metadata: input.metadata ?? {},
-    created_at: timestamp2,
+    created_at: existing?.created_at ?? timestamp2,
     updated_at: timestamp2
   };
   await store.upsert("refs", gitRef, context);
@@ -36634,7 +38943,7 @@ async function createProject2(input, store, context) {
   if (!derivedSlug || !taskListId)
     throw new Error("Project name and task-list slug must be non-empty");
   const project = {
-    id: randomUUID4(),
+    id: randomUUID5(),
     name: input.name,
     path: input.path,
     description: input.description ?? null,
@@ -36666,7 +38975,7 @@ async function createPlan2(input, store, context) {
     store
   });
   return store.upsert("plans", {
-    id: randomUUID4(),
+    id: randomUUID5(),
     slug,
     project_id: projectId,
     task_list_id: input.task_list_id ?? context?.taskListId ?? null,
@@ -36718,7 +39027,7 @@ async function registerAgent2(input, store, context) {
   }
   const timestamp2 = new Date().toISOString();
   const agent = {
-    id: existing?.id ?? randomUUID4().slice(0, 8),
+    id: existing?.id ?? randomUUID5().slice(0, 8),
     name: canonicalName,
     description: input.description ?? existing?.description ?? null,
     role: input.role ?? existing?.role ?? null,
@@ -36791,7 +39100,7 @@ async function createTaskList2(input, store, context) {
   if (!slug)
     throw new Error("Invalid task-list slug \u2014 must be non-empty kebab-case");
   return store.upsert("task_lists", {
-    id: randomUUID4(),
+    id: randomUUID5(),
     project_id: input.project_id ?? context?.projectId ?? null,
     slug,
     name: input.name,
@@ -36826,7 +39135,7 @@ async function updateTaskList2(id, input, store) {
 async function createTemplate2(input, store, context) {
   const timestamp2 = new Date().toISOString();
   const template = {
-    id: randomUUID4(),
+    id: randomUUID5(),
     name: input.name,
     title_pattern: input.title_pattern,
     description: input.description ?? null,
@@ -36847,7 +39156,7 @@ async function createTemplate2(input, store, context) {
 }
 function buildTemplateTasks(templateId, inputs, timestamp2) {
   return inputs.map((input, position) => ({
-    id: randomUUID4(),
+    id: randomUUID5(),
     template_id: templateId,
     position,
     title_pattern: input.title_pattern,
@@ -36880,7 +39189,7 @@ async function updateTemplate2(id, input, store) {
 }
 async function logTaskChange2(taskId, action, field, oldValue, newValue, agentId, store, context) {
   const entry2 = {
-    id: randomUUID4(),
+    id: randomUUID5(),
     task_id: taskId,
     action,
     field: field ?? null,
@@ -36894,7 +39203,7 @@ async function logTaskChange2(taskId, action, field, oldValue, newValue, agentId
 }
 async function addComment2(input, store, context) {
   const comment = {
-    id: randomUUID4(),
+    id: randomUUID5(),
     task_id: input.task_id,
     agent_id: input.agent_id ?? context?.agentId ?? null,
     session_id: input.session_id ?? context?.sessionId ?? null,
@@ -37133,6 +39442,7 @@ var init_postgres_adapter = __esm(() => {
   init_integrity();
   init_redaction();
   init_audit_history_import();
+  init_canonical();
   TASK_ORDER_BY = `ORDER BY ${TASK_ORDER_TIEBREAK}`;
 });
 
@@ -38620,25 +40930,25 @@ var init_sqlite = __esm(() => {
 });
 
 // src/project-registration/authority.ts
-import { createHash as createHash11 } from "crypto";
+import { createHash as createHash13 } from "crypto";
 function canonicalProjectRegistrationJson(value) {
-  return JSON.stringify(canonicalize2(value));
+  return JSON.stringify(canonicalize3(value));
 }
-function canonicalize2(value) {
+function canonicalize3(value) {
   if (Array.isArray(value))
-    return value.map(canonicalize2);
+    return value.map(canonicalize3);
   if (!value || typeof value !== "object")
     return value;
   const out = {};
   for (const key of Object.keys(value).sort()) {
     const entry2 = value[key];
     if (entry2 !== undefined)
-      out[key] = canonicalize2(entry2);
+      out[key] = canonicalize3(entry2);
   }
   return out;
 }
 function digestProjectRegistrationValue(value) {
-  return createHash11("sha256").update(canonicalProjectRegistrationJson(value)).digest("hex");
+  return createHash13("sha256").update(canonicalProjectRegistrationJson(value)).digest("hex");
 }
 function deriveTodosProjectRegistrationIdempotencyKey(input) {
   return `prk_${digestProjectRegistrationValue({
@@ -39633,31 +41943,6 @@ var init_project_registration = __esm(() => {
   init_types3();
 });
 
-// src/task-manifest/canonical.ts
-import { createHash as createHash12 } from "crypto";
-function canonicalize3(value) {
-  if (Array.isArray(value))
-    return value.map(canonicalize3);
-  if (value !== null && typeof value === "object") {
-    return Object.fromEntries(Object.entries(value).filter(([, entry2]) => entry2 !== undefined).sort(([left], [right]) => left.localeCompare(right)).map(([key, entry2]) => [key, canonicalize3(entry2)]));
-  }
-  return value;
-}
-function canonicalJson2(value) {
-  return JSON.stringify(canonicalize3(value));
-}
-function canonicalDigest(value) {
-  return createHash12("sha256").update(canonicalJson2(value)).digest("hex");
-}
-function deterministicUuid(namespace, ...parts) {
-  const bytes = createHash12("sha256").update([namespace, ...parts].join("\x1F")).digest().subarray(0, 16);
-  bytes[6] = bytes[6] & 15 | 80;
-  bytes[8] = bytes[8] & 63 | 128;
-  const hex = bytes.toString("hex");
-  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
-}
-var init_canonical = () => {};
-
 // node_modules/.bun/zod@3.25.76/node_modules/zod/v3/helpers/util.js
 var util, objectUtil, ZodParsedType, getParsedType = (data) => {
   const t = typeof data;
@@ -44211,7 +46496,7 @@ class PostgresTodosTaskManifestBackend {
         result_digest: input.result_digest
       };
       const manifestJson = canonicalJson2(manifest);
-      const resultJson = canonicalJson2(result);
+      const resultJson2 = canonicalJson2(result);
       await tx.query(`INSERT INTO todos_task_manifest_receipts (
         receipt_id, tenant_id, authority, route, schema_version, kind, operation_id, idempotency_key,
         request_digest, result_digest, binding_version, apply_receipt_id, manifest_json, result_json, created_at
@@ -44223,7 +46508,7 @@ class PostgresTodosTaskManifestBackend {
         input.request_digest,
         input.result_digest,
         manifestJson,
-        resultJson,
+        resultJson2,
         input.now
       ]);
       for (const entry2 of input.outbox) {
@@ -44250,7 +46535,7 @@ class PostgresTodosTaskManifestBackend {
         input.result_digest,
         input.receipt_id,
         manifestJson,
-        resultJson,
+        resultJson2,
         input.now
       ]);
       fault(faults, "after_receipt_write");
@@ -47160,6 +49445,7 @@ function buildV1OpenApiDocument(version = getPackageVersion()) {
             plan_id: { type: "string" },
             assigned_to: { type: "string" },
             agent_id: { type: "string" },
+            created_by: { type: "string" },
             tags: { type: "array", items: { type: "string" } }
           }
         },
@@ -49002,6 +51288,7 @@ var init_openapi = __esm(() => {
       parent_id: { type: "string", nullable: true },
       assigned_to: { type: "string", nullable: true },
       agent_id: { type: "string", nullable: true },
+      created_by: { type: "string", nullable: true },
       reason: { type: "string", nullable: true },
       tags: { type: "array", items: { type: "string" } },
       version: { type: "number" },
@@ -51598,7 +53885,7 @@ async function validateMcpAssignee(value, allowSeat) {
 function registerTaskCrudTools(server, ctx) {
   const { shouldRegisterTool, resolveId, formatError, formatTask, applyFocus } = ctx;
   function mutationTaskResponse(task2) {
-    const compact = compactTask(task2, 240);
+    const compact = compactTask2(task2, 240);
     compact["version"] = task2.version;
     compact["created_at"] = task2.created_at;
     compact["task_list_id"] = task2.task_list_id;
@@ -51820,7 +54107,7 @@ function registerTaskCrudTools(server, ctx) {
           throw new TaskNotFoundError(task_id);
         const focus = ctx.getAgentFocus(task2.assigned_to || "");
         if (detail !== "full") {
-          const compact = compactTask(task2, max_description_chars || 240);
+          const compact = compactTask2(task2, max_description_chars || 240);
           compact["version"] = task2.version;
           compact["created_at"] = task2.created_at;
           compact["focus"] = focus ? { agent_id: focus.agent_id, project_id: focus.project_id || null } : null;
@@ -52168,7 +54455,7 @@ var exports_mention_resolver = {};
 __export(exports_mention_resolver, {
   resolveMentions: () => resolveMentions
 });
-import { existsSync as existsSync19, readdirSync as readdirSync4, readFileSync as readFileSync12, statSync as statSync10 } from "fs";
+import { existsSync as existsSync19, readdirSync as readdirSync4, readFileSync as readFileSync13, statSync as statSync10 } from "fs";
 import { basename as basename8, isAbsolute, join as join19, relative as relative5, resolve as resolve18, sep as sep5 } from "path";
 function blankResolution(parsed) {
   return {
@@ -52277,7 +54564,7 @@ function resolveFile(parsed, workspace) {
     return resolution;
   }
   if (parsed.line !== undefined) {
-    const lineCount = readFileSync12(absolutePath, "utf-8").split(/\r?\n/).length;
+    const lineCount = readFileSync13(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;
@@ -52330,7 +54617,7 @@ function resolveSymbol(parsed, workspace, maxMatches) {
   const pattern = symbolPattern(name);
   const matches = [];
   for (const file of walkSourceFiles(workspace)) {
-    const lines = readFileSync12(file, "utf-8").split(/\r?\n/);
+    const lines = readFileSync13(file, "utf-8").split(/\r?\n/);
     for (let index = 0;index < lines.length; index += 1) {
       const line = lines[index];
       const found = pattern.exec(line);
@@ -54783,7 +57070,7 @@ __export(exports_audit_ledger, {
   LOCAL_AUDIT_LEDGER_INITIAL_HASH: () => LOCAL_AUDIT_LEDGER_INITIAL_HASH,
   LOCAL_AUDIT_LEDGER_HASH_ALGORITHM: () => LOCAL_AUDIT_LEDGER_HASH_ALGORITHM
 });
-import { createHash as createHash13 } from "crypto";
+import { createHash as createHash14 } from "crypto";
 function canonicalize4(value) {
   if (value === null || typeof value !== "object")
     return JSON.stringify(value);
@@ -54793,7 +57080,7 @@ function canonicalize4(value) {
   return `{${Object.keys(object).sort().map((key2) => `${JSON.stringify(key2)}:${canonicalize4(object[key2])}`).join(",")}}`;
 }
 function hash(value) {
-  return createHash13("sha256").update(value).digest("hex");
+  return createHash14("sha256").update(value).digest("hex");
 }
 function parsePayload3(value) {
   if (!value)
@@ -55072,7 +57359,7 @@ __export(exports_release_compatibility, {
   createReleaseCompatibilityReport: () => createReleaseCompatibilityReport,
   LOCAL_RELEASE_COMPATIBILITY_SCHEMA_VERSION: () => LOCAL_RELEASE_COMPATIBILITY_SCHEMA_VERSION
 });
-import { readFileSync as readFileSync13 } from "fs";
+import { readFileSync as readFileSync14 } from "fs";
 import { join as join20, resolve as resolve19 } from "path";
 import { Database as Database3 } from "bun:sqlite";
 function pass(id, message, details) {
@@ -55085,7 +57372,7 @@ function warn(id, message, details) {
   return { id, status: "warning", message, details };
 }
 function readPackageJson2(root) {
-  return JSON.parse(readFileSync13(join20(root, "package.json"), "utf8"));
+  return JSON.parse(readFileSync14(join20(root, "package.json"), "utf8"));
 }
 function sortedKeys(value) {
   return Object.keys(value ?? {}).sort((left, right) => left.localeCompare(right));
@@ -58193,7 +60480,7 @@ function registerTaskWorkflowTools(server, ctx) {
               type: "text",
               text: compactJson({
                 status: compactStatus(cloudStatus),
-                next_task: next_task2 ? compactTask(next_task2, max_description_chars || 180) : null,
+                next_task: next_task2 ? compactTask2(next_task2, max_description_chars || 180) : null,
                 overdue_count: 0,
                 latest_handoff: null,
                 as_of: payload2.as_of
@@ -58232,7 +60519,7 @@ function registerTaskWorkflowTools(server, ctx) {
             type: "text",
             text: compactJson({
               status: compactStatus(status2),
-              next_task: next_task ? compactTask(next_task, max_description_chars || 180) : null,
+              next_task: next_task ? compactTask2(next_task, max_description_chars || 180) : null,
               overdue_count: overdue.length,
               latest_handoff: compactHandoff(latest_handoff),
               as_of: payload.as_of
@@ -59634,7 +61921,7 @@ function registerTaskAdvTools(server, ctx) {
           const task3 = await cloudGetTask(cloud, task_id);
           if (!task3)
             throw new Error(`Task not found: ${task_id}`);
-          return { content: [{ type: "text", text: compactJson({ source: "cloud", task: compactTask(task3, 160) }) }] };
+          return { content: [{ type: "text", text: compactJson({ source: "cloud", task: compactTask2(task3, 160) }) }] };
         }
         const resolvedId = resolveId(task_id);
         const { getTask: getTask2 } = (init_tasks(), __toCommonJS(exports_tasks));
@@ -59655,7 +61942,7 @@ function registerTaskAdvTools(server, ctx) {
             content: [{
               type: "text",
               text: compactJson({
-                task: compactTask(task2, 160),
+                task: compactTask2(task2, 160),
                 dependencies: {
                   count: deps.length,
                   items: deps.slice(0, 10).map((d) => ({ direction: d.direction, task_id: d.task_id, status: d.status })),
@@ -59737,7 +62024,7 @@ Files (${files.length}):` : null,
             content: [{
               type: "text",
               text: compactJson({
-                task: compactTask(task2, max_description_chars || 240),
+                task: compactTask2(task2, max_description_chars || 240),
                 dependencies: {
                   count: deps.length,
                   items: deps.slice(0, 10).map((d) => ({ direction: d.direction, task_id: d.task_id, status: d.status })),
@@ -60749,7 +63036,7 @@ function updateDispatcherMetadata(runId, dispatcher, db) {
   d.run("UPDATE task_runs SET metadata = ?, updated_at = ? WHERE id = ?", [JSON.stringify(metadata), now(), run.id]);
   return getTaskRun(run.id, d);
 }
-function resolveAdapter(adapter) {
+function resolveAdapter2(adapter) {
   if (!adapter)
     return null;
   return loadConfig().agent_run_adapters?.[adapter] || null;
@@ -60800,7 +63087,7 @@ function removeAgentRunAdapter(name) {
   return true;
 }
 function queueAgentRun(input, db) {
-  const adapter = resolveAdapter(input.adapter);
+  const adapter = resolveAdapter2(input.adapter);
   const command = input.command || adapter?.command;
   if (!command)
     throw new Error("agent run requires --command or a configured adapter command");
@@ -60867,7 +63154,7 @@ async function runNextAgentDispatch(input = {}, db) {
   const next = listAgentRunQueue(d).find((item) => item.dispatcher.state === "queued" && (!input.adapter || item.dispatcher.adapter === input.adapter));
   if (!next)
     return null;
-  const adapter = resolveAdapter(next.dispatcher.adapter);
+  const adapter = resolveAdapter2(next.dispatcher.adapter);
   const command = renderCommand(next.dispatcher.command, next.run);
   const cwd = next.dispatcher.cwd || adapter?.cwd || process.cwd();
   const sandbox = next.dispatcher.sandbox || adapter?.sandbox;
@@ -60963,7 +63250,7 @@ function queuedRunById(runId, db) {
   return item.dispatcher ? item : null;
 }
 function enqueueAgentRun(input, db) {
-  const command = input.command || resolveAdapter(input.adapter)?.command || `agent-run:${input.adapter ?? "custom"}`;
+  const command = input.command || resolveAdapter2(input.adapter)?.command || `agent-run:${input.adapter ?? "custom"}`;
   const queued = queueAgentRun({
     task_id: input.task_id,
     agent_id: input.agent_id,
@@ -61055,7 +63342,7 @@ __export(exports_verification_providers, {
   getVerificationRecord: () => getVerificationRecord,
   discoverVerificationProviderCapabilities: () => discoverVerificationProviderCapabilities
 });
-import { existsSync as existsSync20, readFileSync as readFileSync14 } from "fs";
+import { existsSync as existsSync20, readFileSync as readFileSync15 } from "fs";
 function normalizeName6(name) {
   const normalized = name.trim().toLowerCase();
   if (!/^[a-z0-9][a-z0-9_-]{0,63}$/.test(normalized)) {
@@ -61207,7 +63494,7 @@ Timed out after ${provider.timeout_ms}ms`);
   };
 }
 function runCiLogProvider(input) {
-  const text = input.log_text ?? (input.log_path && existsSync20(input.log_path) ? readFileSync14(input.log_path, "utf-8") : "");
+  const text = input.log_text ?? (input.log_path && existsSync20(input.log_path) ? readFileSync15(input.log_path, "utf-8") : "");
   return {
     status: classifyLog(text),
     attempts: 1,
@@ -63509,8 +65796,8 @@ __export(exports_local_backups, {
   TODOS_LOCAL_BACKUP_KIND: () => TODOS_LOCAL_BACKUP_KIND,
   LOCAL_BACKUP_CHECKSUM_ALGORITHM: () => LOCAL_BACKUP_CHECKSUM_ALGORITHM
 });
-import { createHash as createHash14 } from "crypto";
-import { readFileSync as readFileSync15, writeFileSync as writeFileSync8 } from "fs";
+import { createHash as createHash15 } from "crypto";
+import { readFileSync as readFileSync16, writeFileSync as writeFileSync8 } from "fs";
 import { dirname as dirname9, resolve as resolve20 } from "path";
 import { mkdirSync as mkdirSync10 } from "fs";
 function stableJson2(value) {
@@ -63522,7 +65809,7 @@ function stableJson2(value) {
   return `{${Object.keys(record).sort().map((key2) => `${JSON.stringify(key2)}:${stableJson2(record[key2])}`).join(",")}}`;
 }
 function sha2565(value) {
-  return createHash14("sha256").update(stableJson2(value)).digest("hex");
+  return createHash15("sha256").update(stableJson2(value)).digest("hex");
 }
 function sqliteIntegrity(db) {
   let quick = "unknown";
@@ -63620,7 +65907,7 @@ function writeLocalBackupFile(backup, outputPath) {
   return path;
 }
 function readLocalBackupFile(path) {
-  return JSON.parse(readFileSync15(resolve20(path), "utf-8"));
+  return JSON.parse(readFileSync16(resolve20(path), "utf-8"));
 }
 function verifyLocalBackup(value, options = {}, db) {
   const verifiedAt = options.verified_at ?? now();
@@ -64203,7 +66490,7 @@ __export(exports_local_snapshots, {
   getLocalSnapshot: () => getLocalSnapshot,
   TODOS_LOCAL_SNAPSHOT_SCHEMA_VERSION: () => TODOS_LOCAL_SNAPSHOT_SCHEMA_VERSION
 });
-import { createHash as createHash15 } from "crypto";
+import { createHash as createHash16 } from "crypto";
 function source2(version) {
   return {
     packageName: "@hasna/todos",
@@ -64227,7 +66514,7 @@ function stable(value) {
   return Object.fromEntries(Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key2, item]) => [key2, stable(item)]));
 }
 function sha2566(value) {
-  return createHash15("sha256").update(JSON.stringify(stable(value))).digest("hex");
+  return createHash16("sha256").update(JSON.stringify(stable(value))).digest("hex");
 }
 function latestTimestamp2(items, fallback) {
   const timestamps = [];
@@ -64799,8 +67086,8 @@ __export(exports_agent_replay_simulator, {
   simulateAgentReplay: () => simulateAgentReplay,
   renderAgentReplaySimulationMarkdown: () => renderAgentReplaySimulationMarkdown
 });
-import { createHash as createHash16 } from "crypto";
-import { readFileSync as readFileSync16 } from "fs";
+import { createHash as createHash17 } from "crypto";
+import { readFileSync as readFileSync17 } from "fs";
 function isObject2(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
@@ -64821,7 +67108,7 @@ function stable2(value) {
   return Object.fromEntries(Object.keys(value).sort().map((key2) => [key2, stable2(value[key2])]));
 }
 function fingerprint2(value) {
-  return createHash16("sha256").update(JSON.stringify(stable2(value))).digest("hex");
+  return createHash17("sha256").update(JSON.stringify(stable2(value))).digest("hex");
 }
 function unpackFixture(input) {
   if (!isObject2(input))
@@ -65033,7 +67320,7 @@ function simulateAgentReplay(input, options = {}) {
   };
 }
 function simulateAgentReplayFile(path, options = {}) {
-  const parsed = JSON.parse(readFileSync16(path, "utf8"));
+  const parsed = JSON.parse(readFileSync17(path, "utf8"));
   return simulateAgentReplay(parsed, options);
 }
 function renderAgentReplaySimulationMarkdown(simulation) {
@@ -65139,7 +67426,7 @@ __export(exports_inbox, {
   deriveInboxTitle: () => deriveInboxTitle,
   createInboxItem: () => createInboxItem
 });
-import { createHash as createHash17 } from "crypto";
+import { createHash as createHash18 } from "crypto";
 function parseMetadata3(value) {
   if (!value)
     return {};
@@ -65159,7 +67446,7 @@ function compactWhitespace(value) {
 function fingerprintInboxInput(input) {
   const sourceType = input.source_type || detectInboxSourceType(input.body, input.source_url);
   const normalized = compactWhitespace(sanitizePreWriteText(input.body, "inbox.fingerprint")).slice(0, 8000);
-  return createHash17("sha256").update(`${sourceType}
+  return createHash18("sha256").update(`${sourceType}
 ${input.source_url || ""}
 ${normalized}`).digest("hex");
 }
@@ -70371,13 +72658,13 @@ __export(exports_environment_snapshots, {
   compareEnvironmentSnapshotFiles: () => compareEnvironmentSnapshotFiles,
   captureEnvironmentSnapshot: () => captureEnvironmentSnapshot
 });
-import { createHash as createHash18 } from "crypto";
-import { existsSync as existsSync21, readFileSync as readFileSync17, statSync as statSync11 } from "fs";
+import { createHash as createHash19 } from "crypto";
+import { existsSync as existsSync21, readFileSync as readFileSync18, statSync as statSync11 } from "fs";
 import { hostname as hostname2, platform, arch } from "os";
 import { dirname as dirname10, join as join22, resolve as resolve21 } from "path";
 import { tmpdir as tmpdir4 } from "os";
 function sha2567(value) {
-  return createHash18("sha256").update(value).digest("hex");
+  return createHash19("sha256").update(value).digest("hex");
 }
 function fileRecord(root, relativePath) {
   const path = join22(root, relativePath);
@@ -70386,7 +72673,7 @@ function fileRecord(root, relativePath) {
   const stat = statSync11(path);
   if (!stat.isFile())
     return null;
-  const content = readFileSync17(path);
+  const content = readFileSync18(path);
   return { path: relativePath, sha256: sha2567(content), size_bytes: content.length };
 }
 function manifestRecord(root, relativePath) {
@@ -70756,7 +73043,7 @@ Environment:
   TODOS_TOOL_GROUPS=<list>   Comma-separated tool group filter`);
 }
 function shouldRegisterTool(name) {
-  return shouldRegisterToolForProfile(name);
+  return shouldRegisterToolForProfile2(name);
 }
 function getAgentFocus(agentId) {
   const sessionFocus = agentFocusMap.get(agentId);
@@ -73432,7 +75719,7 @@ __export(exports_config_serve_commands, {
   registerConfigServeCommands: () => registerConfigServeCommands
 });
 import chalk7 from "chalk";
-import { existsSync as existsSync23, mkdirSync as mkdirSync12, readFileSync as readFileSync18, writeFileSync as writeFileSync10 } from "fs";
+import { existsSync as existsSync23, mkdirSync as mkdirSync12, readFileSync as readFileSync19, writeFileSync as writeFileSync10 } from "fs";
 import { dirname as dirname12, join as join24 } from "path";
 function registerConfigServeCommands(program2) {
   program2.command("config").description("View or update configuration").option("--get <key>", "Get a config value").option("--set <key=value>", "Set a config value (e.g. completion_guard.enabled=true)").action((opts) => {
@@ -73463,7 +75750,7 @@ function registerConfigServeCommands(program2) {
       }
       let config2 = {};
       try {
-        config2 = JSON.parse(readFileSync18(configPath, "utf-8"));
+        config2 = JSON.parse(readFileSync19(configPath, "utf-8"));
       } catch {}
       const keys = key2.split(".");
       let obj = config2;
@@ -73603,7 +75890,7 @@ function registerConfigServeCommands(program2) {
   redaction.command("scan [text]").description("Scan text or a file for secret-like values without printing values").option("--file <path>", "File to scan").action(async (text2, opts) => {
     const globalOpts = program2.opts();
     const { listSecretFindings: listSecretFindings2 } = await Promise.resolve().then(() => (init_redaction(), exports_redaction));
-    const value = opts.file ? readFileSync18(opts.file, "utf-8") : text2 || "";
+    const value = opts.file ? readFileSync19(opts.file, "utf-8") : text2 || "";
     const findings = listSecretFindings2(value);
     if (globalOpts.json) {
       output({ ok: findings.length === 0, findings }, true);
@@ -75168,14 +77455,14 @@ __export(exports_task_route_sources, {
   TASK_ROUTE_SOURCE_DISCOVERY_SCHEMA_VERSION: () => TASK_ROUTE_SOURCE_DISCOVERY_SCHEMA_VERSION
 });
 import { Database as Database4 } from "bun:sqlite";
-import { createHash as createHash19 } from "crypto";
+import { createHash as createHash20 } from "crypto";
 import { existsSync as existsSync25, readdirSync as readdirSync5, statSync as statSync12 } from "fs";
 import { basename as basename10, dirname as dirname14, join as join26, resolve as resolve22 } from "path";
 function normalizePath6(input) {
   return resolve22(input);
 }
 function sourceStoreId(sourceDbPath) {
-  const digest2 = createHash19("sha256").update(sourceDbPath).digest("hex").slice(0, 16);
+  const digest2 = createHash20("sha256").update(sourceDbPath).digest("hex").slice(0, 16);
   return `sqlite:${digest2}`;
 }
 function inferSourceRepoPath(sourceDbPath) {
@@ -75507,7 +77794,7 @@ __export(exports_tester_issue_reports, {
   TESTERS_ISSUE_REPORT_RESULT_SCHEMA_VERSION: () => TESTERS_ISSUE_REPORT_RESULT_SCHEMA_VERSION,
   TESTERS_ISSUE_REPORT_BATCH_RESULT_SCHEMA_VERSION: () => TESTERS_ISSUE_REPORT_BATCH_RESULT_SCHEMA_VERSION
 });
-import { createHash as createHash20 } from "crypto";
+import { createHash as createHash21 } from "crypto";
 function asObject3(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
@@ -75679,7 +77966,7 @@ function fingerprintTesterIssueReport(report) {
     normalizeText4(report.failure?.message || report.summary || report.title).slice(0, 240),
     normalizeText4(stackTop).slice(0, 160)
   ].join("::");
-  return `testers:${createHash20("sha256").update(raw).digest("hex").slice(0, 16)}`;
+  return `testers:${createHash21("sha256").update(raw).digest("hex").slice(0, 16)}`;
 }
 function priorityForSeverity(severity, fallback) {
   return PRIORITIES5.includes(severity) ? severity : fallback;
@@ -75978,7 +78265,7 @@ __export(exports_query_commands, {
   registerQueryCommands: () => registerQueryCommands
 });
 import chalk9 from "chalk";
-import { readFileSync as readFileSync19, writeFileSync as writeFileSync12 } from "fs";
+import { readFileSync as readFileSync20, writeFileSync as writeFileSync12 } from "fs";
 function parseJsonObjectOption2(value, label) {
   if (!value)
     return;
@@ -77742,7 +80029,7 @@ Findings`));
     const sessionId = opts.session || globalOpts.session || undefined;
     try {
       if (opts.import) {
-        const bundle = JSON.parse(readFileSync19(opts.import, "utf-8"));
+        const bundle = JSON.parse(readFileSync20(opts.import, "utf-8"));
         const result = importHandoffBundle(bundle, { apply: opts.apply }, db);
         if (opts.json || globalOpts.json) {
           console.log(JSON.stringify(result));
@@ -78116,7 +80403,7 @@ Findings`));
   });
   calendar.command("import <path>").description("Import VEVENT entries from an ICS file as local imported calendar items").option("-j, --json", "Output JSON").action((path, opts) => {
     try {
-      const result = importCalendarIcs(readFileSync19(path, "utf-8"));
+      const result = importCalendarIcs(readFileSync20(path, "utf-8"));
       if (opts.json || program2.opts().json) {
         output(result, true);
         return;
@@ -78267,7 +80554,7 @@ Findings`));
   });
   board.command("import <path>").description("Import local board definitions from a JSON bundle").option("-j, --json", "Output JSON").action((path, opts) => {
     try {
-      const bundle = JSON.parse(readFileSync19(path, "utf-8"));
+      const bundle = JSON.parse(readFileSync20(path, "utf-8"));
       const result = importTaskBoardBundle(bundle);
       if (opts.json || program2.opts().json) {
         output(result, true);
@@ -78643,7 +80930,7 @@ Findings`));
       const { importExternalIssues: importExternalIssues2 } = await Promise.resolve().then(() => (init_external_issue_importers(), exports_external_issue_importers));
       let body2 = text2 || "";
       if (opts.file)
-        body2 = readFileSync19(opts.file, "utf-8");
+        body2 = readFileSync20(opts.file, "utf-8");
       if (!body2 && !opts.url && !process.stdin.isTTY)
         body2 = await Bun.stdin.text();
       if (!body2.trim() && !opts.url) {
@@ -78700,7 +80987,7 @@ Findings`));
       } = await Promise.resolve().then(() => (init_tester_issue_reports(), exports_tester_issue_reports));
       let body2 = jsonText || "";
       if (opts.file)
-        body2 = readFileSync19(opts.file, "utf-8");
+        body2 = readFileSync20(opts.file, "utf-8");
       if (!body2 && !process.stdin.isTTY)
         body2 = await Bun.stdin.text();
       if (!body2.trim()) {
@@ -78743,11 +81030,11 @@ Findings`));
   const inbox = program2.command("inbox").description("Capture local inbox items from pasted errors, CI logs, git context, files, or GitHub issue URLs");
   inbox.command("add [text]").description("Create a local inbox item and linked task from text, stdin, or a file").option("--file <path>", "Read captured context from a file").option("--source-type <type>", "pasted_error, ci_log, git_context, github_issue, file, or other").option("--source-name <name>", "Human-readable source name").option("--source-url <url>", "Source URL, including GitHub issue URLs").option("--title <title>", "Task/inbox title").option("--priority <priority>", "Task priority").option("--tags <tags>", "Comma-separated extra tags").option("--metadata <json>", "Additional JSON metadata").option("--no-task", "Only store inbox item; do not create a linked task").option("-j, --json", "Output as JSON").action(async (text2, opts) => {
     const globalOpts = program2.opts();
-    const { readFileSync: readFileSync20 } = await import("fs");
+    const { readFileSync: readFileSync21 } = await import("fs");
     const { createInboxItem: createInboxItem2 } = await Promise.resolve().then(() => (init_inbox(), exports_inbox));
     let body2 = text2 || "";
     if (opts.file)
-      body2 = readFileSync20(opts.file, "utf-8");
+      body2 = readFileSync21(opts.file, "utf-8");
     if (!body2 && !process.stdin.isTTY)
       body2 = await Bun.stdin.text();
     if (!body2.trim()) {
@@ -78807,11 +81094,11 @@ ${diff}` : null].filter(Boolean).join(`
   });
   inbox.command("parse [text]").description("Preview or apply deterministic local natural-language task intake").option("--file <path>", "Read natural-language input from a file").option("--priority <priority>", "Default priority for parsed tasks", "medium").option("--project <id>", "Project ID for applied tasks").option("--list <id>", "Task list ID for applied tasks").option("--reference-date <iso>", "Reference date for due today/tomorrow/next week").option("--apply", "Create parsed tasks; default is dry-run preview").option("-j, --json", "Output as JSON").action(async (text2, opts) => {
     const globalOpts = program2.opts();
-    const { readFileSync: readFileSync20 } = await import("fs");
+    const { readFileSync: readFileSync21 } = await import("fs");
     const { previewNaturalLanguageIntake: previewNaturalLanguageIntake2 } = await Promise.resolve().then(() => (init_natural_language_intake(), exports_natural_language_intake));
     let body2 = text2 || "";
     if (opts.file)
-      body2 = readFileSync20(opts.file, "utf-8");
+      body2 = readFileSync21(opts.file, "utf-8");
     if (!body2 && !process.stdin.isTTY)
       body2 = await Bun.stdin.text();
     if (!body2.trim()) {
@@ -79138,7 +81425,7 @@ __export(exports_mcp_hooks_commands, {
 });
 import chalk10 from "chalk";
 import { execSync as execSync3 } from "child_process";
-import { existsSync as existsSync26, readFileSync as readFileSync20, writeFileSync as writeFileSync13, mkdirSync as mkdirSync14, chmodSync as chmodSync3 } from "fs";
+import { existsSync as existsSync26, readFileSync as readFileSync21, writeFileSync as writeFileSync13, mkdirSync as mkdirSync14, chmodSync as chmodSync3 } from "fs";
 import { dirname as dirname15, join as join27 } from "path";
 function getMcpBinaryPath() {
   try {
@@ -79155,7 +81442,7 @@ function readJsonFile2(path) {
   if (!existsSync26(path))
     return {};
   try {
-    return JSON.parse(readFileSync20(path, "utf-8"));
+    return JSON.parse(readFileSync21(path, "utf-8"));
   } catch {
     return {};
   }
@@ -79170,7 +81457,7 @@ function writeJsonFile2(path, data) {
 function readTomlFile(path) {
   if (!existsSync26(path))
     return "";
-  return readFileSync20(path, "utf-8");
+  return readFileSync21(path, "utf-8");
 }
 function writeTomlFile(path, content) {
   const dir = dirname15(path);
@@ -80361,7 +82648,7 @@ Artifacts:`));
       const hookPath = `${gitDir}/hooks/post-commit`;
       const marker = "# todos-auto-link";
       if (existsSync26(hookPath)) {
-        const existing = readFileSync20(hookPath, "utf-8");
+        const existing = readFileSync21(hookPath, "utf-8");
         if (existing.includes(marker)) {
           console.log(chalk10.yellow("Hook already installed."));
           return;
@@ -80391,7 +82678,7 @@ $(dirname "$0")/../../scripts/post-commit-hook.sh
         console.log(chalk10.dim("No post-commit hook found."));
         return;
       }
-      const content = readFileSync20(hookPath, "utf-8");
+      const content = readFileSync21(hookPath, "utf-8");
       if (!content.includes(marker)) {
         console.log(chalk10.dim("Hook not managed by todos."));
         return;
@@ -80574,7 +82861,7 @@ var init_dispatch3 = __esm(() => {
 });
 
 // src/lib/delegation-brief.ts
-import { createHash as createHash21 } from "crypto";
+import { createHash as createHash22 } from "crypto";
 function resolveDelegationBrief(input, sources) {
   const hasPath = typeof input.briefPath === "string" && input.briefPath.length > 0;
   const hasText = typeof input.briefText === "string" && input.briefText.length > 0;
@@ -80634,7 +82921,7 @@ function resolveDelegationBrief(input, sources) {
     ok: true,
     text: text2,
     source: source3,
-    sha256: createHash21("sha256").update(text2, "utf8").digest("hex"),
+    sha256: createHash22("sha256").update(text2, "utf8").digest("hex"),
     bytes: Buffer.byteLength(text2, "utf8")
   };
 }
@@ -80642,7 +82929,7 @@ var STDIN_SENTINEL = "-";
 var init_delegation_brief = () => {};
 
 // src/lib/delegation-policy.ts
-import { readFileSync as readFileSync21 } from "fs";
+import { readFileSync as readFileSync22 } from "fs";
 import { homedir as homedir4 } from "os";
 import { join as join28 } from "path";
 function defaultDelegationEmbargoPath() {
@@ -80650,7 +82937,7 @@ function defaultDelegationEmbargoPath() {
 }
 function loadDelegationEmbargo(path = defaultDelegationEmbargoPath()) {
   try {
-    const parsed = JSON.parse(readFileSync21(path, "utf8"));
+    const parsed = JSON.parse(readFileSync22(path, "utf8"));
     const entries = Array.isArray(parsed) ? parsed : Array.isArray(parsed?.embargoed) ? parsed.embargoed : [];
     const names = new Set;
     for (const entry2 of entries) {
@@ -80733,15 +83020,15 @@ __export(exports_delegate, {
   registerDelegateCommands: () => registerDelegateCommands
 });
 import chalk12 from "chalk";
-import { readFileSync as readFileSync22 } from "fs";
+import { readFileSync as readFileSync23 } from "fs";
 function registerDelegateCommands(program2) {
   program2.command("delegate <task> <worker>").description("Hand a filed task to a worker in one call: brief, depth, lineage, assignment, record and notice").option("--brief <path>", "Path to the self-sufficient brief; `-` reads stdin").option("--brief-text <text>", "Inline brief, as an alternative to --brief").option("--depth-threshold <n>", "Open-task count above which this delegation parks").option("--despite-depth", "Proceed past an armed depth threshold; recorded in the [DISPATCH] comment").option("--owner-directive", "Mark as an owner-directive dispatch: depth warns and never parks").option("--seat <slug>", "Seat whose open count is read (default: the lineage parent)").option("--runtime <name>", "Worker runtime label recorded in the comment (e.g. claude-code-subagent)").option("--reports-to <agent>", "Lineage parent for the worker identity (default: the dispatcher)").option("--reuse-identity", "Skip registration and reuse an existing worker identity").option("--depth <n>", "Explicit delegation_depth (default: the task's current depth + 1)").option("--channel <name>", "Channel for the one-line notice (default: $TODOS_DELEGATE_NOTICE_CHANNEL)").option("--no-post", "Skip the channel notice").option("--claim-window <minutes>", `Minutes before the claim deadline (default: ${DEFAULT_CLAIM_WINDOW_MINUTES})`).option("--assign-seat", "Allow <worker> to name a durable seat (a seat queue has no session watching it)").option("--dry-run", "Report all seven effects and perform none").option("-j, --json", "Output as JSON").action(async (taskRef, workerInput, opts) => {
     const globalOpts = program2.opts();
     const useJson = Boolean(opts.json || globalOpts.json);
     try {
       const brief = resolveDelegationBrief({ briefPath: opts.brief, briefText: opts.briefText }, {
-        readFile: (path) => readFileSync22(path, "utf8"),
-        readStdin: () => readFileSync22(0, "utf8")
+        readFile: (path) => readFileSync23(path, "utf8"),
+        readStdin: () => readFileSync23(0, "utf8")
       });
       if (!brief.ok)
         handleError(new Error(brief.message));
@@ -80989,7 +83276,7 @@ __export(exports_machines, {
 });
 import chalk13 from "chalk";
 import { execSync as execSync4 } from "child_process";
-import { readFileSync as readFileSync23, unlinkSync as unlinkSync3, writeFileSync as writeFileSync14 } from "fs";
+import { readFileSync as readFileSync24, unlinkSync as unlinkSync3, writeFileSync as writeFileSync14 } from "fs";
 import { tmpdir as tmpdir5 } from "os";
 import { join as join29 } from "path";
 function getOrCreateLocalMachineName() {
@@ -81033,7 +83320,7 @@ function readRemoteBridgeBundle(sshAddress) {
   try {
     runSsh(sshAddress, `todos export --format bridge --allow-plaintext-sensitive --output ${shellQuote(remotePath)}`, 120000);
     scpFromRemote(sshAddress, remotePath, localPath);
-    return JSON.parse(readFileSync23(localPath, "utf-8"));
+    return JSON.parse(readFileSync24(localPath, "utf-8"));
   } finally {
     try {
       runSsh(sshAddress, `rm -f ${shellQuote(remotePath)}`, 1e4);
@@ -85991,7 +88278,7 @@ var exports_roadmap_commands = {};
 __export(exports_roadmap_commands, {
   registerRoadmapCommands: () => registerRoadmapCommands
 });
-import { readFileSync as readFileSync24, writeFileSync as writeFileSync16 } from "fs";
+import { readFileSync as readFileSync25, writeFileSync as writeFileSync16 } from "fs";
 import chalk24 from "chalk";
 function splitList3(value) {
   return value?.split(";").flatMap((part) => part.split(",")).map((item) => item.trim()).filter(Boolean);
@@ -86016,14 +88303,14 @@ function resolveMany(table, values) {
     return resolved;
   });
 }
-function globalOptions(program2) {
+function globalOptions2(program2) {
   const command = program2;
   return command.optsWithGlobals?.() ?? program2.opts();
 }
 function registerRoadmapCommands(program2) {
   const roadmaps = program2.command("roadmaps").alias("roadmap").description("Manage local roadmaps, milestones, and release groupings");
   roadmaps.command("create <name>").description("Create a local roadmap").option("--description <text>", "Description").option("--project <id>", "Project ID").option("--status <status>", "planned, active, completed, archived").option("--owner <name>", "Owner name").option("--agent <name>", "Agent owner").option("--release <name>", "Default release label").action(async (name, opts) => {
-    const globalOpts = globalOptions(program2);
+    const globalOpts = globalOptions2(program2);
     try {
       const { createRoadmap: createRoadmap2 } = await Promise.resolve().then(() => (init_roadmaps(), exports_roadmaps));
       const roadmap = createRoadmap2({
@@ -86045,7 +88332,7 @@ function registerRoadmapCommands(program2) {
     }
   });
   roadmaps.command("list").description("List local roadmaps").option("--project <id>", "Project ID").option("--status <status>", "Filter by status").action(async (opts) => {
-    const globalOpts = globalOptions(program2);
+    const globalOpts = globalOptions2(program2);
     try {
       const { listRoadmaps: listRoadmaps2 } = await Promise.resolve().then(() => (init_roadmaps(), exports_roadmaps));
       const items = listRoadmaps2({ project_id: resolveOptional("projects", opts.project || globalOpts.project), status: opts.status });
@@ -86064,7 +88351,7 @@ function registerRoadmapCommands(program2) {
     }
   });
   roadmaps.command("show <roadmap>").description("Show a roadmap summary").option("--format <format>", "json or markdown", "json").action(async (roadmap, opts) => {
-    const globalOpts = globalOptions(program2);
+    const globalOpts = globalOptions2(program2);
     try {
       const { renderRoadmapMarkdown: renderRoadmapMarkdown2, summarizeRoadmap: summarizeRoadmap2 } = await Promise.resolve().then(() => (init_roadmaps(), exports_roadmaps));
       if (opts.format === "markdown") {
@@ -86082,7 +88369,7 @@ function registerRoadmapCommands(program2) {
     }
   });
   roadmaps.command("update <roadmap>").description("Update a local roadmap").option("--name <name>", "New name").option("--description <text>", "Description").option("--project <id>", "Project ID").option("--status <status>", "planned, active, completed, archived").option("--owner <name>", "Owner name").option("--agent <name>", "Agent owner").option("--release <name>", "Release label").action(async (roadmap, opts) => {
-    const globalOpts = globalOptions(program2);
+    const globalOpts = globalOptions2(program2);
     try {
       const { updateRoadmap: updateRoadmap2 } = await Promise.resolve().then(() => (init_roadmaps(), exports_roadmaps));
       const updated = updateRoadmap2(roadmap, {
@@ -86104,7 +88391,7 @@ function registerRoadmapCommands(program2) {
     }
   });
   roadmaps.command("delete <roadmap>").description("Delete a local roadmap and its local milestone/release config").action(async (roadmap) => {
-    const globalOpts = globalOptions(program2);
+    const globalOpts = globalOptions2(program2);
     try {
       const { deleteRoadmap: deleteRoadmap2 } = await Promise.resolve().then(() => (init_roadmaps(), exports_roadmaps));
       const deleted = deleteRoadmap2(roadmap);
@@ -86119,7 +88406,7 @@ function registerRoadmapCommands(program2) {
   });
   const milestones = roadmaps.command("milestones").description("Manage roadmap milestones");
   milestones.command("add <roadmap> <title>").description("Add a milestone to a roadmap").option("--description <text>", "Description").option("--due <iso>", "Due date or timestamp").option("--status <status>", "planned, active, completed, blocked, archived").option("--owner <name>", "Owner name").option("--agent <name>", "Agent owner").option("--tasks <list>", "Comma-separated task IDs").option("--plans <list>", "Comma-separated plan IDs").option("--runs <list>", "Comma-separated run IDs").option("--release <name>", "Release label").option("--tags <list>", "Comma-separated tags").action(async (roadmap, title, opts) => {
-    const globalOpts = globalOptions(program2);
+    const globalOpts = globalOptions2(program2);
     try {
       const { createMilestone: createMilestone2 } = await Promise.resolve().then(() => (init_roadmaps(), exports_roadmaps));
       const milestone = createMilestone2({
@@ -86146,7 +88433,7 @@ function registerRoadmapCommands(program2) {
     }
   });
   milestones.command("update <milestone>").description("Update a roadmap milestone").option("--title <title>", "Title").option("--description <text>", "Description").option("--due <iso>", "Due date or timestamp").option("--status <status>", "planned, active, completed, blocked, archived").option("--owner <name>", "Owner name").option("--agent <name>", "Agent owner").option("--tasks <list>", "Comma-separated task IDs").option("--plans <list>", "Comma-separated plan IDs").option("--runs <list>", "Comma-separated run IDs").option("--release <name>", "Release label").option("--tags <list>", "Comma-separated tags").action(async (milestone, opts) => {
-    const globalOpts = globalOptions(program2);
+    const globalOpts = globalOptions2(program2);
     try {
       const { updateMilestone: updateMilestone2 } = await Promise.resolve().then(() => (init_roadmaps(), exports_roadmaps));
       const updated = updateMilestone2(milestone, {
@@ -86173,7 +88460,7 @@ function registerRoadmapCommands(program2) {
   });
   const releases = roadmaps.command("releases").description("Manage roadmap release groups");
   releases.command("set <roadmap> <name>").description("Create or update a release grouping").option("--release-version <version>", "Version label").option("--status <status>", "planned, active, completed, blocked, archived").option("--milestones <list>", "Comma-separated milestone IDs").option("--tasks <list>", "Comma-separated task IDs").option("--plans <list>", "Comma-separated plan IDs").option("--runs <list>", "Comma-separated run IDs").option("--notes <text>", "Release notes").action(async (roadmap, name, opts) => {
-    const globalOpts = globalOptions(program2);
+    const globalOpts = globalOptions2(program2);
     try {
       const { upsertReleaseGroup: upsertReleaseGroup2 } = await Promise.resolve().then(() => (init_roadmaps(), exports_roadmaps));
       const release = upsertReleaseGroup2({
@@ -86197,7 +88484,7 @@ function registerRoadmapCommands(program2) {
     }
   });
   roadmaps.command("export <roadmap>").description("Export a roadmap as JSON bundle or Markdown").option("--format <format>", "json or markdown", "json").option("--out <path>", "Write output to a file").action(async (roadmap, opts) => {
-    const globalOpts = globalOptions(program2);
+    const globalOpts = globalOptions2(program2);
     try {
       const { exportRoadmapBundle: exportRoadmapBundle2, renderRoadmapMarkdown: renderRoadmapMarkdown2 } = await Promise.resolve().then(() => (init_roadmaps(), exports_roadmaps));
       const content = opts.format === "markdown" ? renderRoadmapMarkdown2(roadmap) : JSON.stringify(exportRoadmapBundle2(roadmap), null, 2);
@@ -86217,10 +88504,10 @@ function registerRoadmapCommands(program2) {
     }
   });
   roadmaps.command("import <path>").description("Preview or apply a roadmap JSON bundle").option("--apply", "Apply the import").action(async (path, opts) => {
-    const globalOpts = globalOptions(program2);
+    const globalOpts = globalOptions2(program2);
     try {
       const { importRoadmapBundle: importRoadmapBundle2 } = await Promise.resolve().then(() => (init_roadmaps(), exports_roadmaps));
-      const bundle = JSON.parse(readFileSync24(path, "utf8"));
+      const bundle = JSON.parse(readFileSync25(path, "utf8"));
       const result = importRoadmapBundle2(bundle, { apply: Boolean(opts.apply) });
       if (globalOpts.json) {
         output(result, true);
@@ -86254,14 +88541,14 @@ function resolveOptional2(table, value) {
     throw new Error(`Could not resolve ${table} ID: ${value}`);
   return resolved;
 }
-function globalOptions2(program2) {
+function globalOptions3(program2) {
   const command = program2;
   return command.optsWithGlobals?.() ?? program2.opts();
 }
 function registerCapacityCommands(program2) {
   const capacity = program2.command("capacity").description("Manage local capacity profiles and planning forecasts");
   capacity.command("set <agent>").description("Create or update a local agent capacity profile").requiredOption("--minutes-per-day <minutes>", "Available minutes per working day").option("--project <id>", "Project ID").option("--days <list>", "Working days as 0-6, where 0 is Sunday", "1,2,3,4,5").option("--from <date>", "Effective date").action(async (agent, opts) => {
-    const globalOpts = globalOptions2(program2);
+    const globalOpts = globalOptions3(program2);
     try {
       const { upsertCapacityProfile: upsertCapacityProfile2 } = await Promise.resolve().then(() => (init_capacity_forecasts(), exports_capacity_forecasts));
       const profile = upsertCapacityProfile2({
@@ -86281,7 +88568,7 @@ function registerCapacityCommands(program2) {
     }
   });
   capacity.command("list").description("List local capacity profiles").option("--agent <id>", "Filter by agent").option("--project <id>", "Filter by project").action(async (opts) => {
-    const globalOpts = globalOptions2(program2);
+    const globalOpts = globalOptions3(program2);
     try {
       const { listCapacityProfiles: listCapacityProfiles2 } = await Promise.resolve().then(() => (init_capacity_forecasts(), exports_capacity_forecasts));
       const profiles = listCapacityProfiles2({
@@ -86304,7 +88591,7 @@ function registerCapacityCommands(program2) {
     }
   });
   capacity.command("remove <agent-or-id>").description("Remove a local capacity profile").option("--project <id>", "Project ID for agent-scoped removal").action(async (agentOrId, opts) => {
-    const globalOpts = globalOptions2(program2);
+    const globalOpts = globalOptions3(program2);
     try {
       const { removeCapacityProfile: removeCapacityProfile2 } = await Promise.resolve().then(() => (init_capacity_forecasts(), exports_capacity_forecasts));
       const removed = removeCapacityProfile2(agentOrId, opts.project ? resolveOptional2("projects", opts.project) : undefined);
@@ -86318,7 +88605,7 @@ function registerCapacityCommands(program2) {
     }
   });
   capacity.command("forecast").description("Forecast local plan or project completion from estimates and capacity").option("--project <id>", "Project ID").option("--plan <id>", "Plan ID").option("--agent <id>", "Agent filter").option("--start-date <date>", "Forecast start date").option("--format <format>", "json or markdown", "json").action(async (opts) => {
-    const globalOpts = globalOptions2(program2);
+    const globalOpts = globalOptions3(program2);
     try {
       const { getPlanningForecast: getPlanningForecast2, renderPlanningForecastMarkdown: renderPlanningForecastMarkdown2 } = await Promise.resolve().then(() => (init_capacity_forecasts(), exports_capacity_forecasts));
       const forecast = getPlanningForecast2({
@@ -86352,7 +88639,7 @@ __export(exports_audit_ledger_commands, {
   registerAuditLedgerCommands: () => registerAuditLedgerCommands
 });
 import chalk26 from "chalk";
-function globalOptions3(program2) {
+function globalOptions4(program2) {
   const command = program2;
   return command.optsWithGlobals?.() ?? program2.opts();
 }
@@ -86369,7 +88656,7 @@ function resolveOptional3(table, value) {
 function registerAuditLedgerCommands(program2) {
   const audit = program2.command("audit-ledger").description("Create and verify tamper-evident local audit ledger checkpoints");
   audit.command("show").description("Build a local audit hash chain from current evidence").option("--project <id>", "Project ID").option("--task <id>", "Task ID").option("--run <id>", "Run ID").option("--entries", "Include per-entry hashes and redacted payloads").option("--format <format>", "json or markdown", "json").action(async (opts) => {
-    const globalOpts = globalOptions3(program2);
+    const globalOpts = globalOptions4(program2);
     try {
       const { getLocalAuditLedger: getLocalAuditLedger2, renderLocalAuditLedgerMarkdown: renderLocalAuditLedgerMarkdown2 } = await Promise.resolve().then(() => (init_audit_ledger(), exports_audit_ledger));
       const ledger2 = getLocalAuditLedger2({
@@ -86392,7 +88679,7 @@ function registerAuditLedgerCommands(program2) {
     }
   });
   audit.command("seal <name>").description("Store a local audit ledger checkpoint for later verification").option("--project <id>", "Project ID").option("--task <id>", "Task ID").option("--run <id>", "Run ID").option("--note <text>", "Checkpoint note").action(async (name, opts) => {
-    const globalOpts = globalOptions3(program2);
+    const globalOpts = globalOptions4(program2);
     try {
       const { sealLocalAuditLedger: sealLocalAuditLedger2 } = await Promise.resolve().then(() => (init_audit_ledger(), exports_audit_ledger));
       const checkpoint = sealLocalAuditLedger2({
@@ -86413,7 +88700,7 @@ function registerAuditLedgerCommands(program2) {
     }
   });
   audit.command("list").description("List local audit ledger checkpoints").action(async () => {
-    const globalOpts = globalOptions3(program2);
+    const globalOpts = globalOptions4(program2);
     try {
       const { listLocalAuditLedgerCheckpoints: listLocalAuditLedgerCheckpoints2 } = await Promise.resolve().then(() => (init_audit_ledger(), exports_audit_ledger));
       const checkpoints = listLocalAuditLedgerCheckpoints2();
@@ -86433,7 +88720,7 @@ function registerAuditLedgerCommands(program2) {
     }
   });
   audit.command("verify <checkpoint>").description("Verify current local evidence against a sealed checkpoint").option("--format <format>", "json or markdown", "json").action(async (checkpoint, opts) => {
-    const globalOpts = globalOptions3(program2);
+    const globalOpts = globalOptions4(program2);
     try {
       const { renderLocalAuditLedgerMarkdown: renderLocalAuditLedgerMarkdown2, verifyLocalAuditLedger: verifyLocalAuditLedger2 } = await Promise.resolve().then(() => (init_audit_ledger(), exports_audit_ledger));
       const result = verifyLocalAuditLedger2(checkpoint);
@@ -86465,7 +88752,7 @@ __export(exports_release_compatibility_commands, {
   registerReleaseCompatibilityCommands: () => registerReleaseCompatibilityCommands
 });
 import chalk27 from "chalk";
-function globalOptions4(program2) {
+function globalOptions5(program2) {
   const command = program2;
   return command.optsWithGlobals?.() ?? program2.opts();
 }
@@ -86477,7 +88764,7 @@ function parseLevels(value) {
 function registerReleaseCompatibilityCommands(program2) {
   const releaseCompat = program2.command("release-compat").description("Check local release compatibility, migrations, exports, and Bun install guidance");
   releaseCompat.command("check").description("Build a local release compatibility report").option("--root <path>", "Package root", process.cwd()).option("--levels <csv>", "Comma-separated migration levels to simulate").option("--format <format>", "json or markdown", "json").action(async (opts) => {
-    const globalOpts = globalOptions4(program2);
+    const globalOpts = globalOptions5(program2);
     try {
       const { createReleaseCompatibilityReport: createReleaseCompatibilityReport2, renderReleaseCompatibilityMarkdown: renderReleaseCompatibilityMarkdown2 } = await Promise.resolve().then(() => (init_release_compatibility(), exports_release_compatibility));
       const report = createReleaseCompatibilityReport2({
@@ -86513,7 +88800,7 @@ var exports_usage_ledger_commands = {};
 __export(exports_usage_ledger_commands, {
   registerUsageLedgerCommands: () => registerUsageLedgerCommands
 });
-function globalOptions5(program2) {
+function globalOptions6(program2) {
   const command = program2;
   return command.optsWithGlobals?.() ?? program2.opts();
 }
@@ -86539,7 +88826,7 @@ function registerUsageLedgerCommands(program2) {
   const usage = program2.command("usage").description("Report local task, run, command, cost, duration, storage, and quota usage");
   usage.command("report").description("Build an aggregate local usage ledger").option("--project <id>", "Filter by project").option("--agent <name>", "Filter by agent").option("--since <iso>", "Only include records created or started at or after this timestamp").option("--until <iso>", "Only include records created or started at or before this timestamp").option("--max-tasks <n>", "Simulate a task quota").option("--max-projects <n>", "Simulate a project quota").option("--max-runs <n>", "Simulate a run quota").option("--max-commands <n>", "Simulate a command quota").option("--max-tokens <n>", "Simulate a token quota").option("--max-cost-usd <n>", "Simulate a USD cost quota").option("--max-storage-bytes <n>", "Simulate an evidence storage quota").option("--format <format>", "json or markdown", "json").option("-j, --json", "Output as JSON").action(async (opts) => {
     try {
-      const globalOpts = globalOptions5(program2);
+      const globalOpts = globalOptions6(program2);
       const { createLocalUsageLedger: createLocalUsageLedger2, renderLocalUsageLedgerMarkdown: renderLocalUsageLedgerMarkdown2 } = await Promise.resolve().then(() => (init_usage_ledger(), exports_usage_ledger));
       const report = createLocalUsageLedger2({
         project_id: resolveProjectInput(opts.project || globalOpts.project),
@@ -86581,7 +88868,7 @@ __export(exports_local_backup_commands, {
 });
 import chalk28 from "chalk";
 import { resolve as resolve25 } from "path";
-function globalOptions6(program2) {
+function globalOptions7(program2) {
   const command = program2;
   return command.optsWithGlobals?.() ?? program2.opts();
 }
@@ -86597,7 +88884,7 @@ function registerLocalBackupCommands(program2) {
   const backup = program2.command("backup").description("Create, verify, restore, and inspect local backup bundles");
   backup.command("create").description("Create a local backup bundle with a manifest and checksums").option("-o, --output <path>", "Write backup JSON to a file").option("--project-id <id>", "Project id to scope the backup. Defaults to auto-detected project when available.").option("-j, --json", "Output as JSON").action(async (opts) => {
     try {
-      const globalOpts = globalOptions6(program2);
+      const globalOpts = globalOptions7(program2);
       const { createLocalBackup: createLocalBackup2 } = await Promise.resolve().then(() => (init_local_backups(), exports_local_backups));
       const projectId = opts.projectId ?? autoProject(globalOpts);
       const backupBundle = createLocalBackup2({
@@ -86619,7 +88906,7 @@ function registerLocalBackupCommands(program2) {
   });
   backup.command("verify <file>").description("Verify a local backup bundle checksum, manifest, bridge schema, and current SQLite integrity").option("-j, --json", "Output as JSON").action(async (file, opts) => {
     try {
-      const globalOpts = globalOptions6(program2);
+      const globalOpts = globalOptions7(program2);
       const { readLocalBackupFile: readLocalBackupFile2, verifyLocalBackup: verifyLocalBackup2 } = await Promise.resolve().then(() => (init_local_backups(), exports_local_backups));
       const verification2 = verifyLocalBackup2(readLocalBackupFile2(file));
       if (opts.json || globalOpts.json) {
@@ -86639,7 +88926,7 @@ function registerLocalBackupCommands(program2) {
   });
   backup.command("restore <file>").description("Dry-run or apply a local backup restore. Dry-run is the default.").option("--apply", "Apply the restore. Defaults to dry-run.").option("--resolve-conflicts", "Safely merge existing local tasks while preserving divergent fields").option("-j, --json", "Output as JSON").action(async (file, opts) => {
     try {
-      const globalOpts = globalOptions6(program2);
+      const globalOpts = globalOptions7(program2);
       const { readLocalBackupFile: readLocalBackupFile2, restoreLocalBackup: restoreLocalBackup2 } = await Promise.resolve().then(() => (init_local_backups(), exports_local_backups));
       const result = restoreLocalBackup2(readLocalBackupFile2(file), {
         apply: Boolean(opts.apply),
@@ -86667,7 +88954,7 @@ function registerLocalBackupCommands(program2) {
   });
   backup.command("integrity").description("Check local SQLite, bridge, count, and orphan-row integrity").option("--project-id <id>", "Optional project id to scope bridge counts").option("-j, --json", "Output as JSON").action(async (opts) => {
     try {
-      const globalOpts = globalOptions6(program2);
+      const globalOpts = globalOptions7(program2);
       const { checkLocalIntegrity: checkLocalIntegrity2 } = await Promise.resolve().then(() => (init_local_backups(), exports_local_backups));
       const report = checkLocalIntegrity2({
         project_id: opts.projectId ?? autoProject(globalOpts)
@@ -87186,7 +89473,7 @@ var init_hybrid = __esm(() => {
 });
 
 // src/storage/s3-artifacts.ts
-import { createHash as createHash22, createHmac as createHmac2 } from "crypto";
+import { createHash as createHash23, createHmac as createHmac2 } from "crypto";
 function createTodosS3ArtifactStore(options) {
   const requestFetch = options.fetch ?? fetch;
   const now4 = options.now ?? (() => new Date);
@@ -87358,7 +89645,7 @@ function toAmzDate(date) {
   return date.toISOString().replace(/[:-]|\.\d{3}/g, "");
 }
 function sha256Hex(value) {
-  return createHash22("sha256").update(value).digest("hex");
+  return createHash23("sha256").update(value).digest("hex");
 }
 function hmac(key2, value) {
   return createHmac2("sha256", key2).update(value).digest();
@@ -87966,7 +90253,7 @@ __export(exports_storage_commands, {
   registerStorageCommands: () => registerStorageCommands
 });
 import chalk29 from "chalk";
-function globalOptions7(program2) {
+function globalOptions8(program2) {
   const command = program2;
   return command.optsWithGlobals?.() ?? program2.opts();
 }
@@ -88102,7 +90389,7 @@ function registerStorageCommands(program2) {
   const storage = program2.command("storage").description("Inspect explicit native local and remote storage configuration");
   storage.command("status").description("Show redacted native storage configuration without opening network connections").option("-j, --json", "Output as JSON").action(async (opts) => {
     try {
-      const globalOpts = globalOptions7(program2);
+      const globalOpts = globalOptions8(program2);
       const { getNativeStorageStatus: getNativeStorageStatus2 } = await Promise.resolve().then(() => (init_native_storage_status(), exports_native_storage_status));
       const nativeStatus = getNativeStorageStatus2();
       const remoteAuthority = getTodosRemoteAuthorityConfigStatus();
@@ -88160,7 +90447,7 @@ function registerStorageCommands(program2) {
   });
   storage.command("sync-plan").description("Preview native storage sync work without opening network connections").option("--schema-sql", "Include Postgres schema SQL in the dry-run output").option("-j, --json", "Output as JSON").action(async (opts) => {
     try {
-      const globalOpts = globalOptions7(program2);
+      const globalOpts = globalOptions8(program2);
       const { getNativeStorageSyncPlan: getNativeStorageSyncPlan2 } = await Promise.resolve().then(() => (init_native_storage_status(), exports_native_storage_status));
       const plan = getNativeStorageSyncPlan2(process.env, {
         includeSchemaSql: Boolean(opts.schemaSql)
@@ -88177,7 +90464,7 @@ function registerStorageCommands(program2) {
   storage.command("shadow-status").description("Report dual-write shadow divergence: local vs cloud row counts and last mirror lag (opens a read-only DB connection)").option("-j, --json", "Output as JSON").action(async (opts) => {
     let cloud = null;
     try {
-      const globalOpts = globalOptions7(program2);
+      const globalOpts = globalOptions8(program2);
       const asJson = Boolean(opts.json || globalOpts.json);
       const {
         createTodosCloudQueryClientFromEnv: createTodosCloudQueryClientFromEnv2,
@@ -88217,7 +90504,7 @@ function registerStorageCommands(program2) {
   });
   storage.command("shadow-drain").description("Drain the durable dual-write shadow outbox to cloud Postgres (one-way, write-only)").option("-j, --json", "Output as JSON").option("--timeout <ms>", "Max drain time in milliseconds", "30000").action(async (opts) => {
     try {
-      const globalOpts = globalOptions7(program2);
+      const globalOpts = globalOptions8(program2);
       const asJson = Boolean(opts.json || globalOpts.json);
       const {
         isTodosShadowEnabled: isTodosShadowEnabled2,
@@ -88259,7 +90546,7 @@ function registerStorageCommands(program2) {
   const artifacts = storage.command("artifacts").description("Preview or apply native S3 sync for locally stored run artifacts");
   artifacts.command("upload").description("Upload locally stored run artifact bytes to configured S3. Dry-run by default.").option("--run-id <id>", "Limit to one run id").option("--task-id <id>", "Limit to one task id").option("--limit <n>", "Maximum artifacts to scan").option("--include-already-synced", "Include artifacts that already have a remote reference").option("--apply", "Perform S3 uploads. Defaults to dry-run.").option("-j, --json", "Output as JSON").action(async (opts) => {
     try {
-      const globalOpts = globalOptions7(program2);
+      const globalOpts = globalOptions8(program2);
       const { planRunArtifactsS3Sync: planRunArtifactsS3Sync2, uploadRunArtifactsToS3: uploadRunArtifactsToS32 } = await Promise.resolve().then(() => (init_storage(), exports_storage));
       const filter = artifactFilter(opts);
       if (!opts.apply) {
@@ -88283,7 +90570,7 @@ function registerStorageCommands(program2) {
   });
   artifacts.command("download").description("Restore locally stored run artifact bytes from configured S3. Dry-run by default.").option("--run-id <id>", "Limit to one run id").option("--task-id <id>", "Limit to one task id").option("--limit <n>", "Maximum artifacts to scan").option("--force", "Download even when local stored content already verifies").option("--apply", "Perform S3 downloads. Defaults to dry-run.").option("-j, --json", "Output as JSON").action(async (opts) => {
     try {
-      const globalOpts = globalOptions7(program2);
+      const globalOpts = globalOptions8(program2);
       const { downloadRunArtifactsFromS3: downloadRunArtifactsFromS32, planRunArtifactsS3Sync: planRunArtifactsS3Sync2 } = await Promise.resolve().then(() => (init_storage(), exports_storage));
       const filter = artifactFilter(opts);
       if (!opts.apply) {
@@ -88550,7 +90837,7 @@ __export(exports_scale_hardening_commands, {
   registerScaleHardeningCommands: () => registerScaleHardeningCommands
 });
 import chalk30 from "chalk";
-function globalOptions8(program2) {
+function globalOptions9(program2) {
   const command = program2;
   return command.optsWithGlobals?.() ?? program2.opts();
 }
@@ -88567,7 +90854,7 @@ function registerScaleHardeningCommands(program2) {
   const scale = program2.command("scale").description("Benchmark local performance, archive readiness, compaction, and SQLite integrity");
   scale.command("report").description("Build a local scale hardening report without network access").option("--older-than-days <days>", "Archive-readiness window for terminal tasks", "30").option("--format <format>", "json or markdown", "markdown").option("-j, --json", "Output as JSON").action(async (opts) => {
     try {
-      const globalOpts = globalOptions8(program2);
+      const globalOpts = globalOptions9(program2);
       const { createScalePerformanceReport: createScalePerformanceReport2, renderScalePerformanceReportMarkdown: renderScalePerformanceReportMarkdown2 } = await Promise.resolve().then(() => (init_scale_hardening(), exports_scale_hardening));
       const report = createScalePerformanceReport2({
         older_than_days: parsePositiveInteger2(opts.olderThanDays, 30)
@@ -88586,7 +90873,7 @@ function registerScaleHardeningCommands(program2) {
   });
   scale.command("compact").description("Preview or apply local SQLite optimization and VACUUM compaction").option("--apply", "Run PRAGMA optimize and VACUUM; dry-run by default").option("--format <format>", "json or markdown", "json").option("-j, --json", "Output as JSON").action(async (opts) => {
     try {
-      const globalOpts = globalOptions8(program2);
+      const globalOpts = globalOptions9(program2);
       const { compactScaleStorage: compactScaleStorage2 } = await Promise.resolve().then(() => (init_scale_hardening(), exports_scale_hardening));
       const result = compactScaleStorage2({ apply: Boolean(opts.apply) });
       const format = opts.json || globalOpts.json ? "json" : opts.format || "json";
@@ -88617,7 +90904,7 @@ __export(exports_pr_group_commands, {
   registerPrGroupCommands: () => registerPrGroupCommands
 });
 import chalk31 from "chalk";
-function globalOptions9(program2) {
+function globalOptions10(program2) {
   const command = program2;
   return command.optsWithGlobals?.() ?? program2.opts();
 }
@@ -88639,7 +90926,7 @@ function registerPrGroupCommands(program2) {
     try {
       const remote = getTodosCloudClient();
       const view = remote ? await cloudGetPrGroup(remote, groupId) : await createLocalPrGroupLedger(getDatabase()).get(groupId);
-      if (opts.json || globalOptions9(program2)["json"]) {
+      if (opts.json || globalOptions10(program2)["json"]) {
         output(view, true);
         return;
       }
@@ -88657,7 +90944,7 @@ function registerPrGroupCommands(program2) {
       };
       const remote = getTodosCloudClient();
       const history = remote ? await cloudPrGroupEvents(remote, groupId, options) : await createLocalPrGroupLedger(getDatabase()).events(groupId, options);
-      if (opts.json || globalOptions9(program2)["json"]) {
+      if (opts.json || globalOptions10(program2)["json"]) {
         output(history, true);
         return;
       }
@@ -88940,7 +91227,7 @@ var exports_help_commands = {};
 __export(exports_help_commands, {
   registerHelpCommands: () => registerHelpCommands
 });
-function globalOptions10(program2) {
+function globalOptions11(program2) {
   const command = program2;
   return command.optsWithGlobals?.() ?? program2.opts();
 }
@@ -88949,19 +91236,19 @@ function parseShell(value) {
     return value;
   throw new Error(`Unsupported shell: ${value}. Expected one of: ${COMPLETION_SHELLS.join(", ")}`);
 }
-function registerHelpCommands(program2, route = "local") {
+function registerHelpCommands(program2, route = "local", remoteCapabilities = new Set) {
   program2.command("completions").alias("completion").description("Generate shell completions for bash, zsh, or fish").argument("<shell>", "Shell to generate: bash, zsh, or fish").action((shell) => {
     try {
-      console.log(generateCompletionScript(program2, parseShell(shell), (command) => isTodosCliCommandVisibleForRoute(command, route)));
+      console.log(generateCompletionScript(program2, parseShell(shell), (command) => isTodosCliCommandVisibleForRoute(command, route, remoteCapabilities)));
     } catch (error2) {
       handleError(error2);
     }
   });
   program2.command("manual").description("Print the complete local CLI manual").option("--format <format>", "markdown or json", "markdown").option("-j, --json", "Output as JSON").action((opts) => {
     try {
-      const globalOpts = globalOptions10(program2);
+      const globalOpts = globalOptions11(program2);
       const manual = createCliManual(program2, {
-        isCommandVisible: (command) => isTodosCliCommandVisibleForRoute(command, route),
+        isCommandVisible: (command) => isTodosCliCommandVisibleForRoute(command, route, remoteCapabilities),
         localOnly: route === "local"
       });
       const format = opts.json || globalOpts.json ? "json" : opts.format || "markdown";
@@ -88987,6 +91274,7 @@ var init_help_commands = __esm(() => {
 init_esm();
 init_package_version();
 init_stage_a();
+init_cloud_router();
 var program2 = new Command;
 function fallbackJsonRequested() {
   return program2.opts().json === true || process.argv.includes("--json");
@@ -89049,12 +91337,25 @@ try {
   console.error(error2 instanceof Error ? error2.message : String(error2));
   process.exit(1);
 }
+var remoteCommandCapabilities = new Set;
+var metadataRequested = authority.route === "remote-diagnostic";
+if (authority.route !== "local" && metadataRequested) {
+  try {
+    const client = getTodosCloudClient();
+    if (client) {
+      remoteCommandCapabilities = await getTodosRemoteCommandCapabilities(client);
+    }
+  } catch {
+    remoteCommandCapabilities = new Set;
+  }
+}
 var [
   { handleError: handleError2 },
   { registerTaskCommands: registerTaskCommands2 },
   { registerPlanTemplateCommands: registerPlanTemplateCommands2 },
   { registerProjectCommands: registerProjectCommands2 },
   { registerAgentCommands: registerAgentCommands2 },
+  { registerAiCommands: registerAiCommands2 },
   { registerConfigServeCommands: registerConfigServeCommands2 },
   { registerQueryCommands: registerQueryCommands2 },
   { registerMcpHooksCommands: registerMcpHooksCommands2 },
@@ -89087,6 +91388,7 @@ var [
   Promise.resolve().then(() => (init_plan_template_commands(), exports_plan_template_commands)),
   Promise.resolve().then(() => (init_project_commands(), exports_project_commands)),
   Promise.resolve().then(() => (init_agent_commands(), exports_agent_commands)),
+  Promise.resolve().then(() => (init_ai_commands(), exports_ai_commands)),
   Promise.resolve().then(() => (init_config_serve_commands(), exports_config_serve_commands)),
   Promise.resolve().then(() => (init_query_commands(), exports_query_commands)),
   Promise.resolve().then(() => (init_mcp_hooks_commands(), exports_mcp_hooks_commands)),
@@ -89118,6 +91420,7 @@ registerTaskCommands2(program2);
 registerPlanTemplateCommands2(program2);
 registerProjectCommands2(program2);
 registerAgentCommands2(program2);
+registerAiCommands2(program2);
 registerConfigServeCommands2(program2);
 registerQueryCommands2(program2);
 registerMcpHooksCommands2(program2);
@@ -89144,9 +91447,15 @@ registerStorageCommands2(program2);
 registerScaleHardeningCommands2(program2);
 registerPrGroupCommands2(program2);
 await registerOptionalEventsCommands(program2);
-registerHelpCommands2(program2, authority.route);
-applyTodosCliHelpVisibility(program2, authority.route);
+registerHelpCommands2(program2, authority.route, remoteCommandCapabilities);
+applyTodosCliHelpVisibility(program2, authority.route, remoteCommandCapabilities);
 try {
+  if (metadataRequested) {
+    const unavailableCommand = getUnavailableTodosCliRemoteMetadataCommand(authority.route, remoteCommandCapabilities, process.argv.slice(2));
+    if (unavailableCommand) {
+      throw new Error(`REMOTE_COMMAND_UNAVAILABLE: configured Todos authority does not advertise ${unavailableCommand}; help is unavailable for this command`);
+    }
+  }
   await program2.parseAsync();
 } catch (err) {
   handleError2(err);