@hasna/todos 0.15.17 → 0.15.19

package/dist/mcp/index.js

@@ -47,7 +47,7 @@ function isBlockingDependencyStatus(status) {
 function isTerminalStatus(status) {
   return status === "completed" || status === "failed" || status === "cancelled";
 }
-var TASK_STATUSES, TASK_PRIORITIES, VersionConflictError, TaskNotFoundError, TaskNotStartableError, TaskReferenceAmbiguousError, ProjectNotFoundError, ResourceConflictError, PlanNotFoundError, LockError, AgentNotFoundError, IdentityAliasAmbiguousError, IdentityIdImmutableError, TaskListNotFoundError, DependencyCycleError, CompletionGuardError, DispatchNotFoundError;
+var TASK_STATUSES, TASK_PRIORITIES, VersionConflictError, TaskNotFoundError, TaskNotStartableError, TaskReferenceAmbiguousError, ProjectNotFoundError, ResourceConflictError, PlanRevisionConflictError, PlanNotFoundError, LockError, AgentNotFoundError, IdentityAliasAmbiguousError, IdentityIdImmutableError, TaskListNotFoundError, DependencyCycleError, CompletionGuardError, DispatchNotFoundError;
 var init_types = __esm(() => {
   TASK_STATUSES = [
     "pending",
@@ -134,6 +134,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";
@@ -15309,6 +15322,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);
@@ -21322,7 +21377,7 @@ function resolveTaskListFromCandidates(lists, input) {
   ];
   for (const matches of matchGroups) {
     if (matches.length === 1)
-      return matches[0].id;
+      return matches[0];
     if (matches.length > 1) {
       throw new Error(`Task list reference is ambiguous: "${input}"`);
     }
@@ -21335,27 +21390,26 @@ async function legacyProjectTaskLists(client, projectId) {
     return [];
   return (await cloudListTaskLists(client)).filter((list) => list.project_id == null && list.slug === project.task_list_id);
 }
-async function cloudResolveTaskListRef(client, ref, projectId) {
+async function cloudResolveTaskList(client, ref, projectId) {
   const input = ref.trim();
   const normalizedIdRef = input.toLowerCase();
-  if (UUID_RE.test(input) && !projectId)
-    return normalizedIdRef;
-  if (UUID_RE.test(input) && projectId) {
+  if (UUID_RE.test(input)) {
     const direct = await cloudGetTaskList(client, normalizedIdRef);
     if (direct?.id?.toLowerCase() === normalizedIdRef) {
-      if (direct.project_id === projectId)
-        return direct.id;
+      if (!projectId || direct.project_id === projectId)
+        return direct;
       if (direct.project_id == null) {
         const project = await cloudGetProjectById(client, projectId);
         if (project?.task_list_id === direct.slug)
-          return direct.id;
+          return direct;
       }
       throw new Error(`Task list not found: "${input}"`);
     }
   }
   const scopedMatch = resolveTaskListFromCandidates(await cloudListTaskLists(client, projectId), input);
-  if (scopedMatch)
+  if (scopedMatch && (!projectId || scopedMatch.project_id === projectId)) {
     return scopedMatch;
+  }
   if (projectId) {
     const legacyMatch = resolveTaskListFromCandidates(await legacyProjectTaskLists(client, projectId), input);
     if (legacyMatch)
@@ -21363,7 +21417,13 @@ async function cloudResolveTaskListRef(client, ref, projectId) {
   }
   throw new Error(`Task list not found: "${input}"`);
 }
-var UUID_RE, TRANSPORT_TOKENS, completionCapabilityCache, gitRefCapabilityCache, SERVER_MODE_CANDIDATES, cachedServerMode = null, PRIORITY_RANK, listTagsCapabilityCache;
+async function cloudResolveTaskListRef(client, ref, projectId) {
+  const input = ref.trim();
+  if (UUID_RE.test(input) && !projectId)
+    return input.toLowerCase();
+  return (await cloudResolveTaskList(client, ref, projectId)).id;
+}
+var UUID_RE, TRANSPORT_TOKENS, completionCapabilityCache, retryCapabilityCache, gitRefCapabilityCache, SERVER_MODE_CANDIDATES, cachedServerMode = null, PRIORITY_RANK, listTagsCapabilityCache;
 var init_cloud_router = __esm(() => {
   init_types();
   init_redaction();
@@ -21380,6 +21440,7 @@ var init_cloud_router = __esm(() => {
     hybrid: "http"
   };
   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 };
@@ -35476,7 +35537,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@hasna/todos",
-    version: "0.15.17",
+    version: "0.15.19",
     description: "Universal task management for AI coding agents - CLI + MCP server + interactive TUI",
     type: "module",
     main: "dist/index.js",
@@ -45072,7 +45133,7 @@ function importSqliteTodosStorageSnapshot(snapshot, db) {
   }
   if (result.errors.length > 0)
     return result;
-  const applyRows = (objectType2, table, columns, rows, updateClockColumn, afterUpsert) => {
+  const applyRows = (objectType2, table, columns, rows, updateClockColumn, acceptEqualClock = true, afterUpsert) => {
     for (const row of rows) {
       try {
         const record = asRecord2(row);
@@ -45081,7 +45142,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")
@@ -45098,10 +45159,10 @@ 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, sortedTasks2(snapshot.tasks), "updated_at", (row, changed) => {
+  applyRows("tasks", "tasks", TASK_COLUMNS, sortedTasks2(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);
     }
@@ -45110,7 +45171,7 @@ function importSqliteTodosStorageSnapshot(snapshot, db) {
   applyTombstones(d, snapshot.tombstones ?? [], result);
   return result;
 }
-function upsertById(db, table, columns, row, updateClockColumn) {
+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`);
@@ -45122,7 +45183,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 (${placeholders2})
        ON CONFLICT(id) DO UPDATE SET ${updateSet}${clockGuard}` : `INSERT OR IGNORE INTO ${table} (${presentColumns.join(", ")}) VALUES (${placeholders2})`;
   const changes = db.run(sql, values).changes;
@@ -45541,6 +45602,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: {
@@ -46501,6 +46563,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: {
@@ -46988,6 +47051,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 = [
@@ -55529,8 +55640,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: {
@@ -55549,7 +55660,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"] }
+                        }
+                      }
+                    }
                   }
                 }
               }
@@ -55572,6 +55698,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" }
+                          }
+                        }
                       }
                     }
                   }
@@ -56768,6 +56914,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/"))
@@ -57704,6 +57909,36 @@ 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/...)");
       }
@@ -57730,6 +57965,18 @@ async function handleV1Request(req, url, dependencies = {}) {
     if (e instanceof TaskNotFoundError) {
       return error(404, e.message, { code: TaskNotFoundError.code });
     }
+    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) {

package/dist/mcp.js

@@ -41,7 +41,7 @@ var __require = import.meta.require;
 // package.json
 var package_default = {
   name: "@hasna/todos",
-  version: "0.15.17",
+  version: "0.15.19",
   description: "Universal task management for AI coding agents - CLI + MCP server + interactive TUI",
   type: "module",
   main: "dist/index.js",

package/dist/project-registration.js

@@ -117,7 +117,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, AgentNotFoundError, IdentityAliasAmbiguousError, IdentityIdImmutableError, TaskListNotFoundError, DependencyCycleError, CompletionGuardError, DISPATCH_STATUSES, DispatchNotFoundError;
 var init_types = __esm(() => {
   TASK_STATUSES = [
     "pending",
@@ -205,6 +205,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";
@@ -10521,6 +10534,48 @@ function updatePlan2(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);
@@ -12383,7 +12438,7 @@ import { createHash as createHash5 } from "crypto";
 // package.json
 var package_default = {
   name: "@hasna/todos",
-  version: "0.15.17",
+  version: "0.15.19",
   description: "Universal task management for AI coding agents - CLI + MCP server + interactive TUI",
   type: "module",
   main: "dist/index.js",
@@ -13288,6 +13343,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) => updatePlan(id, input, store),
+      completeAtRevision: (id, expectedUpdatedAt, context) => store.completePlanAtRevision(id, expectedUpdatedAt, context),
       delete: (id, context) => store.deletePlan(id, context)
     },
     planProjectLinks: {
@@ -13775,6 +13831,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 = [
@@ -16879,7 +16983,7 @@ function importSqliteTodosStorageSnapshot(snapshot, db) {
   }
   if (result.errors.length > 0)
     return result;
-  const applyRows = (objectType, table, columns, rows, updateClockColumn, afterUpsert) => {
+  const applyRows = (objectType, table, columns, rows, updateClockColumn, acceptEqualClock = true, afterUpsert) => {
     for (const row of rows) {
       try {
         const record = asRecord(row);
@@ -16888,7 +16992,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")
@@ -16905,10 +17009,10 @@ 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);
     }
@@ -16917,7 +17021,7 @@ function importSqliteTodosStorageSnapshot(snapshot, db) {
   applyTombstones(d, snapshot.tombstones ?? [], result);
   return result;
 }
-function upsertById(db, table, columns, row, updateClockColumn) {
+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`);
@@ -16929,7 +17033,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;
@@ -17169,6 +17273,7 @@ function createLocalSqliteTodosStorageAdapter(options = {}) {
       get: (id) => getPlan(id, database()),
       list: (projectId) => listPlans(projectId, database()),
       update: (id, input) => updatePlan2(id, input, database()),
+      completeAtRevision: (id, expectedUpdatedAt) => completePlanAtRevision(id, expectedUpdatedAt, database()),
       delete: (id) => deletePlan(id, database())
     },
     planProjectLinks: {