@hasna/todos 0.15.46 → 0.15.49

package/dist/task-manifest.js

@@ -615,13 +615,15 @@ function upsertSecretSafetyConfig(input) {
   saveConfig({ ...config, secret_safety: next });
   return next;
 }
-var DEFAULT_SECRET_PATTERNS, DEFAULT_SECRET_KEY_PATTERN, NON_SECRET_USAGE_KEYS, REDACTION_PLACEHOLDER;
+var XAI_PREFIX, DEFAULT_SECRET_PATTERNS, DEFAULT_SECRET_KEY_PATTERN, NON_SECRET_USAGE_KEYS, REDACTION_PLACEHOLDER;
 var init_redaction = __esm(() => {
   init_config();
+  XAI_PREFIX = ["x", "ai", "-"].join("");
   DEFAULT_SECRET_PATTERNS = [
     { name: "aws-access-key", regex: /\b(AKIA|ASIA)[0-9A-Z]{16}\b/g, replacement: "[REDACTED_AWS_KEY]" },
     { name: "private-key", regex: /-----BEGIN (?:RSA |EC |OPENSSH |)PRIVATE KEY-----[\s\S]*?-----END (?:RSA |EC |OPENSSH |)PRIVATE KEY-----/g, replacement: "[REDACTED_PRIVATE_KEY]" },
     { name: "openai-token", regex: /\bsk-[A-Za-z0-9_-]{12,}\b/g, replacement: "[REDACTED_TOKEN]" },
+    { name: `${XAI_PREFIX}token`, regex: /\bxai[-][A-Za-z0-9]{20,80}\b/g, replacement: "[REDACTED_TOKEN]" },
     { name: "npm-token", regex: /\bnpm_[A-Za-z0-9]{20,}\b/g, replacement: "[REDACTED_NPM_TOKEN]" },
     { name: "github-fine-grained-token", regex: /\bgithub_pat_[A-Za-z0-9_]{20,}\b/g, replacement: "[REDACTED_GITHUB_TOKEN]" },
     { name: "github-token", regex: /\bgh[opsu]_[A-Za-z0-9]{20,}\b/g, replacement: "[REDACTED_GITHUB_TOKEN]" },
@@ -6010,6 +6012,30 @@ class SqliteTodosTaskManifestBackend {
   }
 }
 
+// src/storage/postgres-sync.ts
+init_types();
+
+// src/storage/postgres-errors.ts
+function isPostgresUniqueViolation(error) {
+  if (typeof error !== "object" || error === null)
+    return false;
+  const candidate = error;
+  const states = [candidate.code, candidate.errno, candidate.sqlState, candidate.sqlstate];
+  if (typeof candidate.cause === "object" && candidate.cause !== null) {
+    const cause = candidate.cause;
+    states.push(cause.code, cause.errno, cause.sqlState, cause.sqlstate);
+  }
+  return states.some((state) => String(state) === "23505");
+}
+function postgresConstraintName(error) {
+  if (typeof error !== "object" || error === null)
+    return "";
+  const candidate = error;
+  const cause = typeof candidate.cause === "object" && candidate.cause !== null ? candidate.cause : undefined;
+  const constraint = candidate.constraint ?? candidate.constraint_name ?? cause?.constraint ?? cause?.constraint_name;
+  return typeof constraint === "string" ? constraint : "";
+}
+
 // src/storage/postgres-sync.ts
 var DEFAULT_TODOS_POSTGRES_SYNC_TABLE = "todos_sync_records";
 var DEFAULT_TODOS_POSTGRES_CURSOR_TABLE = "todos_sync_cursors";
@@ -6212,53 +6238,98 @@ class PostgresTodosSyncStore {
     if (routingErrors.length > 0) {
       throw new Error(`Invalid snapshot routing metadata: ${routingErrors.join("; ")}`);
     }
-    const existing = await this.client.query(`SELECT object_type, object_id, payload, updated_at, deleted_at, source_machine_id, version
-       FROM ${this.tableName}
-       WHERE service = $1 AND object_type IN ($2, $3) AND deleted_at IS NULL`, [this.service, "projects", "task_lists"]);
-    const existingProjects = [];
-    const existingTaskLists = [];
-    for (const row of existing.rows) {
-      const payload = payloadRecord(row.payload);
-      if (row.object_type === "projects")
-        existingProjects.push(payload);
-      if (row.object_type === "task_lists")
-        existingTaskLists.push(payload);
-    }
-    const destinationErrors = validateSnapshotRoutingDestinationConflicts(snapshot.projects, snapshot.taskLists, existingProjects, existingTaskLists);
-    if (destinationErrors.length > 0) {
-      throw new Error(`Snapshot routing conflicts with destination: ${destinationErrors.join("; ")}`);
-    }
-    const result = { records: 0, objectTypes: {} };
-    const sourceMachineId = context.requestId ?? this.sourceMachineId ?? null;
-    for (const entry of snapshotEntries(snapshot)) {
-      if (entry.deletedAt === null)
-        assertCanonicalScopedSlugEntry(entry);
-      await this.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, $6::timestamptz, $7, $8)
-        ON CONFLICT (service, object_type, object_id) DO UPDATE SET
-          payload = EXCLUDED.payload,
-          updated_at = EXCLUDED.updated_at,
-          deleted_at = EXCLUDED.deleted_at,
-          source_machine_id = EXCLUDED.source_machine_id,
-          version = EXCLUDED.version
-        WHERE ${this.tableName}.updated_at < EXCLUDED.updated_at
-           OR (${this.tableName}.updated_at = EXCLUDED.updated_at
-               AND COALESCE(${this.tableName}.version, 0) <= COALESCE(EXCLUDED.version, 0))`, [
-        this.service,
-        entry.type,
-        entry.id,
-        entry.payload,
-        entry.updatedAt,
-        entry.deletedAt,
-        sourceMachineId,
-        entry.version
-      ]);
-      result.records += 1;
-      result.objectTypes[entry.type] = (result.objectTypes[entry.type] ?? 0) + 1;
+    const push = async (client) => {
+      const existing = await client.query(`SELECT object_type, object_id, payload, updated_at, deleted_at, source_machine_id, version
+         FROM ${this.tableName}
+         WHERE service = $1 AND object_type IN ($2, $3) AND deleted_at IS NULL`, [this.service, "projects", "task_lists"]);
+      const existingProjects = [];
+      const existingTaskLists = [];
+      for (const row of existing.rows) {
+        const payload = payloadRecord(row.payload);
+        if (row.object_type === "projects")
+          existingProjects.push(payload);
+        if (row.object_type === "task_lists")
+          existingTaskLists.push(payload);
+      }
+      const destinationErrors = validateSnapshotRoutingDestinationConflicts(snapshot.projects, snapshot.taskLists, existingProjects, existingTaskLists);
+      if (destinationErrors.length > 0) {
+        throw new ResourceConflictError("SNAPSHOT_DESTINATION_CONFLICT", `Snapshot routing conflicts with destination: ${destinationErrors.join("; ")}`);
+      }
+      const result = { records: 0, objectTypes: {} };
+      const sourceMachineId = context.requestId ?? this.sourceMachineId ?? null;
+      for (const entry of snapshotEntries(snapshot)) {
+        if (entry.deletedAt === null)
+          assertCanonicalScopedSlugEntry(entry);
+        try {
+          await 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, $6::timestamptz, $7, $8)
+            ON CONFLICT (service, object_type, object_id) DO UPDATE SET
+              payload = EXCLUDED.payload,
+              updated_at = EXCLUDED.updated_at,
+              deleted_at = EXCLUDED.deleted_at,
+              source_machine_id = EXCLUDED.source_machine_id,
+              version = EXCLUDED.version
+            WHERE ${this.tableName}.updated_at < EXCLUDED.updated_at
+               OR (${this.tableName}.updated_at = EXCLUDED.updated_at
+                   AND COALESCE(${this.tableName}.version, 0) <= COALESCE(EXCLUDED.version, 0))`, [
+            this.service,
+            entry.type,
+            entry.id,
+            entry.payload,
+            entry.updatedAt,
+            entry.deletedAt,
+            sourceMachineId,
+            entry.version
+          ]);
+        } catch (error) {
+          await this.classifySyncInsertConflict(error, entry);
+        }
+        result.records += 1;
+        result.objectTypes[entry.type] = (result.objectTypes[entry.type] ?? 0) + 1;
+      }
+      return result;
+    };
+    if (typeof this.client.transaction === "function") {
+      return this.client.transaction((client) => push(client));
+    }
+    return push(this.client);
+  }
+  async classifySyncInsertConflict(error, entry) {
+    if (!isPostgresUniqueViolation(error))
+      throw error;
+    const payload = entry.payload;
+    const taskListSlug = String(payload["slug"] ?? "");
+    const projectSlug = String(payload["task_list_id"] ?? "");
+    const constraintName = postgresConstraintName(error);
+    if (entry.type === "projects" && constraintName.includes("project_task_list_slug_uidx")) {
+      throw new ResourceConflictError("PROJECT_SLUG_CONFLICT", `Project slug "${projectSlug}" already exists`);
+    }
+    if (entry.type === "task_lists" && constraintName.includes("task_list_scope_slug_uidx")) {
+      throw new ResourceConflictError("TASK_LIST_SLUG_CONFLICT", `Task list with slug "${taskListSlug}" already exists in this scope`);
+    }
+    if (entry.type === "task_lists") {
+      const scope = typeof payload["project_id"] === "string" ? payload["project_id"] : "";
+      const conflict = await this.client.query(`/* todos:classify-sync-task-list-conflict */ SELECT EXISTS (
+          SELECT 1 FROM ${this.tableName}
+          WHERE service = $1 AND object_type = 'task_lists' AND object_id <> $2
+            AND deleted_at IS NULL AND COALESCE(payload->>'project_id','') = $3 AND payload->>'slug' = $4
+        ) AS conflict`, [this.service, entry.id, scope, taskListSlug]);
+      if (conflict.rows[0]?.conflict) {
+        throw new ResourceConflictError("TASK_LIST_SLUG_CONFLICT", `Task list with slug "${taskListSlug}" already exists in this scope`);
+      }
+    } else if (entry.type === "projects") {
+      const conflict = await this.client.query(`/* todos:classify-sync-project-conflict */ SELECT EXISTS (
+          SELECT 1 FROM ${this.tableName}
+          WHERE service = $1 AND object_type = 'projects' AND object_id <> $2
+            AND deleted_at IS NULL AND payload->>'task_list_id' = $3
+        ) AS conflict`, [this.service, entry.id, projectSlug]);
+      if (conflict.rows[0]?.conflict) {
+        throw new ResourceConflictError("PROJECT_SLUG_CONFLICT", `Project slug "${projectSlug}" already exists`);
+      }
     }
-    return result;
+    throw error;
   }
   async pullSnapshot(options = {}) {
     const params = [this.service];

package/dist/task-subtree-transfer.js

@@ -39,6 +39,219 @@ var __export = (target, all) => {
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = import.meta.require;
 
+// src/types/index.ts
+function isBlockingDependencyStatus(status) {
+  return status !== "completed" && status !== "cancelled";
+}
+function isTerminalStatus(status) {
+  return status === "completed" || status === "failed" || status === "cancelled";
+}
+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",
+    "in_progress",
+    "completed",
+    "failed",
+    "cancelled"
+  ];
+  TASK_PRIORITIES = [
+    "low",
+    "medium",
+    "high",
+    "critical"
+  ];
+  PLAN_STATUSES = ["active", "completed", "archived"];
+  VersionConflictError = class VersionConflictError extends Error {
+    taskId;
+    expectedVersion;
+    actualVersion;
+    static code = "VERSION_CONFLICT";
+    static suggestion = "Fetch the task with get_task to get the current version before updating.";
+    constructor(taskId, expectedVersion, actualVersion) {
+      super(`Version conflict for task ${taskId}: expected ${expectedVersion}, got ${actualVersion}`);
+      this.taskId = taskId;
+      this.expectedVersion = expectedVersion;
+      this.actualVersion = actualVersion;
+      this.name = "VersionConflictError";
+    }
+  };
+  TaskNotFoundError = class TaskNotFoundError extends Error {
+    taskId;
+    static code = "TASK_NOT_FOUND";
+    static suggestion = "Verify the task ID. Use list_tasks or search_tasks to find the correct ID.";
+    constructor(taskId) {
+      super(`Task not found: ${taskId}`);
+      this.taskId = taskId;
+      this.name = "TaskNotFoundError";
+    }
+  };
+  TaskNotStartableError = class TaskNotStartableError extends Error {
+    taskId;
+    status;
+    agentId;
+    static code = "TASK_NOT_STARTABLE";
+    static suggestion = "Reset the task status to pending before starting it again.";
+    constructor(taskId, status, agentId) {
+      super(`Task ${taskId} is ${status} and cannot be started by ${agentId}; ` + "reset the task status to pending before starting it again");
+      this.taskId = taskId;
+      this.status = status;
+      this.agentId = agentId;
+      this.name = "TaskNotStartableError";
+    }
+  };
+  TaskReferenceAmbiguousError = class TaskReferenceAmbiguousError extends Error {
+    reference;
+    static code = "TASK_REFERENCE_AMBIGUOUS";
+    candidateTaskIds;
+    candidateProjectIds;
+    constructor(reference, candidates) {
+      const candidateTaskIds = [...new Set(candidates.map((candidate) => candidate.task_id))].sort();
+      const candidateProjectIds = [...new Set(candidates.map((candidate) => candidate.project_id).filter((projectId) => typeof projectId === "string" && projectId.length > 0))].sort();
+      const projectList = candidateProjectIds.length > 0 ? candidateProjectIds.join(", ") : "(unscoped)";
+      super(`Task reference is ambiguous: "${reference}". Candidate project IDs: ${projectList}. ` + "Use a full task UUID.");
+      this.reference = reference;
+      this.name = "TaskReferenceAmbiguousError";
+      this.candidateTaskIds = candidateTaskIds;
+      this.candidateProjectIds = candidateProjectIds;
+    }
+  };
+  ProjectNotFoundError = class ProjectNotFoundError extends Error {
+    projectId;
+    static code = "PROJECT_NOT_FOUND";
+    static suggestion = "Use list_projects to see available projects.";
+    constructor(projectId) {
+      super(`Project not found: ${projectId}`);
+      this.projectId = projectId;
+      this.name = "ProjectNotFoundError";
+    }
+  };
+  ResourceConflictError = class ResourceConflictError extends Error {
+    code;
+    constructor(code, message) {
+      super(message);
+      this.code = code;
+      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";
+    static suggestion = "Use list_plans to see available plans.";
+    constructor(planId) {
+      super(`Plan not found: ${planId}`);
+      this.planId = planId;
+      this.name = "PlanNotFoundError";
+    }
+  };
+  LockError = class LockError extends Error {
+    taskId;
+    lockedBy;
+    static code = "LOCK_ERROR";
+    static suggestion = "Wait for the lock to expire (30 min) or contact the lock holder.";
+    constructor(taskId, lockedBy) {
+      super(`Task ${taskId} is locked by ${lockedBy}`);
+      this.taskId = taskId;
+      this.lockedBy = lockedBy;
+      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";
+    static suggestion = "Use register_agent to create the agent first, or list_agents to find existing ones.";
+    constructor(agentId) {
+      super(`Agent not found: ${agentId}`);
+      this.agentId = agentId;
+      this.name = "AgentNotFoundError";
+    }
+  };
+  IdentityAliasAmbiguousError = class IdentityAliasAmbiguousError extends Error {
+    code = "IDENTITY_ALIAS_AMBIGUOUS";
+    candidates;
+    constructor(subject, candidates = []) {
+      super(`Identity alias or source is ambiguous: ${subject}`);
+      this.name = "IdentityAliasAmbiguousError";
+      this.candidates = [...new Set(candidates)].sort();
+    }
+  };
+  IdentityIdImmutableError = class IdentityIdImmutableError extends Error {
+    code = "IDENTITY_ID_IMMUTABLE";
+    constructor(agentId) {
+      super(`IDENTITY_ID_IMMUTABLE: canonical identity for agent ${agentId} cannot be replaced`);
+      this.name = "IdentityIdImmutableError";
+    }
+  };
+  TaskListNotFoundError = class TaskListNotFoundError extends Error {
+    taskListId;
+    static code = "TASK_LIST_NOT_FOUND";
+    static suggestion = "Use list_task_lists to see available lists.";
+    constructor(taskListId) {
+      super(`Task list not found: ${taskListId}`);
+      this.taskListId = taskListId;
+      this.name = "TaskListNotFoundError";
+    }
+  };
+  DependencyCycleError = class DependencyCycleError extends Error {
+    taskId;
+    dependsOn;
+    static code = "DEPENDENCY_CYCLE";
+    static suggestion = "Check the dependency chain with get_task to avoid circular references.";
+    constructor(taskId, dependsOn) {
+      super(`Adding dependency ${taskId} -> ${dependsOn} would create a cycle`);
+      this.taskId = taskId;
+      this.dependsOn = dependsOn;
+      this.name = "DependencyCycleError";
+    }
+  };
+  CompletionGuardError = class CompletionGuardError extends Error {
+    reason;
+    retryAfterSeconds;
+    static code = "COMPLETION_BLOCKED";
+    static suggestion = "Wait for the cooldown period, then retry.";
+    constructor(reason, retryAfterSeconds) {
+      super(reason);
+      this.reason = reason;
+      this.retryAfterSeconds = retryAfterSeconds;
+      this.name = "CompletionGuardError";
+    }
+  };
+  DISPATCH_STATUSES = ["pending", "sent", "failed", "cancelled"];
+  DispatchNotFoundError = class DispatchNotFoundError extends Error {
+    dispatchId;
+    static code = "DISPATCH_NOT_FOUND";
+    static suggestion = "Check the dispatch ID with list_dispatches.";
+    constructor(dispatchId) {
+      super(`Dispatch not found: ${dispatchId}`);
+      this.dispatchId = dispatchId;
+      this.name = "DispatchNotFoundError";
+    }
+  };
+});
+
 // src/lib/slugs.ts
 function normalizeSlug(value) {
   return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
@@ -165,6 +378,30 @@ function deriveTodosTaskSubtreeTransferIdempotencyKey(input) {
   }).slice(0, 48)}`;
 }
 
+// src/storage/postgres-sync.ts
+init_types();
+
+// src/storage/postgres-errors.ts
+function isPostgresUniqueViolation(error) {
+  if (typeof error !== "object" || error === null)
+    return false;
+  const candidate = error;
+  const states = [candidate.code, candidate.errno, candidate.sqlState, candidate.sqlstate];
+  if (typeof candidate.cause === "object" && candidate.cause !== null) {
+    const cause = candidate.cause;
+    states.push(cause.code, cause.errno, cause.sqlState, cause.sqlstate);
+  }
+  return states.some((state) => String(state) === "23505");
+}
+function postgresConstraintName(error) {
+  if (typeof error !== "object" || error === null)
+    return "";
+  const candidate = error;
+  const cause = typeof candidate.cause === "object" && candidate.cause !== null ? candidate.cause : undefined;
+  const constraint = candidate.constraint ?? candidate.constraint_name ?? cause?.constraint ?? cause?.constraint_name;
+  return typeof constraint === "string" ? constraint : "";
+}
+
 // src/storage/postgres-sync.ts
 var DEFAULT_TODOS_POSTGRES_SYNC_TABLE = "todos_sync_records";
 var DEFAULT_TODOS_POSTGRES_CURSOR_TABLE = "todos_sync_cursors";
@@ -367,53 +604,98 @@ class PostgresTodosSyncStore {
     if (routingErrors.length > 0) {
       throw new Error(`Invalid snapshot routing metadata: ${routingErrors.join("; ")}`);
     }
-    const existing = await this.client.query(`SELECT object_type, object_id, payload, updated_at, deleted_at, source_machine_id, version
-       FROM ${this.tableName}
-       WHERE service = $1 AND object_type IN ($2, $3) AND deleted_at IS NULL`, [this.service, "projects", "task_lists"]);
-    const existingProjects = [];
-    const existingTaskLists = [];
-    for (const row of existing.rows) {
-      const payload = payloadRecord(row.payload);
-      if (row.object_type === "projects")
-        existingProjects.push(payload);
-      if (row.object_type === "task_lists")
-        existingTaskLists.push(payload);
+    const push = async (client) => {
+      const existing = await client.query(`SELECT object_type, object_id, payload, updated_at, deleted_at, source_machine_id, version
+         FROM ${this.tableName}
+         WHERE service = $1 AND object_type IN ($2, $3) AND deleted_at IS NULL`, [this.service, "projects", "task_lists"]);
+      const existingProjects = [];
+      const existingTaskLists = [];
+      for (const row of existing.rows) {
+        const payload = payloadRecord(row.payload);
+        if (row.object_type === "projects")
+          existingProjects.push(payload);
+        if (row.object_type === "task_lists")
+          existingTaskLists.push(payload);
+      }
+      const destinationErrors = validateSnapshotRoutingDestinationConflicts(snapshot.projects, snapshot.taskLists, existingProjects, existingTaskLists);
+      if (destinationErrors.length > 0) {
+        throw new ResourceConflictError("SNAPSHOT_DESTINATION_CONFLICT", `Snapshot routing conflicts with destination: ${destinationErrors.join("; ")}`);
+      }
+      const result = { records: 0, objectTypes: {} };
+      const sourceMachineId = context.requestId ?? this.sourceMachineId ?? null;
+      for (const entry of snapshotEntries(snapshot)) {
+        if (entry.deletedAt === null)
+          assertCanonicalScopedSlugEntry(entry);
+        try {
+          await 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, $6::timestamptz, $7, $8)
+            ON CONFLICT (service, object_type, object_id) DO UPDATE SET
+              payload = EXCLUDED.payload,
+              updated_at = EXCLUDED.updated_at,
+              deleted_at = EXCLUDED.deleted_at,
+              source_machine_id = EXCLUDED.source_machine_id,
+              version = EXCLUDED.version
+            WHERE ${this.tableName}.updated_at < EXCLUDED.updated_at
+               OR (${this.tableName}.updated_at = EXCLUDED.updated_at
+                   AND COALESCE(${this.tableName}.version, 0) <= COALESCE(EXCLUDED.version, 0))`, [
+            this.service,
+            entry.type,
+            entry.id,
+            entry.payload,
+            entry.updatedAt,
+            entry.deletedAt,
+            sourceMachineId,
+            entry.version
+          ]);
+        } catch (error) {
+          await this.classifySyncInsertConflict(error, entry);
+        }
+        result.records += 1;
+        result.objectTypes[entry.type] = (result.objectTypes[entry.type] ?? 0) + 1;
+      }
+      return result;
+    };
+    if (typeof this.client.transaction === "function") {
+      return this.client.transaction((client) => push(client));
+    }
+    return push(this.client);
+  }
+  async classifySyncInsertConflict(error, entry) {
+    if (!isPostgresUniqueViolation(error))
+      throw error;
+    const payload = entry.payload;
+    const taskListSlug = String(payload["slug"] ?? "");
+    const projectSlug = String(payload["task_list_id"] ?? "");
+    const constraintName = postgresConstraintName(error);
+    if (entry.type === "projects" && constraintName.includes("project_task_list_slug_uidx")) {
+      throw new ResourceConflictError("PROJECT_SLUG_CONFLICT", `Project slug "${projectSlug}" already exists`);
     }
-    const destinationErrors = validateSnapshotRoutingDestinationConflicts(snapshot.projects, snapshot.taskLists, existingProjects, existingTaskLists);
-    if (destinationErrors.length > 0) {
-      throw new Error(`Snapshot routing conflicts with destination: ${destinationErrors.join("; ")}`);
+    if (entry.type === "task_lists" && constraintName.includes("task_list_scope_slug_uidx")) {
+      throw new ResourceConflictError("TASK_LIST_SLUG_CONFLICT", `Task list with slug "${taskListSlug}" already exists in this scope`);
     }
-    const result = { records: 0, objectTypes: {} };
-    const sourceMachineId = context.requestId ?? this.sourceMachineId ?? null;
-    for (const entry of snapshotEntries(snapshot)) {
-      if (entry.deletedAt === null)
-        assertCanonicalScopedSlugEntry(entry);
-      await this.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, $6::timestamptz, $7, $8)
-        ON CONFLICT (service, object_type, object_id) DO UPDATE SET
-          payload = EXCLUDED.payload,
-          updated_at = EXCLUDED.updated_at,
-          deleted_at = EXCLUDED.deleted_at,
-          source_machine_id = EXCLUDED.source_machine_id,
-          version = EXCLUDED.version
-        WHERE ${this.tableName}.updated_at < EXCLUDED.updated_at
-           OR (${this.tableName}.updated_at = EXCLUDED.updated_at
-               AND COALESCE(${this.tableName}.version, 0) <= COALESCE(EXCLUDED.version, 0))`, [
-        this.service,
-        entry.type,
-        entry.id,
-        entry.payload,
-        entry.updatedAt,
-        entry.deletedAt,
-        sourceMachineId,
-        entry.version
-      ]);
-      result.records += 1;
-      result.objectTypes[entry.type] = (result.objectTypes[entry.type] ?? 0) + 1;
+    if (entry.type === "task_lists") {
+      const scope = typeof payload["project_id"] === "string" ? payload["project_id"] : "";
+      const conflict = await this.client.query(`/* todos:classify-sync-task-list-conflict */ SELECT EXISTS (
+          SELECT 1 FROM ${this.tableName}
+          WHERE service = $1 AND object_type = 'task_lists' AND object_id <> $2
+            AND deleted_at IS NULL AND COALESCE(payload->>'project_id','') = $3 AND payload->>'slug' = $4
+        ) AS conflict`, [this.service, entry.id, scope, taskListSlug]);
+      if (conflict.rows[0]?.conflict) {
+        throw new ResourceConflictError("TASK_LIST_SLUG_CONFLICT", `Task list with slug "${taskListSlug}" already exists in this scope`);
+      }
+    } else if (entry.type === "projects") {
+      const conflict = await this.client.query(`/* todos:classify-sync-project-conflict */ SELECT EXISTS (
+          SELECT 1 FROM ${this.tableName}
+          WHERE service = $1 AND object_type = 'projects' AND object_id <> $2
+            AND deleted_at IS NULL AND payload->>'task_list_id' = $3
+        ) AS conflict`, [this.service, entry.id, projectSlug]);
+      if (conflict.rows[0]?.conflict) {
+        throw new ResourceConflictError("PROJECT_SLUG_CONFLICT", `Project slug "${projectSlug}" already exists`);
+      }
     }
-    return result;
+    throw error;
   }
   async pullSnapshot(options = {}) {
     const params = [this.service];

package/dist/types/index.d.ts

@@ -1219,8 +1219,8 @@ export declare class ProjectNotFoundError extends Error {
     constructor(projectId: string);
 }
 export declare class ResourceConflictError extends Error {
-    readonly code: "PROJECT_SLUG_CONFLICT" | "TASK_LIST_SLUG_CONFLICT" | "PLAN_SLUG_CONFLICT" | "PLAN_PROJECT_LINK_CONFLICT" | "TASK_PARENT_CYCLE" | "PROJECT_PARENT_CYCLE";
-    constructor(code: "PROJECT_SLUG_CONFLICT" | "TASK_LIST_SLUG_CONFLICT" | "PLAN_SLUG_CONFLICT" | "PLAN_PROJECT_LINK_CONFLICT" | "TASK_PARENT_CYCLE" | "PROJECT_PARENT_CYCLE", message: string);
+    readonly code: "PROJECT_SLUG_CONFLICT" | "TASK_LIST_SLUG_CONFLICT" | "PLAN_SLUG_CONFLICT" | "PLAN_PROJECT_LINK_CONFLICT" | "TASK_PARENT_CYCLE" | "PROJECT_PARENT_CYCLE" | "SNAPSHOT_DESTINATION_CONFLICT";
+    constructor(code: "PROJECT_SLUG_CONFLICT" | "TASK_LIST_SLUG_CONFLICT" | "PLAN_SLUG_CONFLICT" | "PLAN_PROJECT_LINK_CONFLICT" | "TASK_PARENT_CYCLE" | "PROJECT_PARENT_CYCLE" | "SNAPSHOT_DESTINATION_CONFLICT", message: string);
 }
 export declare class PlanRevisionConflictError extends Error {
     readonly planId: string;