@hasna/todos 0.15.19 → 0.15.20

package/dist/project-registration.js

@@ -117,7 +117,7 @@ function isBlockingDependencyStatus(status) {
 function isTerminalStatus(status) {
   return status === "completed" || status === "failed" || status === "cancelled";
 }
-var TASK_STATUSES, TASK_PRIORITIES, PLAN_STATUSES, VersionConflictError, TaskNotFoundError, TaskNotStartableError, TaskReferenceAmbiguousError, ProjectNotFoundError, ResourceConflictError, PlanRevisionConflictError, PlanNotFoundError, LockError, AgentNotFoundError, IdentityAliasAmbiguousError, IdentityIdImmutableError, TaskListNotFoundError, DependencyCycleError, CompletionGuardError, DISPATCH_STATUSES, DispatchNotFoundError;
+var TASK_STATUSES, TASK_PRIORITIES, PLAN_STATUSES, VersionConflictError, TaskNotFoundError, TaskNotStartableError, TaskReferenceAmbiguousError, ProjectNotFoundError, ResourceConflictError, PlanRevisionConflictError, PlanNotFoundError, LockError, StaleLockHandoffError, AgentNotFoundError, IdentityAliasAmbiguousError, IdentityIdImmutableError, TaskListNotFoundError, DependencyCycleError, CompletionGuardError, DISPATCH_STATUSES, DispatchNotFoundError;
 var init_types = __esm(() => {
   TASK_STATUSES = [
     "pending",
@@ -240,6 +240,16 @@ var init_types = __esm(() => {
       this.name = "LockError";
     }
   };
+  StaleLockHandoffError = class StaleLockHandoffError extends Error {
+    code;
+    details;
+    constructor(code, message, details = {}) {
+      super(message);
+      this.code = code;
+      this.details = details;
+      this.name = "StaleLockHandoffError";
+    }
+  };
   AgentNotFoundError = class AgentNotFoundError extends Error {
     agentId;
     static code = "AGENT_NOT_FOUND";
@@ -624,225 +634,593 @@ var init_redaction = __esm(() => {
   REDACTION_PLACEHOLDER = String.raw`\[REDACTED(?:_[A-Z_]+)?\]`;
 });
 
-// src/project-registration/schema.ts
-function sqliteTodosProjectRegistrationSchemaSql() {
-  return `
-    CREATE TABLE IF NOT EXISTS todos_project_registration_receipts (
-      receipt_id TEXT PRIMARY KEY,
-      authority TEXT NOT NULL CHECK(authority = 'todos'),
-      route TEXT NOT NULL,
-      package_version TEXT NOT NULL,
-      authority_id TEXT NOT NULL,
-      tenant_id TEXT NOT NULL,
-      corpus_id TEXT NOT NULL,
-      operation_id TEXT NOT NULL,
-      step_id TEXT NOT NULL,
-      resource_kind TEXT NOT NULL CHECK(resource_kind IN ('project', 'task_list')),
-      direction TEXT NOT NULL CHECK(direction IN ('forward', 'inverse')),
-      target_selector TEXT NOT NULL,
-      idempotency_key TEXT NOT NULL,
-      request_digest TEXT NOT NULL,
-      precondition_digest TEXT NOT NULL,
-      normalized_call_digest TEXT NOT NULL,
-      outcome TEXT NOT NULL CHECK(outcome IN (
-        'accepted', 'duplicate_of_accepted', 'terminal_nonacceptance'
-      )),
-      reason TEXT,
-      target_id TEXT,
-      result_revision TEXT,
-      result_digest TEXT,
-      duplicate_of_receipt_id TEXT,
-      accepted_receipt_id TEXT,
-      created_by_operation INTEGER NOT NULL CHECK(created_by_operation IN (0, 1)),
-      created_at TEXT NOT NULL
-    );
-
-    CREATE INDEX IF NOT EXISTS idx_todos_project_registration_receipts_lookup
-      ON todos_project_registration_receipts (
-        authority_id, tenant_id, corpus_id, operation_id, step_id,
-        resource_kind, direction, idempotency_key
-      );
-    CREATE INDEX IF NOT EXISTS idx_todos_project_registration_receipts_step
-      ON todos_project_registration_receipts (
-        authority_id, tenant_id, corpus_id, operation_id, step_id,
-        resource_kind, direction, outcome
-      );
-    CREATE UNIQUE INDEX IF NOT EXISTS idx_todos_project_registration_receipts_accepted_step
-      ON todos_project_registration_receipts (
-        authority_id, tenant_id, corpus_id, operation_id, step_id,
-        resource_kind, direction
-      )
-      WHERE outcome = 'accepted';
-    CREATE INDEX IF NOT EXISTS idx_todos_project_registration_receipts_target
-      ON todos_project_registration_receipts (
-        authority_id, tenant_id, corpus_id, resource_kind, target_id
-      );
-
-    CREATE TABLE IF NOT EXISTS todos_project_registration_bindings (
-      authority_id TEXT NOT NULL,
-      tenant_id TEXT NOT NULL,
-      corpus_id TEXT NOT NULL,
-      resource_kind TEXT NOT NULL CHECK(resource_kind IN ('project', 'task_list')),
-      target_selector TEXT NOT NULL,
-      operation_id TEXT NOT NULL,
-      step_id TEXT NOT NULL,
-      direction TEXT NOT NULL CHECK(direction = 'forward'),
-      idempotency_key TEXT NOT NULL,
-      request_digest TEXT NOT NULL,
-      precondition_digest TEXT NOT NULL,
-      normalized_call_digest TEXT NOT NULL,
-      state TEXT NOT NULL CHECK(state IN (
-        'pending', 'accepted', 'terminal_nonacceptance', 'removed'
-      )),
-      target_id TEXT,
-      accepted_receipt_id TEXT,
-      result_revision TEXT,
-      result_digest TEXT,
-      removed_receipt_id TEXT,
-      created_at TEXT NOT NULL,
-      updated_at TEXT NOT NULL,
-      PRIMARY KEY(
-        authority_id, tenant_id, corpus_id, resource_kind, target_selector
-      ),
-      UNIQUE(accepted_receipt_id)
-    );
-    CREATE UNIQUE INDEX IF NOT EXISTS idx_todos_project_registration_binding_target
-      ON todos_project_registration_bindings(
-        authority_id, tenant_id, corpus_id, resource_kind, target_id
-      )
-      WHERE target_id IS NOT NULL;
-
-    CREATE TRIGGER IF NOT EXISTS todos_project_registration_receipts_immutable_update
-    BEFORE UPDATE ON todos_project_registration_receipts
-    BEGIN
-      SELECT RAISE(ABORT, 'todos project registration receipts are immutable');
-    END;
-
-    CREATE TRIGGER IF NOT EXISTS todos_project_registration_receipts_immutable_delete
-    BEFORE DELETE ON todos_project_registration_receipts
-    BEGIN
-      SELECT RAISE(ABORT, 'todos project registration receipts are immutable');
-    END;
-  `;
+// src/lib/secret-redaction.ts
+import { readFileSync as readFileSync2, existsSync as existsSync3 } from "fs";
+function registerCustomRedactor(fn) {
+  customRedactors.push(fn);
 }
-function postgresTodosProjectRegistrationSchemaSql() {
-  return [
-    `CREATE TABLE IF NOT EXISTS todos_project_registration_receipts (
-      receipt_id text PRIMARY KEY,
-      authority text NOT NULL CHECK(authority = 'todos'),
-      route text NOT NULL,
-      package_version text NOT NULL,
-      authority_id text NOT NULL,
-      tenant_id text NOT NULL,
-      corpus_id text NOT NULL,
-      operation_id text NOT NULL,
-      step_id text NOT NULL,
-      resource_kind text NOT NULL CHECK(resource_kind IN ('project', 'task_list')),
-      direction text NOT NULL CHECK(direction IN ('forward', 'inverse')),
-      target_selector text NOT NULL,
-      idempotency_key text NOT NULL,
-      request_digest text NOT NULL,
-      precondition_digest text NOT NULL,
-      normalized_call_digest text NOT NULL,
-      outcome text NOT NULL CHECK(outcome IN (
-        'accepted', 'duplicate_of_accepted', 'terminal_nonacceptance'
-      )),
-      reason text,
-      target_id text,
-      result_revision text,
-      result_digest text,
-      duplicate_of_receipt_id text,
-      accepted_receipt_id text,
-      created_by_operation boolean NOT NULL,
-      created_at timestamptz NOT NULL
-    )`,
-    `CREATE INDEX IF NOT EXISTS todos_project_registration_receipts_lookup_idx
-      ON todos_project_registration_receipts (
-        authority_id, tenant_id, corpus_id, operation_id, step_id,
-        resource_kind, direction, idempotency_key
-      )`,
-    `CREATE INDEX IF NOT EXISTS todos_project_registration_receipts_step_idx
-      ON todos_project_registration_receipts (
-        authority_id, tenant_id, corpus_id, operation_id, step_id,
-        resource_kind, direction, outcome
-      )`,
-    `CREATE UNIQUE INDEX IF NOT EXISTS todos_project_registration_receipts_accepted_step_uidx
-      ON todos_project_registration_receipts (
-        authority_id, tenant_id, corpus_id, operation_id, step_id,
-        resource_kind, direction
-      )
-      WHERE outcome = 'accepted'`,
-    `CREATE INDEX IF NOT EXISTS todos_project_registration_receipts_target_idx
-      ON todos_project_registration_receipts (
-        authority_id, tenant_id, corpus_id, resource_kind, target_id
-      )`,
-    `CREATE TABLE IF NOT EXISTS todos_project_registration_bindings (
-      authority_id text NOT NULL,
-      tenant_id text NOT NULL,
-      corpus_id text NOT NULL,
-      resource_kind text NOT NULL CHECK(resource_kind IN ('project', 'task_list')),
-      target_selector text NOT NULL,
-      operation_id text NOT NULL,
-      step_id text NOT NULL,
-      direction text NOT NULL CHECK(direction = 'forward'),
-      idempotency_key text NOT NULL,
-      request_digest text NOT NULL,
-      precondition_digest text NOT NULL,
-      normalized_call_digest text NOT NULL,
-      state text NOT NULL CHECK(state IN (
-        'pending', 'accepted', 'terminal_nonacceptance', 'removed'
-      )),
-      target_id text,
-      accepted_receipt_id text UNIQUE,
-      result_revision text,
-      result_digest text,
-      removed_receipt_id text,
-      created_at timestamptz NOT NULL,
-      updated_at timestamptz NOT NULL,
-      PRIMARY KEY(
-        authority_id, tenant_id, corpus_id, resource_kind, target_selector
-      )
-    )`,
-    `CREATE UNIQUE INDEX IF NOT EXISTS todos_project_registration_binding_target_uidx
-      ON todos_project_registration_bindings(
-        authority_id, tenant_id, corpus_id, resource_kind, target_id
-      )
-      WHERE target_id IS NOT NULL`,
-    `CREATE OR REPLACE FUNCTION todos_project_registration_receipts_immutable()
-      RETURNS trigger
-      LANGUAGE plpgsql
-      AS $$
-      BEGIN
-        RAISE EXCEPTION 'todos project registration receipts are immutable';
-      END;
-      $$`,
-    `DROP TRIGGER IF EXISTS todos_project_registration_receipts_immutable
-      ON todos_project_registration_receipts`,
-    `CREATE TRIGGER todos_project_registration_receipts_immutable
-      BEFORE UPDATE OR DELETE ON todos_project_registration_receipts
-      FOR EACH ROW EXECUTE FUNCTION todos_project_registration_receipts_immutable()`
+function resetCustomRedactors() {
+  customRedactors = [];
+}
+function isAllowlisted(text, match, allowlist) {
+  const context = text.slice(Math.max(0, text.indexOf(match) - 20), text.indexOf(match) + match.length + 20);
+  return allowlist.some((re) => re.test(context) || re.test(match));
+}
+function scanTextForSecrets(text, options = {}) {
+  const allowlist = [...DEFAULT_ALLOWLIST, ...options.allowlist ?? []];
+  const matches = [];
+  const patterns = [
+    ...DEFAULT_PATTERNS,
+    ...options.custom_patterns?.map((p, i) => ({ name: `custom_${i}`, pattern: p })) ?? []
   ];
+  for (const { name, pattern, allowlist_ok } of patterns) {
+    const re = new RegExp(pattern.source, pattern.flags);
+    let m;
+    while ((m = re.exec(text)) !== null) {
+      const match = m[0];
+      if (allowlist_ok && isAllowlisted(text, match, allowlist))
+        continue;
+      if (isAllowlisted(text, match, allowlist))
+        continue;
+      const line = text.slice(0, m.index).split(`
+`).length;
+      matches.push({ pattern: name, match: match.slice(0, 12) + (match.length > 12 ? "\u2026" : ""), index: m.index, line });
+    }
+  }
+  return {
+    schema_version: SECRET_REDACTION_SCHEMA,
+    clean: matches.length === 0,
+    matches
+  };
 }
-
-// src/db/migrations.ts
-var MIGRATIONS;
-var init_migrations = __esm(() => {
-  MIGRATIONS = [
-    `
-  CREATE TABLE IF NOT EXISTS projects (
-    id TEXT PRIMARY KEY,
-    name TEXT NOT NULL,
-    path TEXT UNIQUE NOT NULL,
-    description TEXT,
-    created_at TEXT NOT NULL DEFAULT (datetime('now')),
-    updated_at TEXT NOT NULL DEFAULT (datetime('now'))
-  );
-
-  CREATE TABLE IF NOT EXISTS tasks (
-    id TEXT PRIMARY KEY,
-    project_id TEXT REFERENCES projects(id) ON DELETE SET NULL,
-    parent_id TEXT REFERENCES tasks(id) ON DELETE CASCADE,
-    title TEXT NOT NULL,
+function redactText(text, options = {}) {
+  const placeholder = options.placeholder ?? REDACTION_PLACEHOLDER2;
+  let out = text;
+  for (const { pattern, allowlist_ok } of DEFAULT_PATTERNS) {
+    out = out.replace(new RegExp(pattern.source, pattern.flags), (match) => {
+      if (allowlist_ok && isAllowlisted(out, match, [...DEFAULT_ALLOWLIST, ...options.allowlist ?? []])) {
+        return match;
+      }
+      return placeholder;
+    });
+  }
+  for (const custom of options.custom_patterns ?? []) {
+    out = out.replace(custom, placeholder);
+  }
+  for (const fn of customRedactors) {
+    out = fn(out);
+  }
+  return out;
+}
+function scanAndRedactText(text, options = {}) {
+  const scan = scanTextForSecrets(text, options);
+  return {
+    ...scan,
+    redacted_text: redactText(text, options)
+  };
+}
+function scanFileForSecrets(path, options = {}) {
+  if (!existsSync3(path))
+    throw new Error(`File not found: ${path}`);
+  const content = readFileSync2(path, "utf8");
+  return scanAndRedactText(content, options);
+}
+function safeStringify(value, space) {
+  const redacted = typeof value === "object" && value !== null && !Array.isArray(value) ? redactValue(value) : value;
+  const json = JSON.stringify(redacted, null, space);
+  return redactText(json);
+}
+function assertNoSecrets(text, context) {
+  const scan = scanTextForSecrets(text);
+  if (!scan.clean) {
+    const summary = scan.matches.map((m) => `${m.pattern}@${m.line ?? m.index}`).join(", ");
+    throw new Error(`Secret pattern detected${context ? ` in ${context}` : ""}: ${summary}`);
+  }
+}
+function redactCommentContent(content) {
+  return redactText(content);
+}
+function redactHandoffPayload(payload) {
+  return redactValue(payload);
+}
+function redactExportRecord(record) {
+  const base = redactValue(record);
+  for (const [key, value] of Object.entries(base)) {
+    if (typeof value === "string") {
+      base[key] = redactText(value);
+    }
+  }
+  return base;
+}
+function getDefaultSecretPatterns() {
+  return DEFAULT_PATTERNS.map((p) => ({ name: p.name, source: p.pattern.source }));
+}
+var SECRET_REDACTION_SCHEMA, REDACTION_PLACEHOLDER2 = "[REDACTED]", DEFAULT_PATTERNS, DEFAULT_ALLOWLIST, customRedactors;
+var init_secret_redaction = __esm(() => {
+  init_redaction();
+  SECRET_REDACTION_SCHEMA = ["todos", "secret_redaction", "v1"].join(".");
+  DEFAULT_PATTERNS = [
+    { name: "openai_sk", pattern: /\bsk-[a-zA-Z0-9]{10,}\b/g },
+    { name: "github_pat", pattern: /\bghp_[a-zA-Z0-9]{20,}\b/g },
+    { name: "github_oauth", pattern: /\bgho_[a-zA-Z0-9]{20,}\b/g },
+    { name: "aws_access_key", pattern: /\bAKIA[0-9A-Z]{16}\b/g },
+    { name: "bearer_token", pattern: /\bBearer\s+[a-zA-Z0-9\-._~+/]+=*\b/gi },
+    { name: "jwt", pattern: /\beyJ[a-zA-Z0-9_-]+\.eyJ[a-zA-Z0-9_-]+\.[a-zA-Z0-9_-]+\b/g },
+    { name: "private_key_block", pattern: /-----BEGIN (?:RSA |EC |OPENSSH )?PRIVATE KEY-----[\s\S]*?-----END (?:RSA |EC |OPENSSH )?PRIVATE KEY-----/g },
+    { name: "generic_api_key", pattern: /\b(?:api[_-]?key|secret|token|password)\s*[:=]\s*['"]?[a-zA-Z0-9\-._]{8,}['"]?/gi, allowlist_ok: true }
+  ];
+  DEFAULT_ALLOWLIST = [
+    /\[REDACTED\]/,
+    /example\.com/i,
+    /your-api-key-here/i,
+    /sk-test/i,
+    /ghp_xxx/i
+  ];
+  customRedactors = [];
+});
+
+// src/lib/prewrite-secrets.ts
+function mergeFindings(findings) {
+  const byPattern = new Map;
+  for (const finding of findings) {
+    const existing = byPattern.get(finding.pattern);
+    if (!existing) {
+      byPattern.set(finding.pattern, {
+        pattern: finding.pattern,
+        count: finding.count,
+        lines: Array.from(new Set(finding.lines)).sort((a, b) => a - b)
+      });
+      continue;
+    }
+    existing.count += finding.count;
+    existing.lines = Array.from(new Set([...existing.lines, ...finding.lines])).sort((a, b) => a - b);
+  }
+  return [...byPattern.values()].sort((left, right) => left.pattern.localeCompare(right.pattern));
+}
+function redactPreWriteText(value) {
+  return redactText(redactEvidenceText(value));
+}
+function scanPreWriteText(value, context = "text") {
+  const redacted = redactPreWriteText(value);
+  if (redacted === value) {
+    return {
+      schema_version: PREWRITE_SECRET_SCAN_SCHEMA,
+      clean: true,
+      context,
+      findings: []
+    };
+  }
+  const structural = scanTextForSecrets(value).matches.map((match) => ({
+    pattern: match.pattern,
+    count: 1,
+    lines: match.line ? [match.line] : []
+  }));
+  const configured = listSecretFindings(value).map((finding) => ({
+    pattern: finding.pattern,
+    count: finding.count,
+    lines: []
+  }));
+  return {
+    schema_version: PREWRITE_SECRET_SCAN_SCHEMA,
+    clean: false,
+    context,
+    findings: mergeFindings([...structural, ...configured])
+  };
+}
+function assertPreWriteTextClean(value, context = "text") {
+  const scan = scanPreWriteText(value, context);
+  if (!scan.clean)
+    throw new PreWriteSecretError(context, scan.findings);
+}
+function sanitizePreWriteText(value, context = "text", options = {}) {
+  const mode = options.mode ?? "redact";
+  if (mode === "block") {
+    assertPreWriteTextClean(value, context);
+    return value;
+  }
+  return redactPreWriteText(value);
+}
+function sanitizePreWriteValue(value, context = "value", options = {}) {
+  if (typeof value === "string")
+    return sanitizePreWriteText(value, context, options);
+  if (Array.isArray(value)) {
+    return value.map((item, index) => sanitizePreWriteValue(item, `${context}[${index}]`, options));
+  }
+  if (value && typeof value === "object") {
+    const sanitized = {};
+    for (const [key, child] of Object.entries(value)) {
+      const safeKey = sanitizePreWriteText(key, `${context}.$key`, options);
+      sanitized[safeKey] = sanitizePreWriteValue(child, `${context}.${safeKey}`, options);
+    }
+    return redactValue(sanitized);
+  }
+  return value;
+}
+function sanitizePreWriteJsonString(value, context = "json") {
+  if (value === undefined || value === null)
+    return null;
+  try {
+    return JSON.stringify(sanitizePreWriteValue(JSON.parse(value), context));
+  } catch {
+    return sanitizePreWriteText(value, context);
+  }
+}
+var PREWRITE_SECRET_SCAN_SCHEMA, PreWriteSecretError;
+var init_prewrite_secrets = __esm(() => {
+  init_redaction();
+  init_secret_redaction();
+  PREWRITE_SECRET_SCAN_SCHEMA = ["todos", "prewrite_secret_scan", "v1"].join(".");
+  PreWriteSecretError = class PreWriteSecretError extends Error {
+    context;
+    findings;
+    constructor(context, findings) {
+      const summary = findings.map((finding) => `${finding.pattern}:${finding.count}`).join(", ");
+      super(`Secret pattern detected before persistence in ${context}: ${summary}`);
+      this.name = "PreWriteSecretError";
+      this.context = context;
+      this.findings = findings;
+    }
+  };
+});
+
+// src/lib/stale-lock-handoff.ts
+function normalizeExactTaskId(value) {
+  if (typeof value !== "string" || !EXACT_TASK_UUID_RE.test(value.trim())) {
+    throw new StaleLockHandoffError("STALE_LOCK_HANDOFF_INVALID_TASK_ID", "stale-lock handoff requires one exact full task UUID", { task_id: typeof value === "string" ? value : null });
+  }
+  return value.trim().toLowerCase();
+}
+function requireNonEmptyString(value, field) {
+  if (typeof value !== "string" || !value.trim()) {
+    throw new StaleLockHandoffError("STALE_LOCK_HANDOFF_INVALID_INPUT", `${field} must be a non-empty string`, { field });
+  }
+  const trimmed = value.trim();
+  if (field === "reason" && trimmed.length > MAX_REASON_LENGTH) {
+    throw new StaleLockHandoffError("STALE_LOCK_HANDOFF_INVALID_INPUT", `reason must be at most ${MAX_REASON_LENGTH} characters`, { field, max_length: MAX_REASON_LENGTH });
+  }
+  return trimmed;
+}
+function requireCanonicalLockVersion(value) {
+  if (typeof value !== "string" || !CANONICAL_LOCK_VERSION_RE.test(value)) {
+    throw new StaleLockHandoffError("STALE_LOCK_HANDOFF_INVALID_INPUT", "expected_lock_version must be the exact canonical locked_at timestamp (YYYY-MM-DDTHH:mm:ss.sssZ)", { field: "expected_lock_version" });
+  }
+  const parsed = Date.parse(value);
+  if (Number.isNaN(parsed) || new Date(parsed).toISOString() !== value) {
+    throw new StaleLockHandoffError("STALE_LOCK_HANDOFF_INVALID_INPUT", "expected_lock_version must name a real canonical UTC instant", { field: "expected_lock_version" });
+  }
+  return value;
+}
+function requireStaleThreshold(value) {
+  if (!Number.isSafeInteger(value) || Number(value) <= 0) {
+    throw new StaleLockHandoffError("STALE_LOCK_HANDOFF_INVALID_INPUT", "stale_after_seconds must be a positive safe integer", { field: "stale_after_seconds" });
+  }
+  return Number(value);
+}
+function prepareStaleLockHandoff(input, options = {}) {
+  const taskId = normalizeExactTaskId(input.task_id);
+  const actor = requireNonEmptyString(input.actor, "actor");
+  const expectedHolder = requireNonEmptyString(input.expected_holder, "expected_holder");
+  const newHolder = requireNonEmptyString(input.new_holder, "new_holder");
+  const expectedLockVersion = requireCanonicalLockVersion(input.expected_lock_version);
+  const staleAfterSeconds = requireStaleThreshold(input.stale_after_seconds);
+  const reason = sanitizePreWriteText(requireNonEmptyString(input.reason, "reason"), "stale_lock_handoff.reason").trim();
+  if (!reason) {
+    throw new StaleLockHandoffError("STALE_LOCK_HANDOFF_INVALID_INPUT", "reason must remain non-empty after safety filtering", { field: "reason" });
+  }
+  if (canonicalAgentRef(actor) !== canonicalAgentRef(newHolder)) {
+    throw new StaleLockHandoffError("STALE_LOCK_HANDOFF_ACTOR_MISMATCH", "new_holder must match the authenticated actor", { actor, new_holder: newHolder });
+  }
+  if (canonicalAgentRef(expectedHolder) === canonicalAgentRef(newHolder)) {
+    throw new StaleLockHandoffError("STALE_LOCK_HANDOFF_INVALID_INPUT", "new_holder must differ from expected_holder", { field: "new_holder" });
+  }
+  const operationTimestamp = options.now ?? new Date().toISOString();
+  if (!CANONICAL_LOCK_VERSION_RE.test(operationTimestamp) || new Date(Date.parse(operationTimestamp)).toISOString() !== operationTimestamp) {
+    throw new StaleLockHandoffError("STALE_LOCK_HANDOFF_INVALID_INPUT", "operation timestamp must be a canonical UTC instant");
+  }
+  const staleCutoff = new Date(Date.parse(operationTimestamp) - staleAfterSeconds * 1000).toISOString();
+  return {
+    task_id: taskId,
+    actor,
+    expected_holder: expectedHolder,
+    expected_lock_version: expectedLockVersion,
+    stale_after_seconds: staleAfterSeconds,
+    new_holder: newHolder,
+    reason,
+    operation_timestamp: operationTimestamp,
+    stale_cutoff: staleCutoff,
+    receipt_id: options.receiptId ?? crypto.randomUUID()
+  };
+}
+function buildStaleLockHandoffReceipt(input) {
+  return {
+    schema_version: STALE_LOCK_HANDOFF_SCHEMA_VERSION,
+    receipt_id: input.receipt_id,
+    task_id: input.task_id,
+    actor: input.actor,
+    previous_holder: input.expected_holder,
+    previous_lock_version: input.expected_lock_version,
+    new_holder: input.new_holder,
+    new_lock_version: input.operation_timestamp,
+    stale_after_seconds: input.stale_after_seconds,
+    stale_cutoff: input.stale_cutoff,
+    reason: input.reason,
+    created_at: input.operation_timestamp
+  };
+}
+function staleLockHandoffHistory(receipt, machineId) {
+  return {
+    id: receipt.receipt_id,
+    task_id: receipt.task_id,
+    action: STALE_LOCK_HANDOFF_ACTION,
+    field: STALE_LOCK_HANDOFF_FIELD,
+    old_value: JSON.stringify({
+      holder: receipt.previous_holder,
+      lock_version: receipt.previous_lock_version
+    }),
+    new_value: JSON.stringify(receipt),
+    agent_id: receipt.actor,
+    created_at: receipt.created_at,
+    machine_id: machineId
+  };
+}
+function throwStaleLockHandoffConflict(task, input) {
+  if (!task.locked_by || !task.locked_at) {
+    throw new StaleLockHandoffError("STALE_LOCK_HANDOFF_NOT_LOCKED", `Task ${input.task_id} does not have a complete lock to hand off`, { task_id: input.task_id });
+  }
+  if (task.locked_at !== input.expected_lock_version) {
+    throw new StaleLockHandoffError("STALE_LOCK_HANDOFF_VERSION_MISMATCH", `Task ${input.task_id} lock version changed`, {
+      task_id: input.task_id,
+      expected_lock_version: input.expected_lock_version,
+      current_lock_version: task.locked_at
+    });
+  }
+  if (task.locked_by !== input.expected_holder) {
+    throw new StaleLockHandoffError("STALE_LOCK_HANDOFF_HOLDER_MISMATCH", `Task ${input.task_id} lock holder changed`, {
+      task_id: input.task_id,
+      expected_holder: input.expected_holder,
+      current_holder: task.locked_by
+    });
+  }
+  if (isTerminalStatus(task.status)) {
+    throw new StaleLockHandoffError("STALE_LOCK_HANDOFF_TERMINAL", `Task ${input.task_id} is ${task.status} and cannot transfer a lock`, { task_id: input.task_id, status: task.status });
+  }
+  if (task.locked_at >= input.stale_cutoff) {
+    throw new StaleLockHandoffError("STALE_LOCK_HANDOFF_NOT_STALE", `Task ${input.task_id} lock is not older than the supplied stale threshold`, {
+      task_id: input.task_id,
+      current_lock_version: task.locked_at,
+      stale_cutoff: input.stale_cutoff
+    });
+  }
+  throw new StaleLockHandoffError("STALE_LOCK_HANDOFF_CONFLICT", `Task ${input.task_id} changed during stale-lock handoff`, { task_id: input.task_id });
+}
+var STALE_LOCK_HANDOFF_SCHEMA_VERSION = "todos.stale-lock-handoff.v1", STALE_LOCK_HANDOFF_ACTION = "stale_lock_handoff", STALE_LOCK_HANDOFF_FIELD = "lock", EXACT_TASK_UUID_RE, CANONICAL_LOCK_VERSION_RE, MAX_REASON_LENGTH = 4096;
+var init_stale_lock_handoff = __esm(() => {
+  init_types();
+  init_creator_identity();
+  init_prewrite_secrets();
+  EXACT_TASK_UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+  CANONICAL_LOCK_VERSION_RE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;
+});
+
+// src/project-registration/schema.ts
+function sqliteTodosProjectRegistrationSchemaSql() {
+  return `
+    CREATE TABLE IF NOT EXISTS todos_project_registration_receipts (
+      receipt_id TEXT PRIMARY KEY,
+      authority TEXT NOT NULL CHECK(authority = 'todos'),
+      route TEXT NOT NULL,
+      package_version TEXT NOT NULL,
+      authority_id TEXT NOT NULL,
+      tenant_id TEXT NOT NULL,
+      corpus_id TEXT NOT NULL,
+      operation_id TEXT NOT NULL,
+      step_id TEXT NOT NULL,
+      resource_kind TEXT NOT NULL CHECK(resource_kind IN ('project', 'task_list')),
+      direction TEXT NOT NULL CHECK(direction IN ('forward', 'inverse')),
+      target_selector TEXT NOT NULL,
+      idempotency_key TEXT NOT NULL,
+      request_digest TEXT NOT NULL,
+      precondition_digest TEXT NOT NULL,
+      normalized_call_digest TEXT NOT NULL,
+      outcome TEXT NOT NULL CHECK(outcome IN (
+        'accepted', 'duplicate_of_accepted', 'terminal_nonacceptance'
+      )),
+      reason TEXT,
+      target_id TEXT,
+      result_revision TEXT,
+      result_digest TEXT,
+      duplicate_of_receipt_id TEXT,
+      accepted_receipt_id TEXT,
+      created_by_operation INTEGER NOT NULL CHECK(created_by_operation IN (0, 1)),
+      created_at TEXT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_todos_project_registration_receipts_lookup
+      ON todos_project_registration_receipts (
+        authority_id, tenant_id, corpus_id, operation_id, step_id,
+        resource_kind, direction, idempotency_key
+      );
+    CREATE INDEX IF NOT EXISTS idx_todos_project_registration_receipts_step
+      ON todos_project_registration_receipts (
+        authority_id, tenant_id, corpus_id, operation_id, step_id,
+        resource_kind, direction, outcome
+      );
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_todos_project_registration_receipts_accepted_step
+      ON todos_project_registration_receipts (
+        authority_id, tenant_id, corpus_id, operation_id, step_id,
+        resource_kind, direction
+      )
+      WHERE outcome = 'accepted';
+    CREATE INDEX IF NOT EXISTS idx_todos_project_registration_receipts_target
+      ON todos_project_registration_receipts (
+        authority_id, tenant_id, corpus_id, resource_kind, target_id
+      );
+
+    CREATE TABLE IF NOT EXISTS todos_project_registration_bindings (
+      authority_id TEXT NOT NULL,
+      tenant_id TEXT NOT NULL,
+      corpus_id TEXT NOT NULL,
+      resource_kind TEXT NOT NULL CHECK(resource_kind IN ('project', 'task_list')),
+      target_selector TEXT NOT NULL,
+      operation_id TEXT NOT NULL,
+      step_id TEXT NOT NULL,
+      direction TEXT NOT NULL CHECK(direction = 'forward'),
+      idempotency_key TEXT NOT NULL,
+      request_digest TEXT NOT NULL,
+      precondition_digest TEXT NOT NULL,
+      normalized_call_digest TEXT NOT NULL,
+      state TEXT NOT NULL CHECK(state IN (
+        'pending', 'accepted', 'terminal_nonacceptance', 'removed'
+      )),
+      target_id TEXT,
+      accepted_receipt_id TEXT,
+      result_revision TEXT,
+      result_digest TEXT,
+      removed_receipt_id TEXT,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      PRIMARY KEY(
+        authority_id, tenant_id, corpus_id, resource_kind, target_selector
+      ),
+      UNIQUE(accepted_receipt_id)
+    );
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_todos_project_registration_binding_target
+      ON todos_project_registration_bindings(
+        authority_id, tenant_id, corpus_id, resource_kind, target_id
+      )
+      WHERE target_id IS NOT NULL;
+
+    CREATE TRIGGER IF NOT EXISTS todos_project_registration_receipts_immutable_update
+    BEFORE UPDATE ON todos_project_registration_receipts
+    BEGIN
+      SELECT RAISE(ABORT, 'todos project registration receipts are immutable');
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS todos_project_registration_receipts_immutable_delete
+    BEFORE DELETE ON todos_project_registration_receipts
+    BEGIN
+      SELECT RAISE(ABORT, 'todos project registration receipts are immutable');
+    END;
+  `;
+}
+function postgresTodosProjectRegistrationSchemaSql() {
+  return [
+    `CREATE TABLE IF NOT EXISTS todos_project_registration_receipts (
+      receipt_id text PRIMARY KEY,
+      authority text NOT NULL CHECK(authority = 'todos'),
+      route text NOT NULL,
+      package_version text NOT NULL,
+      authority_id text NOT NULL,
+      tenant_id text NOT NULL,
+      corpus_id text NOT NULL,
+      operation_id text NOT NULL,
+      step_id text NOT NULL,
+      resource_kind text NOT NULL CHECK(resource_kind IN ('project', 'task_list')),
+      direction text NOT NULL CHECK(direction IN ('forward', 'inverse')),
+      target_selector text NOT NULL,
+      idempotency_key text NOT NULL,
+      request_digest text NOT NULL,
+      precondition_digest text NOT NULL,
+      normalized_call_digest text NOT NULL,
+      outcome text NOT NULL CHECK(outcome IN (
+        'accepted', 'duplicate_of_accepted', 'terminal_nonacceptance'
+      )),
+      reason text,
+      target_id text,
+      result_revision text,
+      result_digest text,
+      duplicate_of_receipt_id text,
+      accepted_receipt_id text,
+      created_by_operation boolean NOT NULL,
+      created_at timestamptz NOT NULL
+    )`,
+    `CREATE INDEX IF NOT EXISTS todos_project_registration_receipts_lookup_idx
+      ON todos_project_registration_receipts (
+        authority_id, tenant_id, corpus_id, operation_id, step_id,
+        resource_kind, direction, idempotency_key
+      )`,
+    `CREATE INDEX IF NOT EXISTS todos_project_registration_receipts_step_idx
+      ON todos_project_registration_receipts (
+        authority_id, tenant_id, corpus_id, operation_id, step_id,
+        resource_kind, direction, outcome
+      )`,
+    `CREATE UNIQUE INDEX IF NOT EXISTS todos_project_registration_receipts_accepted_step_uidx
+      ON todos_project_registration_receipts (
+        authority_id, tenant_id, corpus_id, operation_id, step_id,
+        resource_kind, direction
+      )
+      WHERE outcome = 'accepted'`,
+    `CREATE INDEX IF NOT EXISTS todos_project_registration_receipts_target_idx
+      ON todos_project_registration_receipts (
+        authority_id, tenant_id, corpus_id, resource_kind, target_id
+      )`,
+    `CREATE TABLE IF NOT EXISTS todos_project_registration_bindings (
+      authority_id text NOT NULL,
+      tenant_id text NOT NULL,
+      corpus_id text NOT NULL,
+      resource_kind text NOT NULL CHECK(resource_kind IN ('project', 'task_list')),
+      target_selector text NOT NULL,
+      operation_id text NOT NULL,
+      step_id text NOT NULL,
+      direction text NOT NULL CHECK(direction = 'forward'),
+      idempotency_key text NOT NULL,
+      request_digest text NOT NULL,
+      precondition_digest text NOT NULL,
+      normalized_call_digest text NOT NULL,
+      state text NOT NULL CHECK(state IN (
+        'pending', 'accepted', 'terminal_nonacceptance', 'removed'
+      )),
+      target_id text,
+      accepted_receipt_id text UNIQUE,
+      result_revision text,
+      result_digest text,
+      removed_receipt_id text,
+      created_at timestamptz NOT NULL,
+      updated_at timestamptz NOT NULL,
+      PRIMARY KEY(
+        authority_id, tenant_id, corpus_id, resource_kind, target_selector
+      )
+    )`,
+    `CREATE UNIQUE INDEX IF NOT EXISTS todos_project_registration_binding_target_uidx
+      ON todos_project_registration_bindings(
+        authority_id, tenant_id, corpus_id, resource_kind, target_id
+      )
+      WHERE target_id IS NOT NULL`,
+    `CREATE OR REPLACE FUNCTION todos_project_registration_receipts_immutable()
+      RETURNS trigger
+      LANGUAGE plpgsql
+      AS $$
+      BEGIN
+        RAISE EXCEPTION 'todos project registration receipts are immutable';
+      END;
+      $$`,
+    `DROP TRIGGER IF EXISTS todos_project_registration_receipts_immutable
+      ON todos_project_registration_receipts`,
+    `CREATE TRIGGER todos_project_registration_receipts_immutable
+      BEFORE UPDATE OR DELETE ON todos_project_registration_receipts
+      FOR EACH ROW EXECUTE FUNCTION todos_project_registration_receipts_immutable()`
+  ];
+}
+
+// src/db/migrations.ts
+var MIGRATIONS;
+var init_migrations = __esm(() => {
+  MIGRATIONS = [
+    `
+  CREATE TABLE IF NOT EXISTS projects (
+    id TEXT PRIMARY KEY,
+    name TEXT NOT NULL,
+    path TEXT UNIQUE NOT NULL,
+    description TEXT,
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+
+  CREATE TABLE IF NOT EXISTS tasks (
+    id TEXT PRIMARY KEY,
+    project_id TEXT REFERENCES projects(id) ON DELETE SET NULL,
+    parent_id TEXT REFERENCES tasks(id) ON DELETE CASCADE,
+    title TEXT NOT NULL,
     description TEXT,
     status TEXT NOT NULL DEFAULT 'pending' CHECK(status IN ('pending', 'in_progress', 'completed', 'failed', 'cancelled')),
     priority TEXT NOT NULL DEFAULT 'medium' CHECK(priority IN ('low', 'medium', 'high', 'critical')),
@@ -3935,7 +4313,7 @@ var init_schema = __esm(() => {
 });
 
 // src/db/machines.ts
-import { existsSync as existsSync3 } from "fs";
+import { existsSync as existsSync4 } from "fs";
 import { hostname as osHostname, platform as osPlatform, arch as osArch } from "os";
 import { resolve } from "path";
 import { spawnSync } from "child_process";
@@ -4145,7 +4523,7 @@ function getMachineTopologyDiagnostics(opts = {}, db, at = new Date) {
         message: `${project.name} has ${distinctPaths.length} different machine-local paths`
       });
     }
-    if (localRow && !existsSync3(localRow.path)) {
+    if (localRow && !existsSync4(localRow.path)) {
       pathIssues.push({
         type: "path_missing",
         project_id: project.id,
@@ -4156,7 +4534,7 @@ function getMachineTopologyDiagnostics(opts = {}, db, at = new Date) {
         message: `Local path does not exist on this machine: ${localRow.path}`
       });
     }
-    if (!localRow && project.path && machineById.has(localMachine.id) && !existsSync3(project.path)) {
+    if (!localRow && project.path && machineById.has(localMachine.id) && !existsSync4(project.path)) {
       pathIssues.push({
         type: "path_missing",
         project_id: project.id,
@@ -4744,7 +5122,7 @@ __export(exports_database, {
   LOCK_EXPIRY_MINUTES: () => LOCK_EXPIRY_MINUTES
 });
 import { Database } from "bun:sqlite";
-import { existsSync as existsSync4, mkdirSync as mkdirSync2 } from "fs";
+import { existsSync as existsSync5, mkdirSync as mkdirSync2 } from "fs";
 import { dirname as dirname2, join as join3, resolve as resolve2 } from "path";
 function isInMemoryDb(path) {
   return path === ":memory:" || path.startsWith("file::memory:");
@@ -4755,7 +5133,7 @@ function findNearestProjectDb(startDir) {
   let dir = resolve2(startDir);
   while (true) {
     const candidate = join3(dir, ".hasna", "todos", "todos.db");
-    if (existsSync4(candidate))
+    if (existsSync5(candidate))
       return candidate;
     if (dir === stopAt)
       break;
@@ -4769,7 +5147,7 @@ function findNearestProjectDb(startDir) {
 function findGitRoot(startDir) {
   let dir = resolve2(startDir);
   while (true) {
-    if (existsSync4(join3(dir, ".git")))
+    if (existsSync5(join3(dir, ".git")))
       return dir;
     const parent = dirname2(dir);
     if (parent === dir)
@@ -4829,7 +5207,7 @@ function ensureDir2(filePath) {
   if (isInMemoryDb(filePath))
     return;
   const dir = dirname2(resolve2(filePath));
-  if (!existsSync4(dir)) {
+  if (!existsSync5(dir)) {
     mkdirSync2(dir, { recursive: true });
   }
 }
@@ -6097,7 +6475,7 @@ var init_event_hooks = __esm(() => {
 
 // node_modules/.bun/@hasna+events@0.1.11/node_modules/@hasna/events/dist/index.js
 import { chmod, mkdir, readFile, rename, writeFile } from "fs/promises";
-import { existsSync as existsSync5 } from "fs";
+import { existsSync as existsSync6 } from "fs";
 import { homedir as homedir2 } from "os";
 import { join as join4 } from "path";
 import { createHmac, timingSafeEqual } from "crypto";
@@ -6284,7 +6662,7 @@ class JsonEventsStore {
     };
   }
   async ensureArrayFile(path) {
-    if (!existsSync5(path)) {
+    if (!existsSync6(path)) {
       await writeFile(path, `[]
 `, { encoding: "utf-8", mode: 384 });
     }
@@ -6847,476 +7225,247 @@ function booleanField(value) {
     if (value === 1)
       return true;
     if (value === 0)
-      return false;
-  }
-  if (typeof value === "string") {
-    const normalized = value.trim().toLowerCase();
-    if (["true", "1", "yes", "on"].includes(normalized))
-      return true;
-    if (["false", "0", "no", "off"].includes(normalized))
-      return false;
-  }
-  return;
-}
-function objectField(value) {
-  return value && typeof value === "object" && !Array.isArray(value) ? value : undefined;
-}
-function collectBooleans(records, keys) {
-  const values = [];
-  for (const record of records) {
-    if (!record)
-      continue;
-    for (const key of keys) {
-      const value = booleanField(record[key]);
-      if (value !== undefined)
-        values.push(value);
-    }
-  }
-  return values;
-}
-function mergedBoolean(records, keys, trueWins) {
-  const values = collectBooleans(records, keys);
-  if (values.length === 0)
-    return;
-  if (trueWins)
-    return values.some(Boolean);
-  return values.includes(false) ? false : true;
-}
-function routingAutomationMetadata(task, taskList) {
-  const taskAutomation = objectField(task.metadata.automation);
-  const taskListAutomation = taskList ? objectField(taskList.metadata.automation) : undefined;
-  const records = [task.metadata, taskAutomation, taskList?.metadata, taskListAutomation];
-  const result = {};
-  const aliases = [
-    ["allowed", ["allowed", "automation_allowed", "automationAllowed"]],
-    ["no_auto", ["no_auto", "noAuto"]],
-    ["manual", ["manual"]],
-    ["manual_required", ["manual_required", "manualRequired"]],
-    ["requires_approval", ["requires_approval", "requiresApproval"]],
-    ["approval_required", ["approval_required", "approvalRequired"]]
-  ];
-  for (const [canonical, keys] of aliases) {
-    const value = mergedBoolean(records, keys, canonical !== "allowed");
-    if (value !== undefined)
-      result[canonical] = value;
-  }
-  if (task.requires_approval)
-    result.requires_approval = true;
-  return Object.keys(result).length > 0 ? result : undefined;
-}
-function routeEnabledForTask(task, taskList) {
-  const explicit = booleanField(task.metadata.route_enabled);
-  if (explicit !== undefined)
-    return explicit;
-  const taskListDefault = taskList ? booleanField(taskList.metadata.route_enabled) : undefined;
-  if (taskListDefault !== undefined)
-    return taskListDefault;
-  return;
-}
-function stringField(value) {
-  return typeof value === "string" && value.trim() ? value : undefined;
-}
-function workflowPointersFromMetadata(metadata) {
-  const nested = objectField(metadata.workflow_invocation) ?? objectField(metadata.workflow) ?? {};
-  return {
-    current_workflow_invocation_id: stringField(metadata.current_workflow_invocation_id) ?? stringField(nested.current_workflow_invocation_id) ?? stringField(nested.invocation_id),
-    current_run_id: stringField(metadata.current_run_id) ?? stringField(nested.current_run_id) ?? stringField(nested.run_id),
-    latest_manifest_path: stringField(metadata.latest_manifest_path) ?? stringField(nested.latest_manifest_path) ?? stringField(nested.manifest_path),
-    latest_evaluation_path: stringField(metadata.latest_evaluation_path) ?? stringField(nested.latest_evaluation_path) ?? stringField(nested.evaluation_path),
-    workflow_state: stringField(metadata.workflow_state) ?? stringField(nested.workflow_state) ?? stringField(nested.state)
-  };
-}
-function compactWorkflowPointers(pointers) {
-  return Object.fromEntries(Object.entries(pointers).filter(([, value]) => typeof value === "string" && value.length > 0));
-}
-function metadataStringField(record, keys) {
-  if (!record)
-    return;
-  for (const key of keys) {
-    const value = record[key];
-    if (typeof value === "string" && value.trim())
-      return value.trim();
-  }
-  return;
-}
-function projectKindFromMetadata(...records) {
-  for (const record of records) {
-    const value = metadataStringField(record ?? undefined, ["project_kind", "projectKind", "source_kind", "sourceKind"]);
-    if (value)
-      return value;
-  }
-  return null;
-}
-function classifyProjectKind(_path, metadata) {
-  return projectKindFromMetadata(metadata);
-}
-function isWorktreePath(path) {
-  return path.includes("/.codewith/worktrees/") || path.includes("/.worktrees/");
-}
-function inferRootProjectId(project) {
-  return isWorktreePath(project.path) ? null : project.id;
-}
-var TODOS_TASK_ROUTE_STATE_SCHEMA_VERSION = "todos.task_route_state.v1", TASK_WORKFLOW_POINTER_SCHEMA_VERSION = "todos.task_workflow_pointer.v1";
-
-// src/lib/shared-events.ts
-function taskEventData(task, extra = {}) {
-  return {
-    id: task.id,
-    task_id: task.id,
-    short_id: task.short_id,
-    title: task.title,
-    description: task.description,
-    status: task.status,
-    priority: task.priority,
-    project_id: task.project_id,
-    parent_id: task.parent_id,
-    plan_id: task.plan_id,
-    task_list_id: task.task_list_id,
-    agent_id: task.agent_id,
-    assigned_to: task.assigned_to,
-    session_id: task.session_id,
-    working_dir: task.working_dir,
-    tags: task.tags,
-    metadata: task.metadata,
-    version: task.version,
-    created_at: task.created_at,
-    updated_at: task.updated_at,
-    started_at: task.started_at,
-    completed_at: task.completed_at,
-    due_at: task.due_at,
-    requires_approval: task.requires_approval,
-    approved_by: task.approved_by,
-    approved_at: task.approved_at,
-    ...extra
-  };
-}
-function taskEventMetadata(task) {
-  const metadata = {
-    package: "@hasna/todos",
-    todos_event_schema_version: 1,
-    route_state_schema_version: TODOS_TASK_ROUTE_STATE_SCHEMA_VERSION,
-    task_id: task.id,
-    task_short_id: task.short_id,
-    project_id: task.project_id,
-    task_list_id: task.task_list_id,
-    working_dir: task.working_dir
-  };
-  const pointers = workflowPointersFromMetadata(task.metadata);
-  for (const [key, value] of Object.entries(pointers)) {
-    if (value)
-      metadata[key] = value;
-  }
-  try {
-    const project = task.project_id ? getProject(task.project_id) : null;
-    const projectPath = project ? readMachineLocalPath(project) ?? project.path : task.working_dir;
-    if (project) {
-      metadata.project_id = project.id;
-      metadata.project_name = project.name;
-      metadata.project_path = projectPath;
-      metadata.project_canonical_path = project.path;
-      metadata.project_default_task_list_slug = project.task_list_id;
-      metadata.root_project_id = inferRootProjectId(project);
-    } else if (projectPath) {
-      metadata.project_path = projectPath;
-      metadata.project_canonical_path = projectPath;
-    }
-    if (projectPath) {
-      metadata.project_is_worktree = isWorktreePath(projectPath);
-      metadata.working_dir = task.working_dir ?? projectPath;
-    }
-    const taskList = task.task_list_id ? getTaskList(task.task_list_id) ?? (project ? getTaskListBySlug(task.task_list_id, project.id) : null) : project?.task_list_id ? getTaskListBySlug(project.task_list_id, project.id) : null;
-    if (taskList) {
-      metadata.task_list_id = taskList.id;
-      metadata.task_list_slug = taskList.slug;
-      metadata.task_list_name = taskList.name;
-      metadata.task_list_project_id = taskList.project_id;
-      metadata.task_list_is_project_default = Boolean(project?.task_list_id && taskList.slug === project.task_list_id);
-    }
-    const projectKind = projectKindFromMetadata(task.metadata, taskList?.metadata);
-    if (projectKind) {
-      metadata.project_kind = classifyProjectKind(projectPath ?? "", { project_kind: projectKind });
-    }
-    const routeEnabled = routeEnabledForTask(task, taskList);
-    if (routeEnabled !== undefined) {
-      metadata.route_enabled = routeEnabled;
-    }
-    const automation = routingAutomationMetadata(task, taskList);
-    if (automation) {
-      metadata.automation = automation;
-      metadata.route_blocked_by_no_auto = automation.no_auto === true;
-      metadata.route_blocked_by_manual = automation.manual === true || automation.manual_required === true;
-      metadata.route_blocked_by_approval = (automation.requires_approval === true || automation.approval_required === true) && !task.approved_by;
-    }
-  } catch {}
-  return metadata;
-}
-function readMachineLocalPath(project) {
-  const machineId = process.env["TODOS_MACHINE_ID"];
-  if (!machineId)
-    return null;
-  try {
-    const row = getDatabase().query("SELECT path FROM project_machine_paths WHERE project_id = ? AND machine_id = ?").get(project.id, machineId);
-    return row?.path ?? null;
-  } catch {
-    return null;
-  }
-}
-async function emitSharedTaskEvent(input) {
-  if (!shouldEmitSharedTaskEvents(input.databasePath))
-    return;
-  const data = taskEventData(input.task, input.data);
-  await new EventsClient().emit({
-    source: SOURCE,
-    type: input.type,
-    subject: input.task.id,
-    severity: input.severity ?? "info",
-    message: input.message ?? `${input.type}: ${input.task.title}`,
-    data,
-    dedupeKey: input.dedupeKey ?? `${input.type}:${input.task.id}:${input.task.version}`,
-    metadata: taskEventMetadata(input.task)
-  }, { deliver: true, dedupe: true });
-}
-function emitSharedTaskEventQuiet(input) {
-  emitSharedTaskEvent(input).catch(() => {
-    return;
-  });
-}
-var SOURCE = "todos";
-var init_shared_events = __esm(() => {
-  init_dist();
-  init_database();
-  init_projects();
-  init_task_lists();
-  init_event_emission_safety();
-});
-
-// src/lib/secret-redaction.ts
-import { readFileSync as readFileSync2, existsSync as existsSync6 } from "fs";
-function registerCustomRedactor(fn) {
-  customRedactors.push(fn);
-}
-function resetCustomRedactors() {
-  customRedactors = [];
+      return false;
+  }
+  if (typeof value === "string") {
+    const normalized = value.trim().toLowerCase();
+    if (["true", "1", "yes", "on"].includes(normalized))
+      return true;
+    if (["false", "0", "no", "off"].includes(normalized))
+      return false;
+  }
+  return;
 }
-function isAllowlisted(text, match, allowlist) {
-  const context = text.slice(Math.max(0, text.indexOf(match) - 20), text.indexOf(match) + match.length + 20);
-  return allowlist.some((re) => re.test(context) || re.test(match));
+function objectField(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : undefined;
 }
-function scanTextForSecrets(text, options = {}) {
-  const allowlist = [...DEFAULT_ALLOWLIST, ...options.allowlist ?? []];
-  const matches = [];
-  const patterns = [
-    ...DEFAULT_PATTERNS,
-    ...options.custom_patterns?.map((p, i) => ({ name: `custom_${i}`, pattern: p })) ?? []
-  ];
-  for (const { name, pattern, allowlist_ok } of patterns) {
-    const re = new RegExp(pattern.source, pattern.flags);
-    let m;
-    while ((m = re.exec(text)) !== null) {
-      const match = m[0];
-      if (allowlist_ok && isAllowlisted(text, match, allowlist))
-        continue;
-      if (isAllowlisted(text, match, allowlist))
-        continue;
-      const line = text.slice(0, m.index).split(`
-`).length;
-      matches.push({ pattern: name, match: match.slice(0, 12) + (match.length > 12 ? "\u2026" : ""), index: m.index, line });
+function collectBooleans(records, keys) {
+  const values = [];
+  for (const record of records) {
+    if (!record)
+      continue;
+    for (const key of keys) {
+      const value = booleanField(record[key]);
+      if (value !== undefined)
+        values.push(value);
     }
   }
-  return {
-    schema_version: SECRET_REDACTION_SCHEMA,
-    clean: matches.length === 0,
-    matches
-  };
+  return values;
 }
-function redactText(text, options = {}) {
-  const placeholder = options.placeholder ?? REDACTION_PLACEHOLDER2;
-  let out = text;
-  for (const { pattern, allowlist_ok } of DEFAULT_PATTERNS) {
-    out = out.replace(new RegExp(pattern.source, pattern.flags), (match) => {
-      if (allowlist_ok && isAllowlisted(out, match, [...DEFAULT_ALLOWLIST, ...options.allowlist ?? []])) {
-        return match;
-      }
-      return placeholder;
-    });
-  }
-  for (const custom of options.custom_patterns ?? []) {
-    out = out.replace(custom, placeholder);
-  }
-  for (const fn of customRedactors) {
-    out = fn(out);
+function mergedBoolean(records, keys, trueWins) {
+  const values = collectBooleans(records, keys);
+  if (values.length === 0)
+    return;
+  if (trueWins)
+    return values.some(Boolean);
+  return values.includes(false) ? false : true;
+}
+function routingAutomationMetadata(task, taskList) {
+  const taskAutomation = objectField(task.metadata.automation);
+  const taskListAutomation = taskList ? objectField(taskList.metadata.automation) : undefined;
+  const records = [task.metadata, taskAutomation, taskList?.metadata, taskListAutomation];
+  const result = {};
+  const aliases = [
+    ["allowed", ["allowed", "automation_allowed", "automationAllowed"]],
+    ["no_auto", ["no_auto", "noAuto"]],
+    ["manual", ["manual"]],
+    ["manual_required", ["manual_required", "manualRequired"]],
+    ["requires_approval", ["requires_approval", "requiresApproval"]],
+    ["approval_required", ["approval_required", "approvalRequired"]]
+  ];
+  for (const [canonical, keys] of aliases) {
+    const value = mergedBoolean(records, keys, canonical !== "allowed");
+    if (value !== undefined)
+      result[canonical] = value;
   }
-  return out;
+  if (task.requires_approval)
+    result.requires_approval = true;
+  return Object.keys(result).length > 0 ? result : undefined;
 }
-function scanAndRedactText(text, options = {}) {
-  const scan = scanTextForSecrets(text, options);
+function routeEnabledForTask(task, taskList) {
+  const explicit = booleanField(task.metadata.route_enabled);
+  if (explicit !== undefined)
+    return explicit;
+  const taskListDefault = taskList ? booleanField(taskList.metadata.route_enabled) : undefined;
+  if (taskListDefault !== undefined)
+    return taskListDefault;
+  return;
+}
+function stringField(value) {
+  return typeof value === "string" && value.trim() ? value : undefined;
+}
+function workflowPointersFromMetadata(metadata) {
+  const nested = objectField(metadata.workflow_invocation) ?? objectField(metadata.workflow) ?? {};
   return {
-    ...scan,
-    redacted_text: redactText(text, options)
+    current_workflow_invocation_id: stringField(metadata.current_workflow_invocation_id) ?? stringField(nested.current_workflow_invocation_id) ?? stringField(nested.invocation_id),
+    current_run_id: stringField(metadata.current_run_id) ?? stringField(nested.current_run_id) ?? stringField(nested.run_id),
+    latest_manifest_path: stringField(metadata.latest_manifest_path) ?? stringField(nested.latest_manifest_path) ?? stringField(nested.manifest_path),
+    latest_evaluation_path: stringField(metadata.latest_evaluation_path) ?? stringField(nested.latest_evaluation_path) ?? stringField(nested.evaluation_path),
+    workflow_state: stringField(metadata.workflow_state) ?? stringField(nested.workflow_state) ?? stringField(nested.state)
   };
 }
-function scanFileForSecrets(path, options = {}) {
-  if (!existsSync6(path))
-    throw new Error(`File not found: ${path}`);
-  const content = readFileSync2(path, "utf8");
-  return scanAndRedactText(content, options);
-}
-function safeStringify(value, space) {
-  const redacted = typeof value === "object" && value !== null && !Array.isArray(value) ? redactValue(value) : value;
-  const json = JSON.stringify(redacted, null, space);
-  return redactText(json);
+function compactWorkflowPointers(pointers) {
+  return Object.fromEntries(Object.entries(pointers).filter(([, value]) => typeof value === "string" && value.length > 0));
 }
-function assertNoSecrets(text, context) {
-  const scan = scanTextForSecrets(text);
-  if (!scan.clean) {
-    const summary = scan.matches.map((m) => `${m.pattern}@${m.line ?? m.index}`).join(", ");
-    throw new Error(`Secret pattern detected${context ? ` in ${context}` : ""}: ${summary}`);
+function metadataStringField(record, keys) {
+  if (!record)
+    return;
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "string" && value.trim())
+      return value.trim();
   }
+  return;
 }
-function redactCommentContent(content) {
-  return redactText(content);
-}
-function redactHandoffPayload(payload) {
-  return redactValue(payload);
-}
-function redactExportRecord(record) {
-  const base = redactValue(record);
-  for (const [key, value] of Object.entries(base)) {
-    if (typeof value === "string") {
-      base[key] = redactText(value);
-    }
+function projectKindFromMetadata(...records) {
+  for (const record of records) {
+    const value = metadataStringField(record ?? undefined, ["project_kind", "projectKind", "source_kind", "sourceKind"]);
+    if (value)
+      return value;
   }
-  return base;
+  return null;
 }
-function getDefaultSecretPatterns() {
-  return DEFAULT_PATTERNS.map((p) => ({ name: p.name, source: p.pattern.source }));
+function classifyProjectKind(_path, metadata) {
+  return projectKindFromMetadata(metadata);
 }
-var SECRET_REDACTION_SCHEMA, REDACTION_PLACEHOLDER2 = "[REDACTED]", DEFAULT_PATTERNS, DEFAULT_ALLOWLIST, customRedactors;
-var init_secret_redaction = __esm(() => {
-  init_redaction();
-  SECRET_REDACTION_SCHEMA = ["todos", "secret_redaction", "v1"].join(".");
-  DEFAULT_PATTERNS = [
-    { name: "openai_sk", pattern: /\bsk-[a-zA-Z0-9]{10,}\b/g },
-    { name: "github_pat", pattern: /\bghp_[a-zA-Z0-9]{20,}\b/g },
-    { name: "github_oauth", pattern: /\bgho_[a-zA-Z0-9]{20,}\b/g },
-    { name: "aws_access_key", pattern: /\bAKIA[0-9A-Z]{16}\b/g },
-    { name: "bearer_token", pattern: /\bBearer\s+[a-zA-Z0-9\-._~+/]+=*\b/gi },
-    { name: "jwt", pattern: /\beyJ[a-zA-Z0-9_-]+\.eyJ[a-zA-Z0-9_-]+\.[a-zA-Z0-9_-]+\b/g },
-    { name: "private_key_block", pattern: /-----BEGIN (?:RSA |EC |OPENSSH )?PRIVATE KEY-----[\s\S]*?-----END (?:RSA |EC |OPENSSH )?PRIVATE KEY-----/g },
-    { name: "generic_api_key", pattern: /\b(?:api[_-]?key|secret|token|password)\s*[:=]\s*['"]?[a-zA-Z0-9\-._]{8,}['"]?/gi, allowlist_ok: true }
-  ];
-  DEFAULT_ALLOWLIST = [
-    /\[REDACTED\]/,
-    /example\.com/i,
-    /your-api-key-here/i,
-    /sk-test/i,
-    /ghp_xxx/i
-  ];
-  customRedactors = [];
-});
-
-// src/lib/prewrite-secrets.ts
-function mergeFindings(findings) {
-  const byPattern = new Map;
-  for (const finding of findings) {
-    const existing = byPattern.get(finding.pattern);
-    if (!existing) {
-      byPattern.set(finding.pattern, {
-        pattern: finding.pattern,
-        count: finding.count,
-        lines: Array.from(new Set(finding.lines)).sort((a, b) => a - b)
-      });
-      continue;
-    }
-    existing.count += finding.count;
-    existing.lines = Array.from(new Set([...existing.lines, ...finding.lines])).sort((a, b) => a - b);
-  }
-  return [...byPattern.values()].sort((left, right) => left.pattern.localeCompare(right.pattern));
+function isWorktreePath(path) {
+  return path.includes("/.codewith/worktrees/") || path.includes("/.worktrees/");
 }
-function redactPreWriteText(value) {
-  return redactText(redactEvidenceText(value));
+function inferRootProjectId(project) {
+  return isWorktreePath(project.path) ? null : project.id;
 }
-function scanPreWriteText(value, context = "text") {
-  const redacted = redactPreWriteText(value);
-  if (redacted === value) {
-    return {
-      schema_version: PREWRITE_SECRET_SCAN_SCHEMA,
-      clean: true,
-      context,
-      findings: []
-    };
-  }
-  const structural = scanTextForSecrets(value).matches.map((match) => ({
-    pattern: match.pattern,
-    count: 1,
-    lines: match.line ? [match.line] : []
-  }));
-  const configured = listSecretFindings(value).map((finding) => ({
-    pattern: finding.pattern,
-    count: finding.count,
-    lines: []
-  }));
+var TODOS_TASK_ROUTE_STATE_SCHEMA_VERSION = "todos.task_route_state.v1", TASK_WORKFLOW_POINTER_SCHEMA_VERSION = "todos.task_workflow_pointer.v1";
+
+// src/lib/shared-events.ts
+function taskEventData(task, extra = {}) {
   return {
-    schema_version: PREWRITE_SECRET_SCAN_SCHEMA,
-    clean: false,
-    context,
-    findings: mergeFindings([...structural, ...configured])
+    id: task.id,
+    task_id: task.id,
+    short_id: task.short_id,
+    title: task.title,
+    description: task.description,
+    status: task.status,
+    priority: task.priority,
+    project_id: task.project_id,
+    parent_id: task.parent_id,
+    plan_id: task.plan_id,
+    task_list_id: task.task_list_id,
+    agent_id: task.agent_id,
+    assigned_to: task.assigned_to,
+    session_id: task.session_id,
+    working_dir: task.working_dir,
+    tags: task.tags,
+    metadata: task.metadata,
+    version: task.version,
+    created_at: task.created_at,
+    updated_at: task.updated_at,
+    started_at: task.started_at,
+    completed_at: task.completed_at,
+    due_at: task.due_at,
+    requires_approval: task.requires_approval,
+    approved_by: task.approved_by,
+    approved_at: task.approved_at,
+    ...extra
   };
 }
-function assertPreWriteTextClean(value, context = "text") {
-  const scan = scanPreWriteText(value, context);
-  if (!scan.clean)
-    throw new PreWriteSecretError(context, scan.findings);
-}
-function sanitizePreWriteText(value, context = "text", options = {}) {
-  const mode = options.mode ?? "redact";
-  if (mode === "block") {
-    assertPreWriteTextClean(value, context);
-    return value;
-  }
-  return redactPreWriteText(value);
-}
-function sanitizePreWriteValue(value, context = "value", options = {}) {
-  if (typeof value === "string")
-    return sanitizePreWriteText(value, context, options);
-  if (Array.isArray(value)) {
-    return value.map((item, index) => sanitizePreWriteValue(item, `${context}[${index}]`, options));
+function taskEventMetadata(task) {
+  const metadata = {
+    package: "@hasna/todos",
+    todos_event_schema_version: 1,
+    route_state_schema_version: TODOS_TASK_ROUTE_STATE_SCHEMA_VERSION,
+    task_id: task.id,
+    task_short_id: task.short_id,
+    project_id: task.project_id,
+    task_list_id: task.task_list_id,
+    working_dir: task.working_dir
+  };
+  const pointers = workflowPointersFromMetadata(task.metadata);
+  for (const [key, value] of Object.entries(pointers)) {
+    if (value)
+      metadata[key] = value;
   }
-  if (value && typeof value === "object") {
-    const sanitized = {};
-    for (const [key, child] of Object.entries(value)) {
-      const safeKey = sanitizePreWriteText(key, `${context}.$key`, options);
-      sanitized[safeKey] = sanitizePreWriteValue(child, `${context}.${safeKey}`, options);
+  try {
+    const project = task.project_id ? getProject(task.project_id) : null;
+    const projectPath = project ? readMachineLocalPath(project) ?? project.path : task.working_dir;
+    if (project) {
+      metadata.project_id = project.id;
+      metadata.project_name = project.name;
+      metadata.project_path = projectPath;
+      metadata.project_canonical_path = project.path;
+      metadata.project_default_task_list_slug = project.task_list_id;
+      metadata.root_project_id = inferRootProjectId(project);
+    } else if (projectPath) {
+      metadata.project_path = projectPath;
+      metadata.project_canonical_path = projectPath;
     }
-    return redactValue(sanitized);
-  }
-  return value;
+    if (projectPath) {
+      metadata.project_is_worktree = isWorktreePath(projectPath);
+      metadata.working_dir = task.working_dir ?? projectPath;
+    }
+    const taskList = task.task_list_id ? getTaskList(task.task_list_id) ?? (project ? getTaskListBySlug(task.task_list_id, project.id) : null) : project?.task_list_id ? getTaskListBySlug(project.task_list_id, project.id) : null;
+    if (taskList) {
+      metadata.task_list_id = taskList.id;
+      metadata.task_list_slug = taskList.slug;
+      metadata.task_list_name = taskList.name;
+      metadata.task_list_project_id = taskList.project_id;
+      metadata.task_list_is_project_default = Boolean(project?.task_list_id && taskList.slug === project.task_list_id);
+    }
+    const projectKind = projectKindFromMetadata(task.metadata, taskList?.metadata);
+    if (projectKind) {
+      metadata.project_kind = classifyProjectKind(projectPath ?? "", { project_kind: projectKind });
+    }
+    const routeEnabled = routeEnabledForTask(task, taskList);
+    if (routeEnabled !== undefined) {
+      metadata.route_enabled = routeEnabled;
+    }
+    const automation = routingAutomationMetadata(task, taskList);
+    if (automation) {
+      metadata.automation = automation;
+      metadata.route_blocked_by_no_auto = automation.no_auto === true;
+      metadata.route_blocked_by_manual = automation.manual === true || automation.manual_required === true;
+      metadata.route_blocked_by_approval = (automation.requires_approval === true || automation.approval_required === true) && !task.approved_by;
+    }
+  } catch {}
+  return metadata;
 }
-function sanitizePreWriteJsonString(value, context = "json") {
-  if (value === undefined || value === null)
+function readMachineLocalPath(project) {
+  const machineId = process.env["TODOS_MACHINE_ID"];
+  if (!machineId)
     return null;
   try {
-    return JSON.stringify(sanitizePreWriteValue(JSON.parse(value), context));
+    const row = getDatabase().query("SELECT path FROM project_machine_paths WHERE project_id = ? AND machine_id = ?").get(project.id, machineId);
+    return row?.path ?? null;
   } catch {
-    return sanitizePreWriteText(value, context);
+    return null;
   }
 }
-var PREWRITE_SECRET_SCAN_SCHEMA, PreWriteSecretError;
-var init_prewrite_secrets = __esm(() => {
-  init_redaction();
-  init_secret_redaction();
-  PREWRITE_SECRET_SCAN_SCHEMA = ["todos", "prewrite_secret_scan", "v1"].join(".");
-  PreWriteSecretError = class PreWriteSecretError extends Error {
-    context;
-    findings;
-    constructor(context, findings) {
-      const summary = findings.map((finding) => `${finding.pattern}:${finding.count}`).join(", ");
-      super(`Secret pattern detected before persistence in ${context}: ${summary}`);
-      this.name = "PreWriteSecretError";
-      this.context = context;
-      this.findings = findings;
-    }
-  };
+async function emitSharedTaskEvent(input) {
+  if (!shouldEmitSharedTaskEvents(input.databasePath))
+    return;
+  const data = taskEventData(input.task, input.data);
+  await new EventsClient().emit({
+    source: SOURCE,
+    type: input.type,
+    subject: input.task.id,
+    severity: input.severity ?? "info",
+    message: input.message ?? `${input.type}: ${input.task.title}`,
+    data,
+    dedupeKey: input.dedupeKey ?? `${input.type}:${input.task.id}:${input.task.version}`,
+    metadata: taskEventMetadata(input.task)
+  }, { deliver: true, dedupe: true });
+}
+function emitSharedTaskEventQuiet(input) {
+  emitSharedTaskEvent(input).catch(() => {
+    return;
+  });
+}
+var SOURCE = "todos";
+var init_shared_events = __esm(() => {
+  init_dist();
+  init_database();
+  init_projects();
+  init_task_lists();
+  init_event_emission_safety();
 });
 
 // src/lib/activity-audit.ts
@@ -7511,28 +7660,55 @@ var init_activity_audit = __esm(() => {
 function sanitizeHistoryValue(value, context) {
   return value === undefined || value === null ? null : sanitizePreWriteText(String(value), context);
 }
-function logTaskChange2(taskId, action, field, oldValue, newValue, agentId, db) {
+function insertTaskHistory(entry2, db) {
   const d = db || getDatabase();
-  const id = uuid();
-  const timestamp2 = now();
-  const machineId = currentStorageMachineId(d);
-  const safeOldValue = sanitizeHistoryValue(oldValue, "task_history.old_value");
-  const safeNewValue = sanitizeHistoryValue(newValue, "task_history.new_value");
+  const safeEntry = {
+    ...entry2,
+    field: entry2.field || null,
+    old_value: sanitizeHistoryValue(entry2.old_value, "task_history.old_value"),
+    new_value: sanitizeHistoryValue(entry2.new_value, "task_history.new_value"),
+    agent_id: entry2.agent_id || null,
+    machine_id: entry2.machine_id ?? currentStorageMachineId(d)
+  };
   d.run(`INSERT INTO task_history (id, task_id, action, field, old_value, new_value, agent_id, created_at, machine_id)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`, [id, taskId, action, field || null, safeOldValue, safeNewValue, agentId || null, timestamp2, machineId]);
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+    safeEntry.id,
+    safeEntry.task_id,
+    safeEntry.action,
+    safeEntry.field,
+    safeEntry.old_value,
+    safeEntry.new_value,
+    safeEntry.agent_id,
+    safeEntry.created_at,
+    safeEntry.machine_id ?? null
+  ]);
   try {
     const { logActivity: logActivity2 } = (init_activity_audit(), __toCommonJS(exports_activity_audit));
     logActivity2({
       entity_type: "task",
-      entity_id: taskId,
-      action,
-      field,
-      old_value: safeOldValue,
-      new_value: safeNewValue,
-      actor_id: agentId ?? undefined
+      entity_id: safeEntry.task_id,
+      action: safeEntry.action,
+      field: safeEntry.field ?? undefined,
+      old_value: safeEntry.old_value,
+      new_value: safeEntry.new_value,
+      actor_id: safeEntry.agent_id ?? undefined
     }, d);
   } catch {}
-  return { id, task_id: taskId, action, field: field || null, old_value: safeOldValue, new_value: safeNewValue, agent_id: agentId || null, created_at: timestamp2, machine_id: machineId };
+  return safeEntry;
+}
+function logTaskChange2(taskId, action, field, oldValue, newValue, agentId, db) {
+  const d = db || getDatabase();
+  return insertTaskHistory({
+    id: uuid(),
+    task_id: taskId,
+    action,
+    field: field || null,
+    old_value: oldValue ?? null,
+    new_value: newValue ?? null,
+    agent_id: agentId || null,
+    created_at: now(),
+    machine_id: currentStorageMachineId(d)
+  }, d);
 }
 function getTaskHistory(taskId, db) {
   const d = db || getDatabase();
@@ -8555,6 +8731,7 @@ __export(exports_task_lifecycle, {
   startTask: () => startTask2,
   spawnNextRecurrence: () => spawnNextRecurrence,
   lockTask: () => lockTask2,
+  handoffStaleTaskLock: () => handoffStaleTaskLock,
   getTasksChangedSince: () => getTasksChangedSince,
   getTaskLockStatus: () => getTaskLockStatus,
   getStaleTasks: () => getStaleTasks,
@@ -8823,6 +9000,38 @@ function unlockTask2(id, agentId, db) {
      WHERE id = ?`, [timestamp2, id]);
   return true;
 }
+function handoffStaleTaskLock(input, db) {
+  const d = db || getDatabase();
+  const prepared = prepareStaleLockHandoff(input);
+  const receipt = buildStaleLockHandoffReceipt(prepared);
+  const history = staleLockHandoffHistory(receipt, null);
+  const transfer = d.transaction(() => {
+    const result = d.run(`UPDATE tasks
+       SET locked_by = ?, locked_at = ?, updated_at = ?, version = version + 1
+       WHERE id = ?
+         AND locked_by = ?
+         AND locked_at = ?
+         AND julianday(locked_at) < julianday(?)
+         AND status NOT IN ('completed', 'failed', 'cancelled')`, [
+      prepared.new_holder,
+      prepared.operation_timestamp,
+      prepared.operation_timestamp,
+      prepared.task_id,
+      prepared.expected_holder,
+      prepared.expected_lock_version,
+      prepared.stale_cutoff
+    ]);
+    if (result.changes === 0) {
+      const current = getTask(prepared.task_id, d);
+      if (!current)
+        throw new TaskNotFoundError(prepared.task_id);
+      throwStaleLockHandoffConflict(current, prepared);
+    }
+    insertTaskHistory(history, d);
+  });
+  transfer();
+  return receipt;
+}
 function getTaskLockStatus(id, db) {
   const d = db || getDatabase();
   const task = getTask(id, d);
@@ -9123,6 +9332,7 @@ var init_task_lifecycle = __esm(() => {
   init_task_crud();
   init_task_graph();
   init_prewrite_secrets();
+  init_stale_lock_handoff();
 });
 
 // src/db/task-crud.ts
@@ -12438,7 +12648,7 @@ import { createHash as createHash5 } from "crypto";
 // package.json
 var package_default = {
   name: "@hasna/todos",
-  version: "0.15.19",
+  version: "0.15.20",
   description: "Universal task management for AI coding agents - CLI + MCP server + interactive TUI",
   type: "module",
   main: "dist/index.js",
@@ -12509,6 +12719,8 @@ var package_default = {
     "dev:mcp": "bun run src/mcp/index.ts",
     "dev:serve": "bun run src/server/index.ts",
     "verify:release": "bun run scripts/verify-public-release.ts --mode=review",
+    "verify:release-review": "bun run scripts/verify-npm-release-agent-review.ts",
+    "issue:release-review": "bun run scripts/issue-npm-release-agent-review.ts",
     prepublishOnly: "bun run scripts/verify-public-release.ts --mode=publish",
     postinstall: "mkdir -p $HOME/.hasna/todos $HOME/.hasna/todos/training 2>/dev/null || true"
   },
@@ -12636,6 +12848,9 @@ function assertPlanProjectLinkReceipt(value) {
   return receipt;
 }
 
+// src/storage/postgres-adapter.ts
+init_stale_lock_handoff();
+
 // src/storage/postgres-sync.ts
 var DEFAULT_TODOS_POSTGRES_SYNC_TABLE = "todos_sync_records";
 var DEFAULT_TODOS_POSTGRES_CURSOR_TABLE = "todos_sync_cursors";
@@ -13279,6 +13494,36 @@ function measureIntegrityRows(spec, sets) {
 
 // src/storage/postgres-adapter.ts
 init_redaction();
+
+// src/storage/audit-history-import.ts
+var AUDIT_HISTORY_DIVERGENT_REPLAY = "AUDIT_HISTORY_DIVERGENT_REPLAY";
+var AUDIT_HISTORY_TOMBSTONE_FORBIDDEN = "AUDIT_HISTORY_TOMBSTONE_FORBIDDEN";
+var AUDIT_HISTORY_FIELDS = [
+  "id",
+  "task_id",
+  "action",
+  "field",
+  "old_value",
+  "new_value",
+  "agent_id",
+  "created_at",
+  "machine_id"
+];
+function auditHistoryRowsAreFieldIdentical(left, right) {
+  return AUDIT_HISTORY_FIELDS.every((field) => {
+    const leftValue = field === "machine_id" ? left[field] ?? null : left[field];
+    const rightValue = field === "machine_id" ? right[field] ?? null : right[field];
+    return leftValue === rightValue;
+  });
+}
+function divergentAuditHistoryReplayError(id) {
+  return `${AUDIT_HISTORY_DIVERGENT_REPLAY}: immutable audit_history row ${id} differs from stored row`;
+}
+function forbiddenAuditHistoryTombstoneError(id) {
+  return `${AUDIT_HISTORY_TOMBSTONE_FORBIDDEN}: audit_history tombstone ${id} is not allowed`;
+}
+
+// src/storage/postgres-adapter.ts
 function createPostgresTodosStorageAdapter(options) {
   const store = new PostgresJsonRecordStore(options);
   const adapter = {
@@ -13307,6 +13552,7 @@ function createPostgresTodosStorageAdapter(options) {
       getChangedSince: (since, filters) => getChangedSince(since, filters, store),
       lock: (id, agentId) => lockTask(id, agentId, store),
       unlock: (id, agentId) => unlockTask(id, agentId, store),
+      handoffStaleLock: (input, context) => store.handoffStaleLock(input, context),
       getByFingerprint: (fingerprint) => store.getTaskByFingerprint(fingerprint)
     },
     dependencies: {
@@ -13453,6 +13699,91 @@ class PostgresJsonRecordStore {
        LIMIT 1`, [this.service, type, id]);
     return result.rows[0] ? payloadRecord2(result.rows[0].payload) : null;
   }
+  async handoffStaleLock(input, context = {}) {
+    const prepared = prepareStaleLockHandoff(input);
+    const receipt = buildStaleLockHandoffReceipt(prepared);
+    const history = staleLockHandoffHistory(receipt, this.machineId(context));
+    await this.ensureSchema();
+    const result = await this.options.client.query(`/* todos:stale-lock-handoff-atomic */ WITH
+       target AS MATERIALIZED (
+         SELECT payload
+         FROM ${this.tableName}
+         WHERE service = $1
+           AND object_type = 'tasks'
+           AND object_id = $2
+           AND deleted_at IS NULL
+         FOR UPDATE
+       ),
+       updated AS (
+         UPDATE ${this.tableName} AS task_record
+         SET payload = jsonb_set(
+               jsonb_set(
+                 jsonb_set(
+                   jsonb_set(
+                     task_record.payload,
+                     '{locked_by}',
+                     to_jsonb($6::text),
+                     true
+                   ),
+                   '{locked_at}',
+                   to_jsonb($7::text),
+                   true
+                 ),
+                 '{updated_at}',
+                 to_jsonb($7::text),
+                 true
+               ),
+               '{version}',
+               to_jsonb(COALESCE((task_record.payload->>'version')::integer, 0) + 1),
+               true
+             ),
+             updated_at = $7::timestamptz,
+             source_machine_id = $10,
+             version = COALESCE(task_record.version, 0) + 1
+         FROM target
+         WHERE task_record.service = $1
+           AND task_record.object_type = 'tasks'
+           AND task_record.object_id = $2
+           AND task_record.deleted_at IS NULL
+           AND target.payload->>'locked_by' = $3
+           AND target.payload->>'locked_at' = $4
+           AND todos_try_timestamptz(target.payload->>'locked_at') < $5::timestamptz
+           AND COALESCE(target.payload->>'status', '') NOT IN ('completed', 'failed', 'cancelled')
+         RETURNING task_record.payload
+       ),
+       audit AS (
+         INSERT INTO ${this.tableName} (
+           service, object_type, object_id, payload, updated_at,
+           deleted_at, source_machine_id, version
+         )
+         SELECT $1, 'audit_history', $8, $9::jsonb, $7::timestamptz,
+                NULL, $10, NULL
+         FROM updated
+         RETURNING payload
+       )
+       SELECT
+         (SELECT payload FROM target) AS current_payload,
+         (SELECT payload FROM updated) AS updated_payload,
+         (SELECT payload FROM audit) AS audit_payload`, [
+      this.service,
+      prepared.task_id,
+      prepared.expected_holder,
+      prepared.expected_lock_version,
+      prepared.stale_cutoff,
+      prepared.new_holder,
+      prepared.operation_timestamp,
+      receipt.receipt_id,
+      jsonbParam(history),
+      this.machineId(context)
+    ]);
+    const row = result.rows[0];
+    if (!row?.current_payload)
+      throw new TaskNotFoundError(prepared.task_id);
+    if (!row.updated_payload || !row.audit_payload) {
+      throwStaleLockHandoffConflict(payloadRecord2(row.current_payload), prepared);
+    }
+    return receipt;
+  }
   async list(type) {
     return (await this.listRecords(type)).map((record) => record.payload);
   }
@@ -13722,6 +14053,28 @@ class PostgresJsonRecordStore {
     }
     return value;
   }
+  async insertImmutableAuditHistory(value, context = {}) {
+    await this.ensureSchema();
+    const inserted = await this.options.client.query(`INSERT INTO ${this.tableName} (
+        service, object_type, object_id, payload, updated_at,
+        deleted_at, source_machine_id, version
+      ) VALUES ($1, $2, $3, $4::jsonb, $5::timestamptz, NULL, $6, NULL)
+      ON CONFLICT (service, object_type, object_id) DO NOTHING
+      RETURNING object_id`, [
+      this.service,
+      "audit_history",
+      value.id,
+      jsonbParam(value),
+      value.created_at,
+      context.requestId ?? this.sourceMachineId ?? null
+    ]);
+    if (inserted.rows.length > 0)
+      return "inserted";
+    const existing = await this.get("audit_history", value.id);
+    if (existing && auditHistoryRowsAreFieldIdentical(existing, value))
+      return "identical";
+    throw new Error(divergentAuditHistoryReplayError(value.id));
+  }
   async upsertTaskWithPlanMembershipGuard(value, guardedPlanIds, explicitProject, context = {}) {
     const planIds = [...new Set(guardedPlanIds.filter(Boolean))].sort();
     if (planIds.length === 0)
@@ -15213,6 +15566,11 @@ async function importSnapshot(snapshot, store, context) {
   result.errors.push(...validateSnapshotRoutingDestinationConflicts(snapshot.projects, snapshot.taskLists, existingProjects, existingTaskLists));
   if (result.errors.length > 0)
     return result;
+  const auditHistory = await preflightAuditHistoryImport(snapshot.auditHistory, snapshot.tombstones ?? [], store);
+  result.errors.push(...auditHistory.errors);
+  if (result.errors.length > 0)
+    return result;
+  result.skipped += auditHistory.identical;
   const entries = [
     ...snapshot.tasks.map((row) => ["tasks", row]),
     ...snapshot.projects.map((row) => ["projects", row]),
@@ -15221,9 +15579,20 @@ async function importSnapshot(snapshot, store, context) {
     ...snapshot.agents.map((row) => ["agents", row]),
     ...snapshot.taskLists.map((row) => ["task_lists", row]),
     ...snapshot.templates.map((row) => ["templates", row]),
-    ...(snapshot.templateTasks ?? []).map((row) => ["template_tasks", row]),
-    ...snapshot.auditHistory.map((row) => ["audit_history", row])
+    ...(snapshot.templateTasks ?? []).map((row) => ["template_tasks", row])
   ];
+  for (const row of auditHistory.rowsToInsert) {
+    try {
+      const outcome = await store.insertImmutableAuditHistory(row, context);
+      if (outcome === "inserted")
+        result.inserted += 1;
+      else
+        result.skipped += 1;
+    } catch (error) {
+      result.errors.push(error instanceof Error ? error.message : String(error));
+      return result;
+    }
+  }
   for (const [type, row] of entries) {
     try {
       const existing = await store.get(type, row.id);
@@ -15257,6 +15626,32 @@ async function importSnapshot(snapshot, store, context) {
   }
   return result;
 }
+async function preflightAuditHistoryImport(rows, tombstones, store) {
+  const errors = tombstones.filter((tombstone) => tombstone.object_type === "audit_history").map((tombstone) => forbiddenAuditHistoryTombstoneError(tombstone.object_id));
+  const rowsToInsert = [];
+  const seen = new Map;
+  let identical = 0;
+  for (const row of rows) {
+    const prior = seen.get(row.id);
+    if (prior) {
+      if (auditHistoryRowsAreFieldIdentical(prior, row))
+        identical += 1;
+      else
+        errors.push(divergentAuditHistoryReplayError(row.id));
+      continue;
+    }
+    seen.set(row.id, row);
+    const existing = await store.get("audit_history", row.id);
+    if (!existing) {
+      rowsToInsert.push(row);
+    } else if (auditHistoryRowsAreFieldIdentical(existing, row)) {
+      identical += 1;
+    } else {
+      errors.push(divergentAuditHistoryReplayError(row.id));
+    }
+  }
+  return { rowsToInsert, identical, errors };
+}
 async function requireRecord(type, id, store) {
   const record = await store.get(type, id);
   if (!record)
@@ -16981,8 +17376,11 @@ function importSqliteTodosStorageSnapshot(snapshot, db) {
     const existingTaskLists = d.query("SELECT id, project_id, slug FROM task_lists").all();
     result.errors.push(...validateSnapshotRoutingDestinationConflicts(snapshot.projects, snapshot.taskLists, existingProjects, existingTaskLists));
   }
+  const auditImport = preflightAuditHistoryImport2(d, snapshot.auditHistory, snapshot.tombstones ?? []);
+  result.errors.push(...auditImport.errors);
   if (result.errors.length > 0)
     return result;
+  result.skipped += auditImport.identicalReplayCount;
   const applyRows = (objectType, table, columns, rows, updateClockColumn, acceptEqualClock = true, afterUpsert) => {
     for (const row of rows) {
       try {
@@ -17017,10 +17415,72 @@ function importSqliteTodosStorageSnapshot(snapshot, db) {
       replaceTaskTags(row["id"], row["tags"].filter((tag) => typeof tag === "string"), d);
     }
   });
-  applyRows("audit_history", "task_history", AUDIT_COLUMNS, snapshot.auditHistory);
+  insertAuditHistoryRows(d, auditImport.rowsToInsert, result);
   applyTombstones(d, snapshot.tombstones ?? [], result);
   return result;
 }
+function preflightAuditHistoryImport2(db, rows, tombstones) {
+  const errors = tombstones.filter((tombstone) => tombstone.object_type === "audit_history").map((tombstone) => forbiddenAuditHistoryTombstoneError(tombstone.object_id));
+  const rowsToInsert = [];
+  const seen = new Map;
+  let identicalReplayCount = 0;
+  for (const rawRow of rows) {
+    try {
+      const row = asRecord(rawRow);
+      if (typeof row.id !== "string" || !row.id) {
+        throw new Error("task_history row is missing id");
+      }
+      const prior = seen.get(row.id);
+      if (prior) {
+        if (auditHistoryRowsAreFieldIdentical(prior, row))
+          identicalReplayCount += 1;
+        else
+          errors.push(divergentAuditHistoryReplayError(row.id));
+        continue;
+      }
+      seen.set(row.id, row);
+      const existing = getAuditHistoryById(db, row.id);
+      if (!existing) {
+        rowsToInsert.push(row);
+      } else if (auditHistoryRowsAreFieldIdentical(existing, row)) {
+        identicalReplayCount += 1;
+      } else {
+        errors.push(divergentAuditHistoryReplayError(row.id));
+      }
+    } catch (error) {
+      errors.push(error instanceof Error ? error.message : String(error));
+    }
+  }
+  return { rowsToInsert, identicalReplayCount, errors };
+}
+function insertAuditHistoryRows(db, rows, result) {
+  for (const rawRow of rows) {
+    try {
+      const row = asRecord(rawRow);
+      const presentColumns = AUDIT_COLUMNS.filter((column) => (column in row));
+      if (!presentColumns.includes("id"))
+        presentColumns.unshift("id");
+      const placeholders = presentColumns.map(() => "?").join(", ");
+      const values = presentColumns.map((column) => valueForColumn(column, row[column]));
+      const changes = db.run(`INSERT OR IGNORE INTO task_history (${presentColumns.join(", ")}) VALUES (${placeholders})`, values).changes;
+      if (changes > 0) {
+        result.inserted += 1;
+        continue;
+      }
+      const existing = getAuditHistoryById(db, String(row["id"]));
+      if (existing && auditHistoryRowsAreFieldIdentical(existing, row)) {
+        result.skipped += 1;
+      } else {
+        result.errors.push(divergentAuditHistoryReplayError(String(row["id"])));
+      }
+    } catch (error) {
+      result.errors.push(error instanceof Error ? error.message : String(error));
+    }
+  }
+}
+function getAuditHistoryById(db, id) {
+  return db.query(`SELECT ${AUDIT_COLUMNS.join(", ")} FROM task_history WHERE id = ? LIMIT 1`).get(id);
+}
 function upsertById(db, table, columns, row, updateClockColumn, acceptEqualClock = true) {
   const id = row["id"];
   if (typeof id !== "string" || !id)
@@ -17118,7 +17578,7 @@ function tableForTombstone(objectType) {
     return "task_templates";
   if (objectType === "template_tasks")
     return "template_tasks";
-  return "task_history";
+  throw new Error(`unsupported storage tombstone object_type: ${String(objectType)}`);
 }
 function listRows(db, table, columns) {
   return db.query(`SELECT ${columns.join(", ")} FROM ${table} ORDER BY id`).all();
@@ -17250,6 +17710,7 @@ function createLocalSqliteTodosStorageAdapter(options = {}) {
         unlockTask2(id, agentId, database());
         return true;
       },
+      handoffStaleLock: (input) => handoffStaleTaskLock(input, database()),
       delete: (id) => deleteTask(id, database()),
       start: (id, agentId) => startTask2(id, agentId, database()),
       complete: (id, agentId, options2) => completeTask2(id, agentId, database(), options2),