@hasna/todos 0.15.34 → 0.15.41

package/dist/task-subtree-transfer.js

@@ -0,0 +1,1869 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// 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/task-manifest/canonical.ts
+import { createHash } from "crypto";
+function canonicalize(value) {
+  if (Array.isArray(value))
+    return value.map(canonicalize);
+  if (value !== null && typeof value === "object") {
+    return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== undefined).sort(([left], [right]) => left.localeCompare(right)).map(([key, entry]) => [key, canonicalize(entry)]));
+  }
+  return value;
+}
+function canonicalJson(value) {
+  return JSON.stringify(canonicalize(value));
+}
+function canonicalDigest(value) {
+  return createHash("sha256").update(canonicalJson(value)).digest("hex");
+}
+function deterministicUuid(namespace, ...parts) {
+  const bytes = createHash("sha256").update([namespace, ...parts].join("\x1F")).digest().subarray(0, 16);
+  bytes[6] = bytes[6] & 15 | 80;
+  bytes[8] = bytes[8] & 63 | 128;
+  const hex = bytes.toString("hex");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+
+// src/task-subtree-transfer/types.ts
+var TODOS_TASK_SUBTREE_TRANSFER_ROUTE = "todos.task-subtree-transfer.v1";
+var TODOS_TASK_SUBTREE_TRANSFER_SCHEMA_VERSION = 1;
+
+class TodosTaskSubtreeTransferError extends Error {
+  code;
+  details;
+  constructor(code, message, details = {}) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.name = "TodosTaskSubtreeTransferError";
+  }
+}
+
+// src/task-subtree-transfer/canonical.ts
+function taskSubtreeTransferRequestDigest(input) {
+  const { idempotency_key: _idempotencyKey, ...request } = input;
+  return canonicalDigest(request);
+}
+function taskSubtreeTransferRollbackRequestDigest(input) {
+  const { idempotency_key: _idempotencyKey, ...request } = input;
+  return canonicalDigest(request);
+}
+function deriveTodosTaskSubtreeTransferIdempotencyKey(input) {
+  return `tstk_${canonicalDigest({
+    route: TODOS_TASK_SUBTREE_TRANSFER_ROUTE,
+    ...input
+  }).slice(0, 48)}`;
+}
+
+// src/storage/postgres-sync.ts
+var DEFAULT_TODOS_POSTGRES_SYNC_TABLE = "todos_sync_records";
+var DEFAULT_TODOS_POSTGRES_CURSOR_TABLE = "todos_sync_cursors";
+function postgresTodosSyncSchemaSql(tableName = DEFAULT_TODOS_POSTGRES_SYNC_TABLE, cursorTableName = DEFAULT_TODOS_POSTGRES_CURSOR_TABLE) {
+  assertSafeIdentifier(tableName);
+  assertSafeIdentifier(cursorTableName);
+  return [
+    `CREATE TABLE IF NOT EXISTS ${tableName} (
+      service text NOT NULL,
+      object_type text NOT NULL,
+      object_id text NOT NULL,
+      payload jsonb NOT NULL,
+      updated_at timestamptz NOT NULL,
+      deleted_at timestamptz,
+      source_machine_id text,
+      version integer,
+      PRIMARY KEY (service, object_type, object_id)
+    )`,
+    `CREATE INDEX IF NOT EXISTS ${tableName}_updated_idx ON ${tableName} (service, updated_at)`,
+    `CREATE INDEX IF NOT EXISTS ${tableName}_task_status_idx ON ${tableName} ((payload->>'status')) WHERE object_type = 'tasks' AND deleted_at IS NULL`,
+    `CREATE INDEX IF NOT EXISTS ${tableName}_task_project_idx ON ${tableName} ((payload->>'project_id')) WHERE object_type = 'tasks' AND deleted_at IS NULL`,
+    `CREATE INDEX IF NOT EXISTS ${tableName}_payload_gin ON ${tableName} USING gin (payload jsonb_path_ops)`,
+    `CREATE EXTENSION IF NOT EXISTS pg_trgm`,
+    `CREATE EXTENSION IF NOT EXISTS unaccent`,
+    `CREATE OR REPLACE FUNCTION todos_immutable_unaccent(text)
+      RETURNS text
+      LANGUAGE sql IMMUTABLE PARALLEL SAFE STRICT
+      AS $$ SELECT unaccent('unaccent', $1) $$`,
+    `CREATE OR REPLACE FUNCTION todos_try_timestamptz(text)
+      RETURNS timestamptz
+      LANGUAGE plpgsql IMMUTABLE PARALLEL UNSAFE
+      SET DateStyle TO 'ISO, YMD'
+      AS $$
+      BEGIN
+        RETURN CASE
+          WHEN $1 ~ '(Z|[+-][0-9]{2}:?[0-9]{2})$' THEN $1::timestamptz
+          ELSE ($1::timestamp AT TIME ZONE 'UTC')
+        END;
+      EXCEPTION WHEN others THEN RETURN NULL; END $$`,
+    `DROP INDEX IF EXISTS ${tableName}_task_updated_at_idx`,
+    `CREATE INDEX IF NOT EXISTS ${tableName}_task_updated_at_utc_idx
+      ON ${tableName} (todos_try_timestamptz(payload->>'updated_at'))
+      WHERE object_type = 'tasks' AND deleted_at IS NULL`,
+    `ALTER TABLE ${tableName}
+      ADD COLUMN IF NOT EXISTS task_search_tsv tsvector
+      GENERATED ALWAYS AS (
+        setweight(to_tsvector('simple', todos_immutable_unaccent(COALESCE(payload->>'title', ''))), 'A')
+        || setweight(to_tsvector('simple', todos_immutable_unaccent(COALESCE(payload->>'description', ''))), 'B')
+        || setweight(to_tsvector('simple', todos_immutable_unaccent(translate(COALESCE(payload->>'tags', '[]'), '[]",', '    '))), 'C')
+      ) STORED`,
+    `CREATE INDEX IF NOT EXISTS ${tableName}_task_search_tsv_idx
+      ON ${tableName} USING gin (task_search_tsv)
+      WHERE object_type = 'tasks' AND deleted_at IS NULL`,
+    `CREATE INDEX IF NOT EXISTS ${tableName}_task_search_trgm_idx
+      ON ${tableName} USING gin (
+        todos_immutable_unaccent(COALESCE(payload->>'title', '') || ' ' || COALESCE(payload->>'description', '')) gin_trgm_ops
+      )
+      WHERE object_type = 'tasks' AND deleted_at IS NULL`,
+    `CREATE TABLE IF NOT EXISTS ${cursorTableName} (
+      service text NOT NULL,
+      cursor_name text NOT NULL,
+      value text NOT NULL,
+      updated_at timestamptz NOT NULL DEFAULT now(),
+      PRIMARY KEY (service, cursor_name)
+    )`
+  ];
+}
+
+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
+    ON ${tableName} (service, (payload->>'task_id'), (payload->>'created_at'), object_id)
+    WHERE object_type = 'comments' AND deleted_at IS NULL`;
+}
+class PostgresTodosSyncStore {
+  client;
+  service;
+  sourceMachineId;
+  tableName;
+  cursorTableName;
+  constructor(client, options = {}) {
+    this.client = client;
+    this.service = options.service ?? "todos";
+    this.sourceMachineId = options.sourceMachineId;
+    this.tableName = options.tableName ?? DEFAULT_TODOS_POSTGRES_SYNC_TABLE;
+    this.cursorTableName = options.cursorTableName ?? DEFAULT_TODOS_POSTGRES_CURSOR_TABLE;
+    assertSafeIdentifier(this.tableName);
+    assertSafeIdentifier(this.cursorTableName);
+  }
+  async ensureSchema() {
+    for (const sql of postgresTodosSyncSchemaSql(this.tableName, this.cursorTableName)) {
+      await this.client.query(sql);
+    }
+  }
+  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
+        ) 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;
+    }
+    return result;
+  }
+  async pullSnapshot(options = {}) {
+    const params = [this.service];
+    const filters = ["service = $1"];
+    if (options.since) {
+      params.push(options.since);
+      filters.push(`updated_at > $${params.length}::timestamptz`);
+    }
+    if (options.objectTypes?.length) {
+      params.push(options.objectTypes);
+      filters.push(`object_type = ANY($${params.length}::text[])`);
+    }
+    const response = await this.client.query(`SELECT object_type, object_id, payload, updated_at, deleted_at, source_machine_id, version FROM ${this.tableName}
+       WHERE ${filters.join(" AND ")}
+       ORDER BY updated_at ASC, object_type ASC, object_id ASC`, params);
+    return rowsToSnapshot(response.rows);
+  }
+  async getCursor(name) {
+    const result = await this.client.query(`SELECT value FROM ${this.cursorTableName} WHERE service = $1 AND cursor_name = $2`, [this.service, name]);
+    return result.rows[0]?.value ?? null;
+  }
+  async setCursor(name, value) {
+    await this.client.query(`INSERT INTO ${this.cursorTableName} (service, cursor_name, value, updated_at)
+       VALUES ($1, $2, $3, now())
+       ON CONFLICT (service, cursor_name) DO UPDATE SET
+         value = EXCLUDED.value,
+         updated_at = EXCLUDED.updated_at`, [this.service, name, value]);
+  }
+}
+function createPostgresTodosSyncStore(client, options = {}) {
+  return new PostgresTodosSyncStore(client, options);
+}
+function snapshotEntries(snapshot) {
+  return [
+    ...snapshot.tasks.map((payload) => entry("tasks", payload, snapshot.exportedAt)),
+    ...snapshot.projects.map((payload) => entry("projects", payload, snapshot.exportedAt)),
+    ...(snapshot.projectMachinePaths ?? []).map((payload) => entry("project_machine_paths", payload, snapshot.exportedAt)),
+    ...snapshot.plans.map((payload) => entry("plans", payload, snapshot.exportedAt)),
+    ...snapshot.agents.map((payload) => entry("agents", payload, snapshot.exportedAt)),
+    ...snapshot.taskLists.map((payload) => entry("task_lists", payload, snapshot.exportedAt)),
+    ...snapshot.templates.map((payload) => entry("templates", payload, snapshot.exportedAt)),
+    ...(snapshot.templateTasks ?? []).map((payload) => entry("template_tasks", payload, snapshot.exportedAt)),
+    ...snapshot.auditHistory.map((payload) => entry("audit_history", payload, snapshot.exportedAt)),
+    ...(snapshot.tombstones ?? []).map((tombstone) => ({
+      type: tombstone.object_type,
+      id: tombstone.object_id,
+      payload: tombstone.payload ?? { id: tombstone.object_id, deleted_at: tombstone.deleted_at },
+      updatedAt: tombstone.updated_at || tombstone.deleted_at,
+      deletedAt: tombstone.deleted_at,
+      version: tombstone.version ?? null
+    }))
+  ];
+}
+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)
+    throw new Error(`${type} record is missing a stable id`);
+  return {
+    type,
+    id,
+    payload,
+    updatedAt: stringValue(payload["updated_at"]) ?? stringValue(payload["created_at"]) ?? fallbackUpdatedAt,
+    deletedAt: stringValue(payload["deleted_at"]),
+    version: numberValue(payload["version"])
+  };
+}
+function rowsToSnapshot(rows) {
+  const snapshot = {
+    exportedAt: new Date().toISOString(),
+    source: "postgres",
+    tasks: [],
+    projects: [],
+    projectMachinePaths: [],
+    plans: [],
+    agents: [],
+    taskLists: [],
+    templates: [],
+    templateTasks: [],
+    auditHistory: [],
+    tombstones: []
+  };
+  for (const row of rows) {
+    const payload = payloadRecord(row.payload);
+    const deletedAt = stringValue(row.deleted_at);
+    if (deletedAt) {
+      snapshot.tombstones ??= [];
+      snapshot.tombstones.push({
+        object_type: row.object_type,
+        object_id: stringValue(row.object_id) ?? stringValue(payload["id"]) ?? "",
+        deleted_at: deletedAt,
+        updated_at: stringValue(row.updated_at) ?? deletedAt,
+        source_machine_id: stringValue(row.source_machine_id),
+        payload,
+        version: numberValue(row.version)
+      });
+      continue;
+    }
+    if (row.object_type === "tasks")
+      snapshot.tasks.push(payload);
+    else if (row.object_type === "projects")
+      snapshot.projects.push(payload);
+    else if (row.object_type === "project_machine_paths") {
+      snapshot.projectMachinePaths ??= [];
+      snapshot.projectMachinePaths.push(payload);
+    } else if (row.object_type === "plans")
+      snapshot.plans.push(payload);
+    else if (row.object_type === "agents")
+      snapshot.agents.push(payload);
+    else if (row.object_type === "task_lists")
+      snapshot.taskLists.push(payload);
+    else if (row.object_type === "templates")
+      snapshot.templates.push(payload);
+    else if (row.object_type === "template_tasks")
+      snapshot.templateTasks.push(payload);
+    else if (row.object_type === "audit_history")
+      snapshot.auditHistory.push(payload);
+  }
+  return snapshot;
+}
+function payloadRecord(value) {
+  if (typeof value === "string")
+    return JSON.parse(value);
+  if (value && typeof value === "object" && !Array.isArray(value))
+    return value;
+  throw new Error("Postgres sync payload must be a JSON object");
+}
+function stringValue(value) {
+  if (value instanceof Date)
+    return value.toISOString();
+  return typeof value === "string" && value ? value : null;
+}
+function numberValue(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) ? value : null;
+}
+function assertSafeIdentifier(value) {
+  if (!/^[a-z_][a-z0-9_]*$/i.test(value))
+    throw new Error(`Unsafe Postgres identifier: ${value}`);
+}
+
+// src/task-subtree-transfer/planner.ts
+function sortedTaskImage(task) {
+  return {
+    task_id: task.task_id,
+    project_id: task.project_id,
+    parent_id: task.parent_id,
+    plan_id: task.plan_id,
+    task_list_id: task.task_list_id,
+    version: task.version,
+    updated_at: task.updated_at
+  };
+}
+function sourcePopulationDigest(tasks) {
+  return canonicalDigest(tasks.map((task) => ({
+    ...sortedTaskImage(task),
+    archived_at: task.archived_at ?? null
+  })).sort((left, right) => left.task_id.localeCompare(right.task_id)));
+}
+function closure(tasks, rootTaskId) {
+  const byId = new Map(tasks.map((task) => [task.task_id, task]));
+  if (!byId.has(rootTaskId)) {
+    throw new TodosTaskSubtreeTransferError("TODOS_TASK_SUBTREE_TRANSFER_NOT_FOUND", `Root task not found in the exact source project: ${rootTaskId}`, { root_task_id: rootTaskId });
+  }
+  const children = new Map;
+  for (const task of tasks) {
+    if (!task.parent_id)
+      continue;
+    const siblings = children.get(task.parent_id) ?? [];
+    siblings.push(task.task_id);
+    children.set(task.parent_id, siblings);
+  }
+  for (const ids of children.values())
+    ids.sort();
+  const visiting = new Set;
+  const visited = new Set;
+  const result = [];
+  const visit = (id) => {
+    if (visiting.has(id)) {
+      throw new TodosTaskSubtreeTransferError("TODOS_TASK_SUBTREE_TRANSFER_HIERARCHY_CYCLE", "Task hierarchy contains a cycle in the requested descendant closure", { task_id: id });
+    }
+    if (visited.has(id))
+      return;
+    const task = byId.get(id);
+    if (!task) {
+      throw new TodosTaskSubtreeTransferError("TODOS_TASK_SUBTREE_TRANSFER_FOREIGN_REFERENCE", "Task hierarchy references a parent outside the exact source population", { task_id: id });
+    }
+    visiting.add(id);
+    result.push(task);
+    for (const child of children.get(id) ?? [])
+      visit(child);
+    visiting.delete(id);
+    visited.add(id);
+  };
+  visit(rootTaskId);
+  return result.sort((left, right) => left.task_id.localeCompare(right.task_id));
+}
+function prepareTransfer(snapshot, input) {
+  if (!snapshot.destination_project_found || !snapshot.destination_task_list_found || !snapshot.destination_parent_found) {
+    throw new TodosTaskSubtreeTransferError("TODOS_TASK_SUBTREE_TRANSFER_FOREIGN_REFERENCE", "Destination project, task list, or parent does not match the exact requested target");
+  }
+  const moved = closure(snapshot.source_tasks, input.root_task_id);
+  const movedIds = new Set(moved.map((task) => task.task_id));
+  if (input.destination_parent_id && movedIds.has(input.destination_parent_id)) {
+    throw new TodosTaskSubtreeTransferError("TODOS_TASK_SUBTREE_TRANSFER_HIERARCHY_CYCLE", "Destination parent cannot be inside the transferred subtree", { destination_parent_id: input.destination_parent_id });
+  }
+  const planIds = [...new Set(moved.map((task) => task.plan_id).filter((id) => Boolean(id)))].sort();
+  const allPlanTasks = new Map;
+  for (const task of snapshot.plan_tasks) {
+    if (!task.plan_id)
+      continue;
+    const rows = allPlanTasks.get(task.plan_id) ?? [];
+    rows.push(task);
+    allPlanTasks.set(task.plan_id, rows);
+  }
+  const contained = [];
+  const shared = [];
+  const planById = new Map(snapshot.plans.map((plan) => [plan.plan_id, plan]));
+  for (const planId of planIds) {
+    const plan = planById.get(planId);
+    if (!plan || plan.project_id !== input.source_project_id) {
+      throw new TodosTaskSubtreeTransferError("TODOS_TASK_SUBTREE_TRANSFER_PLAN_CONFLICT", "A moved task references a plan absent from the exact source project", { plan_id: planId });
+    }
+    const members = allPlanTasks.get(planId) ?? [];
+    if (members.length === 0) {
+      throw new TodosTaskSubtreeTransferError("TODOS_TASK_SUBTREE_TRANSFER_PLAN_CONFLICT", "A moved task references a plan with no authoritative task membership", { plan_id: planId });
+    }
+    if (members.every((task) => movedIds.has(task.task_id)))
+      contained.push(planId);
+    else
+      shared.push(planId);
+  }
+  const inspection = {
+    source_project_id: input.source_project_id,
+    destination_project_id: input.destination_project_id,
+    destination_task_list_id: input.destination_task_list_id,
+    root_task_id: input.root_task_id,
+    destination_parent_id: input.destination_parent_id,
+    expected_root_parent_id: moved.find((task) => task.task_id === input.root_task_id).parent_id,
+    source_population_digest: sourcePopulationDigest(snapshot.source_tasks),
+    expected_tasks: moved.map((task) => ({ task_id: task.task_id, version: task.version })),
+    contained_plan_ids: contained,
+    shared_plan_ids: shared,
+    complete: true
+  };
+  return {
+    inspection,
+    prior_tasks: moved.map(sortedTaskImage),
+    prior_plans: contained.map((id) => planById.get(id)),
+    task_plan_targets: new Map(moved.map((task) => [task.task_id, task.plan_id]))
+  };
+}
+function validateApplySnapshot(prepared, request, plans) {
+  if (request.expected_root_parent_id !== prepared.inspection.expected_root_parent_id) {
+    throw new TodosTaskSubtreeTransferError("TODOS_TASK_SUBTREE_TRANSFER_CAS_CONFLICT", "Root parent changed since inspection");
+  }
+  if (request.source_population_digest !== prepared.inspection.source_population_digest) {
+    throw new TodosTaskSubtreeTransferError("TODOS_TASK_SUBTREE_TRANSFER_POPULATION_DRIFT", "Complete source-project task population changed since inspection");
+  }
+  const expected = request.expected_tasks.map((task) => ({ task_id: task.task_id, version: task.version })).sort((left, right) => left.task_id.localeCompare(right.task_id));
+  if (JSON.stringify(expected) !== JSON.stringify(prepared.inspection.expected_tasks)) {
+    const actualById = new Map(prepared.inspection.expected_tasks.map((task) => [task.task_id, task.version]));
+    const sameIds = expected.length === prepared.inspection.expected_tasks.length && expected.every((task) => actualById.has(task.task_id));
+    throw new TodosTaskSubtreeTransferError(sameIds ? "TODOS_TASK_SUBTREE_TRANSFER_CAS_CONFLICT" : "TODOS_TASK_SUBTREE_TRANSFER_CLOSURE_DRIFT", sameIds ? "At least one exact task version changed since inspection" : "Exact descendant closure changed since inspection");
+  }
+  const requestedSources = request.shared_plan_splits.map((mapping) => mapping.source_plan_id).sort();
+  if (JSON.stringify(requestedSources) !== JSON.stringify(prepared.inspection.shared_plan_ids)) {
+    throw new TodosTaskSubtreeTransferError("TODOS_TASK_SUBTREE_TRANSFER_PARTIAL_PLAN", "Shared plans require one exact explicit destination-plan mapping each", {
+      expected_shared_plan_ids: prepared.inspection.shared_plan_ids,
+      received_shared_plan_ids: requestedSources
+    });
+  }
+  const planById = new Map(plans.map((plan) => [plan.plan_id, plan]));
+  const destinationIds = new Set;
+  for (const mapping of request.shared_plan_splits) {
+    if (destinationIds.has(mapping.destination_plan_id)) {
+      throw new TodosTaskSubtreeTransferError("TODOS_TASK_SUBTREE_TRANSFER_PLAN_CONFLICT", "Two shared source plans cannot collapse into one destination plan");
+    }
+    destinationIds.add(mapping.destination_plan_id);
+    const destination = planById.get(mapping.destination_plan_id);
+    if (!destination || destination.project_id !== request.destination_project_id || destination.task_list_id !== request.destination_task_list_id) {
+      throw new TodosTaskSubtreeTransferError("TODOS_TASK_SUBTREE_TRANSFER_PLAN_CONFLICT", "Shared-plan destination does not match the exact destination project and task list", { destination_plan_id: mapping.destination_plan_id });
+    }
+    for (const [taskId, planId] of prepared.task_plan_targets) {
+      if (planId === mapping.source_plan_id) {
+        prepared.task_plan_targets.set(taskId, mapping.destination_plan_id);
+      }
+    }
+  }
+}
+
+// src/task-subtree-transfer/schema-sql.ts
+function sqliteTodosTaskSubtreeTransferSchemaSql() {
+  return `
+    CREATE TABLE IF NOT EXISTS todos_task_subtree_transfer_receipts (
+      receipt_id TEXT PRIMARY KEY,
+      tenant_id TEXT NOT NULL,
+      kind TEXT NOT NULL CHECK(kind IN ('apply', 'rollback')),
+      operation_id TEXT NOT NULL,
+      step_id TEXT NOT NULL,
+      idempotency_key TEXT NOT NULL,
+      request_digest TEXT NOT NULL,
+      precondition_digest TEXT NOT NULL,
+      result_digest TEXT NOT NULL,
+      apply_receipt_id TEXT,
+      request_json TEXT NOT NULL,
+      result_json TEXT NOT NULL,
+      created_at TEXT NOT NULL,
+      UNIQUE(tenant_id, kind, operation_id, step_id),
+      UNIQUE(tenant_id, kind, idempotency_key)
+    );
+    CREATE TRIGGER IF NOT EXISTS todos_task_subtree_transfer_receipts_immutable_update
+      BEFORE UPDATE ON todos_task_subtree_transfer_receipts BEGIN
+        SELECT RAISE(ABORT, 'todos task subtree transfer receipts are immutable');
+      END;
+    CREATE TRIGGER IF NOT EXISTS todos_task_subtree_transfer_receipts_immutable_delete
+      BEFORE DELETE ON todos_task_subtree_transfer_receipts BEGIN
+        SELECT RAISE(ABORT, 'todos task subtree transfer receipts are immutable');
+      END;
+  `;
+}
+function ensureSqliteTodosTaskSubtreeTransferSchema(db) {
+  db.exec(sqliteTodosTaskSubtreeTransferSchemaSql());
+}
+function postgresTodosTaskSubtreeTransferSchemaSql() {
+  return [
+    `CREATE TABLE IF NOT EXISTS todos_task_subtree_transfer_receipts (
+      receipt_id text PRIMARY KEY,
+      tenant_id text NOT NULL,
+      kind text NOT NULL CHECK(kind IN ('apply', 'rollback')),
+      operation_id text NOT NULL,
+      step_id text NOT NULL,
+      idempotency_key text NOT NULL,
+      request_digest text NOT NULL,
+      precondition_digest text NOT NULL,
+      result_digest text NOT NULL,
+      apply_receipt_id text,
+      request_json jsonb NOT NULL,
+      result_json jsonb NOT NULL,
+      created_at timestamptz NOT NULL,
+      UNIQUE(tenant_id, kind, operation_id, step_id),
+      UNIQUE(tenant_id, kind, idempotency_key)
+    )`,
+    `CREATE OR REPLACE FUNCTION reject_todos_task_subtree_transfer_receipt_mutation()
+      RETURNS trigger LANGUAGE plpgsql AS $$
+      BEGIN
+        RAISE EXCEPTION 'todos task subtree transfer receipts are immutable';
+      END $$`,
+    `DROP TRIGGER IF EXISTS todos_task_subtree_transfer_receipts_immutable_update
+      ON todos_task_subtree_transfer_receipts`,
+    `CREATE TRIGGER todos_task_subtree_transfer_receipts_immutable_update
+      BEFORE UPDATE OR DELETE ON todos_task_subtree_transfer_receipts
+      FOR EACH ROW EXECUTE FUNCTION reject_todos_task_subtree_transfer_receipt_mutation()`
+  ];
+}
+
+// src/task-subtree-transfer/postgres.ts
+function safeIdentifier(value, fallback) {
+  const candidate = value ?? fallback;
+  if (!/^[a-z_][a-z0-9_]*$/.test(candidate)) {
+    throw new TodosTaskSubtreeTransferError("TODOS_TASK_SUBTREE_TRANSFER_INVALID_INPUT", "PostgreSQL table name must be a safe identifier");
+  }
+  return candidate;
+}
+function timestamp(value) {
+  return value instanceof Date ? value.toISOString() : new Date(String(value)).toISOString();
+}
+function payloadOf(row) {
+  return typeof row.payload === "string" ? JSON.parse(row.payload) : row.payload;
+}
+function taskRecord(row) {
+  const payload = payloadOf(row);
+  return {
+    task_id: String(payload.id ?? row.object_id),
+    project_id: payload.project_id == null ? null : String(payload.project_id),
+    parent_id: payload.parent_id == null ? null : String(payload.parent_id),
+    plan_id: payload.plan_id == null ? null : String(payload.plan_id),
+    task_list_id: payload.task_list_id == null ? null : String(payload.task_list_id),
+    version: Number(payload.version ?? row.version ?? 1),
+    updated_at: timestamp(payload.updated_at ?? row.updated_at),
+    archived_at: payload.archived_at == null ? null : String(payload.archived_at)
+  };
+}
+function planRecord(row) {
+  const payload = payloadOf(row);
+  return {
+    plan_id: String(payload.id ?? row.object_id),
+    project_id: payload.project_id == null ? null : String(payload.project_id),
+    task_list_id: payload.task_list_id == null ? null : String(payload.task_list_id),
+    updated_at: timestamp(payload.updated_at ?? row.updated_at)
+  };
+}
+
+class PostgresTodosTaskSubtreeTransferBackend {
+  client;
+  kind = "postgresql";
+  service;
+  tableName;
+  tenantId;
+  schemaReady = null;
+  constructor(client, options = {}) {
+    this.client = client;
+    this.service = options.service ?? "todos";
+    this.tableName = safeIdentifier(options.tableName, DEFAULT_TODOS_POSTGRES_SYNC_TABLE);
+    this.tenantId = options.tenantId ?? "default";
+  }
+  async ensureSchema() {
+    this.schemaReady ??= (async () => {
+      for (const sql of postgresTodosSyncSchemaSql(this.tableName))
+        await this.client.query(sql);
+      for (const sql of postgresTodosTaskSubtreeTransferSchemaSql())
+        await this.client.query(sql);
+    })();
+    await this.schemaReady;
+  }
+  async snapshot(client, input, forUpdate = false) {
+    const lock = forUpdate ? " FOR UPDATE" : "";
+    const source = await client.query(`SELECT object_id, payload, updated_at, version FROM ${this.tableName}
+       WHERE service = $1 AND object_type = 'tasks' AND deleted_at IS NULL
+         AND payload->>'project_id' = $2 ORDER BY object_id${lock}`, [this.service, input.source_project_id]);
+    const allTasks = await client.query(`SELECT object_id, payload, updated_at, version FROM ${this.tableName}
+       WHERE service = $1 AND object_type = 'tasks' AND deleted_at IS NULL ORDER BY object_id${lock}`, [this.service]);
+    const plans = await client.query(`SELECT object_id, payload, updated_at, version FROM ${this.tableName}
+       WHERE service = $1 AND object_type = 'plans' AND deleted_at IS NULL ORDER BY object_id${lock}`, [this.service]);
+    const destinationProject = await client.query(`SELECT 1 FROM ${this.tableName}
+       WHERE service = $1 AND object_type = 'projects' AND object_id = $2
+         AND deleted_at IS NULL LIMIT 1${lock}`, [this.service, input.destination_project_id]);
+    const destinationList = await client.query(`SELECT 1 FROM ${this.tableName}
+       WHERE service = $1 AND object_type = 'task_lists' AND object_id = $2
+         AND deleted_at IS NULL AND payload->>'project_id' = $3 LIMIT 1`, [this.service, input.destination_task_list_id, input.destination_project_id]);
+    const destinationParent = input.destination_parent_id === null ? true : (await client.query(`SELECT 1 FROM ${this.tableName}
+         WHERE service = $1 AND object_type = 'tasks' AND object_id = $2
+           AND deleted_at IS NULL AND payload->>'project_id' = $3 LIMIT 1`, [this.service, input.destination_parent_id, input.destination_project_id])).rows.length === 1;
+    return {
+      source_tasks: source.rows.map(taskRecord),
+      plan_tasks: allTasks.rows.map(taskRecord),
+      plans: plans.rows.map(planRecord),
+      destination_project_found: destinationProject.rows.length === 1,
+      destination_task_list_found: destinationList.rows.length === 1,
+      destination_parent_found: destinationParent
+    };
+  }
+  async inspect(input) {
+    await this.ensureSchema();
+    return prepareTransfer(await this.snapshot(this.client, input), input).inspection;
+  }
+  async insertPayload(client, task, update, now) {
+    const current = await client.query(`SELECT payload FROM ${this.tableName}
+       WHERE service = $1 AND object_type = 'tasks' AND object_id = $2
+         AND deleted_at IS NULL FOR UPDATE`, [this.service, task.task_id]);
+    const row = current.rows[0];
+    if (!row)
+      throw new TodosTaskSubtreeTransferError("TODOS_TASK_SUBTREE_TRANSFER_NOT_FOUND", `Task not found: ${task.task_id}`);
+    const payload = payloadOf(row);
+    if (Number(payload.version ?? 1) !== task.version) {
+      throw new TodosTaskSubtreeTransferError("TODOS_TASK_SUBTREE_TRANSFER_CAS_CONFLICT", "Task changed during transfer", { task_id: task.task_id });
+    }
+    const next = {
+      ...payload,
+      ...update,
+      version: task.version + 1,
+      updated_at: now
+    };
+    const result = await client.query(`UPDATE ${this.tableName} SET payload = $1::jsonb, updated_at = $2, version = $3
+       WHERE service = $4 AND object_type = 'tasks' AND object_id = $5
+         AND deleted_at IS NULL AND version = $6
+       RETURNING object_id`, [canonicalJson(next), now, task.version + 1, this.service, task.task_id, task.version]);
+    if (result.rows.length !== 1) {
+      throw new TodosTaskSubtreeTransferError("TODOS_TASK_SUBTREE_TRANSFER_CAS_CONFLICT", "Task CAS failed", { task_id: task.task_id });
+    }
+  }
+  async apply(input, options) {
+    await this.ensureSchema();
+    if (!this.client.transaction) {
+      throw new TodosTaskSubtreeTransferError("TODOS_TASK_SUBTREE_TRANSFER_ATOMICITY_UNAVAILABLE", "PostgreSQL subtree transfer requires an authoritative transaction-capable client");
+    }
+    return this.client.transaction(async (tx) => {
+      await tx.query("SELECT pg_advisory_xact_lock(hashtextextended('todos:task-parent-integrity', 0))");
+      const requestDigest = taskSubtreeTransferRequestDigest(input);
+      const existing = await tx.query(`SELECT result_json, request_digest, precondition_digest, idempotency_key
+         FROM todos_task_subtree_transfer_receipts
+         WHERE tenant_id = $1 AND kind = 'apply'
+           AND (idempotency_key = $2 OR (operation_id = $3 AND step_id = $4))
+         ORDER BY created_at ASC LIMIT 1`, [this.tenantId, input.idempotency_key, input.operation_id, input.step_id]);
+      if (existing.rows[0]) {
+        const row = existing.rows[0];
+        if (row.request_digest !== requestDigest || row.precondition_digest !== input.precondition_digest || row.idempotency_key !== input.idempotency_key) {
+          throw new TodosTaskSubtreeTransferError("TODOS_TASK_SUBTREE_TRANSFER_IDEMPOTENCY_CONFLICT", "The operation was already accepted for a different request");
+        }
+        return { ...typeof row.result_json === "string" ? JSON.parse(row.result_json) : row.result_json, duplicate: true };
+      }
+      const snapshot = await this.snapshot(tx, input, true);
+      const prepared = prepareTransfer(snapshot, input);
+      validateApplySnapshot(prepared, input, snapshot.plans);
+      const now = options.now?.() ?? new Date().toISOString();
+      const priorImage = {
+        tasks: prepared.prior_tasks,
+        plans: prepared.prior_plans
+      };
+      for (const task of prepared.prior_tasks) {
+        await this.insertPayload(tx, task, {
+          project_id: input.destination_project_id,
+          task_list_id: input.destination_task_list_id,
+          plan_id: prepared.task_plan_targets.get(task.task_id) ?? null,
+          parent_id: task.task_id === input.root_task_id ? input.destination_parent_id : task.parent_id
+        }, now);
+      }
+      if (options.faultInjector && await options.faultInjector("after_task_writes"))
+        throw new Error("Injected task-subtree-transfer fault at after_task_writes");
+      for (const plan of prepared.prior_plans) {
+        const row = await tx.query(`SELECT payload FROM ${this.tableName}
+           WHERE service = $1 AND object_type = 'plans' AND object_id = $2
+             AND deleted_at IS NULL FOR UPDATE`, [this.service, plan.plan_id]);
+        const current = row.rows[0] ? payloadOf(row.rows[0]) : null;
+        if (!current || String(current.project_id ?? "") !== String(plan.project_id ?? "") || (current.task_list_id ?? null) !== plan.task_list_id || timestamp(current.updated_at ?? row.rows[0]?.updated_at) !== plan.updated_at) {
+          throw new TodosTaskSubtreeTransferError("TODOS_TASK_SUBTREE_TRANSFER_CAS_CONFLICT", "Contained plan changed during transfer", { plan_id: plan.plan_id });
+        }
+        const result2 = await tx.query(`UPDATE ${this.tableName} SET payload = jsonb_set(jsonb_set(jsonb_set(payload, '{project_id}', to_jsonb($1::text)), '{task_list_id}', to_jsonb($2::text)), '{updated_at}', to_jsonb($3::text)), updated_at = $3
+           WHERE service = $4 AND object_type = 'plans' AND object_id = $5 AND deleted_at IS NULL
+           RETURNING object_id`, [input.destination_project_id, input.destination_task_list_id, now, this.service, plan.plan_id]);
+        if (result2.rows.length !== 1) {
+          throw new TodosTaskSubtreeTransferError("TODOS_TASK_SUBTREE_TRANSFER_CAS_CONFLICT", "Contained plan update did not affect exactly one row", { plan_id: plan.plan_id });
+        }
+      }
+      if (options.faultInjector && await options.faultInjector("after_plan_writes"))
+        throw new Error("Injected task-subtree-transfer fault at after_plan_writes");
+      const postImage = {
+        tasks: prepared.prior_tasks.map((task) => ({
+          ...task,
+          project_id: input.destination_project_id,
+          task_list_id: input.destination_task_list_id,
+          plan_id: prepared.task_plan_targets.get(task.task_id) ?? null,
+          parent_id: task.task_id === input.root_task_id ? input.destination_parent_id : task.parent_id,
+          version: task.version + 1,
+          updated_at: now
+        })),
+        plans: prepared.prior_plans.map((plan) => ({ ...plan, project_id: input.destination_project_id, task_list_id: input.destination_task_list_id, updated_at: now }))
+      };
+      const resultDigest = canonicalDigest({ route: TODOS_TASK_SUBTREE_TRANSFER_ROUTE, request_digest: requestDigest, prior_image: priorImage, post_image: postImage });
+      const receipt = {
+        receipt_id: deterministicUuid(TODOS_TASK_SUBTREE_TRANSFER_ROUTE, "apply", input.operation_id, input.step_id, input.idempotency_key, requestDigest),
+        authority: "todos",
+        route: TODOS_TASK_SUBTREE_TRANSFER_ROUTE,
+        schema_version: 1,
+        kind: "apply",
+        operation_id: input.operation_id,
+        step_id: input.step_id,
+        idempotency_key: input.idempotency_key,
+        request_digest: requestDigest,
+        precondition_digest: input.precondition_digest,
+        result_digest: resultDigest,
+        apply_receipt_id: null,
+        source_project_id: input.source_project_id,
+        destination_project_id: input.destination_project_id,
+        destination_task_list_id: input.destination_task_list_id,
+        root_task_id: input.root_task_id,
+        source_population_digest: input.source_population_digest,
+        prior_image: priorImage,
+        post_image: postImage,
+        shared_plan_splits: input.shared_plan_splits,
+        created_at: now
+      };
+      const result = { duplicate: false, receipt, moved_task_ids: prepared.prior_tasks.map((task) => task.task_id), moved_plan_ids: prepared.prior_plans.map((plan) => plan.plan_id), complete: true };
+      await tx.query(`INSERT INTO todos_task_subtree_transfer_receipts (
+          receipt_id, tenant_id, kind, operation_id, step_id, idempotency_key,
+          request_digest, precondition_digest, result_digest, apply_receipt_id,
+          request_json, result_json, created_at
+        ) VALUES ($1, $2, 'apply', $3, $4, $5, $6, $7, $8, NULL, $9::jsonb, $10::jsonb, $11)`, [receipt.receipt_id, this.tenantId, receipt.operation_id, receipt.step_id, receipt.idempotency_key, receipt.request_digest, receipt.precondition_digest, receipt.result_digest, canonicalJson(input), canonicalJson(result), now]);
+      if (options.faultInjector && await options.faultInjector("after_receipt_write"))
+        throw new Error("Injected task-subtree-transfer fault at after_receipt_write");
+      return result;
+    });
+  }
+  async readExact(receiptId) {
+    await this.ensureSchema();
+    const row = await this.client.query(`SELECT result_json FROM todos_task_subtree_transfer_receipts WHERE tenant_id = $1 AND receipt_id = $2 LIMIT 1`, [this.tenantId, receiptId]);
+    if (!row.rows[0])
+      throw new TodosTaskSubtreeTransferError("TODOS_TASK_SUBTREE_TRANSFER_RECEIPT_NOT_FOUND", `Transfer receipt not found: ${receiptId}`);
+    return { ...typeof row.rows[0].result_json === "string" ? JSON.parse(String(row.rows[0].result_json)) : row.rows[0].result_json, duplicate: false };
+  }
+  async rollback(input, options) {
+    await this.ensureSchema();
+    if (!this.client.transaction)
+      throw new TodosTaskSubtreeTransferError("TODOS_TASK_SUBTREE_TRANSFER_ATOMICITY_UNAVAILABLE", "PostgreSQL subtree rollback requires a transaction-capable client");
+    return this.client.transaction(async (tx) => {
+      await tx.query("SELECT pg_advisory_xact_lock(hashtextextended('todos:task-parent-integrity', 0))");
+      const requestDigest = taskSubtreeTransferRollbackRequestDigest(input);
+      const existing = await tx.query(`SELECT result_json, request_digest, precondition_digest, idempotency_key
+         FROM todos_task_subtree_transfer_receipts
+         WHERE tenant_id = $1 AND kind = 'rollback'
+           AND (idempotency_key = $2 OR (operation_id = $3 AND step_id = $4))
+         ORDER BY created_at ASC LIMIT 1`, [this.tenantId, input.idempotency_key, input.operation_id, input.step_id]);
+      if (existing.rows[0]) {
+        const row = existing.rows[0];
+        if (row.request_digest !== requestDigest || row.precondition_digest !== input.precondition_digest || row.idempotency_key !== input.idempotency_key)
+          throw new TodosTaskSubtreeTransferError("TODOS_TASK_SUBTREE_TRANSFER_IDEMPOTENCY_CONFLICT", "The rollback operation was already accepted for a different request");
+        return { ...typeof row.result_json === "string" ? JSON.parse(String(row.result_json)) : row.result_json, duplicate: true };
+      }
+      const applyRow = await tx.query(`SELECT result_json FROM todos_task_subtree_transfer_receipts WHERE tenant_id = $1 AND kind = 'apply' AND receipt_id = $2 LIMIT 1`, [this.tenantId, input.receipt_id]);
+      if (!applyRow.rows[0])
+        throw new TodosTaskSubtreeTransferError("TODOS_TASK_SUBTREE_TRANSFER_RECEIPT_NOT_FOUND", `Apply receipt not found: ${input.receipt_id}`);
+      const applied = typeof applyRow.rows[0].result_json === "string" ? JSON.parse(String(applyRow.rows[0].result_json)) : applyRow.rows[0].result_json;
+      if (applied.receipt.operation_id !== input.operation_id) {
+        throw new TodosTaskSubtreeTransferError("TODOS_TASK_SUBTREE_TRANSFER_ROLLBACK_CONFLICT", "Rollback operation does not match the apply receipt");
+      }
+      const expectedPrecondition = canonicalDigest({ route: TODOS_TASK_SUBTREE_TRANSFER_ROUTE, direction: "rollback", operation_id: input.operation_id, step_id: input.step_id, apply_receipt_id: input.receipt_id, apply_result_digest: applied.receipt.result_digest });
+      if (input.precondition_digest !== expectedPrecondition)
+        throw new TodosTaskSubtreeTransferError("TODOS_TASK_SUBTREE_TRANSFER_DIGEST_MISMATCH", "Rollback precondition digest does not match the exact apply receipt", { expected_precondition_digest: expectedPrecondition });
+      const now = options.now?.() ?? new Date().toISOString();
+      for (const task of applied.receipt.post_image.tasks) {
+        const row = await tx.query(`SELECT payload FROM ${this.tableName} WHERE service = $1 AND object_type = 'tasks' AND object_id = $2 AND deleted_at IS NULL FOR UPDATE`, [this.service, task.task_id]);
+        if (!row.rows[0])
+          throw new TodosTaskSubtreeTransferError("TODOS_TASK_SUBTREE_TRANSFER_ROLLBACK_CONFLICT", "Transferred task disappeared", { task_id: task.task_id });
+        const payload = payloadOf(row.rows[0]);
+        if (Number(payload.version ?? 1) !== task.version || String(payload.project_id ?? "") !== String(task.project_id ?? "") || (payload.parent_id ?? null) !== task.parent_id || (payload.plan_id ?? null) !== task.plan_id || (payload.task_list_id ?? null) !== task.task_list_id)
+          throw new TodosTaskSubtreeTransferError("TODOS_TASK_SUBTREE_TRANSFER_ROLLBACK_CONFLICT", "Transferred task changed after apply", { task_id: task.task_id });
+      }
+      for (const task of applied.receipt.prior_image.tasks) {
+        const row = await tx.query(`SELECT payload FROM ${this.tableName} WHERE service = $1 AND object_type = 'tasks' AND object_id = $2 AND deleted_at IS NULL`, [this.service, task.task_id]);
+        const payload = row.rows[0] ? payloadOf(row.rows[0]) : null;
+        if (!payload)
+          throw new TodosTaskSubtreeTransferError("TODOS_TASK_SUBTREE_TRANSFER_ROLLBACK_CONFLICT", "Task disappeared during rollback", { task_id: task.task_id });
+        const next = { ...payload, project_id: task.project_id, task_list_id: task.task_list_id, plan_id: task.plan_id, parent_id: task.parent_id, version: task.version + 2, updated_at: now };
+        const result2 = await tx.query(`UPDATE ${this.tableName} SET payload = $1::jsonb, updated_at = $2, version = $3
+           WHERE service = $4 AND object_type = 'tasks' AND object_id = $5 AND deleted_at IS NULL AND version = $6
+           RETURNING object_id`, [canonicalJson(next), now, task.version + 2, this.service, task.task_id, task.version + 1]);
+        if (result2.rows.length !== 1) {
+          throw new TodosTaskSubtreeTransferError("TODOS_TASK_SUBTREE_TRANSFER_ROLLBACK_CONFLICT", "Task rollback did not affect exactly one row", { task_id: task.task_id });
+        }
+      }
+      if (options.faultInjector && await options.faultInjector("after_rollback_task_writes"))
+        throw new Error("Injected task-subtree-transfer fault at after_rollback_task_writes");
+      for (const plan of applied.receipt.prior_image.plans) {
+        const post = applied.receipt.post_image.plans.find((candidate) => candidate.plan_id === plan.plan_id);
+        const result2 = await tx.query(`UPDATE ${this.tableName}
+           SET payload = jsonb_set(
+             jsonb_set(
+               jsonb_set(payload, '{project_id}', to_jsonb($1::text)),
+               '{task_list_id}',
+               COALESCE(to_jsonb($2::text), 'null'::jsonb)
+             ),
+             '{updated_at}',
+             to_jsonb($3::text)
+           ), updated_at = $3
+           WHERE service = $4 AND object_type = 'plans' AND object_id = $5 AND deleted_at IS NULL
+             AND payload->>'project_id' = $6 AND COALESCE(payload->>'task_list_id', '') = COALESCE($7, '') AND payload->>'updated_at' = $8
+           RETURNING object_id`, [plan.project_id, plan.task_list_id, now, this.service, plan.plan_id, post.project_id, post.task_list_id, post.updated_at]);
+        if (result2.rows.length !== 1) {
+          throw new TodosTaskSubtreeTransferError("TODOS_TASK_SUBTREE_TRANSFER_ROLLBACK_CONFLICT", "Contained plan rollback did not affect exactly one row", { plan_id: plan.plan_id });
+        }
+      }
+      if (options.faultInjector && await options.faultInjector("after_rollback_plan_writes"))
+        throw new Error("Injected task-subtree-transfer fault at after_rollback_plan_writes");
+      const restored = {
+        tasks: applied.receipt.prior_image.tasks.map((task) => ({ ...task, version: task.version + 2, updated_at: now })),
+        plans: applied.receipt.prior_image.plans.map((plan) => ({ ...plan, updated_at: now }))
+      };
+      const resultDigest = canonicalDigest({ route: TODOS_TASK_SUBTREE_TRANSFER_ROUTE, direction: "rollback", apply_receipt_id: input.receipt_id, prior_image: applied.receipt.post_image, post_image: restored });
+      const receipt = { ...applied.receipt, receipt_id: deterministicUuid(TODOS_TASK_SUBTREE_TRANSFER_ROUTE, "rollback", input.operation_id, input.step_id, input.idempotency_key, input.receipt_id), kind: "rollback", operation_id: input.operation_id, step_id: input.step_id, idempotency_key: input.idempotency_key, request_digest: requestDigest, precondition_digest: input.precondition_digest, result_digest: resultDigest, apply_receipt_id: input.receipt_id, prior_image: applied.receipt.post_image, post_image: restored, created_at: now };
+      const result = { duplicate: false, receipt, moved_task_ids: applied.moved_task_ids, moved_plan_ids: applied.moved_plan_ids, complete: true };
+      await tx.query(`INSERT INTO todos_task_subtree_transfer_receipts (
+          receipt_id, tenant_id, kind, operation_id, step_id, idempotency_key,
+          request_digest, precondition_digest, result_digest, apply_receipt_id,
+          request_json, result_json, created_at
+        ) VALUES ($1, $2, 'rollback', $3, $4, $5, $6, $7, $8, $9, $10::jsonb, $11::jsonb, $12)`, [receipt.receipt_id, this.tenantId, receipt.operation_id, receipt.step_id, receipt.idempotency_key, receipt.request_digest, receipt.precondition_digest, receipt.result_digest, receipt.apply_receipt_id, canonicalJson(input), canonicalJson(result), now]);
+      if (options.faultInjector && await options.faultInjector("after_rollback_receipt_write"))
+        throw new Error("Injected task-subtree-transfer fault at after_rollback_receipt_write");
+      return result;
+    });
+  }
+}
+
+// src/task-subtree-transfer/sqlite.ts
+var sqliteTails = new WeakMap;
+async function fault(options, point) {
+  if (options.faultInjector && await options.faultInjector(point) === true) {
+    throw new Error(`Injected task-subtree-transfer fault at ${point}`);
+  }
+}
+function parseResult(value, duplicate) {
+  return { ...JSON.parse(value), duplicate };
+}
+function rowImage(row) {
+  return {
+    task_id: String(row.id),
+    project_id: row.project_id == null ? null : String(row.project_id),
+    parent_id: row.parent_id == null ? null : String(row.parent_id),
+    plan_id: row.plan_id == null ? null : String(row.plan_id),
+    task_list_id: row.task_list_id == null ? null : String(row.task_list_id),
+    version: Number(row.version),
+    updated_at: String(row.updated_at),
+    archived_at: row.archived_at == null ? null : String(row.archived_at)
+  };
+}
+function planImage(row) {
+  return {
+    plan_id: String(row.id),
+    project_id: row.project_id == null ? null : String(row.project_id),
+    task_list_id: row.task_list_id == null ? null : String(row.task_list_id),
+    updated_at: String(row.updated_at)
+  };
+}
+function imageFromTaskRow(row) {
+  const image = rowImage(row);
+  const { archived_at: _archivedAt, ...withoutArchive } = image;
+  return withoutArchive;
+}
+function imageFromPlanRow(row) {
+  return planImage(row);
+}
+function receiptId(input) {
+  return deterministicUuid(TODOS_TASK_SUBTREE_TRANSFER_ROUTE, "apply", input.operation_id, input.step_id, input.idempotency_key, taskSubtreeTransferRequestDigest(input));
+}
+function rollbackReceiptId(input) {
+  return deterministicUuid(TODOS_TASK_SUBTREE_TRANSFER_ROUTE, "rollback", input.operation_id, input.step_id, input.idempotency_key, input.receipt_id);
+}
+function taskWhere(db, taskId) {
+  const row = db.query(`SELECT id, project_id, parent_id, plan_id, task_list_id, version, updated_at, archived_at
+     FROM tasks WHERE id = ? LIMIT 1`).get(taskId);
+  if (!row) {
+    throw new TodosTaskSubtreeTransferError("TODOS_TASK_SUBTREE_TRANSFER_NOT_FOUND", `Task not found: ${taskId}`, { task_id: taskId });
+  }
+  return row;
+}
+
+class SqliteTodosTaskSubtreeTransferBackend {
+  db;
+  tenantId;
+  kind = "sqlite";
+  constructor(db, tenantId = "default") {
+    this.db = db;
+    this.tenantId = tenantId;
+    ensureSqliteTodosTaskSubtreeTransferSchema(db);
+  }
+  async serialized(run) {
+    const previous = sqliteTails.get(this.db) ?? Promise.resolve();
+    let release;
+    const current = new Promise((resolve) => {
+      release = resolve;
+    });
+    const tail = previous.then(() => current);
+    sqliteTails.set(this.db, tail);
+    await previous;
+    try {
+      this.db.exec("BEGIN IMMEDIATE");
+      try {
+        const result = await run();
+        this.db.exec("COMMIT");
+        return result;
+      } catch (error) {
+        this.db.exec("ROLLBACK");
+        throw error;
+      }
+    } finally {
+      release();
+      if (sqliteTails.get(this.db) === tail)
+        sqliteTails.delete(this.db);
+    }
+  }
+  snapshot(input) {
+    const sourceTasks = this.db.query(`SELECT id, project_id, parent_id, plan_id, task_list_id, version, updated_at, archived_at
+       FROM tasks WHERE project_id = ? ORDER BY id`).all(input.source_project_id).map(rowImage);
+    const allTasks = this.db.query(`SELECT id, project_id, parent_id, plan_id, task_list_id, version, updated_at, archived_at
+       FROM tasks ORDER BY id`).all().map(rowImage);
+    const plans = this.db.query(`SELECT id, project_id, task_list_id, updated_at
+       FROM plans ORDER BY id`).all().map(planImage);
+    const destinationProjectFound = Boolean(this.db.query("SELECT id FROM projects WHERE id = ? LIMIT 1").get(input.destination_project_id));
+    const destinationTaskList = this.db.query("SELECT id FROM task_lists WHERE id = ? AND project_id = ? LIMIT 1").get(input.destination_task_list_id, input.destination_project_id);
+    const destinationParentFound = input.destination_parent_id === null || Boolean(this.db.query("SELECT id FROM tasks WHERE id = ? AND project_id = ? LIMIT 1").get(input.destination_parent_id, input.destination_project_id));
+    return {
+      source_tasks: sourceTasks,
+      plan_tasks: allTasks,
+      plans,
+      destination_project_found: destinationProjectFound,
+      destination_task_list_found: Boolean(destinationTaskList),
+      destination_parent_found: destinationParentFound
+    };
+  }
+  async inspect(input) {
+    return this.serialized(() => prepareTransfer(this.snapshot(input), input).inspection);
+  }
+  async apply(input, options) {
+    return this.serialized(async () => {
+      const requestDigest = taskSubtreeTransferRequestDigest(input);
+      const existing = this.db.query(`SELECT result_json, request_digest, precondition_digest, idempotency_key
+         FROM todos_task_subtree_transfer_receipts
+         WHERE tenant_id = ? AND kind = 'apply'
+           AND (idempotency_key = ? OR (operation_id = ? AND step_id = ?))
+         ORDER BY created_at ASC LIMIT 1`).get(this.tenantId, input.idempotency_key, input.operation_id, input.step_id);
+      if (existing) {
+        if (existing.request_digest !== requestDigest || existing.precondition_digest !== input.precondition_digest || existing.idempotency_key !== input.idempotency_key) {
+          throw new TodosTaskSubtreeTransferError("TODOS_TASK_SUBTREE_TRANSFER_IDEMPOTENCY_CONFLICT", "The operation/step or idempotency key was already accepted for a different request");
+        }
+        return parseResult(String(existing.result_json), true);
+      }
+      const snapshot = this.snapshot(input);
+      const prepared = prepareTransfer(snapshot, input);
+      validateApplySnapshot(prepared, input, snapshot.plans);
+      const priorImage = {
+        tasks: prepared.prior_tasks,
+        plans: prepared.prior_plans
+      };
+      const now = options.now?.() ?? new Date().toISOString();
+      const movedTaskIds = prepared.prior_tasks.map((task) => task.task_id);
+      for (const task of prepared.prior_tasks) {
+        const current = imageFromTaskRow(taskWhere(this.db, task.task_id));
+        if (canonicalJson(current) !== canonicalJson(task)) {
+          throw new TodosTaskSubtreeTransferError("TODOS_TASK_SUBTREE_TRANSFER_CAS_CONFLICT", "A task changed after inspection", { task_id: task.task_id });
+        }
+      }
+      for (const task of prepared.prior_tasks) {
+        const targetPlan = prepared.task_plan_targets.get(task.task_id) ?? null;
+        const parentId = task.task_id === input.root_task_id ? input.destination_parent_id : task.parent_id;
+        const result2 = this.db.query(`UPDATE tasks
+           SET project_id = ?, task_list_id = ?, plan_id = ?, parent_id = ?, version = version + 1, updated_at = ?
+           WHERE id = ? AND version = ?`).run(input.destination_project_id, input.destination_task_list_id, targetPlan, parentId, now, task.task_id, task.version);
+        if (result2.changes !== 1) {
+          throw new TodosTaskSubtreeTransferError("TODOS_TASK_SUBTREE_TRANSFER_CAS_CONFLICT", "A task version changed during the atomic transfer", { task_id: task.task_id });
+        }
+      }
+      await fault(options, "after_task_writes");
+      for (const plan of prepared.prior_plans) {
+        const result2 = this.db.query(`UPDATE plans SET project_id = ?, task_list_id = ?, updated_at = ?
+           WHERE id = ? AND project_id IS ? AND task_list_id IS ? AND updated_at = ?`).run(input.destination_project_id, input.destination_task_list_id, now, plan.plan_id, plan.project_id, plan.task_list_id, plan.updated_at);
+        if (result2.changes !== 1) {
+          throw new TodosTaskSubtreeTransferError("TODOS_TASK_SUBTREE_TRANSFER_CAS_CONFLICT", "A contained plan changed during the atomic transfer", { plan_id: plan.plan_id });
+        }
+      }
+      await fault(options, "after_plan_writes");
+      const postImage = {
+        tasks: prepared.prior_tasks.map((task) => ({
+          ...task,
+          project_id: input.destination_project_id,
+          task_list_id: input.destination_task_list_id,
+          plan_id: prepared.task_plan_targets.get(task.task_id) ?? null,
+          parent_id: task.task_id === input.root_task_id ? input.destination_parent_id : task.parent_id,
+          version: task.version + 1,
+          updated_at: now
+        })),
+        plans: prepared.prior_plans.map((plan) => ({
+          ...plan,
+          project_id: input.destination_project_id,
+          task_list_id: input.destination_task_list_id,
+          updated_at: now
+        }))
+      };
+      const resultDigest = canonicalDigest({
+        route: TODOS_TASK_SUBTREE_TRANSFER_ROUTE,
+        request_digest: requestDigest,
+        prior_image: priorImage,
+        post_image: postImage
+      });
+      const receipt = {
+        receipt_id: receiptId(input),
+        authority: "todos",
+        route: TODOS_TASK_SUBTREE_TRANSFER_ROUTE,
+        schema_version: 1,
+        kind: "apply",
+        operation_id: input.operation_id,
+        step_id: input.step_id,
+        idempotency_key: input.idempotency_key,
+        request_digest: requestDigest,
+        precondition_digest: input.precondition_digest,
+        result_digest: resultDigest,
+        apply_receipt_id: null,
+        source_project_id: input.source_project_id,
+        destination_project_id: input.destination_project_id,
+        destination_task_list_id: input.destination_task_list_id,
+        root_task_id: input.root_task_id,
+        source_population_digest: input.source_population_digest,
+        prior_image: priorImage,
+        post_image: postImage,
+        shared_plan_splits: input.shared_plan_splits,
+        created_at: now
+      };
+      const result = {
+        duplicate: false,
+        receipt,
+        moved_task_ids: movedTaskIds,
+        moved_plan_ids: prepared.prior_plans.map((plan) => plan.plan_id),
+        complete: true
+      };
+      this.db.query(`INSERT INTO todos_task_subtree_transfer_receipts (
+          receipt_id, tenant_id, kind, operation_id, step_id, idempotency_key,
+          request_digest, precondition_digest, result_digest, apply_receipt_id,
+          request_json, result_json, created_at
+        ) VALUES (?, ?, 'apply', ?, ?, ?, ?, ?, ?, NULL, ?, ?, ?)`).run(receipt.receipt_id, this.tenantId, receipt.operation_id, receipt.step_id, receipt.idempotency_key, receipt.request_digest, receipt.precondition_digest, receipt.result_digest, canonicalJson(input), canonicalJson(result), now);
+      await fault(options, "after_receipt_write");
+      return result;
+    });
+  }
+  async readExact(receiptIdValue) {
+    const row = this.db.query(`SELECT result_json FROM todos_task_subtree_transfer_receipts
+       WHERE tenant_id = ? AND receipt_id = ? LIMIT 1`).get(this.tenantId, receiptIdValue);
+    if (!row) {
+      throw new TodosTaskSubtreeTransferError("TODOS_TASK_SUBTREE_TRANSFER_RECEIPT_NOT_FOUND", `Transfer receipt not found: ${receiptIdValue}`);
+    }
+    return parseResult(String(row.result_json), false);
+  }
+  async rollback(input, options) {
+    return this.serialized(async () => {
+      const requestDigest = taskSubtreeTransferRollbackRequestDigest(input);
+      const existing = this.db.query(`SELECT result_json, request_digest, precondition_digest, idempotency_key
+         FROM todos_task_subtree_transfer_receipts
+         WHERE tenant_id = ? AND kind = 'rollback'
+           AND (idempotency_key = ? OR (operation_id = ? AND step_id = ?))
+         ORDER BY created_at ASC LIMIT 1`).get(this.tenantId, input.idempotency_key, input.operation_id, input.step_id);
+      if (existing) {
+        if (existing.request_digest !== requestDigest || existing.precondition_digest !== input.precondition_digest || existing.idempotency_key !== input.idempotency_key) {
+          throw new TodosTaskSubtreeTransferError("TODOS_TASK_SUBTREE_TRANSFER_IDEMPOTENCY_CONFLICT", "The rollback operation/step or idempotency key was already accepted for a different request");
+        }
+        return parseResult(String(existing.result_json), true);
+      }
+      const applyRow = this.db.query(`SELECT result_json FROM todos_task_subtree_transfer_receipts
+         WHERE tenant_id = ? AND kind = 'apply' AND receipt_id = ? LIMIT 1`).get(this.tenantId, input.receipt_id);
+      if (!applyRow) {
+        throw new TodosTaskSubtreeTransferError("TODOS_TASK_SUBTREE_TRANSFER_RECEIPT_NOT_FOUND", `Apply receipt not found: ${input.receipt_id}`);
+      }
+      const applied = parseResult(String(applyRow.result_json), false);
+      if (applied.receipt.operation_id !== input.operation_id) {
+        throw new TodosTaskSubtreeTransferError("TODOS_TASK_SUBTREE_TRANSFER_ROLLBACK_CONFLICT", "Rollback operation does not match the apply receipt");
+      }
+      const expectedPrecondition = canonicalDigest({
+        route: TODOS_TASK_SUBTREE_TRANSFER_ROUTE,
+        direction: "rollback",
+        operation_id: input.operation_id,
+        step_id: input.step_id,
+        apply_receipt_id: input.receipt_id,
+        apply_result_digest: applied.receipt.result_digest
+      });
+      if (input.precondition_digest !== expectedPrecondition) {
+        throw new TodosTaskSubtreeTransferError("TODOS_TASK_SUBTREE_TRANSFER_DIGEST_MISMATCH", "Rollback precondition digest does not match the exact apply receipt", { expected_precondition_digest: expectedPrecondition });
+      }
+      const now = options.now?.() ?? new Date().toISOString();
+      for (const task of applied.receipt.post_image.tasks) {
+        const current = imageFromTaskRow(taskWhere(this.db, task.task_id));
+        if (canonicalJson(current) !== canonicalJson(task)) {
+          throw new TodosTaskSubtreeTransferError("TODOS_TASK_SUBTREE_TRANSFER_ROLLBACK_CONFLICT", "Rollback refused because a transferred task changed after apply", { task_id: task.task_id });
+        }
+      }
+      for (const plan of applied.receipt.post_image.plans) {
+        const row = this.db.query("SELECT id, project_id, task_list_id, updated_at FROM plans WHERE id = ? LIMIT 1").get(plan.plan_id);
+        if (!row || canonicalJson(imageFromPlanRow(row)) !== canonicalJson(plan)) {
+          throw new TodosTaskSubtreeTransferError("TODOS_TASK_SUBTREE_TRANSFER_ROLLBACK_CONFLICT", "Rollback refused because a transferred plan changed after apply", { plan_id: plan.plan_id });
+        }
+      }
+      for (const task of applied.receipt.prior_image.tasks) {
+        const result2 = this.db.query(`UPDATE tasks SET project_id = ?, task_list_id = ?, plan_id = ?, parent_id = ?,
+             version = version + 1, updated_at = ?
+           WHERE id = ? AND version = ?`).run(task.project_id, task.task_list_id, task.plan_id, task.parent_id, now, task.task_id, applied.receipt.post_image.tasks.find((candidate) => candidate.task_id === task.task_id).version);
+        if (result2.changes !== 1) {
+          throw new TodosTaskSubtreeTransferError("TODOS_TASK_SUBTREE_TRANSFER_ROLLBACK_CONFLICT", "Rollback task CAS failed", { task_id: task.task_id });
+        }
+      }
+      await fault(options, "after_rollback_task_writes");
+      for (const plan of applied.receipt.prior_image.plans) {
+        const post = applied.receipt.post_image.plans.find((candidate) => candidate.plan_id === plan.plan_id);
+        const result2 = this.db.query(`UPDATE plans SET project_id = ?, task_list_id = ?, updated_at = ?
+           WHERE id = ? AND project_id IS ? AND task_list_id IS ? AND updated_at = ?`).run(plan.project_id, plan.task_list_id, now, plan.plan_id, post.project_id, post.task_list_id, post.updated_at);
+        if (result2.changes !== 1) {
+          throw new TodosTaskSubtreeTransferError("TODOS_TASK_SUBTREE_TRANSFER_ROLLBACK_CONFLICT", "Rollback plan CAS failed", { plan_id: plan.plan_id });
+        }
+      }
+      await fault(options, "after_rollback_plan_writes");
+      const restored = {
+        tasks: applied.receipt.prior_image.tasks.map((task) => ({
+          ...task,
+          version: applied.receipt.post_image.tasks.find((candidate) => candidate.task_id === task.task_id).version + 1,
+          updated_at: now
+        })),
+        plans: applied.receipt.prior_image.plans.map((plan) => ({ ...plan, updated_at: now }))
+      };
+      const resultDigest = canonicalDigest({
+        route: TODOS_TASK_SUBTREE_TRANSFER_ROUTE,
+        direction: "rollback",
+        apply_receipt_id: input.receipt_id,
+        prior_image: applied.receipt.post_image,
+        post_image: restored
+      });
+      const receipt = {
+        ...applied.receipt,
+        receipt_id: rollbackReceiptId(input),
+        kind: "rollback",
+        step_id: input.step_id,
+        idempotency_key: input.idempotency_key,
+        request_digest: requestDigest,
+        precondition_digest: input.precondition_digest,
+        result_digest: resultDigest,
+        apply_receipt_id: input.receipt_id,
+        prior_image: applied.receipt.post_image,
+        post_image: restored,
+        created_at: now
+      };
+      const result = {
+        duplicate: false,
+        receipt,
+        moved_task_ids: applied.moved_task_ids,
+        moved_plan_ids: applied.moved_plan_ids,
+        complete: true
+      };
+      this.db.query(`INSERT INTO todos_task_subtree_transfer_receipts (
+          receipt_id, tenant_id, kind, operation_id, step_id, idempotency_key,
+          request_digest, precondition_digest, result_digest, apply_receipt_id,
+          request_json, result_json, created_at
+        ) VALUES (?, ?, 'rollback', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(receipt.receipt_id, this.tenantId, receipt.operation_id, receipt.step_id, receipt.idempotency_key, receipt.request_digest, receipt.precondition_digest, receipt.result_digest, receipt.apply_receipt_id, canonicalJson(input), canonicalJson(result), now);
+      await fault(options, "after_rollback_receipt_write");
+      return result;
+    });
+  }
+}
+
+// src/task-subtree-transfer/authority.ts
+var UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+var DIGEST = /^[0-9a-f]{64}$/i;
+function boundedString(value, field, max = 200) {
+  if (typeof value !== "string" || value.length === 0 || value.length > max) {
+    throw new TodosTaskSubtreeTransferError("TODOS_TASK_SUBTREE_TRANSFER_INVALID_INPUT", `${field} must be a non-empty bounded string`);
+  }
+  return value;
+}
+function uuid(value, field) {
+  const parsed = boundedString(value, field, 80);
+  if (!UUID.test(parsed)) {
+    throw new TodosTaskSubtreeTransferError("TODOS_TASK_SUBTREE_TRANSFER_INVALID_INPUT", `${field} must be a UUID`);
+  }
+  return parsed;
+}
+function digest(value, field) {
+  const parsed = boundedString(value, field, 64);
+  if (!DIGEST.test(parsed)) {
+    throw new TodosTaskSubtreeTransferError("TODOS_TASK_SUBTREE_TRANSFER_INVALID_INPUT", `${field} must be a SHA-256 digest`);
+  }
+  return parsed.toLowerCase();
+}
+function nullableUuid(value, field) {
+  if (value === null)
+    return null;
+  return uuid(value, field);
+}
+function strictObject(input, fields) {
+  if (input === null || typeof input !== "object" || Array.isArray(input)) {
+    throw new TodosTaskSubtreeTransferError("TODOS_TASK_SUBTREE_TRANSFER_INVALID_INPUT", "Request must be a JSON object");
+  }
+  const object = input;
+  const allowed = new Set(fields);
+  for (const key of Object.keys(object)) {
+    if (!allowed.has(key)) {
+      throw new TodosTaskSubtreeTransferError("TODOS_TASK_SUBTREE_TRANSFER_INVALID_INPUT", `Unknown field: ${key}`);
+    }
+  }
+  return object;
+}
+var INSPECT_FIELDS = [
+  "source_project_id",
+  "destination_project_id",
+  "destination_task_list_id",
+  "root_task_id",
+  "destination_parent_id"
+];
+function parseTodosTaskSubtreeTransferInspect(input) {
+  const value = strictObject(input, INSPECT_FIELDS);
+  const request = {
+    source_project_id: uuid(value.source_project_id, "source_project_id"),
+    destination_project_id: uuid(value.destination_project_id, "destination_project_id"),
+    destination_task_list_id: uuid(value.destination_task_list_id, "destination_task_list_id"),
+    root_task_id: uuid(value.root_task_id, "root_task_id"),
+    destination_parent_id: nullableUuid(value.destination_parent_id, "destination_parent_id")
+  };
+  if (request.source_project_id === request.destination_project_id) {
+    throw new TodosTaskSubtreeTransferError("TODOS_TASK_SUBTREE_TRANSFER_INVALID_INPUT", "source_project_id and destination_project_id must identify different Projects");
+  }
+  return request;
+}
+var APPLY_FIELDS = [
+  ...INSPECT_FIELDS,
+  "version",
+  "operation_id",
+  "step_id",
+  "idempotency_key",
+  "precondition_digest",
+  "expected_root_parent_id",
+  "source_population_digest",
+  "expected_tasks",
+  "shared_plan_splits"
+];
+function parseTodosTaskSubtreeTransferApply(input) {
+  const value = strictObject(input, APPLY_FIELDS);
+  if (value.version !== 1) {
+    throw new TodosTaskSubtreeTransferError("TODOS_TASK_SUBTREE_TRANSFER_INVALID_INPUT", "version must be 1");
+  }
+  if (!Array.isArray(value.expected_tasks) || value.expected_tasks.length === 0) {
+    throw new TodosTaskSubtreeTransferError("TODOS_TASK_SUBTREE_TRANSFER_INVALID_INPUT", "expected_tasks must be a non-empty array");
+  }
+  const expected_tasks = value.expected_tasks.map((item, index) => {
+    const row = strictObject(item, ["task_id", "version"]);
+    const version = row.version;
+    if (!Number.isSafeInteger(version) || Number(version) < 1) {
+      throw new TodosTaskSubtreeTransferError("TODOS_TASK_SUBTREE_TRANSFER_INVALID_INPUT", `expected_tasks.${index}.version must be a positive integer`);
+    }
+    return { task_id: uuid(row.task_id, `expected_tasks.${index}.task_id`), version: Number(version) };
+  });
+  const ids = new Set;
+  for (const row of expected_tasks) {
+    if (ids.has(row.task_id)) {
+      throw new TodosTaskSubtreeTransferError("TODOS_TASK_SUBTREE_TRANSFER_INVALID_INPUT", "expected_tasks must not contain duplicate task IDs");
+    }
+    ids.add(row.task_id);
+  }
+  if (!Array.isArray(value.shared_plan_splits)) {
+    throw new TodosTaskSubtreeTransferError("TODOS_TASK_SUBTREE_TRANSFER_INVALID_INPUT", "shared_plan_splits must be an array");
+  }
+  const shared_plan_splits = value.shared_plan_splits.map((item, index) => {
+    const row = strictObject(item, ["source_plan_id", "destination_plan_id"]);
+    return {
+      source_plan_id: uuid(row.source_plan_id, `shared_plan_splits.${index}.source_plan_id`),
+      destination_plan_id: uuid(row.destination_plan_id, `shared_plan_splits.${index}.destination_plan_id`)
+    };
+  });
+  return {
+    ...parseTodosTaskSubtreeTransferInspect({
+      source_project_id: value.source_project_id,
+      destination_project_id: value.destination_project_id,
+      destination_task_list_id: value.destination_task_list_id,
+      root_task_id: value.root_task_id,
+      destination_parent_id: value.destination_parent_id
+    }),
+    version: 1,
+    operation_id: boundedString(value.operation_id, "operation_id"),
+    step_id: boundedString(value.step_id, "step_id"),
+    idempotency_key: boundedString(value.idempotency_key, "idempotency_key", 240),
+    precondition_digest: digest(value.precondition_digest, "precondition_digest"),
+    expected_root_parent_id: nullableUuid(value.expected_root_parent_id, "expected_root_parent_id"),
+    source_population_digest: digest(value.source_population_digest, "source_population_digest"),
+    expected_tasks,
+    shared_plan_splits
+  };
+}
+function parseTodosTaskSubtreeTransferRollback(input) {
+  const value = strictObject(input, [
+    "receipt_id",
+    "operation_id",
+    "step_id",
+    "idempotency_key",
+    "precondition_digest"
+  ]);
+  return {
+    receipt_id: uuid(value.receipt_id, "receipt_id"),
+    operation_id: boundedString(value.operation_id, "operation_id"),
+    step_id: boundedString(value.step_id, "step_id"),
+    idempotency_key: boundedString(value.idempotency_key, "idempotency_key", 240),
+    precondition_digest: digest(value.precondition_digest, "precondition_digest")
+  };
+}
+function deriveTodosTaskSubtreeTransferApplyPreconditionDigest(input) {
+  const {
+    source_project_id,
+    destination_project_id,
+    destination_task_list_id,
+    root_task_id,
+    expected_root_parent_id,
+    destination_parent_id,
+    source_population_digest,
+    expected_tasks,
+    shared_plan_splits
+  } = input;
+  return canonicalDigest({
+    route: TODOS_TASK_SUBTREE_TRANSFER_ROUTE,
+    direction: "apply",
+    source_project_id,
+    destination_project_id,
+    destination_task_list_id,
+    root_task_id,
+    expected_root_parent_id,
+    destination_parent_id,
+    source_population_digest,
+    expected_tasks,
+    shared_plan_splits
+  });
+}
+function deriveTodosTaskSubtreeTransferRollbackPreconditionDigest(input) {
+  return canonicalDigest({
+    route: TODOS_TASK_SUBTREE_TRANSFER_ROUTE,
+    direction: "rollback",
+    apply_receipt_id: input.receipt_id,
+    operation_id: input.operation_id,
+    step_id: input.step_id,
+    apply_result_digest: input.apply_result_digest
+  });
+}
+function resolveTenantId(value) {
+  const tenant = value ?? "default";
+  if (!/^[A-Za-z0-9][A-Za-z0-9._:-]{0,199}$/.test(tenant)) {
+    throw new TodosTaskSubtreeTransferError("TODOS_TASK_SUBTREE_TRANSFER_INVALID_INPUT", "tenantId must be a bounded exact authority identifier");
+  }
+  return tenant;
+}
+
+class PackageOwnedTodosTaskSubtreeTransferAuthority {
+  backend;
+  tenantId;
+  backendOptions;
+  constructor(backend, options = {}) {
+    this.backend = backend;
+    this.tenantId = resolveTenantId(options.tenantId);
+    this.backendOptions = { ...options, tenantId: this.tenantId };
+  }
+  async capability() {
+    return {
+      authority: "todos",
+      route: TODOS_TASK_SUBTREE_TRANSFER_ROUTE,
+      schema_version: TODOS_TASK_SUBTREE_TRANSFER_SCHEMA_VERSION,
+      tenant_id: this.tenantId,
+      backend: this.backend.kind,
+      exact_descendant_closure: true,
+      complete_source_population_digest: true,
+      per_task_version_cas: true,
+      explicit_shared_plan_splits: true,
+      atomic_apply: true,
+      immutable_forward_inverse_receipts: true,
+      prior_image_receipts: true,
+      cas_protected_rollback: true,
+      preserves_descendant_parent_ids: true,
+      preserves_task_and_relation_identities: true
+    };
+  }
+  async inspect(input) {
+    return this.backend.inspect(parseTodosTaskSubtreeTransferInspect(input));
+  }
+  async apply(input) {
+    const request = parseTodosTaskSubtreeTransferApply(input);
+    const expected = deriveTodosTaskSubtreeTransferApplyPreconditionDigest(request);
+    if (request.precondition_digest !== expected) {
+      throw new TodosTaskSubtreeTransferError("TODOS_TASK_SUBTREE_TRANSFER_DIGEST_MISMATCH", "precondition_digest does not match the exact transfer target and source snapshot", { expected_precondition_digest: expected });
+    }
+    const requestDigest = taskSubtreeTransferRequestDigest(request);
+    const expectedKey = deriveTodosTaskSubtreeTransferIdempotencyKey({
+      operation_id: request.operation_id,
+      step_id: request.step_id,
+      direction: "apply",
+      target_selector: request.root_task_id,
+      request_digest: requestDigest,
+      precondition_digest: request.precondition_digest
+    });
+    if (request.idempotency_key !== expectedKey) {
+      throw new TodosTaskSubtreeTransferError("TODOS_TASK_SUBTREE_TRANSFER_IDEMPOTENCY_MISMATCH", "idempotency_key does not match the exact transfer request", { expected_idempotency_key: expectedKey });
+    }
+    return this.backend.apply(request, this.backendOptions);
+  }
+  async readExact(receiptIdValue) {
+    return this.backend.readExact(uuid(receiptIdValue, "receipt_id"));
+  }
+  async rollback(input) {
+    const request = parseTodosTaskSubtreeTransferRollback(input);
+    const requestDigest = taskSubtreeTransferRollbackRequestDigest(request);
+    const expectedKey = deriveTodosTaskSubtreeTransferIdempotencyKey({
+      operation_id: request.operation_id,
+      step_id: request.step_id,
+      direction: "rollback",
+      target_selector: request.receipt_id,
+      request_digest: requestDigest,
+      precondition_digest: request.precondition_digest
+    });
+    if (request.idempotency_key !== expectedKey) {
+      throw new TodosTaskSubtreeTransferError("TODOS_TASK_SUBTREE_TRANSFER_IDEMPOTENCY_MISMATCH", "rollback idempotency_key does not match the exact rollback request", { expected_idempotency_key: expectedKey });
+    }
+    return this.backend.rollback(request, this.backendOptions);
+  }
+}
+function createSqliteTodosTaskSubtreeTransferAuthority(options) {
+  return new PackageOwnedTodosTaskSubtreeTransferAuthority(new SqliteTodosTaskSubtreeTransferBackend(options.database, resolveTenantId(options.tenantId)), options);
+}
+function createPostgresTodosTaskSubtreeTransferAuthority(client, options = {}) {
+  return new PackageOwnedTodosTaskSubtreeTransferAuthority(new PostgresTodosTaskSubtreeTransferBackend(client, options), options);
+}
+// src/task-subtree-transfer/http.ts
+var JSON_HEADERS = { "Content-Type": "application/json" };
+var REQUEST_BYTES = 2 * 1024 * 1024;
+var RESPONSE_BYTES = 8 * 1024 * 1024;
+function json(body, status = 200) {
+  return new Response(JSON.stringify(body), { status, headers: JSON_HEADERS });
+}
+function status(error) {
+  switch (error.code) {
+    case "TODOS_TASK_SUBTREE_TRANSFER_INVALID_INPUT":
+    case "TODOS_TASK_SUBTREE_TRANSFER_FOREIGN_REFERENCE":
+    case "TODOS_TASK_SUBTREE_TRANSFER_HIERARCHY_CYCLE":
+      return 400;
+    case "TODOS_TASK_SUBTREE_TRANSFER_RECEIPT_NOT_FOUND":
+    case "TODOS_TASK_SUBTREE_TRANSFER_NOT_FOUND":
+      return 404;
+    case "TODOS_TASK_SUBTREE_TRANSFER_ATOMICITY_UNAVAILABLE":
+      return 503;
+    default:
+      return 409;
+  }
+}
+async function boundedText(message, limit) {
+  if (!message.body)
+    return "";
+  const reader = message.body.getReader();
+  const decoder = new TextDecoder;
+  let bytes = 0;
+  let text = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      bytes += value.byteLength;
+      if (bytes > limit) {
+        await reader.cancel();
+        throw new TodosTaskSubtreeTransferError("TODOS_TASK_SUBTREE_TRANSFER_INVALID_INPUT", "Task-subtree-transfer HTTP body exceeds the byte bound");
+      }
+      text += decoder.decode(value, { stream: true });
+    }
+    return text + decoder.decode();
+  } finally {
+    reader.releaseLock();
+  }
+}
+async function readBody(request) {
+  const declaredLength = Number(request.headers.get("content-length") ?? 0);
+  if (Number.isFinite(declaredLength) && declaredLength > REQUEST_BYTES) {
+    throw new TodosTaskSubtreeTransferError("TODOS_TASK_SUBTREE_TRANSFER_INVALID_INPUT", "Task-subtree-transfer request exceeds the byte bound");
+  }
+  const text = await boundedText(request, REQUEST_BYTES);
+  try {
+    return JSON.parse(text);
+  } catch {
+    throw new TodosTaskSubtreeTransferError("TODOS_TASK_SUBTREE_TRANSFER_INVALID_INPUT", "Invalid JSON body");
+  }
+}
+async function handleTodosTaskSubtreeTransferHttpRequest(request, url, authority, basePath = "/v1/task-subtree-transfer") {
+  if (url.pathname !== basePath && !url.pathname.startsWith(`${basePath}/`))
+    return null;
+  const action = url.pathname.slice(basePath.length).split("/").filter(Boolean).join("/");
+  try {
+    if ((action === "" || action === "capability") && request.method === "GET") {
+      return json({ capability: await authority.capability() });
+    }
+    if (request.method !== "POST")
+      return json({ error: "method not allowed" }, 405);
+    if (action === "inspect")
+      return json({ inspection: await authority.inspect(await readBody(request)) });
+    if (action === "apply")
+      return json({ result: await authority.apply(await readBody(request)) }, 201);
+    if (action === "rollback")
+      return json({ result: await authority.rollback(await readBody(request)) }, 201);
+    if (action === "read-exact") {
+      const input = await readBody(request);
+      if (!input || typeof input.receipt_id !== "string") {
+        throw new TodosTaskSubtreeTransferError("TODOS_TASK_SUBTREE_TRANSFER_INVALID_INPUT", "receipt_id is required");
+      }
+      return json({ result: await authority.readExact(input.receipt_id) });
+    }
+    return json({ error: "unknown task-subtree-transfer route" }, 404);
+  } catch (cause) {
+    if (cause instanceof TodosTaskSubtreeTransferError) {
+      return json({
+        error: cause.message,
+        code: cause.code,
+        details: cause.details,
+        authoritative: true
+      }, status(cause));
+    }
+    return json({ error: "internal task-subtree-transfer error" }, 500);
+  }
+}
+
+class TodosTaskSubtreeTransferHttpClient {
+  baseUrl;
+  fetchImpl;
+  headers;
+  constructor(options) {
+    this.baseUrl = options.baseUrl.replace(/\/+$/, "");
+    this.fetchImpl = options.fetch ?? globalThis.fetch;
+    this.headers = {
+      ...options.headers,
+      ...options.apiKey ? { Authorization: `Bearer ${options.apiKey}` } : {},
+      "Content-Type": "application/json"
+    };
+  }
+  async request(action, init = {}) {
+    const response = await this.fetchImpl(`${this.baseUrl}/v1/task-subtree-transfer${action}`, {
+      ...init,
+      headers: { ...this.headers, ...init.headers ?? {} }
+    });
+    const text = await boundedText(response, RESPONSE_BYTES);
+    let payload;
+    try {
+      payload = JSON.parse(text);
+    } catch {
+      throw new TodosTaskSubtreeTransferError("TODOS_TASK_SUBTREE_TRANSFER_HTTP_ERROR", `Task-subtree-transfer HTTP ${response.status} returned invalid JSON`);
+    }
+    if (!response.ok) {
+      throw new TodosTaskSubtreeTransferError(typeof payload.code === "string" ? payload.code : "TODOS_TASK_SUBTREE_TRANSFER_HTTP_ERROR", typeof payload.error === "string" ? payload.error : `Task-subtree-transfer HTTP ${response.status}`, payload.details && typeof payload.details === "object" ? payload.details : {});
+    }
+    return payload;
+  }
+  async capability() {
+    return (await this.request("/capability")).capability;
+  }
+  async inspect(input) {
+    return (await this.request("/inspect", { method: "POST", body: JSON.stringify(input) })).inspection;
+  }
+  async apply(input) {
+    return (await this.request("/apply", { method: "POST", body: JSON.stringify(input) })).result;
+  }
+  async readExact(receiptId2) {
+    return (await this.request("/read-exact", { method: "POST", body: JSON.stringify({ receipt_id: receiptId2 }) })).result;
+  }
+  async rollback(input) {
+    return (await this.request("/rollback", { method: "POST", body: JSON.stringify(input) })).result;
+  }
+}
+function createTodosTaskSubtreeTransferHttpClient(options) {
+  return new TodosTaskSubtreeTransferHttpClient(options);
+}
+export {
+  taskSubtreeTransferRollbackRequestDigest,
+  taskSubtreeTransferRequestDigest,
+  sqliteTodosTaskSubtreeTransferSchemaSql,
+  postgresTodosTaskSubtreeTransferSchemaSql,
+  parseTodosTaskSubtreeTransferRollback,
+  parseTodosTaskSubtreeTransferInspect,
+  parseTodosTaskSubtreeTransferApply,
+  handleTodosTaskSubtreeTransferHttpRequest,
+  deriveTodosTaskSubtreeTransferRollbackPreconditionDigest,
+  deriveTodosTaskSubtreeTransferIdempotencyKey,
+  deriveTodosTaskSubtreeTransferApplyPreconditionDigest,
+  createTodosTaskSubtreeTransferHttpClient,
+  createSqliteTodosTaskSubtreeTransferAuthority,
+  createPostgresTodosTaskSubtreeTransferAuthority,
+  TodosTaskSubtreeTransferHttpClient,
+  TodosTaskSubtreeTransferError,
+  TODOS_TASK_SUBTREE_TRANSFER_SCHEMA_VERSION,
+  TODOS_TASK_SUBTREE_TRANSFER_ROUTE,
+  PackageOwnedTodosTaskSubtreeTransferAuthority
+};