@hasna/todos 0.11.88 → 0.11.90

package/dist/storage.js

@@ -247,7 +247,7 @@ var init_config = __esm(() => {
 });
 
 // src/types/index.ts
-var TASK_STATUSES, TASK_PRIORITIES, PLAN_STATUSES, VersionConflictError, TaskNotFoundError, ProjectNotFoundError, PlanNotFoundError, LockError, AgentNotFoundError, TaskListNotFoundError, DependencyCycleError, CompletionGuardError, DISPATCH_STATUSES, DispatchNotFoundError;
+var TASK_STATUSES, TASK_PRIORITIES, PLAN_STATUSES, VersionConflictError, TaskNotFoundError, ProjectNotFoundError, ResourceConflictError, PlanNotFoundError, LockError, AgentNotFoundError, TaskListNotFoundError, DependencyCycleError, CompletionGuardError, DISPATCH_STATUSES, DispatchNotFoundError;
 var init_types = __esm(() => {
   TASK_STATUSES = [
     "pending",
@@ -297,6 +297,14 @@ var init_types = __esm(() => {
       this.name = "ProjectNotFoundError";
     }
   };
+  ResourceConflictError = class ResourceConflictError extends Error {
+    code;
+    constructor(code, message) {
+      super(message);
+      this.code = code;
+      this.name = "ResourceConflictError";
+    }
+  };
   PlanNotFoundError = class PlanNotFoundError extends Error {
     planId;
     static code = "PLAN_NOT_FOUND";
@@ -2085,6 +2093,95 @@ function ensureSchema(db) {
     )`);
   ensureIndex("CREATE INDEX IF NOT EXISTS idx_project_machine_paths_project ON project_machine_paths(project_id)");
   ensureIndex("CREATE INDEX IF NOT EXISTS idx_project_machine_paths_machine ON project_machine_paths(machine_id)");
+  ensureTable("canonical_slug_claims", `
+    CREATE TABLE canonical_slug_claims (
+      kind TEXT NOT NULL CHECK(kind IN ('project', 'task_list')),
+      scope_key TEXT NOT NULL,
+      slug TEXT NOT NULL,
+      object_id TEXT NOT NULL,
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      PRIMARY KEY (kind, scope_key, slug)
+    )`);
+  ensureIndex("CREATE INDEX IF NOT EXISTS idx_canonical_slug_claims_object ON canonical_slug_claims(kind, object_id)");
+  ensureColumn("projects", "task_list_id", "TEXT");
+  db.exec(`CREATE TRIGGER IF NOT EXISTS claim_project_canonical_slug_insert
+    BEFORE INSERT ON projects
+    WHEN NEW.task_list_id IS NOT NULL AND NEW.task_list_id <> ''
+    BEGIN
+      SELECT CASE WHEN EXISTS (
+        SELECT 1 FROM projects WHERE id <> NEW.id AND task_list_id = NEW.task_list_id
+      ) THEN RAISE(ABORT, 'PROJECT_SLUG_CONFLICT') END;
+      INSERT OR IGNORE INTO canonical_slug_claims(kind, scope_key, slug, object_id)
+        VALUES ('project', 'global', NEW.task_list_id, NEW.id);
+      SELECT CASE WHEN (
+        SELECT object_id FROM canonical_slug_claims
+        WHERE kind = 'project' AND scope_key = 'global' AND slug = NEW.task_list_id
+      ) <> NEW.id THEN RAISE(ABORT, 'PROJECT_SLUG_CONFLICT') END;
+    END`);
+  db.exec(`CREATE TRIGGER IF NOT EXISTS claim_project_canonical_slug_update
+    BEFORE UPDATE OF task_list_id ON projects
+    WHEN NEW.task_list_id IS NOT OLD.task_list_id
+    BEGIN
+      DELETE FROM canonical_slug_claims WHERE kind = 'project' AND object_id = NEW.id;
+      SELECT CASE WHEN EXISTS (
+        SELECT 1 FROM projects WHERE id <> NEW.id AND task_list_id = NEW.task_list_id
+      ) AND NEW.task_list_id IS NOT NULL AND NEW.task_list_id <> ''
+        THEN RAISE(ABORT, 'PROJECT_SLUG_CONFLICT') END;
+      INSERT OR IGNORE INTO canonical_slug_claims(kind, scope_key, slug, object_id)
+        SELECT 'project', 'global', NEW.task_list_id, NEW.id
+        WHERE NEW.task_list_id IS NOT NULL AND NEW.task_list_id <> '';
+      SELECT CASE WHEN NEW.task_list_id IS NOT NULL AND NEW.task_list_id <> '' AND (
+        SELECT object_id FROM canonical_slug_claims
+        WHERE kind = 'project' AND scope_key = 'global' AND slug = NEW.task_list_id
+      ) <> NEW.id THEN RAISE(ABORT, 'PROJECT_SLUG_CONFLICT') END;
+    END`);
+  db.exec(`CREATE TRIGGER IF NOT EXISTS release_project_canonical_slug_delete
+    AFTER DELETE ON projects
+    BEGIN
+      DELETE FROM canonical_slug_claims WHERE kind = 'project' AND object_id = OLD.id;
+    END`);
+  db.exec(`CREATE TRIGGER IF NOT EXISTS claim_task_list_canonical_slug_insert
+    BEFORE INSERT ON task_lists
+    WHEN NEW.slug IS NOT NULL AND NEW.slug <> ''
+    BEGIN
+      SELECT CASE WHEN EXISTS (
+        SELECT 1 FROM task_lists
+        WHERE id <> NEW.id AND project_id IS NEW.project_id AND slug = NEW.slug
+      ) THEN RAISE(ABORT, 'TASK_LIST_SLUG_CONFLICT') END;
+      INSERT OR IGNORE INTO canonical_slug_claims(kind, scope_key, slug, object_id)
+        VALUES ('task_list', CASE WHEN NEW.project_id IS NULL THEN 'standalone:' ELSE 'project:' || NEW.project_id END, NEW.slug, NEW.id);
+      SELECT CASE WHEN (
+        SELECT object_id FROM canonical_slug_claims
+        WHERE kind = 'task_list'
+          AND scope_key = CASE WHEN NEW.project_id IS NULL THEN 'standalone:' ELSE 'project:' || NEW.project_id END
+          AND slug = NEW.slug
+      ) <> NEW.id THEN RAISE(ABORT, 'TASK_LIST_SLUG_CONFLICT') END;
+    END`);
+  db.exec(`CREATE TRIGGER IF NOT EXISTS claim_task_list_canonical_slug_update
+    BEFORE UPDATE OF slug, project_id ON task_lists
+    WHEN NEW.slug IS NOT OLD.slug OR NEW.project_id IS NOT OLD.project_id
+    BEGIN
+      DELETE FROM canonical_slug_claims WHERE kind = 'task_list' AND object_id = NEW.id;
+      SELECT CASE WHEN EXISTS (
+        SELECT 1 FROM task_lists
+        WHERE id <> NEW.id AND project_id IS NEW.project_id AND slug = NEW.slug
+      ) AND NEW.slug IS NOT NULL AND NEW.slug <> ''
+        THEN RAISE(ABORT, 'TASK_LIST_SLUG_CONFLICT') END;
+      INSERT OR IGNORE INTO canonical_slug_claims(kind, scope_key, slug, object_id)
+        SELECT 'task_list', CASE WHEN NEW.project_id IS NULL THEN 'standalone:' ELSE 'project:' || NEW.project_id END, NEW.slug, NEW.id
+        WHERE NEW.slug IS NOT NULL AND NEW.slug <> '';
+      SELECT CASE WHEN NEW.slug IS NOT NULL AND NEW.slug <> '' AND (
+        SELECT object_id FROM canonical_slug_claims
+        WHERE kind = 'task_list'
+          AND scope_key = CASE WHEN NEW.project_id IS NULL THEN 'standalone:' ELSE 'project:' || NEW.project_id END
+          AND slug = NEW.slug
+      ) <> NEW.id THEN RAISE(ABORT, 'TASK_LIST_SLUG_CONFLICT') END;
+    END`);
+  db.exec(`CREATE TRIGGER IF NOT EXISTS release_task_list_canonical_slug_delete
+    AFTER DELETE ON task_lists
+    BEGIN
+      DELETE FROM canonical_slug_claims WHERE kind = 'task_list' AND object_id = OLD.id;
+    END`);
   ensureTable("storage_tombstones", `
     CREATE TABLE storage_tombstones (
       id TEXT PRIMARY KEY,
@@ -3496,9 +3593,94 @@ var init_storage_tombstones = __esm(() => {
   init_machines();
 });
 
+// src/lib/slugs.ts
+function normalizeSlug(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+function isCanonicalSlug(value) {
+  return typeof value === "string" && value.length > 0 && normalizeSlug(value) === value;
+}
+function isValidTaskListProjectScope(value) {
+  return value === undefined || value === null || typeof value === "string" && value.trim().length > 0;
+}
+function validateSnapshotRoutingRecords(projects, taskLists) {
+  const errors = [];
+  const projectSlugs = new Map;
+  const taskListSlugs = new Map;
+  for (const project of projects) {
+    if (!isCanonicalSlug(project.task_list_id)) {
+      errors.push(`project ${project.id}: task_list_id must be non-empty canonical kebab-case`);
+      continue;
+    }
+    const existing = projectSlugs.get(project.task_list_id);
+    if (projectSlugs.has(project.task_list_id)) {
+      errors.push(`project ${project.id}: task_list_id duplicates project ${existing}: ${project.task_list_id}`);
+    } else {
+      projectSlugs.set(project.task_list_id, project.id);
+    }
+  }
+  for (const taskList of taskLists) {
+    if (!isCanonicalSlug(taskList.slug)) {
+      errors.push(`task list ${taskList.id}: slug must be non-empty canonical kebab-case`);
+      continue;
+    }
+    if (!isValidTaskListProjectScope(taskList.project_id)) {
+      errors.push(`task list ${taskList.id}: project_id must be null, missing, or a non-empty string`);
+      continue;
+    }
+    const scope = taskList.project_id ?? null;
+    const scopedSlugs = taskListSlugs.get(scope) ?? new Map;
+    const existing = scopedSlugs.get(taskList.slug);
+    if (scopedSlugs.has(taskList.slug)) {
+      errors.push(`task list ${taskList.id}: slug duplicates task list ${existing} in the same scope: ${taskList.slug}`);
+    } else {
+      scopedSlugs.set(taskList.slug, taskList.id);
+      taskListSlugs.set(scope, scopedSlugs);
+    }
+  }
+  return errors;
+}
+function validateSnapshotRoutingDestinationConflicts(projects, taskLists, existingProjects, existingTaskLists) {
+  const errors = [];
+  for (const project of projects) {
+    const current = existingProjects.find((candidate) => candidate.id === project.id);
+    if (current?.task_list_id === project.task_list_id)
+      continue;
+    const conflict = existingProjects.find((candidate) => candidate.id !== project.id && candidate.task_list_id === project.task_list_id);
+    if (conflict) {
+      errors.push(`project ${project.id}: task_list_id conflicts with existing project ${conflict.id}: ${String(project.task_list_id)}`);
+    }
+  }
+  for (const taskList of taskLists) {
+    const projectId = taskList.project_id ?? null;
+    const current = existingTaskLists.find((candidate) => candidate.id === taskList.id);
+    if ((current?.project_id ?? null) === projectId && current?.slug === taskList.slug)
+      continue;
+    const conflict = existingTaskLists.find((candidate) => candidate.id !== taskList.id && (candidate.project_id ?? null) === projectId && candidate.slug === taskList.slug);
+    if (conflict) {
+      errors.push(`task list ${taskList.id}: slug conflicts with existing task list ${conflict.id} in the same scope: ${String(taskList.slug)}`);
+    }
+  }
+  return errors;
+}
+
+// src/db/slug-claims.ts
+function taskListSlugScopeKey(projectId) {
+  return projectId ? `project:${projectId}` : "standalone:";
+}
+function claimCanonicalSlug(kind, scopeKey, slug, objectId, db) {
+  db.run(`INSERT OR IGNORE INTO canonical_slug_claims (kind, scope_key, slug, object_id)
+     VALUES (?, ?, ?, ?)`, [kind, scopeKey, slug, objectId]);
+  const claim = db.query("SELECT object_id FROM canonical_slug_claims WHERE kind = ? AND scope_key = ? AND slug = ?").get(kind, scopeKey, slug);
+  return claim?.object_id === objectId;
+}
+function releaseCanonicalSlugClaims(kind, objectId, db) {
+  db.run("DELETE FROM canonical_slug_claims WHERE kind = ? AND object_id = ?", [kind, objectId]);
+}
+
 // src/db/projects.ts
 function slugify(name) {
-  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+  return normalizeSlug(name);
 }
 function generatePrefix(name, db) {
   const words = name.replace(/[^a-zA-Z0-9\s]/g, "").trim().split(/\s+/);
@@ -3522,14 +3704,23 @@ function generatePrefix(name, db) {
 }
 function createProject(input, db) {
   const d = db || getDatabase();
-  const id = uuid();
-  const timestamp = now();
-  const taskListId = input.task_list_id ?? `todos-${slugify(input.name)}`;
-  const taskPrefix = input.task_prefix || generatePrefix(input.name, d);
-  const machineId = currentStorageMachineId(d);
-  d.run(`INSERT INTO projects (id, name, path, description, task_list_id, task_prefix, task_counter, created_at, updated_at, machine_id)
-     VALUES (?, ?, ?, ?, ?, ?, 0, ?, ?, ?)`, [id, input.name, input.path, input.description || null, taskListId, taskPrefix, timestamp, timestamp, machineId]);
-  return getProject(id, d);
+  return d.transaction(() => {
+    const id = uuid();
+    const timestamp = now();
+    const derivedSlug = slugify(input.name);
+    const taskListId = input.task_list_id === undefined ? `todos-${derivedSlug}` : slugify(input.task_list_id);
+    if (!derivedSlug || !taskListId)
+      throw new Error("Project name and task-list slug must be non-empty");
+    const slugConflict = d.query("SELECT id FROM projects WHERE task_list_id = ? LIMIT 1").get(taskListId);
+    if (slugConflict || !claimCanonicalSlug("project", "global", taskListId, id, d)) {
+      throw new ResourceConflictError("PROJECT_SLUG_CONFLICT", `Project slug "${taskListId}" already exists`);
+    }
+    const taskPrefix = input.task_prefix || generatePrefix(input.name, d);
+    const machineId = currentStorageMachineId(d);
+    d.run(`INSERT INTO projects (id, name, path, description, task_list_id, task_prefix, task_counter, created_at, updated_at, machine_id)
+       VALUES (?, ?, ?, ?, ?, ?, 0, ?, ?, ?)`, [id, input.name, input.path, input.description || null, taskListId, taskPrefix, timestamp, timestamp, machineId]);
+    return getProject(id, d);
+  })();
 }
 function getProject(id, db) {
   const d = db || getDatabase();
@@ -3557,6 +3748,9 @@ function updateProject(id, input, db) {
   const project = getProject(id, d);
   if (!project)
     throw new ProjectNotFoundError(id);
+  if ("task_list_id" in input) {
+    throw new Error("task_list_id cannot be changed by updateProject; use renameProject for an atomic canonical rename");
+  }
   const sets = ["updated_at = ?"];
   const params = [now()];
   if (input.name !== undefined) {
@@ -3567,10 +3761,6 @@ function updateProject(id, input, db) {
     sets.push("description = ?");
     params.push(input.description);
   }
-  if (input.task_list_id !== undefined) {
-    sets.push("task_list_id = ?");
-    params.push(input.task_list_id);
-  }
   if (input.path !== undefined) {
     sets.push("path = ?");
     params.push(input.path);
@@ -3581,29 +3771,41 @@ function updateProject(id, input, db) {
 }
 function renameProject(id, input, db) {
   const d = db || getDatabase();
-  const project = getProject(id, d);
-  if (!project)
-    throw new ProjectNotFoundError(id);
-  let taskListsUpdated = 0;
-  const ts = now();
-  if (input.new_slug !== undefined) {
-    const normalised = input.new_slug.toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-|-$/g, "");
-    if (!normalised)
-      throw new Error("Invalid slug \u2014 must be non-empty kebab-case");
-    const conflict = d.query("SELECT id FROM projects WHERE task_list_id = ? AND id != ?").get(normalised, id);
-    if (conflict)
-      throw new Error(`Slug "${normalised}" is already used by another project`);
-    const oldSlug = project.task_list_id;
-    d.run("UPDATE projects SET task_list_id = ?, updated_at = ? WHERE id = ?", [normalised, ts, id]);
-    if (oldSlug) {
-      const result = d.run("UPDATE task_lists SET slug = ?, name = COALESCE(?, name), updated_at = ? WHERE project_id = ? AND slug = ?", [normalised, input.name ?? null, ts, id, oldSlug]);
-      taskListsUpdated = result.changes;
+  return d.transaction(() => {
+    const project = getProject(id, d);
+    if (!project)
+      throw new ProjectNotFoundError(id);
+    let taskListsUpdated = 0;
+    const ts = now();
+    if (input.new_slug !== undefined) {
+      const normalised = normalizeSlug(input.new_slug);
+      if (!normalised)
+        throw new Error("Invalid slug \u2014 must be non-empty kebab-case");
+      const oldSlug = project.task_list_id;
+      if (normalised !== oldSlug) {
+        const conflict = d.query("SELECT id FROM projects WHERE task_list_id = ? AND id != ?").get(normalised, id);
+        if (conflict) {
+          throw new ResourceConflictError("PROJECT_SLUG_CONFLICT", `Slug "${normalised}" is already used by another project`);
+        }
+        const taskListConflict = d.query("SELECT id FROM task_lists WHERE project_id = ? AND slug = ? AND slug != COALESCE(?, '') LIMIT 1").get(id, normalised, oldSlug);
+        if (taskListConflict) {
+          throw new ResourceConflictError("TASK_LIST_SLUG_CONFLICT", `Task-list slug "${normalised}" is already used in project "${project.name}"`);
+        }
+        releaseCanonicalSlugClaims("project", id, d);
+        if (!claimCanonicalSlug("project", "global", normalised, id, d)) {
+          throw new ResourceConflictError("PROJECT_SLUG_CONFLICT", `Slug "${normalised}" is already used by another project`);
+        }
+        d.run("UPDATE projects SET task_list_id = ?, updated_at = ? WHERE id = ?", [normalised, ts, id]);
+      }
+      if (oldSlug && (normalised !== oldSlug || input.name !== undefined && input.name !== project.name)) {
+        taskListsUpdated = d.query("UPDATE task_lists SET slug = ?, name = COALESCE(?, name), updated_at = ? WHERE project_id = ? AND slug = ? RETURNING id").all(normalised, input.name ?? null, ts, id, oldSlug).length;
+      }
     }
-  }
-  if (input.name !== undefined) {
-    d.run("UPDATE projects SET name = ?, updated_at = ? WHERE id = ?", [input.name, ts, id]);
-  }
-  return { project: getProject(id, d), task_lists_updated: taskListsUpdated };
+    if (input.name !== undefined && input.name !== project.name) {
+      d.run("UPDATE projects SET name = ?, updated_at = ? WHERE id = ?", [input.name, ts, id]);
+    }
+    return { project: getProject(id, d), task_lists_updated: taskListsUpdated };
+  })();
 }
 function deleteProject(id, db) {
   const d = db || getDatabase();
@@ -3615,8 +3817,10 @@ function deleteProject(id, db) {
     object_id: id,
     payload: project
   }, d);
-  const result = d.run("DELETE FROM projects WHERE id = ?", [id]);
-  return result.changes > 0;
+  return d.transaction(() => {
+    releaseCanonicalSlugClaims("project", id, d);
+    return d.run("DELETE FROM projects WHERE id = ?", [id]).changes > 0;
+  })();
 }
 function rowToSource(row) {
   return {
@@ -5175,19 +5379,22 @@ function rowToTaskList(row) {
 }
 function createTaskList(input, db) {
   const d = db || getDatabase();
-  const id = uuid();
-  const timestamp = now();
-  const slug = input.slug || slugify(input.name);
-  const machineId = currentStorageMachineId(d);
-  if (!input.project_id) {
-    const existing = d.query("SELECT id FROM task_lists WHERE project_id IS NULL AND slug = ?").get(slug);
-    if (existing) {
-      throw new Error(`Standalone task list with slug "${slug}" already exists`);
-    }
-  }
-  d.run(`INSERT INTO task_lists (id, project_id, slug, name, description, metadata, created_at, updated_at, machine_id)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`, [id, input.project_id || null, slug, input.name, input.description || null, JSON.stringify(input.metadata || {}), timestamp, timestamp, machineId]);
-  return getTaskList(id, d);
+  return d.transaction(() => {
+    const id = uuid();
+    const timestamp = now();
+    const slug = normalizeSlug(input.slug === undefined ? input.name : input.slug);
+    if (!slug)
+      throw new Error("Invalid task-list slug \u2014 must be non-empty kebab-case");
+    const machineId = currentStorageMachineId(d);
+    const scopeKey = taskListSlugScopeKey(input.project_id);
+    const existing = input.project_id ? d.query("SELECT id FROM task_lists WHERE project_id = ? AND slug = ?").get(input.project_id, slug) : d.query("SELECT id FROM task_lists WHERE project_id IS NULL AND slug = ?").get(slug);
+    if (existing || !claimCanonicalSlug("task_list", scopeKey, slug, id, d)) {
+      throw new ResourceConflictError("TASK_LIST_SLUG_CONFLICT", `Task list with slug "${slug}" already exists in this scope`);
+    }
+    d.run(`INSERT INTO task_lists (id, project_id, slug, name, description, metadata, created_at, updated_at, machine_id)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`, [id, input.project_id || null, slug, input.name, input.description || null, JSON.stringify(input.metadata || {}), timestamp, timestamp, machineId]);
+    return getTaskList(id, d);
+  })();
 }
 function getTaskList(id, db) {
   const d = db || getDatabase();
@@ -5213,26 +5420,45 @@ function listTaskLists(projectId, db) {
 }
 function updateTaskList(id, input, db) {
   const d = db || getDatabase();
-  const existing = getTaskList(id, d);
-  if (!existing)
-    throw new TaskListNotFoundError(id);
-  const sets = ["updated_at = ?"];
-  const params = [now()];
-  if (input.name !== undefined) {
-    sets.push("name = ?");
-    params.push(input.name);
-  }
-  if (input.description !== undefined) {
-    sets.push("description = ?");
-    params.push(input.description);
-  }
-  if (input.metadata !== undefined) {
-    sets.push("metadata = ?");
-    params.push(JSON.stringify(input.metadata));
-  }
-  params.push(id);
-  d.run(`UPDATE task_lists SET ${sets.join(", ")} WHERE id = ?`, params);
-  return getTaskList(id, d);
+  return d.transaction(() => {
+    const existing = getTaskList(id, d);
+    if (!existing)
+      throw new TaskListNotFoundError(id);
+    const sets = ["updated_at = ?"];
+    const params = [now()];
+    if (input.slug !== undefined) {
+      const slug = slugify(input.slug);
+      if (!slug)
+        throw new Error("Invalid task-list slug \u2014 must be non-empty kebab-case");
+      const duplicate = existing.project_id ? d.query("SELECT id FROM task_lists WHERE project_id = ? AND slug = ? AND id != ?").get(existing.project_id, slug, id) : d.query("SELECT id FROM task_lists WHERE project_id IS NULL AND slug = ? AND id != ?").get(slug, id);
+      if (duplicate) {
+        throw new ResourceConflictError("TASK_LIST_SLUG_CONFLICT", `Task list with slug "${slug}" already exists in this scope`);
+      }
+      if (slug !== existing.slug) {
+        releaseCanonicalSlugClaims("task_list", id, d);
+        if (!claimCanonicalSlug("task_list", taskListSlugScopeKey(existing.project_id), slug, id, d)) {
+          throw new ResourceConflictError("TASK_LIST_SLUG_CONFLICT", `Task list with slug "${slug}" already exists in this scope`);
+        }
+      }
+      sets.push("slug = ?");
+      params.push(slug);
+    }
+    if (input.name !== undefined) {
+      sets.push("name = ?");
+      params.push(input.name);
+    }
+    if (input.description !== undefined) {
+      sets.push("description = ?");
+      params.push(input.description);
+    }
+    if (input.metadata !== undefined) {
+      sets.push("metadata = ?");
+      params.push(JSON.stringify(input.metadata));
+    }
+    params.push(id);
+    d.run(`UPDATE task_lists SET ${sets.join(", ")} WHERE id = ?`, params);
+    return getTaskList(id, d);
+  })();
 }
 function deleteTaskList(id, db) {
   const d = db || getDatabase();
@@ -5244,7 +5470,10 @@ function deleteTaskList(id, db) {
     object_id: id,
     payload: list
   }, d);
-  return d.run("DELETE FROM task_lists WHERE id = ?", [id]).changes > 0;
+  return d.transaction(() => {
+    releaseCanonicalSlugClaims("task_list", id, d);
+    return d.run("DELETE FROM task_lists WHERE id = ?", [id]).changes > 0;
+  })();
 }
 function ensureTaskList(name, slug, projectId, db) {
   const d = db || getDatabase();
@@ -11364,6 +11593,14 @@ function importSqliteTodosStorageSnapshot(snapshot, db) {
     skipped: 0,
     errors: []
   };
+  result.errors.push(...validateSnapshotRoutingRecords(snapshot.projects, snapshot.taskLists));
+  if (result.errors.length === 0) {
+    const existingProjects = d.query("SELECT id, task_list_id FROM projects").all();
+    const existingTaskLists = d.query("SELECT id, project_id, slug FROM task_lists").all();
+    result.errors.push(...validateSnapshotRoutingDestinationConflicts(snapshot.projects, snapshot.taskLists, existingProjects, existingTaskLists));
+  }
+  if (result.errors.length > 0)
+    return result;
   const applyRows = (objectType, table, columns, rows, updateClockColumn, afterUpsert) => {
     for (const row of rows) {
       try {
@@ -11571,6 +11808,7 @@ function createLocalSqliteTodosStorageAdapter(options = {}) {
       getByPath: (path) => getProjectByPath(path, database()),
       list: () => listProjects(database()),
       update: (id, input) => updateProject(id, input, database()),
+      rename: (id, input) => renameProject(id, input, database()),
       delete: (id) => deleteProject(id, database())
     },
     plans: {
@@ -11668,6 +11906,110 @@ function postgresTodosSyncSchemaSql(tableName = DEFAULT_TODOS_POSTGRES_SYNC_TABL
     )`
   ];
 }
+
+class PostgresScopedSlugMigrationConflictError extends Error {
+  conflicts;
+  constructor(conflicts) {
+    const preview = conflicts.slice(0, 5).map((conflict) => `${conflict.object_type}:${conflict.scope || "global"}:${conflict.slug} [${conflict.object_ids.join(", ")}]`).join("; ");
+    super(`Scoped slug unique-index preflight found ${conflicts.length} invalid or duplicate slug conflict(s): ${preview}. ` + "Resolve these records explicitly without deleting history, then rerun todos-serve migrate.");
+    this.conflicts = conflicts;
+    this.name = "PostgresScopedSlugMigrationConflictError";
+  }
+}
+
+class PostgresScopedSlugIndexBuildError extends Error {
+  index_name;
+  constructor(index_name, cause) {
+    super(`Concurrent scoped-slug index build failed for ${index_name} after a clean duplicate audit. ` + "No records were rewritten; inspect pg_index for an invalid index, resolve any concurrent duplicate, and rerun todos-serve migrate.", { cause });
+    this.index_name = index_name;
+    this.name = "PostgresScopedSlugIndexBuildError";
+  }
+}
+function postgresTodosScopedSlugPreflightSql(tableName = DEFAULT_TODOS_POSTGRES_SYNC_TABLE) {
+  assertSafeIdentifier(tableName);
+  return `/* todos:scoped-slug-duplicate-audit */ WITH candidates AS (
+    SELECT service, object_type, COALESCE(payload->>'project_id', '') AS scope,
+      jsonb_typeof(payload->'project_id') AS scope_type,
+      payload->>'slug' AS slug, jsonb_typeof(payload->'slug') AS slug_type, object_id
+    FROM ${tableName}
+    WHERE object_type = 'task_lists' AND deleted_at IS NULL
+    UNION ALL
+    SELECT service, object_type, '' AS scope, NULL::text AS scope_type, payload->>'task_list_id' AS slug,
+      jsonb_typeof(payload->'task_list_id') AS slug_type, object_id
+    FROM ${tableName}
+    WHERE object_type = 'projects' AND deleted_at IS NULL
+  ), annotated AS (
+    SELECT *, trim(both '-' from regexp_replace(lower(COALESCE(slug, '')), '[^a-z0-9]+', '-', 'g')) AS normalized_slug
+    FROM candidates
+  ), invalid AS (
+    SELECT service, object_type, scope, COALESCE(slug, '<null>') AS slug,
+      ARRAY[object_id] AS object_ids, 1::integer AS duplicate_count, 'invalid'::text AS issue
+    FROM annotated
+    WHERE slug_type IS DISTINCT FROM 'string'
+      OR slug IS NULL OR slug = '' OR normalized_slug = '' OR slug IS DISTINCT FROM normalized_slug
+      OR (object_type = 'task_lists' AND (
+        (scope_type IS NOT NULL AND scope_type NOT IN ('string', 'null'))
+        OR (scope_type = 'string' AND btrim(scope) = '')
+      ))
+  ), duplicates AS (
+    SELECT service, object_type, scope, slug,
+      array_agg(object_id ORDER BY object_id) AS object_ids,
+      count(*)::integer AS duplicate_count, 'duplicate'::text AS issue
+    FROM annotated
+    WHERE slug = normalized_slug AND slug <> ''
+    GROUP BY service, object_type, scope, slug
+    HAVING count(*) > 1
+  ) SELECT * FROM invalid
+    UNION ALL SELECT * FROM duplicates
+    ORDER BY service, object_type, scope, slug`;
+}
+function postgresTodosScopedSlugUniqueIndexSql(tableName = DEFAULT_TODOS_POSTGRES_SYNC_TABLE) {
+  assertSafeIdentifier(tableName);
+  return [
+    `CREATE UNIQUE INDEX CONCURRENTLY IF NOT EXISTS ${tableName}_task_list_scope_slug_uidx
+      ON ${tableName} (service, COALESCE(payload->>'project_id', ''), (payload->>'slug'))
+      WHERE object_type = 'task_lists' AND deleted_at IS NULL AND COALESCE(payload->>'slug', '') <> ''`,
+    `CREATE UNIQUE INDEX CONCURRENTLY IF NOT EXISTS ${tableName}_project_task_list_slug_uidx
+      ON ${tableName} (service, (payload->>'task_list_id'))
+      WHERE object_type = 'projects' AND deleted_at IS NULL AND COALESCE(payload->>'task_list_id', '') <> ''`
+  ];
+}
+function postgresTodosScopedSlugIndexStatusSql(tableName = DEFAULT_TODOS_POSTGRES_SYNC_TABLE) {
+  assertSafeIdentifier(tableName);
+  return `/* todos:scoped-slug-index-status */ SELECT index_class.relname AS index_name,
+      index_meta.indisvalid AS is_valid, index_meta.indisready AS is_ready
+    FROM pg_index index_meta
+    JOIN pg_class index_class ON index_class.oid = index_meta.indexrelid
+    WHERE index_meta.indrelid = to_regclass('${tableName}')
+      AND index_class.relname IN (
+        '${tableName}_task_list_scope_slug_uidx',
+        '${tableName}_project_task_list_slug_uidx'
+      )`;
+}
+async function ensurePostgresScopedSlugUniqueIndexes(client, tableName = DEFAULT_TODOS_POSTGRES_SYNC_TABLE) {
+  const audit = await client.query(postgresTodosScopedSlugPreflightSql(tableName));
+  if (audit.rows.length > 0)
+    throw new PostgresScopedSlugMigrationConflictError(audit.rows);
+  for (const sql of postgresTodosScopedSlugUniqueIndexSql(tableName)) {
+    try {
+      await client.query(sql);
+    } catch (error) {
+      const indexName = sql.match(/INDEX CONCURRENTLY IF NOT EXISTS ([a-zA-Z0-9_]+)/)?.[1] ?? "unknown_index";
+      throw new PostgresScopedSlugIndexBuildError(indexName, error);
+    }
+  }
+  const expected = new Set([
+    `${tableName}_task_list_scope_slug_uidx`,
+    `${tableName}_project_task_list_slug_uidx`
+  ]);
+  const status = await client.query(postgresTodosScopedSlugIndexStatusSql(tableName));
+  for (const indexName of expected) {
+    const row = status.rows.find((candidate) => candidate.index_name === indexName);
+    if (!row?.is_valid || !row.is_ready) {
+      throw new PostgresScopedSlugIndexBuildError(indexName, new Error("index is missing, invalid, or not ready"));
+    }
+  }
+}
 function postgresTodosCommentCursorIndexSql(tableName = DEFAULT_TODOS_POSTGRES_SYNC_TABLE) {
   assertSafeIdentifier(tableName);
   return `CREATE INDEX CONCURRENTLY IF NOT EXISTS ${tableName}_comment_task_created_idx
@@ -11696,9 +12038,31 @@ class PostgresTodosSyncStore {
     }
   }
   async pushSnapshot(snapshot, context = {}) {
+    const routingErrors = validateSnapshotRoutingRecords(snapshot.projects, snapshot.taskLists);
+    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
@@ -11777,6 +12141,22 @@ function snapshotEntries(snapshot) {
     }))
   ];
 }
+function assertCanonicalScopedSlugEntry(entry) {
+  if (!entry.payload || typeof entry.payload !== "object" || Array.isArray(entry.payload))
+    return;
+  const payload = entry.payload;
+  if (entry.type === "projects" && !isCanonicalSlug(payload["task_list_id"])) {
+    throw new Error("Invalid project task-list slug \u2014 sync requires non-empty canonical kebab-case");
+  }
+  if (entry.type === "task_lists") {
+    if (!isCanonicalSlug(payload["slug"])) {
+      throw new Error("Invalid task-list slug \u2014 sync requires non-empty canonical kebab-case");
+    }
+    if (!isValidTaskListProjectScope(payload["project_id"])) {
+      throw new Error("Invalid task-list project scope \u2014 project_id must be null, missing, or a non-empty string");
+    }
+  }
+}
 function entry(type, payload, fallbackUpdatedAt) {
   const id = payload["id"];
   if (typeof id !== "string" || !id)
@@ -11964,6 +12344,7 @@ function createPostgresTodosStorageAdapter(options) {
       getByPath: async (path) => (await store.list("projects")).find((project) => project.path === path) ?? null,
       list: async () => (await store.list("projects")).sort((a, b) => a.name.localeCompare(b.name)),
       update: (id, input) => updateProject2(id, input, store),
+      rename: (id, input, context) => store.renameProject(id, input.new_slug, input.name, context),
       delete: (id, context) => store.delete("projects", id, context)
     },
     plans: {
@@ -12201,9 +12582,22 @@ class PostgresJsonRecordStore {
     });
   }
   async upsert(type, value, context = {}) {
+    if (type === "projects" && !isCanonicalSlug(value.task_list_id)) {
+      throw new Error("Invalid project task-list slug \u2014 imports require non-empty canonical kebab-case");
+    }
+    if (type === "task_lists") {
+      if (!isCanonicalSlug(value.slug)) {
+        throw new Error("Invalid task-list slug \u2014 imports require non-empty canonical kebab-case");
+      }
+      if (!isValidTaskListProjectScope(value.project_id)) {
+        throw new Error("Invalid task-list project scope \u2014 project_id must be null, missing, or a non-empty string");
+      }
+    }
     await this.ensureSchema();
     const updatedAt = stringValue2(value.updated_at) ?? stringValue2(value.created_at) ?? new Date().toISOString();
-    const result = await this.options.client.query(`INSERT INTO ${this.tableName} (
+    let result;
+    try {
+      result = 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, $7)
@@ -12218,14 +12612,23 @@ class PostgresJsonRecordStore {
          OR (${this.tableName}.updated_at = EXCLUDED.updated_at
              AND COALESCE(${this.tableName}.version, 0) <= COALESCE(EXCLUDED.version, 0))
       RETURNING object_id`, [
-      this.service,
-      type,
-      value.id,
-      jsonbParam(value),
-      updatedAt,
-      context.requestId ?? this.sourceMachineId ?? null,
-      numberValue2(value.version)
-    ]);
+        this.service,
+        type,
+        value.id,
+        jsonbParam(value),
+        updatedAt,
+        context.requestId ?? this.sourceMachineId ?? null,
+        numberValue2(value.version)
+      ]);
+    } catch (error) {
+      if (type === "task_lists" && isPostgresUniqueViolation(error)) {
+        throw new ResourceConflictError("TASK_LIST_SLUG_CONFLICT", `Task list with slug "${String(value.slug ?? "")}" already exists in this scope`);
+      }
+      if (type === "projects" && isPostgresUniqueViolation(error)) {
+        throw new ResourceConflictError("PROJECT_SLUG_CONFLICT", `Project slug "${String(value.task_list_id ?? "")}" already exists`);
+      }
+      throw error;
+    }
     if (result.rows.length === 0) {
       const current = await this.get(type, value.id);
       if (current)
@@ -12233,6 +12636,93 @@ class PostgresJsonRecordStore {
     }
     return value;
   }
+  async renameProject(id, newSlug, name, context = {}) {
+    await this.ensureSchema();
+    const normalizedSlug = slugifyRaw(newSlug);
+    if (!normalizedSlug)
+      throw new Error("Invalid slug \u2014 must be non-empty kebab-case");
+    const timestamp = new Date().toISOString();
+    try {
+      const result = await this.options.client.query(`/* todos:rename-project-atomic */ WITH target AS (
+          SELECT payload, payload->>'task_list_id' AS old_slug
+          FROM ${this.tableName}
+          WHERE service = $1 AND object_type = 'projects' AND object_id = $2 AND deleted_at IS NULL
+          FOR UPDATE
+        ), project_conflict AS (
+          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 LIMIT 1
+        ), task_list_conflict AS (
+          SELECT 1 FROM ${this.tableName} r, target
+          WHERE r.service = $1 AND r.object_type = 'task_lists' AND r.deleted_at IS NULL
+            AND r.payload->>'project_id' = $2 AND r.payload->>'slug' = $3
+            AND r.payload->>'slug' IS DISTINCT FROM target.old_slug LIMIT 1
+        ), updated_lists AS (
+          UPDATE ${this.tableName} r SET
+            payload = r.payload || jsonb_build_object('slug', $3::text, 'updated_at', $5::text)
+              || CASE WHEN $4::text IS NULL THEN '{}'::jsonb ELSE jsonb_build_object('name', $4::text) END,
+            updated_at = $5::timestamptz, version = COALESCE(r.version, 0) + 1,
+            source_machine_id = COALESCE($6, r.source_machine_id)
+          FROM target
+          WHERE r.service = $1 AND r.object_type = 'task_lists' AND r.deleted_at IS NULL
+            AND r.payload->>'project_id' = $2 AND r.payload->>'slug' = target.old_slug
+            AND NOT EXISTS (SELECT 1 FROM project_conflict)
+            AND NOT EXISTS (SELECT 1 FROM task_list_conflict)
+            AND (target.old_slug IS DISTINCT FROM $3
+              OR ($4::text IS NOT NULL AND r.payload->>'name' IS DISTINCT FROM $4))
+          RETURNING 1
+        ), updated_project AS (
+          UPDATE ${this.tableName} r SET
+            payload = r.payload || jsonb_build_object('task_list_id', $3::text, 'updated_at', $5::text)
+              || CASE WHEN $4::text IS NULL THEN '{}'::jsonb ELSE jsonb_build_object('name', $4::text) END,
+            updated_at = $5::timestamptz, version = COALESCE(r.version, 0) + 1,
+            source_machine_id = COALESCE($6, r.source_machine_id)
+          FROM target
+          WHERE r.service = $1 AND r.object_type = 'projects' AND r.object_id = $2 AND r.deleted_at IS NULL
+            AND NOT EXISTS (SELECT 1 FROM project_conflict)
+            AND NOT EXISTS (SELECT 1 FROM task_list_conflict)
+            AND (target.old_slug IS DISTINCT FROM $3
+              OR ($4::text IS NOT NULL AND target.payload->>'name' IS DISTINCT FROM $4))
+          RETURNING r.payload
+        ) SELECT
+          EXISTS (SELECT 1 FROM target) AS found,
+          EXISTS (SELECT 1 FROM project_conflict) AS project_conflict,
+          EXISTS (SELECT 1 FROM task_list_conflict) AS task_list_conflict,
+          COALESCE((SELECT payload FROM updated_project), (SELECT payload FROM target)) AS project,
+          (SELECT count(*) FROM updated_lists) AS task_lists_updated`, [this.service, id, normalizedSlug, name ?? null, timestamp, this.machineId(context)]);
+      const row = result.rows[0];
+      if (!row?.found)
+        throw new ProjectNotFoundError(id);
+      if (row.project_conflict) {
+        throw new ResourceConflictError("PROJECT_SLUG_CONFLICT", `Slug "${normalizedSlug}" is already used by another project`);
+      }
+      if (row.task_list_conflict) {
+        throw new ResourceConflictError("TASK_LIST_SLUG_CONFLICT", `Task-list slug "${normalizedSlug}" is already used in this project`);
+      }
+      return {
+        project: payloadRecord2(row.project),
+        task_lists_updated: Number(row.task_lists_updated)
+      };
+    } catch (error) {
+      if (isPostgresUniqueViolation(error)) {
+        const constraintName = postgresConstraintName(error);
+        let projectConflict = constraintName.includes("project_task_list_slug_uidx");
+        if (!constraintName) {
+          const conflict = await this.options.client.query(`/* todos:classify-project-rename-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 project_conflict`, [this.service, id, normalizedSlug]);
+          projectConflict = Boolean(conflict.rows[0]?.project_conflict);
+        }
+        if (projectConflict) {
+          throw new ResourceConflictError("PROJECT_SLUG_CONFLICT", `Slug "${normalizedSlug}" is already used by another project`);
+        }
+        throw new ResourceConflictError("TASK_LIST_SLUG_CONFLICT", `Task-list slug "${normalizedSlug}" is already used in this project`);
+      }
+      throw error;
+    }
+  }
   async incrementProjectTaskCounter(projectId, _context = {}) {
     await this.ensureSchema();
     const result = await this.options.client.query(`UPDATE ${this.tableName}
@@ -12654,12 +13144,16 @@ async function getChangedSince(since, filters, store) {
 }
 async function createProject2(input, store, context) {
   const timestamp = new Date().toISOString();
+  const derivedSlug = slugifyRaw(input.name);
+  const taskListId = input.task_list_id === undefined ? `todos-${derivedSlug}` : slugifyRaw(input.task_list_id);
+  if (!derivedSlug || !taskListId)
+    throw new Error("Project name and task-list slug must be non-empty");
   const project = {
     id: randomUUID3(),
     name: input.name,
     path: input.path,
     description: input.description ?? null,
-    task_list_id: input.task_list_id ?? `todos-${slugify2(input.name)}`,
+    task_list_id: taskListId,
     task_prefix: input.task_prefix ?? await generateProjectPrefix(input.name, store),
     task_counter: 0,
     created_at: timestamp,
@@ -12670,6 +13164,9 @@ async function createProject2(input, store, context) {
   return store.upsert("projects", project, context);
 }
 async function updateProject2(id, input, store) {
+  if ("task_list_id" in input) {
+    throw new Error("task_list_id cannot be changed by updateProject; use renameProject for an atomic canonical rename");
+  }
   const project = await requireRecord("projects", id, store);
   const updated = { ...project, ...definedPatch(input), updated_at: new Date().toISOString() };
   return store.upsert("projects", updated);
@@ -12778,10 +13275,13 @@ async function releaseAgent2(idOrName, sessionId, store, context) {
 }
 async function createTaskList2(input, store, context) {
   const timestamp = new Date().toISOString();
+  const slug = slugifyRaw(input.slug === undefined ? input.name : input.slug);
+  if (!slug)
+    throw new Error("Invalid task-list slug \u2014 must be non-empty kebab-case");
   return store.upsert("task_lists", {
     id: randomUUID3(),
     project_id: input.project_id ?? context?.projectId ?? null,
-    slug: input.slug ?? slugify2(input.name),
+    slug,
     name: input.name,
     description: input.description ?? null,
     metadata: input.metadata ?? {},
@@ -12793,9 +13293,20 @@ async function createTaskList2(input, store, context) {
 }
 async function updateTaskList2(id, input, store) {
   const list = await requireRecord("task_lists", id, store);
+  const patch = definedPatch(input);
+  if (input.slug !== undefined) {
+    const slug = slugifyRaw(input.slug);
+    if (!slug)
+      throw new Error("Invalid task-list slug \u2014 must be non-empty kebab-case");
+    const duplicate = (await store.list("task_lists")).find((candidate) => candidate.id !== id && candidate.project_id === list.project_id && candidate.slug === slug);
+    if (duplicate) {
+      throw new ResourceConflictError("TASK_LIST_SLUG_CONFLICT", `Task list with slug "${slug}" already exists in this scope`);
+    }
+    patch.slug = slug;
+  }
   return store.upsert("task_lists", {
     ...list,
-    ...definedPatch(input),
+    ...patch,
     metadata: input.metadata ?? list.metadata,
     updated_at: new Date().toISOString()
   });
@@ -12879,6 +13390,16 @@ async function exportSnapshot(store) {
 }
 async function importSnapshot(snapshot, store, context) {
   const result = { inserted: 0, updated: 0, deleted: 0, skipped: 0, errors: [] };
+  result.errors.push(...validateSnapshotRoutingRecords(snapshot.projects, snapshot.taskLists));
+  if (result.errors.length > 0)
+    return result;
+  const [existingProjects, existingTaskLists] = await Promise.all([
+    store.list("projects"),
+    store.list("task_lists")
+  ]);
+  result.errors.push(...validateSnapshotRoutingDestinationConflicts(snapshot.projects, snapshot.taskLists, existingProjects, existingTaskLists));
+  if (result.errors.length > 0)
+    return result;
   const entries = [
     ...snapshot.tasks.map((row) => ["tasks", row]),
     ...snapshot.projects.map((row) => ["projects", row]),
@@ -12949,10 +13470,7 @@ async function generateProjectPrefix(name, store) {
   return candidate;
 }
 function slugifyRaw(value) {
-  return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
-}
-function slugify2(value) {
-  return slugifyRaw(value) || "todos";
+  return normalizeSlug(value);
 }
 function normalizePlanSlug2(value) {
   const slug = slugifyRaw(value);
@@ -13006,6 +13524,16 @@ function compareClock(left, right) {
 function numberValue2(value) {
   return typeof value === "number" && Number.isSafeInteger(value) ? value : null;
 }
+function isPostgresUniqueViolation(error) {
+  return typeof error === "object" && error !== null && error.code === "23505";
+}
+function postgresConstraintName(error) {
+  if (typeof error !== "object" || error === null)
+    return "";
+  const candidate = error;
+  const constraint = candidate.constraint ?? candidate.constraint_name;
+  return typeof constraint === "string" ? constraint : "";
+}
 
 // src/storage/shadow.ts
 var SNAPSHOT_TO_OBJECT_TYPE = {
@@ -13271,6 +13799,19 @@ function createShadowTodosStorageAdapter(options) {
         mirror.enqueueUpsert("projects", project, context);
         return project;
       },
+      async rename(id, input, context) {
+        const projectBefore = await local.projects.get(id, context);
+        const cascadeCandidates = projectBefore?.task_list_id ? (await local.taskLists.list(id, context)).filter((list) => list.slug === projectBefore.task_list_id) : [];
+        const result = await local.projects.rename(id, input, context);
+        mirror.enqueueUpsert("projects", result.project, context);
+        for (const candidate of cascadeCandidates) {
+          const changed = await local.taskLists.get(candidate.id, context);
+          if (changed && (changed.slug !== candidate.slug || changed.name !== candidate.name)) {
+            mirror.enqueueUpsert("taskLists", changed, context);
+          }
+        }
+        return result;
+      },
       async delete(id, context) {
         const deleted = await local.projects.delete(id, context);
         if (deleted)
@@ -14321,6 +14862,9 @@ export {
   signAwsV4Request,
   registerShadowExitFlush,
   postgresTodosSyncSchemaSql,
+  postgresTodosScopedSlugUniqueIndexSql,
+  postgresTodosScopedSlugPreflightSql,
+  postgresTodosScopedSlugIndexStatusSql,
   postgresTodosCommentCursorIndexSql,
   planRunArtifactsS3Sync,
   parseStorageMode,
@@ -14343,6 +14887,7 @@ export {
   getRuntimeShadowOutbox,
   getCanonicalTodosRdsConfig,
   exportSqliteTodosStorageSnapshot,
+  ensurePostgresScopedSlugUniqueIndexes,
   downloadRunArtifactsFromS3,
   createTodosStorageAdapter,
   createTodosShadowOutbox,
@@ -14366,6 +14911,8 @@ export {
   TODOS_STORAGE_FALLBACK_ENV,
   TODOS_STORAGE_ENV,
   STORAGE_TABLES,
+  PostgresScopedSlugMigrationConflictError,
+  PostgresScopedSlugIndexBuildError,
   COMMENT_REDACTION_BACKFILL_CONFIRMATION,
   CANONICAL_TODOS_RDS_RUNTIME_PATH,
   CANONICAL_TODOS_RDS_DATABASE,