@hasna/todos 0.15.18 → 0.15.20

package/dist/cli/index.js

@@ -2123,7 +2123,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@hasna/todos",
-    version: "0.15.18",
+    version: "0.15.20",
     description: "Universal task management for AI coding agents - CLI + MCP server + interactive TUI",
     type: "module",
     main: "dist/index.js",
@@ -2194,6 +2194,8 @@ var init_package = __esm(() => {
       "dev:mcp": "bun run src/mcp/index.ts",
       "dev:serve": "bun run src/server/index.ts",
       "verify:release": "bun run scripts/verify-public-release.ts --mode=review",
+      "verify:release-review": "bun run scripts/verify-npm-release-agent-review.ts",
+      "issue:release-review": "bun run scripts/issue-npm-release-agent-review.ts",
       prepublishOnly: "bun run scripts/verify-public-release.ts --mode=publish",
       postinstall: "mkdir -p $HOME/.hasna/todos $HOME/.hasna/todos/training 2>/dev/null || true"
     },
@@ -2269,7 +2271,7 @@ function isBlockingDependencyStatus(status) {
 function isTerminalStatus(status) {
   return status === "completed" || status === "failed" || status === "cancelled";
 }
-var TASK_STATUSES, TASK_PRIORITIES, PLAN_STATUSES, VersionConflictError, TaskNotFoundError, TaskNotStartableError, TaskReferenceAmbiguousError, ProjectNotFoundError, ResourceConflictError, PlanNotFoundError, LockError, AgentNotFoundError, IdentityAliasAmbiguousError, IdentityIdImmutableError, TaskListNotFoundError, DependencyCycleError, CompletionGuardError, DISPATCH_STATUSES, DispatchNotFoundError;
+var TASK_STATUSES, TASK_PRIORITIES, PLAN_STATUSES, VersionConflictError, TaskNotFoundError, TaskNotStartableError, TaskReferenceAmbiguousError, ProjectNotFoundError, ResourceConflictError, PlanRevisionConflictError, PlanNotFoundError, LockError, StaleLockHandoffError, AgentNotFoundError, IdentityAliasAmbiguousError, IdentityIdImmutableError, TaskListNotFoundError, DependencyCycleError, CompletionGuardError, DISPATCH_STATUSES, DispatchNotFoundError;
 var init_types = __esm(() => {
   TASK_STATUSES = [
     "pending",
@@ -2357,6 +2359,19 @@ var init_types = __esm(() => {
       this.name = "ResourceConflictError";
     }
   };
+  PlanRevisionConflictError = class PlanRevisionConflictError extends Error {
+    planId;
+    expectedUpdatedAt;
+    currentUpdatedAt;
+    static code = "PLAN_REVISION_CONFLICT";
+    constructor(planId, expectedUpdatedAt, currentUpdatedAt) {
+      super(`Plan revision conflict for ${planId}: expected ${expectedUpdatedAt}, current ${currentUpdatedAt}`);
+      this.planId = planId;
+      this.expectedUpdatedAt = expectedUpdatedAt;
+      this.currentUpdatedAt = currentUpdatedAt;
+      this.name = "PlanRevisionConflictError";
+    }
+  };
   PlanNotFoundError = class PlanNotFoundError extends Error {
     planId;
     static code = "PLAN_NOT_FOUND";
@@ -2379,6 +2394,16 @@ var init_types = __esm(() => {
       this.name = "LockError";
     }
   };
+  StaleLockHandoffError = class StaleLockHandoffError extends Error {
+    code;
+    details;
+    constructor(code, message, details = {}) {
+      super(message);
+      this.code = code;
+      this.details = details;
+      this.name = "StaleLockHandoffError";
+    }
+  };
   AgentNotFoundError = class AgentNotFoundError extends Error {
     agentId;
     static code = "AGENT_NOT_FOUND";
@@ -5467,6 +5492,7 @@ var init_http_client = __esm(() => {
 // src/cli/cloud-router.ts
 import { resolveStorageClient } from "@hasna/contracts/client/storage";
 import { normalizeStorageMode } from "@hasna/contracts/mode";
+import { randomUUID } from "crypto";
 import { resolve as resolvePath } from "path";
 function cleanMode(value) {
   const normalized = value?.trim().toLowerCase();
@@ -5819,6 +5845,45 @@ async function requestRawCloudTaskPage(client, filter) {
     total: parseCloudTaskTotal(res.raw)
   };
 }
+function cloudPlanTaskListError(planId, detail) {
+  return new Error(`REMOTE_PLAN_TASK_LIST_INCOMPLETE: hosted authority returned an incomplete task set for plan ${planId}; ` + `${detail}; refusing an incomplete plan result`);
+}
+function appendExactPlanTaskPage(target, seen, page, planId) {
+  for (const task of page) {
+    if (task.plan_id !== planId) {
+      throw cloudPlanTaskListError(planId, `response includes task ${task.id} from plan ${task.plan_id ?? "null"}`);
+    }
+    if (seen.has(task.id)) {
+      throw cloudPlanTaskListError(planId, `pagination repeats task id ${task.id}`);
+    }
+    seen.add(task.id);
+    target.push(task);
+  }
+}
+async function cloudListPlanTasks(client, planId) {
+  const filter = { plan_id: planId, include_subtasks: true };
+  const firstPage = await requestRawCloudTaskPage(client, filter);
+  const tasks = [];
+  const seen = new Set;
+  appendExactPlanTaskPage(tasks, seen, firstPage.tasks, planId);
+  if (firstPage.total === undefined)
+    return tasks;
+  const total = firstPage.total;
+  if (tasks.length > total) {
+    throw cloudPlanTaskListError(planId, `first page contains ${tasks.length} rows but reports total ${total}`);
+  }
+  while (tasks.length < total) {
+    const page = await requestRawCloudTaskPage(client, { ...filter, offset: tasks.length });
+    if (page.total !== total) {
+      throw cloudPlanTaskListError(planId, `pagination total changed from ${total} to ${String(page.total)}`);
+    }
+    if (page.tasks.length === 0 || tasks.length + page.tasks.length > total) {
+      throw cloudPlanTaskListError(planId, "pagination did not make bounded progress toward the reported total");
+    }
+    appendExactPlanTaskPage(tasks, seen, page.tasks, planId);
+  }
+  return tasks;
+}
 function cloudTaskListFilterError(code, taskListId, detail) {
   return new Error(`${code}: hosted authority returned rows outside requested task_list_id ${taskListId}; ${detail}; refusing an incomplete exact-list result`);
 }
@@ -5935,7 +6000,10 @@ async function cloudGetTask(client, id) {
 }
 async function cloudCreateTask(client, input) {
   const expectedParentId = typeof input["parent_id"] === "string" ? input["parent_id"] : null;
-  const created = unwrapTask(await requiredRemoteRoute(client, "/v1/tasks", () => client.create("tasks", input, { retry: false }), ["PARENT_TASK_NOT_FOUND"]));
+  const created = unwrapTask(await requiredRemoteRoute(client, "/v1/tasks", () => client.transport.post("/tasks", input, {
+    idempotencyKey: randomUUID(),
+    retry: false
+  }), ["PARENT_TASK_NOT_FOUND"]));
   if (!created || typeof created.id !== "string" || !created.id.trim()) {
     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");
   }
@@ -5946,7 +6014,7 @@ async function cloudCreateTask(client, input) {
   return persisted;
 }
 async function cloudUpdateTask(client, id, patch) {
-  return unwrapTask(await client.update("tasks", id, patch));
+  return unwrapTask(await client.transport.patch(`/tasks/${encodeURIComponent(id)}`, patch));
 }
 async function cloudDeleteTask(client, id) {
   try {
@@ -6004,8 +6072,16 @@ async function cloudTaskAction(client, id, action, body = {}) {
   const raw = await client.transport.post(`/tasks/${encodeURIComponent(id)}/${action}`, body);
   return unwrapTask(raw);
 }
+function isRemoteTaskIdentity(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return false;
+  const id = value["id"];
+  return typeof id === "string" && id.length > 0;
+}
 async function cloudFailTask(client, id, body = {}) {
   const route = `/v1/tasks/${encodeURIComponent(id)}/fail`;
+  if (body.retry === true)
+    await requireRetryCapability(client);
   const raw = await requiredRemoteRoute(client, route, () => client.transport.post(`/tasks/${encodeURIComponent(id)}/fail`, body));
   if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
     throw new Error(`REMOTE_API_INCOMPATIBLE: ${route} returned an invalid failure response envelope`);
@@ -6016,7 +6092,7 @@ async function cloudFailTask(client, id, body = {}) {
   }
   const task = result["task"];
   const retryTask = result["retryTask"];
-  if (!task || typeof task !== "object" || Array.isArray(task) || retryTask !== undefined && (!retryTask || typeof retryTask !== "object" || Array.isArray(retryTask))) {
+  if (!isRemoteTaskIdentity(task) || body.retry === true && !isRemoteTaskIdentity(retryTask) || body.retry !== true && retryTask !== undefined && !isRemoteTaskIdentity(retryTask)) {
     throw new Error(`REMOTE_API_INCOMPATIBLE: ${route} returned an invalid failure result`);
   }
   return result;
@@ -6039,6 +6115,36 @@ function resolveOpenApiSchema(document, schema) {
   }
   return current && typeof current === "object" && !Array.isArray(current) ? current : null;
 }
+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))
+    return false;
+  const doc = document;
+  const paths = doc["paths"];
+  const failPath = paths && typeof paths === "object" && !Array.isArray(paths) ? paths["/v1/tasks/{id}/fail"] : undefined;
+  const post = failPath && typeof failPath === "object" && !Array.isArray(failPath) ? failPath["post"] : undefined;
+  const requestBody = post && typeof post === "object" && !Array.isArray(post) ? post["requestBody"] : undefined;
+  const content = requestBody && typeof requestBody === "object" && !Array.isArray(requestBody) ? requestBody["content"] : undefined;
+  const jsonContent = content && typeof content === "object" && !Array.isArray(content) ? content["application/json"] : undefined;
+  const schema = jsonContent && typeof jsonContent === "object" && !Array.isArray(jsonContent) ? jsonContent["schema"] : undefined;
+  const resolved = resolveOpenApiSchema(document, schema);
+  const properties = resolved?.["properties"];
+  if (!properties || typeof properties !== "object" || Array.isArray(properties))
+    return false;
+  const retry = properties["retry"];
+  return !!retry && typeof retry === "object" && !Array.isArray(retry) && retry["type"] === "boolean";
+}
+async function requireRetryCapability(client) {
+  const authority = remoteAuthorityBase(client);
+  let capability = retryCapabilityCache.get(authority);
+  if (!capability) {
+    capability = fetchRetryCapability(client);
+    retryCapabilityCache.set(authority, capability);
+  }
+  if (!await capability) {
+    throw new Error(`REMOTE_RETRY_UNSUPPORTED: configured Todos authority ${authority} does not advertise retry in the ` + "application/json request schema for POST /v1/tasks/{id}/fail; no failure mutation was sent; " + "deploy a compatible @hasna/todos /v1 server before retrying; local SQLite fallback is disabled");
+  }
+}
 async function fetchCompletionCapabilities(client) {
   const document = await requiredRemoteRoute(client, "/v1/openapi.json", () => client.transport.get("/openapi.json"));
   if (!document || typeof document !== "object" || Array.isArray(document))
@@ -6296,11 +6402,62 @@ function unwrapPlan(raw) {
   }
   return raw;
 }
+async function cloudGetPlanById(client, id) {
+  const raw = await client.get("plans", id);
+  return raw ? unwrapPlan(raw) : null;
+}
+function isUnavailablePlanPatchRoute(error) {
+  if (!error || typeof error !== "object" || error.status !== 404)
+    return false;
+  const body = error.body;
+  const remoteMessage = body && typeof body === "object" && !Array.isArray(body) ? body.error : undefined;
+  return remoteMessage === "unknown /v1 resource: plans";
+}
+function isExactPlanCompletionPatch(patch) {
+  const entries = Object.entries(patch).filter(([, value]) => value !== undefined);
+  return entries.length === 1 && entries[0]?.[0] === "status" && entries[0]?.[1] === "completed";
+}
 async function cloudCreatePlan(client, input) {
   return unwrapPlan(await requiredRemoteRoute(client, "/v1/plans", () => client.create("plans", input)));
 }
 async function cloudUpdatePlan(client, id, patch) {
-  return unwrapPlan(await client.update("plans", id, patch));
+  try {
+    return unwrapPlan(await client.update("plans", id, patch));
+  } catch (error) {
+    if (!isExactPlanCompletionPatch(patch) || !isUnavailablePlanPatchRoute(error))
+      throw error;
+    const existing = await cloudGetPlanById(client, id);
+    if (!existing)
+      throw error;
+    if (existing.status === "completed")
+      return existing;
+    const imported = await requiredRemoteRoute(client, "/v1/import", () => client.transport.post("/import", {
+      source: "postgres",
+      planCompletions: [{
+        id,
+        expected_updated_at: existing.updated_at,
+        status: "completed"
+      }]
+    }));
+    const envelope = imported && typeof imported === "object" && !Array.isArray(imported) ? imported : null;
+    const completion = envelope?.planCompletions?.[0];
+    if (envelope?.received !== 1 || !envelope.result || !Array.isArray(envelope.result.errors) || envelope.result.errors.length > 0 || envelope.planCompletions?.length !== 1 || completion?.id !== id || completion.status !== "completed" || completion.expected_updated_at !== existing.updated_at || typeof completion.result_updated_at !== "string" || typeof completion.applied !== "boolean") {
+      throw new Error("REMOTE_API_INCOMPATIBLE: /v1/import did not confirm one atomic plan completion; " + "local SQLite fallback is disabled");
+    }
+    const persisted = await cloudGetPlanById(client, id);
+    if (!persisted) {
+      throw new Error(`REMOTE_API_INCOMPATIBLE: /v1/import acknowledged plan completion ${id} but authoritative readback returned no plan; ` + "local SQLite fallback is disabled");
+    }
+    if (persisted.status !== "completed" || persisted.updated_at !== completion.result_updated_at) {
+      throw new Error(`REMOTE_API_INCOMPATIBLE: /v1/import completion readback did not match its receipt for plan ${id}; ` + "local SQLite fallback is disabled");
+    }
+    for (const key of PLAN_COMPLETION_PROTECTED_FIELDS) {
+      if (persisted[key] !== existing[key]) {
+        throw new Error(`REMOTE_PLAN_COMPLETION_CONFLICT: /v1/import completion changed protected plan field ${key}; ` + "local SQLite fallback is disabled");
+      }
+    }
+    return persisted;
+  }
 }
 async function cloudDeletePlan(client, id) {
   try {
@@ -6608,6 +6765,19 @@ async function cloudUnlockTask(client, id, agentId, force = false) {
   }
   return true;
 }
+async function cloudHandoffStaleTaskLock(client, input) {
+  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,
+    stale_after_seconds: input.stale_after_seconds,
+    new_holder: input.new_holder,
+    reason: input.reason
+  });
+  if (raw && typeof raw === "object" && "receipt" in raw) {
+    return raw.receipt;
+  }
+  throw new Error("STALE_LOCK_HANDOFF_RECEIPT_MISSING: remote response did not include receipt");
+}
 async function cloudGetDependencies(client, id) {
   const raw = await client.transport.get(`/tasks/${encodeURIComponent(id)}/dependencies`);
   const env = raw ?? {};
@@ -7043,7 +7213,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, gitRefCapabilityCache, SERVER_MODE_CANDIDATES, cachedServerMode = null, PRIORITY_RANK, listTagsCapabilityCache, RELATION_HYDRATION_CONCURRENCY = 6;
+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 init_cloud_router = __esm(() => {
   init_types();
   init_redaction();
@@ -7068,13 +7238,32 @@ var init_cloud_router = __esm(() => {
     "confidence"
   ];
   completionCapabilityCache = new Map;
+  retryCapabilityCache = new Map;
   gitRefCapabilityCache = new Map;
   SERVER_MODE_CANDIDATES = ["postgres", "cloud", "self_hosted"];
   PRIORITY_RANK = { critical: 0, high: 1, medium: 2, low: 3 };
   listTagsCapabilityCache = new Map;
+  PLAN_COMPLETION_PROTECTED_FIELDS = [
+    "id",
+    "slug",
+    "project_id",
+    "task_list_id",
+    "agent_id",
+    "name",
+    "description",
+    "created_at",
+    "machine_id",
+    "synced_at"
+  ];
 });
 
 // src/cli/stage-a.ts
+function applyTodosCliAuthorityEnvironment(authority, env = process.env) {
+  if (authority.route !== "local" || authority.selected_by !== "local-only-command")
+    return;
+  env.HASNA_TODOS_STORAGE_MODE = "sqlite";
+  env.TODOS_STORAGE_MODE = "sqlite";
+}
 function isTodosCliCommandVisibleForRoute(command, route) {
   if (route === "local")
     return true;
@@ -7284,7 +7473,7 @@ function nearestCommands(command, limit = 3) {
   const threshold = command.length <= 4 ? 1 : command.length <= 8 ? 2 : 3;
   return [...COMMAND_CAPABILITY_MATRIX.entries()].filter(([, owner]) => owner !== "local-only").map(([candidate]) => candidate).map((candidate) => ({ candidate, distance: editDistance(command, candidate) })).filter(({ distance }) => distance <= threshold).sort((left, right) => left.distance - right.distance || left.candidate.localeCompare(right.candidate)).slice(0, limit).map(({ candidate }) => candidate);
 }
-function assertRemoteCommandSupported(invocation) {
+function assertInvocationRoutable(invocation) {
   if (invocation.invalidGlobalOption) {
     throw new Error(`REMOTE_COMMAND_UNSUPPORTED: the global option ${invocation.invalidGlobalOption} was given without a value; ` + `pass one as \`${invocation.invalidGlobalOption} <value>\``);
   }
@@ -7298,8 +7487,12 @@ function assertRemoteCommandSupported(invocation) {
     const didYouMean = suggestions.length > 0 ? ` Did you mean: ${suggestions.join(", ")}?` : "";
     throw new Error(`UNKNOWN_COMMAND: \`${command}\` is not a built-in todos command on the /v1 route.${didYouMean} ` + "Run `todos --help` for the commands available here; verbs contributed by optional packages are local-only. " + "(This is not a connectivity, storage-mode or credential problem.)");
   }
+  return owner;
+}
+function assertRemoteCommandSupported(invocation, owner) {
+  const command = invocation.command;
   if (command && owner === "local-only") {
-    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.");
+    throw new Error(`LOCAL_COMMAND_ROUTING_INVARIANT: \`${command}\` must select the local command route before remote authority validation`);
   }
   if (!command || !commandSupportsRemote(invocation)) {
     const blame = command ? disqualifyingArgument(invocation) : null;
@@ -7317,7 +7510,11 @@ function initializeTodosCliAuthority(args = process.argv.slice(2), env = process
     const status = getTodosRemoteAuthorityConfigStatus(env);
     return { route: "remote-diagnostic", v1_base_url: status.v1_base_url };
   }
-  assertRemoteCommandSupported(invocation);
+  const owner = assertInvocationRoutable(invocation);
+  if (owner === "local-only") {
+    return { route: "local", v1_base_url: null, selected_by: "local-only-command" };
+  }
+  assertRemoteCommandSupported(invocation, owner);
   const client = getTodosCloudClient(env);
   if (!client) {
     throw new Error("REMOTE_API_UNAVAILABLE: remote mode did not resolve an HTTP client; local SQLite fallback is disabled");
@@ -7451,6 +7648,7 @@ var init_stage_a = __esm(() => {
     "sprint",
     "stale",
     "standup",
+    "stale-lock-handoff",
     "start",
     "status",
     "steal",
@@ -7583,6 +7781,7 @@ var init_stage_a = __esm(() => {
     "tag",
     "task",
     "task-lists",
+    "stale-lock-handoff",
     "template-export",
     "template-import",
     "template-preview",
@@ -7590,6 +7789,7 @@ var init_stage_a = __esm(() => {
     "timeline",
     "tl",
     "unlock",
+    "unassign",
     "untag",
     "update"
   ]);
@@ -13475,7 +13675,7 @@ __export(exports_event_hooks, {
   emitLocalEventHooks: () => emitLocalEventHooks,
   LOCAL_EVENT_TYPES: () => LOCAL_EVENT_TYPES
 });
-import { createHash as createHash4, randomUUID } from "crypto";
+import { createHash as createHash4, randomUUID as randomUUID2 } from "crypto";
 import { appendFileSync, mkdirSync as mkdirSync4 } from "fs";
 import { dirname as dirname4, resolve as resolve7 } from "path";
 import { createConnection } from "net";
@@ -13536,7 +13736,7 @@ function canonicalEvent(input) {
 }
 function buildEnvelope(type, payload, timestamp2 = new Date().toISOString()) {
   const base = {
-    id: randomUUID(),
+    id: randomUUID2(),
     type,
     timestamp: timestamp2,
     payload: redactValue(payload ?? {}),
@@ -13739,7 +13939,7 @@ import { existsSync as existsSync6 } from "fs";
 import { homedir as homedir2 } from "os";
 import { join as join5 } from "path";
 import { createHmac, timingSafeEqual } from "crypto";
-import { randomUUID as randomUUID2 } from "crypto";
+import { randomUUID as randomUUID3 } from "crypto";
 import { spawn } from "child_process";
 import { randomUUID as randomUUID22 } from "crypto";
 function getPathValue(input, path) {
@@ -14097,7 +14297,7 @@ async function dispatchChannel(event, channel, options = {}) {
 function createDeliveryResult(event, channel, attempts) {
   const status = attempts.some((attempt) => attempt.status === "success") ? "success" : attempts.every((attempt) => attempt.status === "skipped") ? "skipped" : "failed";
   return {
-    id: randomUUID2(),
+    id: randomUUID3(),
     eventId: event.id,
     channelId: channel.id,
     transport: channel.transport,
@@ -15099,6 +15299,7 @@ var init_activity_audit = __esm(() => {
 var exports_audit = {};
 __export(exports_audit, {
   logTaskChange: () => logTaskChange,
+  insertTaskHistory: () => insertTaskHistory,
   getTaskHistory: () => getTaskHistory,
   getRecentActivity: () => getRecentActivity,
   getRecap: () => getRecap
@@ -15106,28 +15307,55 @@ __export(exports_audit, {
 function sanitizeHistoryValue(value, context) {
   return value === undefined || value === null ? null : sanitizePreWriteText(String(value), context);
 }
-function logTaskChange(taskId, action, field, oldValue, newValue, agentId, db) {
+function insertTaskHistory(entry, db) {
   const d = db || getDatabase();
-  const id = uuid();
-  const timestamp2 = now();
-  const machineId = currentStorageMachineId(d);
-  const safeOldValue = sanitizeHistoryValue(oldValue, "task_history.old_value");
-  const safeNewValue = sanitizeHistoryValue(newValue, "task_history.new_value");
+  const safeEntry = {
+    ...entry,
+    field: entry.field || null,
+    old_value: sanitizeHistoryValue(entry.old_value, "task_history.old_value"),
+    new_value: sanitizeHistoryValue(entry.new_value, "task_history.new_value"),
+    agent_id: entry.agent_id || null,
+    machine_id: entry.machine_id ?? currentStorageMachineId(d)
+  };
   d.run(`INSERT INTO task_history (id, task_id, action, field, old_value, new_value, agent_id, created_at, machine_id)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`, [id, taskId, action, field || null, safeOldValue, safeNewValue, agentId || null, timestamp2, machineId]);
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+    safeEntry.id,
+    safeEntry.task_id,
+    safeEntry.action,
+    safeEntry.field,
+    safeEntry.old_value,
+    safeEntry.new_value,
+    safeEntry.agent_id,
+    safeEntry.created_at,
+    safeEntry.machine_id ?? null
+  ]);
   try {
     const { logActivity: logActivity2 } = (init_activity_audit(), __toCommonJS(exports_activity_audit));
     logActivity2({
       entity_type: "task",
-      entity_id: taskId,
-      action,
-      field,
-      old_value: safeOldValue,
-      new_value: safeNewValue,
-      actor_id: agentId ?? undefined
+      entity_id: safeEntry.task_id,
+      action: safeEntry.action,
+      field: safeEntry.field ?? undefined,
+      old_value: safeEntry.old_value,
+      new_value: safeEntry.new_value,
+      actor_id: safeEntry.agent_id ?? undefined
     }, d);
   } catch {}
-  return { id, task_id: taskId, action, field: field || null, old_value: safeOldValue, new_value: safeNewValue, agent_id: agentId || null, created_at: timestamp2, machine_id: machineId };
+  return safeEntry;
+}
+function logTaskChange(taskId, action, field, oldValue, newValue, agentId, db) {
+  const d = db || getDatabase();
+  return insertTaskHistory({
+    id: uuid(),
+    task_id: taskId,
+    action,
+    field: field || null,
+    old_value: oldValue ?? null,
+    new_value: newValue ?? null,
+    agent_id: agentId || null,
+    created_at: now(),
+    machine_id: currentStorageMachineId(d)
+  }, d);
 }
 function getTaskHistory(taskId, db) {
   const d = db || getDatabase();
@@ -16188,6 +16416,145 @@ var init_task_graph = __esm(() => {
   init_task_crud();
 });
 
+// src/lib/stale-lock-handoff.ts
+function normalizeExactTaskId(value) {
+  if (typeof value !== "string" || !EXACT_TASK_UUID_RE.test(value.trim())) {
+    throw new StaleLockHandoffError("STALE_LOCK_HANDOFF_INVALID_TASK_ID", "stale-lock handoff requires one exact full task UUID", { task_id: typeof value === "string" ? value : null });
+  }
+  return value.trim().toLowerCase();
+}
+function requireNonEmptyString(value, field) {
+  if (typeof value !== "string" || !value.trim()) {
+    throw new StaleLockHandoffError("STALE_LOCK_HANDOFF_INVALID_INPUT", `${field} must be a non-empty string`, { field });
+  }
+  const trimmed = value.trim();
+  if (field === "reason" && trimmed.length > MAX_REASON_LENGTH) {
+    throw new StaleLockHandoffError("STALE_LOCK_HANDOFF_INVALID_INPUT", `reason must be at most ${MAX_REASON_LENGTH} characters`, { field, max_length: MAX_REASON_LENGTH });
+  }
+  return trimmed;
+}
+function requireCanonicalLockVersion(value) {
+  if (typeof value !== "string" || !CANONICAL_LOCK_VERSION_RE.test(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) {
+    throw new StaleLockHandoffError("STALE_LOCK_HANDOFF_INVALID_INPUT", "expected_lock_version must name a real canonical UTC instant", { field: "expected_lock_version" });
+  }
+  return value;
+}
+function requireStaleThreshold(value) {
+  if (!Number.isSafeInteger(value) || Number(value) <= 0) {
+    throw new StaleLockHandoffError("STALE_LOCK_HANDOFF_INVALID_INPUT", "stale_after_seconds must be a positive safe integer", { field: "stale_after_seconds" });
+  }
+  return Number(value);
+}
+function prepareStaleLockHandoff(input, options = {}) {
+  const taskId = normalizeExactTaskId(input.task_id);
+  const actor = requireNonEmptyString(input.actor, "actor");
+  const expectedHolder = requireNonEmptyString(input.expected_holder, "expected_holder");
+  const newHolder = requireNonEmptyString(input.new_holder, "new_holder");
+  const expectedLockVersion = requireCanonicalLockVersion(input.expected_lock_version);
+  const staleAfterSeconds = requireStaleThreshold(input.stale_after_seconds);
+  const reason = sanitizePreWriteText(requireNonEmptyString(input.reason, "reason"), "stale_lock_handoff.reason").trim();
+  if (!reason) {
+    throw new StaleLockHandoffError("STALE_LOCK_HANDOFF_INVALID_INPUT", "reason must remain non-empty after safety filtering", { field: "reason" });
+  }
+  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");
+  }
+  const staleCutoff = new Date(Date.parse(operationTimestamp) - staleAfterSeconds * 1000).toISOString();
+  return {
+    task_id: taskId,
+    actor,
+    expected_holder: expectedHolder,
+    expected_lock_version: expectedLockVersion,
+    stale_after_seconds: staleAfterSeconds,
+    new_holder: newHolder,
+    reason,
+    operation_timestamp: operationTimestamp,
+    stale_cutoff: staleCutoff,
+    receipt_id: options.receiptId ?? crypto.randomUUID()
+  };
+}
+function buildStaleLockHandoffReceipt(input) {
+  return {
+    schema_version: STALE_LOCK_HANDOFF_SCHEMA_VERSION,
+    receipt_id: input.receipt_id,
+    task_id: input.task_id,
+    actor: input.actor,
+    previous_holder: input.expected_holder,
+    previous_lock_version: input.expected_lock_version,
+    new_holder: input.new_holder,
+    new_lock_version: input.operation_timestamp,
+    stale_after_seconds: input.stale_after_seconds,
+    stale_cutoff: input.stale_cutoff,
+    reason: input.reason,
+    created_at: input.operation_timestamp
+  };
+}
+function staleLockHandoffHistory(receipt, machineId) {
+  return {
+    id: receipt.receipt_id,
+    task_id: receipt.task_id,
+    action: STALE_LOCK_HANDOFF_ACTION,
+    field: STALE_LOCK_HANDOFF_FIELD,
+    old_value: JSON.stringify({
+      holder: receipt.previous_holder,
+      lock_version: receipt.previous_lock_version
+    }),
+    new_value: JSON.stringify(receipt),
+    agent_id: receipt.actor,
+    created_at: receipt.created_at,
+    machine_id: machineId
+  };
+}
+function throwStaleLockHandoffConflict(task, input) {
+  if (!task.locked_by || !task.locked_at) {
+    throw new StaleLockHandoffError("STALE_LOCK_HANDOFF_NOT_LOCKED", `Task ${input.task_id} does not have a complete lock to hand off`, { task_id: input.task_id });
+  }
+  if (task.locked_at !== input.expected_lock_version) {
+    throw new StaleLockHandoffError("STALE_LOCK_HANDOFF_VERSION_MISMATCH", `Task ${input.task_id} lock version changed`, {
+      task_id: input.task_id,
+      expected_lock_version: input.expected_lock_version,
+      current_lock_version: task.locked_at
+    });
+  }
+  if (task.locked_by !== input.expected_holder) {
+    throw new StaleLockHandoffError("STALE_LOCK_HANDOFF_HOLDER_MISMATCH", `Task ${input.task_id} lock holder changed`, {
+      task_id: input.task_id,
+      expected_holder: input.expected_holder,
+      current_holder: task.locked_by
+    });
+  }
+  if (isTerminalStatus(task.status)) {
+    throw new StaleLockHandoffError("STALE_LOCK_HANDOFF_TERMINAL", `Task ${input.task_id} is ${task.status} and cannot transfer a lock`, { task_id: input.task_id, status: task.status });
+  }
+  if (task.locked_at >= input.stale_cutoff) {
+    throw new StaleLockHandoffError("STALE_LOCK_HANDOFF_NOT_STALE", `Task ${input.task_id} lock is not older than the supplied stale threshold`, {
+      task_id: input.task_id,
+      current_lock_version: task.locked_at,
+      stale_cutoff: input.stale_cutoff
+    });
+  }
+  throw new StaleLockHandoffError("STALE_LOCK_HANDOFF_CONFLICT", `Task ${input.task_id} changed during stale-lock handoff`, { task_id: input.task_id });
+}
+var STALE_LOCK_HANDOFF_SCHEMA_VERSION = "todos.stale-lock-handoff.v1", STALE_LOCK_HANDOFF_ACTION = "stale_lock_handoff", STALE_LOCK_HANDOFF_FIELD = "lock", EXACT_TASK_UUID_RE, CANONICAL_LOCK_VERSION_RE, MAX_REASON_LENGTH = 4096;
+var init_stale_lock_handoff = __esm(() => {
+  init_types();
+  init_creator_identity();
+  init_prewrite_secrets();
+  EXACT_TASK_UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+  CANONICAL_LOCK_VERSION_RE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;
+});
+
 // src/db/task-lifecycle.ts
 var exports_task_lifecycle = {};
 __export(exports_task_lifecycle, {
@@ -16196,6 +16563,7 @@ __export(exports_task_lifecycle, {
   startTask: () => startTask,
   spawnNextRecurrence: () => spawnNextRecurrence,
   lockTask: () => lockTask,
+  handoffStaleTaskLock: () => handoffStaleTaskLock,
   getTasksChangedSince: () => getTasksChangedSince,
   getTaskLockStatus: () => getTaskLockStatus,
   getStaleTasks: () => getStaleTasks,
@@ -16464,6 +16832,38 @@ function unlockTask(id, agentId, db) {
      WHERE id = ?`, [timestamp2, id]);
   return true;
 }
+function handoffStaleTaskLock(input, db) {
+  const d = db || getDatabase();
+  const prepared = prepareStaleLockHandoff(input);
+  const receipt = buildStaleLockHandoffReceipt(prepared);
+  const history = staleLockHandoffHistory(receipt, null);
+  const transfer = d.transaction(() => {
+    const result = d.run(`UPDATE tasks
+       SET locked_by = ?, locked_at = ?, updated_at = ?, version = version + 1
+       WHERE id = ?
+         AND locked_by = ?
+         AND locked_at = ?
+         AND julianday(locked_at) < julianday(?)
+         AND status NOT IN ('completed', 'failed', 'cancelled')`, [
+      prepared.new_holder,
+      prepared.operation_timestamp,
+      prepared.operation_timestamp,
+      prepared.task_id,
+      prepared.expected_holder,
+      prepared.expected_lock_version,
+      prepared.stale_cutoff
+    ]);
+    if (result.changes === 0) {
+      const current = getTask(prepared.task_id, d);
+      if (!current)
+        throw new TaskNotFoundError(prepared.task_id);
+      throwStaleLockHandoffConflict(current, prepared);
+    }
+    insertTaskHistory(history, d);
+  });
+  transfer();
+  return receipt;
+}
 function getTaskLockStatus(id, db) {
   const d = db || getDatabase();
   const task = getTask(id, d);
@@ -16764,6 +17164,7 @@ var init_task_lifecycle = __esm(() => {
   init_task_crud();
   init_task_graph();
   init_prewrite_secrets();
+  init_stale_lock_handoff();
 });
 
 // src/db/task-crud.ts
@@ -18333,6 +18734,48 @@ function updatePlan(id, input, db) {
     return updatePlanStored(id, input, d);
   })();
 }
+function nextPlanCompletionTimestamp(expectedUpdatedAt) {
+  const expected = Date.parse(expectedUpdatedAt);
+  const minimum = Number.isNaN(expected) ? Date.now() : expected + 2;
+  return new Date(Math.max(Date.now(), minimum)).toISOString();
+}
+function completePlanAtRevision(id, expectedUpdatedAt, db) {
+  const d = db || getDatabase();
+  return d.transaction(() => {
+    guardPlanRowsSqlite([id], d);
+    const plan = getPlan(id, d);
+    if (!plan)
+      throw new PlanNotFoundError(id);
+    if (plan.updated_at !== expectedUpdatedAt) {
+      throw new PlanRevisionConflictError(id, expectedUpdatedAt, plan.updated_at);
+    }
+    if (plan.status === "completed")
+      return { plan, applied: false };
+    const updatedAt = nextPlanCompletionTimestamp(expectedUpdatedAt);
+    const result = d.run(`UPDATE plans
+       SET status = 'completed', updated_at = ?
+       WHERE id = ? AND updated_at = ? AND status <> 'completed'`, [updatedAt, id, expectedUpdatedAt]);
+    if (result.changes !== 1) {
+      const current = getPlan(id, d);
+      if (!current)
+        throw new PlanNotFoundError(id);
+      throw new PlanRevisionConflictError(id, expectedUpdatedAt, current.updated_at);
+    }
+    const completed = getPlan(id, d);
+    emitLocalEventHooksQuiet({
+      type: "plan.updated",
+      payload: {
+        id,
+        old_status: plan.status,
+        new_status: completed.status,
+        name: completed.name,
+        project_id: completed.project_id
+      },
+      databasePath: databasePathFromDatabase(d)
+    });
+    return { plan: completed, applied: true };
+  })();
+}
 function deletePlan(id, db) {
   const d = db || getDatabase();
   const plan = getPlan(id, d);
@@ -20331,6 +20774,7 @@ __export(exports_tasks, {
   insertTaskTags: () => insertTaskTags,
   importTaskBoardBundle: () => importTaskBoardBundle,
   importCalendarIcs: () => importCalendarIcs,
+  handoffStaleTaskLock: () => handoffStaleTaskLock,
   getTimeReport: () => getTimeReport,
   getTimeLogs: () => getTimeLogs,
   getTasksChangedSince: () => getTasksChangedSince,
@@ -21973,7 +22417,7 @@ function registerTaskCommands(program2) {
     }
   });
   const task = program2.command("task").description("Task subcommands for deterministic automation");
-  task.command("upsert").description("Create or update a task by stable metadata fingerprint").requiredOption("--fingerprint <key>", "Stable dedupe fingerprint").requiredOption("--title <text>", "Task title").option("-d, --description <text>", "Task description").option("-p, --priority <level>", "Priority: low, medium, high, critical").option("-s, --status <status>", "Task status").option("--list <id>", "Task list ID").option("--task-list <id>", "Task list ID (alias for --list)").option("-t, --tags <tags>", "Comma-separated tags").option("--tag <tags>", "Comma-separated tags (alias for --tags)").option("--metadata-json <json>", "JSON object merged into task metadata").option("--working-dir <path>", "Working directory to store on create/update").option("--project <id>", "Assign to project by ID, slug, or path").option("--assign <agent>", "Assign to agent").option("--assign-seat", "Allow --assign to name a durable seat (a seat queue has no session watching it)").option("--expectation-id <id>", "Expectation metadata ID").option("--expectation-fingerprint <key>", "Expectation metadata fingerprint").option("--evidence-paths <paths>", "Comma-separated evidence paths").option("--origin-loop-id <id>", "Origin loop ID").option("--origin-run-id <id>", "Origin run ID").option("--expected <json-or-text>", "Expected value metadata").option("--observed <json-or-text>", "Observed value metadata").option("--acceptance <json-or-text>", "Acceptance metadata").action(async (opts) => {
+  task.command("upsert").description("Create or update a task by stable metadata fingerprint").requiredOption("--fingerprint <key>", "Stable dedupe fingerprint").requiredOption("--title <text>", "Task title").option("-d, --description <text>", "Task description").option("-p, --priority <level>", "Priority: low, medium, high, critical").option("-s, --status <status>", "Task status").option("--list <id>", "Task list ID").option("--task-list <id>", "Task list ID (alias for --list)").option("--plan <id>", "Assign to a plan").option("-t, --tags <tags>", "Comma-separated tags").option("--tag <tags>", "Comma-separated tags (alias for --tags)").option("--metadata-json <json>", "JSON object merged into task metadata").option("--working-dir <path>", "Working directory to store on create/update").option("--project <id>", "Assign to project by ID, slug, or path").option("--assign <agent>", "Assign to agent").option("--assign-seat", "Allow --assign to name a durable seat (a seat queue has no session watching it)").option("--expectation-id <id>", "Expectation metadata ID").option("--expectation-fingerprint <key>", "Expectation metadata fingerprint").option("--evidence-paths <paths>", "Comma-separated evidence paths").option("--origin-loop-id <id>", "Origin loop ID").option("--origin-run-id <id>", "Origin run ID").option("--expected <json-or-text>", "Expected value metadata").option("--observed <json-or-text>", "Observed value metadata").option("--acceptance <json-or-text>", "Acceptance metadata").action(async (opts) => {
     const globalOpts = program2.opts();
     opts.tags = opts.tags || opts.tag;
     opts.list = opts.list || opts.taskList;
@@ -21987,6 +22431,10 @@ function registerTaskCommands(program2) {
       try {
         const projectId2 = explicitProject ? await cloudResolveProjectRef(cloud, explicitProject) : undefined;
         const taskListId2 = opts.list ? await cloudResolveTaskListRef(cloud, opts.list, projectId2) : undefined;
+        const plan = opts.plan ? await cloudResolvePlan(cloud, opts.plan, projectId2) : null;
+        if (opts.plan && !plan) {
+          throw new Error(`Could not resolve plan ID or slug: ${opts.plan}`);
+        }
         cloudResult = await cloudUpsertTaskByFingerprint(cloud, {
           fingerprint: opts.fingerprint,
           title: opts.title,
@@ -21998,7 +22446,8 @@ function registerTaskCommands(program2) {
           metadata: buildExpectationMetadata(opts),
           working_dir: opts.workingDir ? resolve9(opts.workingDir) : process.cwd(),
           project_id: projectId2,
-          assigned_to: opts.assign
+          assigned_to: opts.assign,
+          plan_id: plan?.id
         });
       } catch (e) {
         handleError(e);
@@ -22020,6 +22469,7 @@ function registerTaskCommands(program2) {
       }
       return id;
     })() : undefined;
+    const planId = opts.plan ? resolvePlanId(opts.plan) : undefined;
     let result;
     try {
       result = upsertTaskByFingerprint({
@@ -22034,6 +22484,7 @@ function registerTaskCommands(program2) {
         working_dir: opts.workingDir ? resolve9(opts.workingDir) : process.cwd(),
         project_id: projectId,
         assigned_to: opts.assign,
+        plan_id: planId,
         agent_id: globalOpts.agent,
         session_id: globalOpts.session
       });
@@ -23027,6 +23478,44 @@ ${chalk3.cyan(sid)} ${statusColor(task2.status)} ${prioColor(task2.priority)} ${
       console.log(chalk3.green("Lock released."));
     }
   });
+  program2.command("stale-lock-handoff <id>").description("Atomically transfer one exact stale lock by holder and locked_at version").requiredOption("--expected-holder <agent>", "Exact current locked_by value").requiredOption("--expected-lock-version <timestamp>", "Exact current locked_at value (canonical UTC)").requiredOption("--stale-after-seconds <seconds>", "Required lock age threshold; no default").requiredOption("--new-holder <agent>", "New holder; must match the authenticated/--agent identity").requiredOption("--reason <text>", "Non-empty audit reason").action(async (id, opts) => {
+    const globalOpts = program2.opts();
+    const taskId = normalizeExactTaskId(id);
+    const actor = resolveClaimIdentity("handoff a stale lock on", globalOpts.agent);
+    const staleAfterSeconds = Number(opts.staleAfterSeconds);
+    const cloud = getTodosCloudClient();
+    let receipt;
+    try {
+      receipt = cloud ? await cloudHandoffStaleTaskLock(cloud, {
+        task_id: taskId,
+        expected_holder: opts.expectedHolder,
+        expected_lock_version: opts.expectedLockVersion,
+        stale_after_seconds: staleAfterSeconds,
+        new_holder: opts.newHolder,
+        reason: opts.reason
+      }) : handoffStaleTaskLock({
+        task_id: taskId,
+        actor,
+        expected_holder: opts.expectedHolder,
+        expected_lock_version: opts.expectedLockVersion,
+        stale_after_seconds: staleAfterSeconds,
+        new_holder: opts.newHolder,
+        reason: opts.reason
+      });
+    } catch (e) {
+      handleError(e);
+    }
+    if (globalOpts.json) {
+      output({ receipt }, true);
+      return;
+    }
+    console.log(chalk3.green(`Stale lock transferred on task ${escapeTerminalControls(receipt.task_id)}.`));
+    console.log(`  ${escapeTerminalControls(receipt.previous_holder)} @ ${escapeTerminalControls(receipt.previous_lock_version)}`);
+    console.log(`  -> ${escapeTerminalControls(receipt.new_holder)} @ ${escapeTerminalControls(receipt.new_lock_version)}`);
+    console.log(`  stale after ${receipt.stale_after_seconds}s (cutoff ${escapeTerminalControls(receipt.stale_cutoff)})`);
+    console.log(`  receipt ${escapeTerminalControls(receipt.receipt_id)}`);
+    console.log(`  reason ${escapeTerminalControls(receipt.reason)}`);
+  });
   program2.command("delete <id>").description("Delete a task").action(async (id) => {
     const globalOpts = program2.opts();
     const cloud = getTodosCloudClient();
@@ -23211,6 +23700,7 @@ var init_task_commands = __esm(() => {
   init_agents();
   init_helpers();
   init_output_redaction();
+  init_stale_lock_handoff();
 });
 
 // src/lib/plan-artifacts.ts
@@ -24198,6 +24688,58 @@ var init_plan_project_links = __esm(() => {
   init_tasks();
 });
 
+// src/storage/audit-history-import.ts
+function auditHistoryRowsAreFieldIdentical(left, right) {
+  return AUDIT_HISTORY_FIELDS.every((field) => {
+    const leftValue = field === "machine_id" ? left[field] ?? null : left[field];
+    const rightValue = field === "machine_id" ? right[field] ?? null : right[field];
+    return leftValue === rightValue;
+  });
+}
+function divergentAuditHistoryReplayError(id) {
+  return `${AUDIT_HISTORY_DIVERGENT_REPLAY}: immutable audit_history row ${id} differs from stored row`;
+}
+function forbiddenAuditHistoryTombstoneError(id) {
+  return `${AUDIT_HISTORY_TOMBSTONE_FORBIDDEN}: audit_history tombstone ${id} is not allowed`;
+}
+function parseAuditHistoryImportFailure(message) {
+  const divergentPrefix = `${AUDIT_HISTORY_DIVERGENT_REPLAY}: immutable audit_history row `;
+  const divergentSuffix = " differs from stored row";
+  if (message.startsWith(divergentPrefix) && message.endsWith(divergentSuffix)) {
+    return {
+      code: AUDIT_HISTORY_DIVERGENT_REPLAY,
+      auditHistoryId: message.slice(divergentPrefix.length, -divergentSuffix.length),
+      conflict: true,
+      status: 409
+    };
+  }
+  const tombstonePrefix = `${AUDIT_HISTORY_TOMBSTONE_FORBIDDEN}: audit_history tombstone `;
+  const tombstoneSuffix = " is not allowed";
+  if (message.startsWith(tombstonePrefix) && message.endsWith(tombstoneSuffix)) {
+    return {
+      code: AUDIT_HISTORY_TOMBSTONE_FORBIDDEN,
+      auditHistoryId: message.slice(tombstonePrefix.length, -tombstoneSuffix.length),
+      conflict: false,
+      status: 400
+    };
+  }
+  return null;
+}
+var AUDIT_HISTORY_DIVERGENT_REPLAY = "AUDIT_HISTORY_DIVERGENT_REPLAY", AUDIT_HISTORY_TOMBSTONE_FORBIDDEN = "AUDIT_HISTORY_TOMBSTONE_FORBIDDEN", AUDIT_HISTORY_FIELDS;
+var init_audit_history_import = __esm(() => {
+  AUDIT_HISTORY_FIELDS = [
+    "id",
+    "task_id",
+    "action",
+    "field",
+    "old_value",
+    "new_value",
+    "agent_id",
+    "created_at",
+    "machine_id"
+  ];
+});
+
 // src/storage/sqlite-snapshot.ts
 function exportSqliteTodosStorageSnapshot(db) {
   const d = db ?? getDatabase();
@@ -24231,9 +24773,12 @@ function importSqliteTodosStorageSnapshot(snapshot, db) {
     const existingTaskLists = d.query("SELECT id, project_id, slug FROM task_lists").all();
     result.errors.push(...validateSnapshotRoutingDestinationConflicts(snapshot.projects, snapshot.taskLists, existingProjects, existingTaskLists));
   }
+  const auditImport = preflightAuditHistoryImport(d, snapshot.auditHistory, snapshot.tombstones ?? []);
+  result.errors.push(...auditImport.errors);
   if (result.errors.length > 0)
     return result;
-  const applyRows = (objectType, table, columns, rows, updateClockColumn, afterUpsert) => {
+  result.skipped += auditImport.identicalReplayCount;
+  const applyRows = (objectType, table, columns, rows, updateClockColumn, acceptEqualClock = true, afterUpsert) => {
     for (const row of rows) {
       try {
         const record = asRecord(row);
@@ -24242,7 +24787,7 @@ function importSqliteTodosStorageSnapshot(snapshot, db) {
           result.skipped += 1;
           continue;
         }
-        const state = upsertById(d, table, columns, record, updateClockColumn);
+        const state = upsertById(d, table, columns, record, updateClockColumn, acceptEqualClock);
         if (state === "inserted")
           result.inserted += 1;
         else if (state === "updated")
@@ -24259,19 +24804,81 @@ function importSqliteTodosStorageSnapshot(snapshot, db) {
   applyRows("project_machine_paths", "project_machine_paths", PROJECT_MACHINE_PATH_COLUMNS, snapshot.projectMachinePaths ?? [], "updated_at");
   applyRows("agents", "agents", AGENT_COLUMNS, snapshot.agents, "last_seen_at");
   applyRows("task_lists", "task_lists", TASK_LIST_COLUMNS, snapshot.taskLists, "updated_at");
-  applyRows("plans", "plans", PLAN_COLUMNS, snapshot.plans, "updated_at");
+  applyRows("plans", "plans", PLAN_COLUMNS, snapshot.plans, "updated_at", false);
   applyRows("templates", "task_templates", TEMPLATE_COLUMNS, snapshot.templates);
   applyRows("template_tasks", "template_tasks", TEMPLATE_TASK_COLUMNS, snapshot.templateTasks ?? []);
-  applyRows("tasks", "tasks", TASK_COLUMNS, sortedTasks(snapshot.tasks), "updated_at", (row, changed) => {
+  applyRows("tasks", "tasks", TASK_COLUMNS, sortedTasks(snapshot.tasks), "updated_at", true, (row, changed) => {
     if (changed && Array.isArray(row["tags"]) && typeof row["id"] === "string") {
       replaceTaskTags(row["id"], row["tags"].filter((tag) => typeof tag === "string"), d);
     }
   });
-  applyRows("audit_history", "task_history", AUDIT_COLUMNS, snapshot.auditHistory);
+  insertAuditHistoryRows(d, auditImport.rowsToInsert, result);
   applyTombstones(d, snapshot.tombstones ?? [], result);
   return result;
 }
-function upsertById(db, table, columns, row, updateClockColumn) {
+function preflightAuditHistoryImport(db, rows, tombstones) {
+  const errors = tombstones.filter((tombstone) => tombstone.object_type === "audit_history").map((tombstone) => forbiddenAuditHistoryTombstoneError(tombstone.object_id));
+  const rowsToInsert = [];
+  const seen = new Map;
+  let identicalReplayCount = 0;
+  for (const rawRow of rows) {
+    try {
+      const row = asRecord(rawRow);
+      if (typeof row.id !== "string" || !row.id) {
+        throw new Error("task_history row is missing id");
+      }
+      const prior = seen.get(row.id);
+      if (prior) {
+        if (auditHistoryRowsAreFieldIdentical(prior, row))
+          identicalReplayCount += 1;
+        else
+          errors.push(divergentAuditHistoryReplayError(row.id));
+        continue;
+      }
+      seen.set(row.id, row);
+      const existing = getAuditHistoryById(db, row.id);
+      if (!existing) {
+        rowsToInsert.push(row);
+      } else if (auditHistoryRowsAreFieldIdentical(existing, row)) {
+        identicalReplayCount += 1;
+      } else {
+        errors.push(divergentAuditHistoryReplayError(row.id));
+      }
+    } catch (error) {
+      errors.push(error instanceof Error ? error.message : String(error));
+    }
+  }
+  return { rowsToInsert, identicalReplayCount, errors };
+}
+function insertAuditHistoryRows(db, rows, result) {
+  for (const rawRow of rows) {
+    try {
+      const row = asRecord(rawRow);
+      const presentColumns = AUDIT_COLUMNS.filter((column) => (column in row));
+      if (!presentColumns.includes("id"))
+        presentColumns.unshift("id");
+      const placeholders = presentColumns.map(() => "?").join(", ");
+      const values = presentColumns.map((column) => valueForColumn(column, row[column]));
+      const changes = db.run(`INSERT OR IGNORE INTO task_history (${presentColumns.join(", ")}) VALUES (${placeholders})`, values).changes;
+      if (changes > 0) {
+        result.inserted += 1;
+        continue;
+      }
+      const existing = getAuditHistoryById(db, String(row["id"]));
+      if (existing && auditHistoryRowsAreFieldIdentical(existing, row)) {
+        result.skipped += 1;
+      } else {
+        result.errors.push(divergentAuditHistoryReplayError(String(row["id"])));
+      }
+    } catch (error) {
+      result.errors.push(error instanceof Error ? error.message : String(error));
+    }
+  }
+}
+function getAuditHistoryById(db, id) {
+  return db.query(`SELECT ${AUDIT_COLUMNS.join(", ")} FROM task_history WHERE id = ? LIMIT 1`).get(id);
+}
+function upsertById(db, table, columns, row, updateClockColumn, acceptEqualClock = true) {
   const id = row["id"];
   if (typeof id !== "string" || !id)
     throw new Error(`${table} row is missing id`);
@@ -24283,7 +24890,7 @@ function upsertById(db, table, columns, row, updateClockColumn) {
   const values = presentColumns.map((column) => valueForColumn(column, row[column]));
   const updateColumns = presentColumns.filter((column) => column !== "id");
   const updateSet = updateColumns.map((column) => column === "version" ? `version = MAX(COALESCE(${table}.version, 0), excluded.version)` : `${column} = excluded.${column}`).join(", ");
-  const clockGuard = updateClockColumn && presentColumns.includes(updateClockColumn) ? ` WHERE ${table}.${updateClockColumn} IS NULL OR ${table}.${updateClockColumn} <= excluded.${updateClockColumn}` : "";
+  const clockGuard = updateClockColumn && presentColumns.includes(updateClockColumn) ? ` WHERE ${table}.${updateClockColumn} IS NULL OR ${table}.${updateClockColumn} ${acceptEqualClock ? "<=" : "<"} excluded.${updateClockColumn}` : "";
   const sql = updateSet ? `INSERT INTO ${table} (${presentColumns.join(", ")}) VALUES (${placeholders})
        ON CONFLICT(id) DO UPDATE SET ${updateSet}${clockGuard}` : `INSERT OR IGNORE INTO ${table} (${presentColumns.join(", ")}) VALUES (${placeholders})`;
   const changes = db.run(sql, values).changes;
@@ -24368,7 +24975,7 @@ function tableForTombstone(objectType) {
     return "task_templates";
   if (objectType === "template_tasks")
     return "template_tasks";
-  return "task_history";
+  throw new Error(`unsupported storage tombstone object_type: ${String(objectType)}`);
 }
 function listRows(db, table, columns) {
   return db.query(`SELECT ${columns.join(", ")} FROM ${table} ORDER BY id`).all();
@@ -24415,6 +25022,7 @@ var init_sqlite_snapshot = __esm(() => {
   init_tasks();
   init_templates();
   init_storage_tombstones();
+  init_audit_history_import();
   PROJECT_COLUMNS = [
     "id",
     "name",
@@ -24679,6 +25287,7 @@ function createLocalSqliteTodosStorageAdapter(options = {}) {
         unlockTask(id, agentId, database());
         return true;
       },
+      handoffStaleLock: (input) => handoffStaleTaskLock(input, database()),
       delete: (id) => deleteTask(id, database()),
       start: (id, agentId) => startTask(id, agentId, database()),
       complete: (id, agentId, options2) => completeTask(id, agentId, database(), options2),
@@ -24702,6 +25311,7 @@ function createLocalSqliteTodosStorageAdapter(options = {}) {
       get: (id) => getPlan(id, database()),
       list: (projectId) => listPlans(projectId, database()),
       update: (id, input) => updatePlan(id, input, database()),
+      completeAtRevision: (id, expectedUpdatedAt) => completePlanAtRevision(id, expectedUpdatedAt, database()),
       delete: (id) => deletePlan(id, database())
     },
     planProjectLinks: {
@@ -25434,7 +26044,7 @@ function registerPlanTemplateCommands(program2) {
         if (!plan2) {
           handleError(new Error(`Plan not found: ${opts.show}`));
         }
-        const tasks2 = await cloudListTasks(cloud, { plan_id: plan2.id, include_subtasks: true });
+        const tasks2 = await cloudListPlanTasks(cloud, plan2.id);
         if (globalOpts.json) {
           output({ plan: plan2, tasks: tasks2, artifact: null }, true);
           return;
@@ -29234,6 +29844,7 @@ __export(exports_project_commands, {
   registerProjectCommands: () => registerProjectCommands
 });
 import chalk5 from "chalk";
+import { readFileSync as readFileSync9, statSync as statSync6 } from "fs";
 import { basename as basename5, resolve as resolve13, sep as sep3 } from "path";
 function collectOption(value, previous = []) {
   return [...previous, value];
@@ -29427,18 +30038,45 @@ function registerProjectCommands(program2) {
       handleError(e);
     }
   });
-  program2.command("comment <id> <text>").alias("log-progress").description("Add a comment to a task (alias: log-progress, for recording intermediate progress)").option("--pct <percent>", "Progress percentage (0-100) to record alongside the note").action(async (id, text, opts) => {
+  program2.command("comment <id> [text]").alias("log-progress").description("Add a comment to a task (alias: log-progress, for recording intermediate progress)").option("--file <path>", "Read comment text from a UTF-8 file").option("--pct <percent>", "Progress percentage (0-100) to record alongside the note").action(async (id, text, opts) => {
+    const hasPositionalContent = text !== undefined;
+    const hasFileContent = opts.file !== undefined;
+    if (hasPositionalContent === hasFileContent) {
+      handleError(new Error("Provide exactly one comment content source: positional text or --file <path>, not both."));
+    }
+    let content;
+    if (opts.file !== undefined) {
+      const commentFilePath = resolve13(opts.file);
+      let isRegularFile = false;
+      try {
+        isRegularFile = statSync6(commentFilePath).isFile();
+      } catch (error) {
+        handleError(new Error(`Unable to read comment file "${opts.file}".`, { cause: error }));
+      }
+      if (!isRegularFile) {
+        handleError(new Error(`Comment file "${opts.file}" must be a regular file.`));
+      }
+      try {
+        content = readFileSync9(commentFilePath, "utf8");
+      } catch (error) {
+        handleError(new Error(`Unable to read comment file "${opts.file}".`, { cause: error }));
+      }
+    } else {
+      content = text;
+    }
+    if (!content.trim()) {
+      handleError(new Error("Comment content must not be empty."));
+    }
     const globalOpts = program2.opts();
     const cloud = getTodosCloudClient();
     const resolvedId = await resolveTaskIdForCommand(id, cloud);
-    let content = text;
     let progressPct;
     if (opts.pct !== undefined) {
       const pct = parseInt(opts.pct, 10);
       if (!Number.isFinite(pct) || pct < 0 || pct > 100) {
         handleError(new Error("--pct must be a number between 0 and 100"));
       }
-      content = `[progress ${pct}%] ${text}`;
+      content = `[progress ${pct}%] ${content}`;
       progressPct = pct;
     }
     const router = resolveWritableIdentity(globalOpts.agent);
@@ -30198,10 +30836,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: readFileSync9 } = await import("fs");
+      const { readFileSync: readFileSync10 } = 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(readFileSync9(resolve13(file), "utf-8"));
+      const parsed = JSON.parse(readFileSync10(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;
@@ -30235,9 +30873,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: readFileSync9 } = await import("fs");
+      const { readFileSync: readFileSync10 } = await import("fs");
       const { importTodosMarkdown: importTodosMarkdown2 } = await Promise.resolve().then(() => (init_todos_md(), exports_todos_md));
-      const result = importTodosMarkdown2(readFileSync9(resolve13(file), "utf-8"), { dryRun: !opts.apply, conflictStrategy: opts.resolveConflicts ? "safe_merge" : "skip" });
+      const result = importTodosMarkdown2(readFileSync10(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) {
@@ -30884,7 +31522,7 @@ async function findFreePort(start) {
 var DEFAULT_PORT = 19427;
 
 // src/lib/db-backup.ts
-import { existsSync as existsSync15, copyFileSync, mkdirSync as mkdirSync8, readFileSync as readFileSync9, renameSync, statSync as statSync6, writeFileSync as writeFileSync7, unlinkSync } from "fs";
+import { existsSync as existsSync15, copyFileSync, mkdirSync as mkdirSync8, readFileSync as readFileSync10, 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) {
@@ -30913,7 +31551,7 @@ function backupDatabase(outputPath, sourcePath) {
   src.close();
   writeFileSync7(outputPath, image);
   const method = "file_copy";
-  const bytes = statSync6(outputPath).size;
+  const bytes = statSync7(outputPath).size;
   return {
     schema_version: DB_BACKUP_SCHEMA,
     source_path: source,
@@ -32250,7 +32888,7 @@ __export(exports_local_extensions, {
   discoverLocalExtensions: () => discoverLocalExtensions
 });
 import { createHash as createHash9, createVerify } from "crypto";
-import { existsSync as existsSync17, readdirSync as readdirSync3, readFileSync as readFileSync10, statSync as statSync7 } from "fs";
+import { existsSync as existsSync17, readdirSync as readdirSync3, readFileSync as readFileSync11, 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));
@@ -32332,7 +32970,7 @@ function normalizeManifest(input) {
   };
 }
 function parseJson(path) {
-  return JSON.parse(readFileSync10(path, "utf8"));
+  return JSON.parse(readFileSync11(path, "utf8"));
 }
 function sha2564(bytes) {
   return `sha256:${createHash9("sha256").update(bytes).digest("hex")}`;
@@ -32512,11 +33150,11 @@ function inspectExtensionSource(source2) {
   const resolved = resolve15(source2);
   if (!existsSync17(resolved))
     throw new Error(`extension source not found: ${source2}`);
-  const stat = statSync7(resolved);
+  const stat = statSync8(resolved);
   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 = readFileSync10(manifestPath);
+  const raw = readFileSync11(manifestPath);
   const parsed = parseJson(manifestPath);
   const bundle = isObject(parsed) && isObject(parsed["manifest"]);
   const manifest = normalizeManifest(bundle ? parsed["manifest"] : parsed);
@@ -32618,7 +33256,7 @@ function projectExtensionSources(projectPath) {
       if (entry.startsWith("."))
         continue;
       const full = join16(extensionDir, entry);
-      if (statSync7(full).isDirectory() || entry.endsWith(".json"))
+      if (statSync8(full).isDirectory() || entry.endsWith(".json"))
         candidates.push(full);
     }
   }
@@ -34258,7 +34896,7 @@ var init_postgres_sync = __esm(() => {
 });
 
 // src/storage/postgres-adapter.ts
-import { randomUUID as randomUUID3 } from "crypto";
+import { randomUUID as randomUUID4 } from "crypto";
 function createPostgresTodosStorageAdapter(options) {
   const store = new PostgresJsonRecordStore(options);
   const adapter = {
@@ -34287,6 +34925,7 @@ function createPostgresTodosStorageAdapter(options) {
       getChangedSince: (since, filters) => getChangedSince(since, filters, store),
       lock: (id, agentId) => lockTask2(id, agentId, store),
       unlock: (id, agentId) => unlockTask2(id, agentId, store),
+      handoffStaleLock: (input, context) => store.handoffStaleLock(input, context),
       getByFingerprint: (fingerprint) => store.getTaskByFingerprint(fingerprint)
     },
     dependencies: {
@@ -34323,6 +34962,7 @@ function createPostgresTodosStorageAdapter(options) {
       get: (id) => store.get("plans", id),
       list: async (projectId) => (await store.list("plans")).filter((plan) => projectId === undefined || plan.project_id === projectId).sort((a, b) => a.name.localeCompare(b.name)),
       update: (id, input) => updatePlan2(id, input, store),
+      completeAtRevision: (id, expectedUpdatedAt, context) => store.completePlanAtRevision(id, expectedUpdatedAt, context),
       delete: (id, context) => store.deletePlan(id, context)
     },
     planProjectLinks: {
@@ -34432,6 +35072,91 @@ class PostgresJsonRecordStore {
        LIMIT 1`, [this.service, type, id]);
     return result.rows[0] ? payloadRecord2(result.rows[0].payload) : null;
   }
+  async handoffStaleLock(input, context = {}) {
+    const prepared = prepareStaleLockHandoff(input);
+    const receipt = buildStaleLockHandoffReceipt(prepared);
+    const history = staleLockHandoffHistory(receipt, this.machineId(context));
+    await this.ensureSchema();
+    const result = await this.options.client.query(`/* todos:stale-lock-handoff-atomic */ WITH
+       target AS MATERIALIZED (
+         SELECT payload
+         FROM ${this.tableName}
+         WHERE service = $1
+           AND object_type = 'tasks'
+           AND object_id = $2
+           AND deleted_at IS NULL
+         FOR UPDATE
+       ),
+       updated AS (
+         UPDATE ${this.tableName} AS task_record
+         SET payload = jsonb_set(
+               jsonb_set(
+                 jsonb_set(
+                   jsonb_set(
+                     task_record.payload,
+                     '{locked_by}',
+                     to_jsonb($6::text),
+                     true
+                   ),
+                   '{locked_at}',
+                   to_jsonb($7::text),
+                   true
+                 ),
+                 '{updated_at}',
+                 to_jsonb($7::text),
+                 true
+               ),
+               '{version}',
+               to_jsonb(COALESCE((task_record.payload->>'version')::integer, 0) + 1),
+               true
+             ),
+             updated_at = $7::timestamptz,
+             source_machine_id = $10,
+             version = COALESCE(task_record.version, 0) + 1
+         FROM target
+         WHERE task_record.service = $1
+           AND task_record.object_type = 'tasks'
+           AND task_record.object_id = $2
+           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 COALESCE(target.payload->>'status', '') NOT IN ('completed', 'failed', 'cancelled')
+         RETURNING task_record.payload
+       ),
+       audit AS (
+         INSERT INTO ${this.tableName} (
+           service, object_type, object_id, payload, updated_at,
+           deleted_at, source_machine_id, version
+         )
+         SELECT $1, 'audit_history', $8, $9::jsonb, $7::timestamptz,
+                NULL, $10, NULL
+         FROM updated
+         RETURNING payload
+       )
+       SELECT
+         (SELECT payload FROM target) AS current_payload,
+         (SELECT payload FROM updated) AS updated_payload,
+         (SELECT payload FROM audit) AS audit_payload`, [
+      this.service,
+      prepared.task_id,
+      prepared.expected_holder,
+      prepared.expected_lock_version,
+      prepared.stale_cutoff,
+      prepared.new_holder,
+      prepared.operation_timestamp,
+      receipt.receipt_id,
+      jsonbParam(history),
+      this.machineId(context)
+    ]);
+    const row = result.rows[0];
+    if (!row?.current_payload)
+      throw new TaskNotFoundError(prepared.task_id);
+    if (!row.updated_payload || !row.audit_payload) {
+      throwStaleLockHandoffConflict(payloadRecord2(row.current_payload), prepared);
+    }
+    return receipt;
+  }
   async list(type) {
     return (await this.listRecords(type)).map((record) => record.payload);
   }
@@ -34701,6 +35426,28 @@ class PostgresJsonRecordStore {
     }
     return value;
   }
+  async insertImmutableAuditHistory(value, context = {}) {
+    await this.ensureSchema();
+    const inserted = await this.options.client.query(`INSERT INTO ${this.tableName} (
+        service, object_type, object_id, payload, updated_at,
+        deleted_at, source_machine_id, version
+      ) VALUES ($1, $2, $3, $4::jsonb, $5::timestamptz, NULL, $6, NULL)
+      ON CONFLICT (service, object_type, object_id) DO NOTHING
+      RETURNING object_id`, [
+      this.service,
+      "audit_history",
+      value.id,
+      jsonbParam(value),
+      value.created_at,
+      context.requestId ?? this.sourceMachineId ?? null
+    ]);
+    if (inserted.rows.length > 0)
+      return "inserted";
+    const existing = await this.get("audit_history", value.id);
+    if (existing && auditHistoryRowsAreFieldIdentical(existing, value))
+      return "identical";
+    throw new Error(divergentAuditHistoryReplayError(value.id));
+  }
   async upsertTaskWithPlanMembershipGuard(value, guardedPlanIds, explicitProject, context = {}) {
     const planIds = [...new Set(guardedPlanIds.filter(Boolean))].sort();
     if (planIds.length === 0)
@@ -34810,6 +35557,54 @@ class PostgresJsonRecordStore {
       throw new PlanNotFoundError(value.id);
     return payloadRecord2(row.payload);
   }
+  async completePlanAtRevision(id, expectedUpdatedAt, context = {}) {
+    await this.ensureSchema();
+    const result = await this.options.client.query(`/* todos:complete-plan-revision-cas */ WITH next_clock AS (
+         SELECT date_trunc(
+           'milliseconds',
+           GREATEST(clock_timestamp(), ($3::text)::timestamptz + interval '2 milliseconds')
+         ) AS completed_at
+       ), stored AS (
+         UPDATE ${this.tableName} AS record SET
+           payload = record.payload || jsonb_build_object(
+             'status', 'completed',
+             'updated_at', to_char(
+               next_clock.completed_at AT TIME ZONE 'UTC',
+               'YYYY-MM-DD"T"HH24:MI:SS.MS"Z"'
+             )
+           ),
+           updated_at = next_clock.completed_at,
+           deleted_at = NULL,
+           source_machine_id = COALESCE($4, record.source_machine_id),
+           version = COALESCE(record.version, 0) + 1
+         FROM next_clock
+         WHERE record.service = $1
+           AND record.object_type = 'plans'
+           AND record.object_id = $2
+           AND record.deleted_at IS NULL
+           AND record.payload->>'updated_at' = $3::text
+           AND record.payload->>'status' IS DISTINCT FROM 'completed'
+         RETURNING record.payload
+       )
+       SELECT payload FROM stored`, [
+      this.service,
+      id,
+      expectedUpdatedAt,
+      context.requestId ?? this.sourceMachineId ?? null
+    ]);
+    const payload = result.rows[0]?.payload;
+    if (payload)
+      return { plan: payloadRecord2(payload), applied: true };
+    const current = await this.get("plans", id);
+    if (!current)
+      throw new PlanNotFoundError(id);
+    if (current.updated_at !== expectedUpdatedAt) {
+      throw new PlanRevisionConflictError(id, expectedUpdatedAt, current.updated_at);
+    }
+    if (current.status === "completed")
+      return { plan: current, applied: false };
+    throw new PlanRevisionConflictError(id, expectedUpdatedAt, current.updated_at);
+  }
   async createTemplateWithTasks(template, tasks, context = {}) {
     await this.ensureSchema();
     const records = [
@@ -35479,7 +36274,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: randomUUID3(),
+    id: randomUUID4(),
     short_id: shortId,
     project_id: effectiveProjectId,
     parent_id: input.parent_id ?? null,
@@ -35725,7 +36520,7 @@ async function addVerification(input, store, context) {
     throw new Error(`Task not found: ${input.task_id}`);
   const timestamp2 = new Date().toISOString();
   const verification = {
-    id: randomUUID3(),
+    id: randomUUID4(),
     task_id: input.task_id,
     command: input.command,
     status: input.status ?? "unknown",
@@ -35746,7 +36541,7 @@ async function addCommit(input, store, context) {
     throw new Error(`Task not found: ${input.task_id}`);
   const timestamp2 = new Date().toISOString();
   const commit = {
-    id: randomUUID3(),
+    id: randomUUID4(),
     task_id: input.task_id,
     sha: input.sha,
     message: input.message ?? null,
@@ -35769,7 +36564,7 @@ async function addGitRef(input, store, context) {
     throw new Error(`Task not found: ${input.task_id}`);
   const timestamp2 = new Date().toISOString();
   const gitRef = {
-    id: randomUUID3(),
+    id: randomUUID4(),
     task_id: input.task_id,
     ref_type: input.ref_type,
     name: input.name,
@@ -35839,7 +36634,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: randomUUID3(),
+    id: randomUUID4(),
     name: input.name,
     path: input.path,
     description: input.description ?? null,
@@ -35871,7 +36666,7 @@ async function createPlan2(input, store, context) {
     store
   });
   return store.upsert("plans", {
-    id: randomUUID3(),
+    id: randomUUID4(),
     slug,
     project_id: projectId,
     task_list_id: input.task_list_id ?? context?.taskListId ?? null,
@@ -35923,7 +36718,7 @@ async function registerAgent2(input, store, context) {
   }
   const timestamp2 = new Date().toISOString();
   const agent = {
-    id: existing?.id ?? randomUUID3().slice(0, 8),
+    id: existing?.id ?? randomUUID4().slice(0, 8),
     name: canonicalName,
     description: input.description ?? existing?.description ?? null,
     role: input.role ?? existing?.role ?? null,
@@ -35996,7 +36791,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: randomUUID3(),
+    id: randomUUID4(),
     project_id: input.project_id ?? context?.projectId ?? null,
     slug,
     name: input.name,
@@ -36031,7 +36826,7 @@ async function updateTaskList2(id, input, store) {
 async function createTemplate2(input, store, context) {
   const timestamp2 = new Date().toISOString();
   const template = {
-    id: randomUUID3(),
+    id: randomUUID4(),
     name: input.name,
     title_pattern: input.title_pattern,
     description: input.description ?? null,
@@ -36052,7 +36847,7 @@ async function createTemplate2(input, store, context) {
 }
 function buildTemplateTasks(templateId, inputs, timestamp2) {
   return inputs.map((input, position) => ({
-    id: randomUUID3(),
+    id: randomUUID4(),
     template_id: templateId,
     position,
     title_pattern: input.title_pattern,
@@ -36085,7 +36880,7 @@ async function updateTemplate2(id, input, store) {
 }
 async function logTaskChange2(taskId, action, field, oldValue, newValue, agentId, store, context) {
   const entry2 = {
-    id: randomUUID3(),
+    id: randomUUID4(),
     task_id: taskId,
     action,
     field: field ?? null,
@@ -36099,7 +36894,7 @@ async function logTaskChange2(taskId, action, field, oldValue, newValue, agentId
 }
 async function addComment2(input, store, context) {
   const comment = {
-    id: randomUUID3(),
+    id: randomUUID4(),
     task_id: input.task_id,
     agent_id: input.agent_id ?? context?.agentId ?? null,
     session_id: input.session_id ?? context?.sessionId ?? null,
@@ -36141,6 +36936,11 @@ async function importSnapshot(snapshot, store, context) {
   result.errors.push(...validateSnapshotRoutingDestinationConflicts(snapshot.projects, snapshot.taskLists, existingProjects, existingTaskLists));
   if (result.errors.length > 0)
     return result;
+  const auditHistory = await preflightAuditHistoryImport2(snapshot.auditHistory, snapshot.tombstones ?? [], store);
+  result.errors.push(...auditHistory.errors);
+  if (result.errors.length > 0)
+    return result;
+  result.skipped += auditHistory.identical;
   const entries = [
     ...snapshot.tasks.map((row) => ["tasks", row]),
     ...snapshot.projects.map((row) => ["projects", row]),
@@ -36149,9 +36949,20 @@ async function importSnapshot(snapshot, store, context) {
     ...snapshot.agents.map((row) => ["agents", row]),
     ...snapshot.taskLists.map((row) => ["task_lists", row]),
     ...snapshot.templates.map((row) => ["templates", row]),
-    ...(snapshot.templateTasks ?? []).map((row) => ["template_tasks", row]),
-    ...snapshot.auditHistory.map((row) => ["audit_history", row])
+    ...(snapshot.templateTasks ?? []).map((row) => ["template_tasks", row])
   ];
+  for (const row of auditHistory.rowsToInsert) {
+    try {
+      const outcome = await store.insertImmutableAuditHistory(row, context);
+      if (outcome === "inserted")
+        result.inserted += 1;
+      else
+        result.skipped += 1;
+    } catch (error) {
+      result.errors.push(error instanceof Error ? error.message : String(error));
+      return result;
+    }
+  }
   for (const [type, row] of entries) {
     try {
       const existing = await store.get(type, row.id);
@@ -36185,6 +36996,32 @@ async function importSnapshot(snapshot, store, context) {
   }
   return result;
 }
+async function preflightAuditHistoryImport2(rows, tombstones, store) {
+  const errors = tombstones.filter((tombstone) => tombstone.object_type === "audit_history").map((tombstone) => forbiddenAuditHistoryTombstoneError(tombstone.object_id));
+  const rowsToInsert = [];
+  const seen = new Map;
+  let identical = 0;
+  for (const row of rows) {
+    const prior = seen.get(row.id);
+    if (prior) {
+      if (auditHistoryRowsAreFieldIdentical(prior, row))
+        identical += 1;
+      else
+        errors.push(divergentAuditHistoryReplayError(row.id));
+      continue;
+    }
+    seen.set(row.id, row);
+    const existing = await store.get("audit_history", row.id);
+    if (!existing) {
+      rowsToInsert.push(row);
+    } else if (auditHistoryRowsAreFieldIdentical(existing, row)) {
+      identical += 1;
+    } else {
+      errors.push(divergentAuditHistoryReplayError(row.id));
+    }
+  }
+  return { rowsToInsert, identical, errors };
+}
 async function requireRecord(type, id, store) {
   const record = await store.get(type, id);
   if (!record)
@@ -36291,9 +37128,11 @@ var init_postgres_adapter = __esm(() => {
   init_types();
   init_creator_identity();
   init_plan_project_link_contract();
+  init_stale_lock_handoff();
   init_postgres_sync();
   init_integrity();
   init_redaction();
+  init_audit_history_import();
   TASK_ORDER_BY = `ORDER BY ${TASK_ORDER_TIEBREAK}`;
 });
 
@@ -44645,7 +45484,7 @@ var exports_doctor = {};
 __export(exports_doctor, {
   runTodosDoctor: () => runTodosDoctor
 });
-import { chmodSync as chmodSync2, copyFileSync as copyFileSync2, existsSync as existsSync18, mkdirSync as mkdirSync9, statSync as statSync8 } from "fs";
+import { chmodSync as chmodSync2, copyFileSync as copyFileSync2, existsSync as existsSync18, mkdirSync as mkdirSync9, statSync as statSync9 } from "fs";
 import { basename as basename7, dirname as dirname8, join as join17 } from "path";
 function tableExists3(db, table) {
   return Boolean(db.query("SELECT name FROM sqlite_master WHERE type='table' AND name=?").get(table));
@@ -44792,7 +45631,7 @@ function databasePermissionsAreUnsafe(dbPath) {
   if (dbPath === ":memory:" || dbPath.startsWith("file::memory:"))
     return false;
   try {
-    return (statSync8(dbPath).mode & 63) !== 0;
+    return (statSync9(dbPath).mode & 63) !== 0;
   } catch {
     return false;
   }
@@ -46297,6 +47136,8 @@ function buildV1OpenApiDocument(version = getPackageVersion()) {
         ProjectTaskListEnsureResult: projectTaskListEnsureResultSchema,
         ProjectTaskListRollbackResult: projectTaskListRollbackResultSchema,
         TaskComment: taskCommentSchema,
+        StaleLockHandoffInput: staleLockHandoffInputSchema,
+        StaleLockHandoffReceipt: staleLockHandoffReceiptSchema,
         TaskGitRef: taskGitRefSchema,
         Plan: planSchema,
         PlanProjectLinkReceipt: planProjectLinkReceiptSchema,
@@ -47504,6 +48345,51 @@ function buildV1OpenApiDocument(version = getPackageVersion()) {
           }
         }
       },
+      "/v1/tasks/{id}/stale-lock-handoff": {
+        post: {
+          operationId: "handoffStaleTaskLock",
+          summary: "Atomically transfer one exact stale task lock",
+          description: "Compares one full task UUID, current holder, and exact locked_at version, verifies the lock is strictly older than the supplied threshold, then transfers it directly and writes an immutable task-history receipt in the same backend transaction.",
+          parameters: [
+            {
+              name: "id",
+              in: "path",
+              required: true,
+              schema: { type: "string", format: "uuid" },
+              description: "Exact full task UUID. Short ids and prefixes are rejected."
+            }
+          ],
+          requestBody: {
+            required: true,
+            content: {
+              "application/json": {
+                schema: { $ref: "#/components/schemas/StaleLockHandoffInput" }
+              }
+            }
+          },
+          responses: {
+            "200": {
+              content: {
+                "application/json": {
+                  schema: {
+                    type: "object",
+                    additionalProperties: false,
+                    required: ["receipt"],
+                    properties: {
+                      receipt: { $ref: "#/components/schemas/StaleLockHandoffReceipt" }
+                    }
+                  }
+                }
+              }
+            },
+            "400": { content: { "application/json": { schema: { $ref: "#/components/schemas/ErrorResponse" } } } },
+            "403": { content: { "application/json": { schema: { $ref: "#/components/schemas/ErrorResponse" } } } },
+            "404": { content: { "application/json": { schema: { $ref: "#/components/schemas/ErrorResponse" } } } },
+            "409": { content: { "application/json": { schema: { $ref: "#/components/schemas/ErrorResponse" } } } },
+            "501": { content: { "application/json": { schema: { $ref: "#/components/schemas/ErrorResponse" } } } }
+          }
+        }
+      },
       "/v1/tasks/{id}/refs": {
         get: {
           operationId: "listTaskGitRefs",
@@ -48010,8 +48896,8 @@ function buildV1OpenApiDocument(version = getPackageVersion()) {
       "/v1/import": {
         post: {
           operationId: "importSnapshot",
-          summary: "Bulk-ingest a full or partial snapshot (idempotent upsert by id)",
-          description: "Upserts every record carried in the body by primary key. All record arrays are optional and default to []; a caller may backfill a single object type (e.g. just tasks) or a complete snapshot. Re-posting the same rows never duplicates. Requires the todos:write scope.",
+          summary: "Bulk-ingest a snapshot or atomically complete one observed plan",
+          description: "Upserts every snapshot record by primary key, or accepts exactly one planCompletions operation that changes only plan status under an expected_updated_at CAS. Snapshot records and planCompletions are mutually exclusive. Requires the todos:write scope.",
           requestBody: {
             required: true,
             content: {
@@ -48030,7 +48916,22 @@ function buildV1OpenApiDocument(version = getPackageVersion()) {
                     templates: { type: "array", items: { type: "object" } },
                     templateTasks: { type: "array", items: { $ref: "#/components/schemas/TemplateTask" } },
                     auditHistory: { type: "array", items: { type: "object" } },
-                    tombstones: { type: "array", items: { type: "object" } }
+                    tombstones: { type: "array", items: { type: "object" } },
+                    planCompletions: {
+                      type: "array",
+                      minItems: 1,
+                      maxItems: 1,
+                      items: {
+                        type: "object",
+                        additionalProperties: false,
+                        required: ["id", "expected_updated_at", "status"],
+                        properties: {
+                          id: { type: "string" },
+                          expected_updated_at: { type: "string", format: "date-time" },
+                          status: { type: "string", enum: ["completed"] }
+                        }
+                      }
+                    }
                   }
                 }
               }
@@ -48053,6 +48954,26 @@ function buildV1OpenApiDocument(version = getPackageVersion()) {
                           skipped: { type: "number" },
                           errors: { type: "array", items: { type: "string" } }
                         }
+                      },
+                      planCompletions: {
+                        type: "array",
+                        items: {
+                          type: "object",
+                          required: [
+                            "id",
+                            "status",
+                            "expected_updated_at",
+                            "result_updated_at",
+                            "applied"
+                          ],
+                          properties: {
+                            id: { type: "string" },
+                            status: { type: "string", enum: ["completed"] },
+                            expected_updated_at: { type: "string", format: "date-time" },
+                            result_updated_at: { type: "string", format: "date-time" },
+                            applied: { type: "boolean" }
+                          }
+                        }
                       }
                     }
                   }
@@ -48065,7 +48986,7 @@ function buildV1OpenApiDocument(version = getPackageVersion()) {
     }
   };
 }
-var taskSchema, projectSchema, taskManifestBindingLookupRequestSchema, taskManifestBindingLookupResultSchema, taskManifestBindingLookupResponseSchema, taskListSchema, projectTaskListEnsureReceiptSchema, projectTaskListEnsureResultSchema, projectTaskListRollbackResultSchema, taskCommentSchema, taskGitRefSchema, planSchema, planProjectLinkReceiptSchema, planProjectLinkResultSchema, planProjectLinkRollbackResultSchema, templateTaskSchema, templateSchema, templateVariableSchema, createTemplateTaskInputSchema;
+var taskSchema, projectSchema, taskManifestBindingLookupRequestSchema, taskManifestBindingLookupResultSchema, taskManifestBindingLookupResponseSchema, taskListSchema, projectTaskListEnsureReceiptSchema, projectTaskListEnsureResultSchema, projectTaskListRollbackResultSchema, taskCommentSchema, staleLockHandoffInputSchema, staleLockHandoffReceiptSchema, taskGitRefSchema, planSchema, planProjectLinkReceiptSchema, planProjectLinkResultSchema, planProjectLinkRollbackResultSchema, templateTaskSchema, templateSchema, templateVariableSchema, createTemplateTaskInputSchema;
 var init_openapi = __esm(() => {
   init_package_version();
   init_types();
@@ -48084,6 +49005,8 @@ var init_openapi = __esm(() => {
       reason: { type: "string", nullable: true },
       tags: { type: "array", items: { type: "string" } },
       version: { type: "number" },
+      locked_by: { type: "string", nullable: true },
+      locked_at: { type: "string", format: "date-time", nullable: true },
       created_at: { type: "string" },
       updated_at: { type: "string" }
     }
@@ -48248,6 +49171,69 @@ var init_openapi = __esm(() => {
       created_at: { type: "string", format: "date-time" }
     }
   };
+  staleLockHandoffInputSchema = {
+    type: "object",
+    additionalProperties: false,
+    required: [
+      "expected_holder",
+      "expected_lock_version",
+      "stale_after_seconds",
+      "new_holder",
+      "reason"
+    ],
+    properties: {
+      expected_holder: { type: "string", minLength: 1 },
+      expected_lock_version: {
+        type: "string",
+        format: "date-time",
+        pattern: "^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}\\.\\d{3}Z$",
+        description: "Exact authoritative locked_at token read from the task; no default or normalization is applied."
+      },
+      stale_after_seconds: {
+        type: "integer",
+        minimum: 1,
+        description: "Lock age threshold supplied by the caller. The lock must be strictly older at the CAS instant."
+      },
+      new_holder: {
+        type: "string",
+        minLength: 1,
+        description: "Must match the agent bound to the authenticated API key."
+      },
+      reason: { type: "string", minLength: 1, maxLength: 4096 }
+    }
+  };
+  staleLockHandoffReceiptSchema = {
+    type: "object",
+    additionalProperties: false,
+    required: [
+      "schema_version",
+      "receipt_id",
+      "task_id",
+      "actor",
+      "previous_holder",
+      "previous_lock_version",
+      "new_holder",
+      "new_lock_version",
+      "stale_after_seconds",
+      "stale_cutoff",
+      "reason",
+      "created_at"
+    ],
+    properties: {
+      schema_version: { type: "string", enum: ["todos.stale-lock-handoff.v1"] },
+      receipt_id: { type: "string", format: "uuid" },
+      task_id: { type: "string", format: "uuid" },
+      actor: { type: "string" },
+      previous_holder: { type: "string" },
+      previous_lock_version: { type: "string", format: "date-time" },
+      new_holder: { type: "string" },
+      new_lock_version: { type: "string", format: "date-time" },
+      stale_after_seconds: { type: "integer", minimum: 1 },
+      stale_cutoff: { type: "string", format: "date-time" },
+      reason: { type: "string" },
+      created_at: { type: "string", format: "date-time" }
+    }
+  };
   taskGitRefSchema = {
     type: "object",
     additionalProperties: false,
@@ -48902,6 +49888,65 @@ function normalizeImportSnapshot(raw) {
 function countSnapshotRecords(s) {
   return s.tasks.length + s.projects.length + (s.projectMachinePaths?.length ?? 0) + s.plans.length + s.agents.length + s.taskLists.length + s.templates.length + s.templateTasks.length + s.auditHistory.length + (s.tombstones?.length ?? 0);
 }
+function validatePlanCompletionImports(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    return { present: false, operations: [] };
+  }
+  const body2 = raw;
+  if (!Object.prototype.hasOwnProperty.call(body2, "planCompletions")) {
+    return { present: false, operations: [] };
+  }
+  if (!Array.isArray(body2["planCompletions"]) || body2["planCompletions"].length !== 1) {
+    return {
+      present: true,
+      operations: [],
+      error: "planCompletions must contain exactly one completion operation"
+    };
+  }
+  const operation = body2["planCompletions"][0];
+  if (!operation || typeof operation !== "object" || Array.isArray(operation)) {
+    return { present: true, operations: [], error: "plan completion must be an object" };
+  }
+  const record = operation;
+  const allowed = new Set(["id", "expected_updated_at", "status"]);
+  const unknown = Object.keys(record).find((key2) => !allowed.has(key2));
+  if (unknown) {
+    return { present: true, operations: [], error: `unknown plan completion field: ${unknown}` };
+  }
+  if (typeof record["id"] !== "string" || !record["id"].trim()) {
+    return { present: true, operations: [], error: "plan completion id must be a non-empty string" };
+  }
+  if (record["status"] !== "completed") {
+    return { present: true, operations: [], error: "plan completion status must be completed" };
+  }
+  const expectedUpdatedAt = typeof record["expected_updated_at"] === "string" ? record["expected_updated_at"] : "";
+  const timestampMatch = RFC3339_DATE_TIME.exec(expectedUpdatedAt);
+  const parsedTimestamp = Date.parse(expectedUpdatedAt);
+  if (!timestampMatch || Number.isNaN(parsedTimestamp)) {
+    return {
+      present: true,
+      operations: [],
+      error: "plan completion expected_updated_at must be an RFC 3339 date-time with an explicit offset"
+    };
+  }
+  const [, year, month, day] = timestampMatch;
+  const calendarProbe = new Date(Date.UTC(Number(year), Number(month) - 1, Number(day)));
+  if (calendarProbe.getUTCFullYear() !== Number(year) || calendarProbe.getUTCMonth() !== Number(month) - 1 || calendarProbe.getUTCDate() !== Number(day)) {
+    return {
+      present: true,
+      operations: [],
+      error: "plan completion expected_updated_at names a date that does not exist"
+    };
+  }
+  return {
+    present: true,
+    operations: [{
+      id: record["id"],
+      expected_updated_at: expectedUpdatedAt,
+      status: "completed"
+    }]
+  };
+}
 async function handleV1Request(req, url, dependencies = {}) {
   const path = url.pathname;
   if (path !== "/v1" && !path.startsWith("/v1/"))
@@ -49083,6 +50128,45 @@ async function handleV1Request(req, url, dependencies = {}) {
         return error(405, `method ${method} not allowed on /v1/tasks`);
       }
       if (action) {
+        if (action === "stale-lock-handoff") {
+          if (method !== "POST") {
+            return error(405, "method must be POST on /v1/tasks/:id/stale-lock-handoff");
+          }
+          const exactId = normalizeExactTaskId(id);
+          if (!principal.agent) {
+            return error(403, "stale-lock handoff requires an authenticated agent-bound key", {
+              code: "STALE_LOCK_HANDOFF_ACTOR_MISMATCH"
+            });
+          }
+          if (typeof store.tasks.handoffStaleLock !== "function") {
+            return error(501, "stale-lock handoff is not supported by this storage backend");
+          }
+          const body3 = await readJson3(req) ?? {};
+          const allowed = new Set([
+            "expected_holder",
+            "expected_lock_version",
+            "stale_after_seconds",
+            "new_holder",
+            "reason"
+          ]);
+          const unknown = Object.keys(body3).find((key2) => !allowed.has(key2));
+          if (unknown) {
+            return error(400, `unknown stale-lock handoff field: ${unknown}`, {
+              code: "STALE_LOCK_HANDOFF_INVALID_INPUT",
+              field: unknown
+            });
+          }
+          const receipt = await store.tasks.handoffStaleLock({
+            task_id: exactId,
+            actor: principal.agent,
+            expected_holder: body3.expected_holder,
+            expected_lock_version: body3.expected_lock_version,
+            stale_after_seconds: body3.stale_after_seconds,
+            new_holder: body3.new_holder,
+            reason: body3.reason
+          }, contextFromPrincipal(principal));
+          return json5({ receipt });
+        }
         if (action === "comments") {
           if (method === "GET") {
             if (!await store.tasks.get(id))
@@ -49838,10 +50922,57 @@ async function handleV1Request(req, url, dependencies = {}) {
         return error(400, "invalid JSON body");
       const snapshot = normalizeImportSnapshot(raw);
       const received = countSnapshotRecords(snapshot);
+      const completionImports = validatePlanCompletionImports(raw);
+      if (completionImports.present) {
+        if (completionImports.error)
+          return error(400, completionImports.error);
+        if (received !== 0) {
+          return error(400, "planCompletions cannot be combined with snapshot record arrays");
+        }
+        if (typeof store.plans.completeAtRevision !== "function") {
+          return error(501, "atomic plan completion is not supported by this storage backend");
+        }
+        const operation = completionImports.operations[0];
+        const completed = await store.plans.completeAtRevision(operation.id, operation.expected_updated_at, contextFromPrincipal(principal));
+        return json5({
+          result: {
+            inserted: 0,
+            updated: completed.applied ? 1 : 0,
+            deleted: 0,
+            skipped: completed.applied ? 0 : 1,
+            errors: []
+          },
+          received: 1,
+          planCompletions: [{
+            id: operation.id,
+            status: "completed",
+            expected_updated_at: operation.expected_updated_at,
+            result_updated_at: completed.plan.updated_at,
+            applied: completed.applied
+          }]
+        });
+      }
       if (received === 0) {
         return error(400, "empty snapshot: provide at least one record array (tasks/projects/plans/...)");
       }
+      const forbiddenAuditTombstone = (snapshot.tombstones ?? []).find((tombstone) => tombstone.object_type === "audit_history");
+      if (forbiddenAuditTombstone) {
+        return error(400, forbiddenAuditHistoryTombstoneError(forbiddenAuditTombstone.object_id), {
+          code: AUDIT_HISTORY_TOMBSTONE_FORBIDDEN,
+          conflict: false,
+          audit_history_id: forbiddenAuditTombstone.object_id
+        });
+      }
       const result = await store.sync.importSnapshot(snapshot, contextFromPrincipal(principal));
+      const auditFailureMessage = result.errors.find((message) => parseAuditHistoryImportFailure(message) !== null);
+      if (auditFailureMessage) {
+        const failure = parseAuditHistoryImportFailure(auditFailureMessage);
+        return error(failure.status, auditFailureMessage, {
+          code: failure.code,
+          conflict: failure.conflict,
+          audit_history_id: failure.auditHistoryId
+        });
+      }
       return json5({ result, received });
     }
     return error(404, `unknown /v1 resource: ${resource ?? "(root)"}`);
@@ -49864,6 +50995,26 @@ async function handleV1Request(req, url, dependencies = {}) {
     if (e instanceof TaskNotFoundError) {
       return error(404, e.message, { code: TaskNotFoundError.code });
     }
+    if (e instanceof StaleLockHandoffError) {
+      const status2 = e.code === "STALE_LOCK_HANDOFF_INVALID_TASK_ID" || e.code === "STALE_LOCK_HANDOFF_INVALID_INPUT" ? 400 : e.code === "STALE_LOCK_HANDOFF_ACTOR_MISMATCH" ? 403 : 409;
+      return error(status2, e.message, {
+        code: e.code,
+        conflict: status2 === 409,
+        ...e.details
+      });
+    }
+    if (e instanceof PlanNotFoundError) {
+      return error(404, e.message, { code: PlanNotFoundError.code });
+    }
+    if (e instanceof PlanRevisionConflictError) {
+      return error(409, e.message, {
+        code: PlanRevisionConflictError.code,
+        conflict: true,
+        plan_id: e.planId,
+        expected_updated_at: e.expectedUpdatedAt,
+        current_updated_at: e.currentUpdatedAt
+      });
+    }
     if (e instanceof LockError)
       return error(409, e.message, { code: LockError.code });
     if (e instanceof TaskNotStartableError) {
@@ -49886,6 +51037,8 @@ var init_v1 = __esm(() => {
   init_redaction();
   init_project_task_list_ensure();
   init_plan_project_link();
+  init_stale_lock_handoff();
+  init_audit_history_import();
   JSON_HEADERS4 = { "Content-Type": "application/json" };
   RFC3339_DATE_TIME = /^(\d{4})-(\d{2})-(\d{2})[Tt]\d{2}:\d{2}:\d{2}(\.\d+)?([Zz]|[+-]\d{2}:\d{2})$/;
 });
@@ -51015,7 +52168,7 @@ var exports_mention_resolver = {};
 __export(exports_mention_resolver, {
   resolveMentions: () => resolveMentions
 });
-import { existsSync as existsSync19, readdirSync as readdirSync4, readFileSync as readFileSync11, statSync as statSync9 } from "fs";
+import { existsSync as existsSync19, readdirSync as readdirSync4, readFileSync as readFileSync12, 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 {
@@ -51118,13 +52271,13 @@ function resolveFile(parsed, workspace) {
     resolution.warnings.push("file does not exist in the local workspace");
     return resolution;
   }
-  const stats = statSync9(absolutePath);
+  const stats = statSync10(absolutePath);
   if (!stats.isFile()) {
     resolution.warnings.push("path exists but is not a file");
     return resolution;
   }
   if (parsed.line !== undefined) {
-    const lineCount = readFileSync11(absolutePath, "utf-8").split(/\r?\n/).length;
+    const lineCount = readFileSync12(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;
@@ -51156,7 +52309,7 @@ function walkSourceFiles(root, current = root, files = []) {
     if (!entry2.isFile())
       continue;
     const extension = `.${basename8(entry2.name).split(".").pop() || ""}`;
-    if (SOURCE_EXTENSIONS.has(extension) && statSync9(absolutePath).size <= 512 * 1024) {
+    if (SOURCE_EXTENSIONS.has(extension) && statSync10(absolutePath).size <= 512 * 1024) {
       files.push(absolutePath);
     }
   }
@@ -51177,7 +52330,7 @@ function resolveSymbol(parsed, workspace, maxMatches) {
   const pattern = symbolPattern(name);
   const matches = [];
   for (const file of walkSourceFiles(workspace)) {
-    const lines = readFileSync11(file, "utf-8").split(/\r?\n/);
+    const lines = readFileSync12(file, "utf-8").split(/\r?\n/);
     for (let index = 0;index < lines.length; index += 1) {
       const line = lines[index];
       const found = pattern.exec(line);
@@ -53919,7 +55072,7 @@ __export(exports_release_compatibility, {
   createReleaseCompatibilityReport: () => createReleaseCompatibilityReport,
   LOCAL_RELEASE_COMPATIBILITY_SCHEMA_VERSION: () => LOCAL_RELEASE_COMPATIBILITY_SCHEMA_VERSION
 });
-import { readFileSync as readFileSync12 } from "fs";
+import { readFileSync as readFileSync13 } from "fs";
 import { join as join20, resolve as resolve19 } from "path";
 import { Database as Database3 } from "bun:sqlite";
 function pass(id, message, details) {
@@ -53932,7 +55085,7 @@ function warn(id, message, details) {
   return { id, status: "warning", message, details };
 }
 function readPackageJson2(root) {
-  return JSON.parse(readFileSync12(join20(root, "package.json"), "utf8"));
+  return JSON.parse(readFileSync13(join20(root, "package.json"), "utf8"));
 }
 function sortedKeys(value) {
   return Object.keys(value ?? {}).sort((left, right) => left.localeCompare(right));
@@ -59902,7 +61055,7 @@ __export(exports_verification_providers, {
   getVerificationRecord: () => getVerificationRecord,
   discoverVerificationProviderCapabilities: () => discoverVerificationProviderCapabilities
 });
-import { existsSync as existsSync20, readFileSync as readFileSync13 } from "fs";
+import { existsSync as existsSync20, readFileSync as readFileSync14 } from "fs";
 function normalizeName6(name) {
   const normalized = name.trim().toLowerCase();
   if (!/^[a-z0-9][a-z0-9_-]{0,63}$/.test(normalized)) {
@@ -60054,7 +61207,7 @@ Timed out after ${provider.timeout_ms}ms`);
   };
 }
 function runCiLogProvider(input) {
-  const text = input.log_text ?? (input.log_path && existsSync20(input.log_path) ? readFileSync13(input.log_path, "utf-8") : "");
+  const text = input.log_text ?? (input.log_path && existsSync20(input.log_path) ? readFileSync14(input.log_path, "utf-8") : "");
   return {
     status: classifyLog(text),
     attempts: 1,
@@ -62357,7 +63510,7 @@ __export(exports_local_backups, {
   LOCAL_BACKUP_CHECKSUM_ALGORITHM: () => LOCAL_BACKUP_CHECKSUM_ALGORITHM
 });
 import { createHash as createHash14 } from "crypto";
-import { readFileSync as readFileSync14, writeFileSync as writeFileSync8 } from "fs";
+import { readFileSync as readFileSync15, writeFileSync as writeFileSync8 } from "fs";
 import { dirname as dirname9, resolve as resolve20 } from "path";
 import { mkdirSync as mkdirSync10 } from "fs";
 function stableJson2(value) {
@@ -62467,7 +63620,7 @@ function writeLocalBackupFile(backup, outputPath) {
   return path;
 }
 function readLocalBackupFile(path) {
-  return JSON.parse(readFileSync14(resolve20(path), "utf-8"));
+  return JSON.parse(readFileSync15(resolve20(path), "utf-8"));
 }
 function verifyLocalBackup(value, options = {}, db) {
   const verifiedAt = options.verified_at ?? now();
@@ -63647,7 +64800,7 @@ __export(exports_agent_replay_simulator, {
   renderAgentReplaySimulationMarkdown: () => renderAgentReplaySimulationMarkdown
 });
 import { createHash as createHash16 } from "crypto";
-import { readFileSync as readFileSync15 } from "fs";
+import { readFileSync as readFileSync16 } from "fs";
 function isObject2(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
@@ -63880,7 +65033,7 @@ function simulateAgentReplay(input, options = {}) {
   };
 }
 function simulateAgentReplayFile(path, options = {}) {
-  const parsed = JSON.parse(readFileSync15(path, "utf8"));
+  const parsed = JSON.parse(readFileSync16(path, "utf8"));
   return simulateAgentReplay(parsed, options);
 }
 function renderAgentReplaySimulationMarkdown(simulation) {
@@ -69219,7 +70372,7 @@ __export(exports_environment_snapshots, {
   captureEnvironmentSnapshot: () => captureEnvironmentSnapshot
 });
 import { createHash as createHash18 } from "crypto";
-import { existsSync as existsSync21, readFileSync as readFileSync16, statSync as statSync10 } from "fs";
+import { existsSync as existsSync21, readFileSync as readFileSync17, 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";
@@ -69230,10 +70383,10 @@ function fileRecord(root, relativePath) {
   const path = join22(root, relativePath);
   if (!existsSync21(path))
     return null;
-  const stat = statSync10(path);
+  const stat = statSync11(path);
   if (!stat.isFile())
     return null;
-  const content = readFileSync16(path);
+  const content = readFileSync17(path);
   return { path: relativePath, sha256: sha2567(content), size_bytes: content.length };
 }
 function manifestRecord(root, relativePath) {
@@ -72279,7 +73432,7 @@ __export(exports_config_serve_commands, {
   registerConfigServeCommands: () => registerConfigServeCommands
 });
 import chalk7 from "chalk";
-import { existsSync as existsSync23, mkdirSync as mkdirSync12, readFileSync as readFileSync17, writeFileSync as writeFileSync10 } from "fs";
+import { existsSync as existsSync23, mkdirSync as mkdirSync12, readFileSync as readFileSync18, 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) => {
@@ -72310,7 +73463,7 @@ function registerConfigServeCommands(program2) {
       }
       let config2 = {};
       try {
-        config2 = JSON.parse(readFileSync17(configPath, "utf-8"));
+        config2 = JSON.parse(readFileSync18(configPath, "utf-8"));
       } catch {}
       const keys = key2.split(".");
       let obj = config2;
@@ -72450,7 +73603,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 ? readFileSync17(opts.file, "utf-8") : text2 || "";
+    const value = opts.file ? readFileSync18(opts.file, "utf-8") : text2 || "";
     const findings = listSecretFindings2(value);
     if (globalOpts.json) {
       output({ ok: findings.length === 0, findings }, true);
@@ -74016,7 +75169,7 @@ __export(exports_task_route_sources, {
 });
 import { Database as Database4 } from "bun:sqlite";
 import { createHash as createHash19 } from "crypto";
-import { existsSync as existsSync25, readdirSync as readdirSync5, statSync as statSync11 } from "fs";
+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);
@@ -74092,7 +75245,7 @@ function discoverStoresUnderRoot(sourceRoot) {
   }
   let rootStat;
   try {
-    rootStat = statSync11(rootPath);
+    rootStat = statSync12(rootPath);
   } catch (error2) {
     const ref = createStoreRef(join26(rootPath, TODO_STORE_RELATIVE_PATH));
     errors2.push({
@@ -74825,7 +75978,7 @@ __export(exports_query_commands, {
   registerQueryCommands: () => registerQueryCommands
 });
 import chalk9 from "chalk";
-import { readFileSync as readFileSync18, writeFileSync as writeFileSync12 } from "fs";
+import { readFileSync as readFileSync19, writeFileSync as writeFileSync12 } from "fs";
 function parseJsonObjectOption2(value, label) {
   if (!value)
     return;
@@ -75407,8 +76560,29 @@ No task claimed (nothing available).`));
       handleError(new Error("Failed to assign"));
     }
   });
-  program2.command("unassign <id>").description("Remove task assignment").option("-j, --json", "Output as JSON").action((id, opts) => {
+  program2.command("unassign <id>").description("Remove task assignment").option("-j, --json", "Output as JSON").action(async (id, opts) => {
     const globalOpts = program2.opts();
+    const cloud = getTodosCloudClient();
+    if (cloud) {
+      try {
+        const resolvedId2 = await resolveTaskIdForCommand(id, cloud);
+        const task4 = await cloudGetTask(cloud, resolvedId2);
+        if (!task4) {
+          throw new Error(`Task not found: ${id}`);
+        }
+        const updated = await cloudUpdateTask(cloud, resolvedId2, {
+          assigned_to: null
+        });
+        if (opts.json || globalOpts.json) {
+          console.log(JSON.stringify(updated));
+          return;
+        }
+        console.log(chalk9.green(`Unassigned: ${formatTaskLine(updated)}`));
+      } catch (error2) {
+        handleError(error2);
+      }
+      return;
+    }
     const resolvedId = resolveTaskId(id);
     const db = getDatabase();
     const task3 = getTask(resolvedId, db);
@@ -75845,13 +77019,13 @@ Findings`));
     try {
       const db = getDatabase();
       const row = db.query("SELECT COUNT(*) as count FROM tasks").get();
-      const { statSync: statSync12 } = await import("fs");
+      const { statSync: statSync13 } = await import("fs");
       const { join: join27 } = await import("path");
       const { getHomeDir: getHomeDir2 } = await Promise.resolve().then(() => (init_sync_utils(), exports_sync_utils));
       const dbPath = process.env["HASNA_TODOS_DB_PATH"] || process.env["TODOS_DB_PATH"] || join27(getHomeDir2(), ".hasna", "todos", "todos.db");
       let size = "unknown";
       try {
-        size = `${(statSync12(dbPath).size / 1024 / 1024).toFixed(1)} MB`;
+        size = `${(statSync13(dbPath).size / 1024 / 1024).toFixed(1)} MB`;
       } catch {}
       checks.push({ name: "Database", ok: true, message: `${row.count} tasks \xB7 ${size} \xB7 ${chalk9.dim(dbPath)}` });
     } catch (e) {
@@ -76568,7 +77742,7 @@ Findings`));
     const sessionId = opts.session || globalOpts.session || undefined;
     try {
       if (opts.import) {
-        const bundle = JSON.parse(readFileSync18(opts.import, "utf-8"));
+        const bundle = JSON.parse(readFileSync19(opts.import, "utf-8"));
         const result = importHandoffBundle(bundle, { apply: opts.apply }, db);
         if (opts.json || globalOpts.json) {
           console.log(JSON.stringify(result));
@@ -76942,7 +78116,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(readFileSync18(path, "utf-8"));
+      const result = importCalendarIcs(readFileSync19(path, "utf-8"));
       if (opts.json || program2.opts().json) {
         output(result, true);
         return;
@@ -77093,7 +78267,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(readFileSync18(path, "utf-8"));
+      const bundle = JSON.parse(readFileSync19(path, "utf-8"));
       const result = importTaskBoardBundle(bundle);
       if (opts.json || program2.opts().json) {
         output(result, true);
@@ -77469,7 +78643,7 @@ Findings`));
       const { importExternalIssues: importExternalIssues2 } = await Promise.resolve().then(() => (init_external_issue_importers(), exports_external_issue_importers));
       let body2 = text2 || "";
       if (opts.file)
-        body2 = readFileSync18(opts.file, "utf-8");
+        body2 = readFileSync19(opts.file, "utf-8");
       if (!body2 && !opts.url && !process.stdin.isTTY)
         body2 = await Bun.stdin.text();
       if (!body2.trim() && !opts.url) {
@@ -77526,7 +78700,7 @@ Findings`));
       } = await Promise.resolve().then(() => (init_tester_issue_reports(), exports_tester_issue_reports));
       let body2 = jsonText || "";
       if (opts.file)
-        body2 = readFileSync18(opts.file, "utf-8");
+        body2 = readFileSync19(opts.file, "utf-8");
       if (!body2 && !process.stdin.isTTY)
         body2 = await Bun.stdin.text();
       if (!body2.trim()) {
@@ -77569,11 +78743,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: readFileSync19 } = await import("fs");
+    const { readFileSync: readFileSync20 } = await import("fs");
     const { createInboxItem: createInboxItem2 } = await Promise.resolve().then(() => (init_inbox(), exports_inbox));
     let body2 = text2 || "";
     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()) {
@@ -77633,11 +78807,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: readFileSync19 } = await import("fs");
+    const { readFileSync: readFileSync20 } = 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 = readFileSync19(opts.file, "utf-8");
+      body2 = readFileSync20(opts.file, "utf-8");
     if (!body2 && !process.stdin.isTTY)
       body2 = await Bun.stdin.text();
     if (!body2.trim()) {
@@ -77964,7 +79138,7 @@ __export(exports_mcp_hooks_commands, {
 });
 import chalk10 from "chalk";
 import { execSync as execSync3 } from "child_process";
-import { existsSync as existsSync26, readFileSync as readFileSync19, writeFileSync as writeFileSync13, mkdirSync as mkdirSync14, chmodSync as chmodSync3 } from "fs";
+import { existsSync as existsSync26, readFileSync as readFileSync20, writeFileSync as writeFileSync13, mkdirSync as mkdirSync14, chmodSync as chmodSync3 } from "fs";
 import { dirname as dirname15, join as join27 } from "path";
 function getMcpBinaryPath() {
   try {
@@ -77981,7 +79155,7 @@ function readJsonFile2(path) {
   if (!existsSync26(path))
     return {};
   try {
-    return JSON.parse(readFileSync19(path, "utf-8"));
+    return JSON.parse(readFileSync20(path, "utf-8"));
   } catch {
     return {};
   }
@@ -77996,7 +79170,7 @@ function writeJsonFile2(path, data) {
 function readTomlFile(path) {
   if (!existsSync26(path))
     return "";
-  return readFileSync19(path, "utf-8");
+  return readFileSync20(path, "utf-8");
 }
 function writeTomlFile(path, content) {
   const dir = dirname15(path);
@@ -79187,7 +80361,7 @@ Artifacts:`));
       const hookPath = `${gitDir}/hooks/post-commit`;
       const marker = "# todos-auto-link";
       if (existsSync26(hookPath)) {
-        const existing = readFileSync19(hookPath, "utf-8");
+        const existing = readFileSync20(hookPath, "utf-8");
         if (existing.includes(marker)) {
           console.log(chalk10.yellow("Hook already installed."));
           return;
@@ -79217,7 +80391,7 @@ $(dirname "$0")/../../scripts/post-commit-hook.sh
         console.log(chalk10.dim("No post-commit hook found."));
         return;
       }
-      const content = readFileSync19(hookPath, "utf-8");
+      const content = readFileSync20(hookPath, "utf-8");
       if (!content.includes(marker)) {
         console.log(chalk10.dim("Hook not managed by todos."));
         return;
@@ -79468,7 +80642,7 @@ var STDIN_SENTINEL = "-";
 var init_delegation_brief = () => {};
 
 // src/lib/delegation-policy.ts
-import { readFileSync as readFileSync20 } from "fs";
+import { readFileSync as readFileSync21 } from "fs";
 import { homedir as homedir4 } from "os";
 import { join as join28 } from "path";
 function defaultDelegationEmbargoPath() {
@@ -79476,7 +80650,7 @@ function defaultDelegationEmbargoPath() {
 }
 function loadDelegationEmbargo(path = defaultDelegationEmbargoPath()) {
   try {
-    const parsed = JSON.parse(readFileSync20(path, "utf8"));
+    const parsed = JSON.parse(readFileSync21(path, "utf8"));
     const entries = Array.isArray(parsed) ? parsed : Array.isArray(parsed?.embargoed) ? parsed.embargoed : [];
     const names = new Set;
     for (const entry2 of entries) {
@@ -79559,15 +80733,15 @@ __export(exports_delegate, {
   registerDelegateCommands: () => registerDelegateCommands
 });
 import chalk12 from "chalk";
-import { readFileSync as readFileSync21 } from "fs";
+import { readFileSync as readFileSync22 } 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) => readFileSync21(path, "utf8"),
-        readStdin: () => readFileSync21(0, "utf8")
+        readFile: (path) => readFileSync22(path, "utf8"),
+        readStdin: () => readFileSync22(0, "utf8")
       });
       if (!brief.ok)
         handleError(new Error(brief.message));
@@ -79815,7 +80989,7 @@ __export(exports_machines, {
 });
 import chalk13 from "chalk";
 import { execSync as execSync4 } from "child_process";
-import { readFileSync as readFileSync22, unlinkSync as unlinkSync3, writeFileSync as writeFileSync14 } from "fs";
+import { readFileSync as readFileSync23, unlinkSync as unlinkSync3, writeFileSync as writeFileSync14 } from "fs";
 import { tmpdir as tmpdir5 } from "os";
 import { join as join29 } from "path";
 function getOrCreateLocalMachineName() {
@@ -79859,7 +81033,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(readFileSync22(localPath, "utf-8"));
+    return JSON.parse(readFileSync23(localPath, "utf-8"));
   } finally {
     try {
       runSsh(sshAddress, `rm -f ${shellQuote(remotePath)}`, 1e4);
@@ -84817,7 +85991,7 @@ var exports_roadmap_commands = {};
 __export(exports_roadmap_commands, {
   registerRoadmapCommands: () => registerRoadmapCommands
 });
-import { readFileSync as readFileSync23, writeFileSync as writeFileSync16 } from "fs";
+import { readFileSync as readFileSync24, 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);
@@ -85046,7 +86220,7 @@ function registerRoadmapCommands(program2) {
     const globalOpts = globalOptions(program2);
     try {
       const { importRoadmapBundle: importRoadmapBundle2 } = await Promise.resolve().then(() => (init_roadmaps(), exports_roadmaps));
-      const bundle = JSON.parse(readFileSync23(path, "utf8"));
+      const bundle = JSON.parse(readFileSync24(path, "utf8"));
       const result = importRoadmapBundle2(bundle, { apply: Boolean(opts.apply) });
       if (globalOpts.json) {
         output(result, true);
@@ -85806,6 +86980,15 @@ function createShadowTodosStorageAdapter(options) {
         mirror.enqueueUpsert("plans", plan, context);
         return plan;
       },
+      async completeAtRevision(id, expectedUpdatedAt, context) {
+        if (typeof local.plans.completeAtRevision !== "function") {
+          throw new Error("Atomic plan completion is not supported by the local shadow adapter");
+        }
+        const completed = await local.plans.completeAtRevision(id, expectedUpdatedAt, context);
+        if (completed.applied)
+          mirror.enqueueUpsert("plans", completed.plan, context);
+        return completed;
+      },
       async delete(id, context) {
         const deleted = await local.plans.delete(id, context);
         if (deleted)
@@ -87861,6 +89044,7 @@ program2.name("todos").description("Universal task management for AI coding agen
 var authority;
 try {
   authority = initializeTodosCliAuthority();
+  applyTodosCliAuthorityEnvironment(authority);
 } catch (error2) {
   console.error(error2 instanceof Error ? error2.message : String(error2));
   process.exit(1);