@hasna/todos 0.15.19 → 0.15.24

package/dist/server/index.js

@@ -70,7 +70,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@hasna/todos",
-    version: "0.15.19",
+    version: "0.15.24",
     description: "Universal task management for AI coding agents - CLI + MCP server + interactive TUI",
     type: "module",
     main: "dist/index.js",
@@ -141,6 +141,8 @@ var init_package = __esm(() => {
       "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"
     },
@@ -861,7 +863,7 @@ function isBlockingDependencyStatus(status) {
 function isTerminalStatus(status) {
   return status === "completed" || status === "failed" || status === "cancelled";
 }
-var TASK_STATUSES, TASK_PRIORITIES, VersionConflictError, TaskNotFoundError, TaskNotStartableError, TaskReferenceAmbiguousError, ProjectNotFoundError, ResourceConflictError, PlanRevisionConflictError, PlanNotFoundError, LockError, AgentNotFoundError, IdentityAliasAmbiguousError, IdentityIdImmutableError, TaskListNotFoundError, DependencyCycleError, CompletionGuardError, DispatchNotFoundError;
+var TASK_STATUSES, TASK_PRIORITIES, VersionConflictError, TaskNotFoundError, TaskNotStartableError, TaskReferenceAmbiguousError, ProjectNotFoundError, ResourceConflictError, PlanRevisionConflictError, PlanNotFoundError, LockError, StaleLockHandoffError, AgentNotFoundError, IdentityAliasAmbiguousError, IdentityIdImmutableError, TaskListNotFoundError, DependencyCycleError, CompletionGuardError, DispatchNotFoundError;
 var init_types = __esm(() => {
   TASK_STATUSES = [
     "pending",
@@ -983,6 +985,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";
@@ -1196,6 +1208,498 @@ var init_plan_project_link_contract = __esm(() => {
   };
 });
 
+// src/lib/config.ts
+import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
+import { dirname, join as join3 } from "path";
+function getConfigPath() {
+  return join3(getTodosGlobalDir(), "config.json");
+}
+function loadConfig() {
+  if (cached)
+    return cached;
+  if (!existsSync3(getConfigPath())) {
+    cached = {};
+    return cached;
+  }
+  const config = readJsonFile(getConfigPath()) || {};
+  if (typeof config.sync_agents === "string") {
+    config.sync_agents = config.sync_agents.split(",").map((a) => a.trim()).filter(Boolean);
+  }
+  cached = config;
+  return cached;
+}
+function saveConfig(config) {
+  const configPath = getConfigPath();
+  ensureDir(dirname(configPath));
+  writeJsonFile(configPath, config);
+  cached = config;
+  return config;
+}
+function getAgentPoolForProject(workingDir) {
+  const config = loadConfig();
+  if (workingDir && config.project_pools) {
+    let bestKey = null;
+    let bestLen = 0;
+    for (const key of Object.keys(config.project_pools)) {
+      if (workingDir.startsWith(key) && key.length > bestLen) {
+        bestKey = key;
+        bestLen = key.length;
+      }
+    }
+    if (bestKey && config.project_pools[bestKey]) {
+      return config.project_pools[bestKey];
+    }
+  }
+  return config.agent_pool || null;
+}
+function getCompletionGuardConfig(projectPath) {
+  const config = loadConfig();
+  const global = { ...GUARD_DEFAULTS, ...config.completion_guard };
+  if (projectPath && config.project_overrides?.[projectPath]?.completion_guard) {
+    return { ...global, ...config.project_overrides[projectPath].completion_guard };
+  }
+  return global;
+}
+var cached = null, GUARD_DEFAULTS;
+var init_config2 = __esm(() => {
+  init_sync_utils();
+  GUARD_DEFAULTS = {
+    enabled: false,
+    min_work_seconds: 30,
+    max_completions_per_window: 5,
+    window_minutes: 10,
+    cooldown_seconds: 60
+  };
+});
+
+// src/lib/redaction.ts
+function unique(values) {
+  return Array.from(new Set((values || []).map((value) => value.trim()).filter(Boolean)));
+}
+function cloneRegex(regex) {
+  return new RegExp(regex.source, regex.flags.includes("g") ? regex.flags : `${regex.flags}g`);
+}
+function customPatterns() {
+  return unique(loadConfig().secret_safety?.redaction_patterns).flatMap((pattern) => {
+    try {
+      return [{ name: `custom:${pattern}`, regex: new RegExp(pattern, "g") }];
+    } catch {
+      return [];
+    }
+  });
+}
+function secretPatterns() {
+  return [...customPatterns(), ...DEFAULT_SECRET_PATTERNS];
+}
+function isRedactionPlaceholderMatch(match) {
+  const trimmed = match.trim();
+  return new RegExp(`^${REDACTION_PLACEHOLDER}$`).test(trimmed) || new RegExp(`=\\s*['"]?${REDACTION_PLACEHOLDER}['"]?$`).test(trimmed);
+}
+function isRedactionPlaceholderKey(key) {
+  return new RegExp(`^${REDACTION_PLACEHOLDER}$`).test(key.trim());
+}
+function isSecretKey(key) {
+  if (isRedactionPlaceholderKey(key))
+    return false;
+  if (NON_SECRET_USAGE_KEYS.has(key.toLowerCase()))
+    return false;
+  if (DEFAULT_SECRET_KEY_PATTERN.test(key))
+    return true;
+  return unique(loadConfig().secret_safety?.redaction_keys).some((pattern) => key.toLowerCase().includes(pattern.toLowerCase()));
+}
+function redactEvidenceText(value) {
+  let redacted = value;
+  for (const pattern of secretPatterns()) {
+    const regex = cloneRegex(pattern.regex);
+    const replacement = pattern.replacement ?? "[REDACTED]";
+    redacted = typeof replacement === "string" ? redacted.replace(regex, replacement) : redacted.replace(regex, replacement);
+  }
+  return redacted;
+}
+function redactValue(value) {
+  if (typeof value === "string")
+    return redactEvidenceText(value);
+  if (Array.isArray(value))
+    return value.map(redactValue);
+  if (value && typeof value === "object") {
+    const redacted = {};
+    for (const [key, child] of Object.entries(value)) {
+      if (isSecretKey(key)) {
+        redacted[key] = "[REDACTED]";
+      } else {
+        redacted[key] = redactValue(child);
+      }
+    }
+    return redacted;
+  }
+  return value;
+}
+function listSecretFindings(value) {
+  const findings = [];
+  for (const pattern of secretPatterns()) {
+    const matches = value.match(cloneRegex(pattern.regex))?.filter((match) => !isRedactionPlaceholderMatch(match));
+    if (matches?.length)
+      findings.push({ pattern: pattern.name, count: matches.length });
+  }
+  return findings;
+}
+function getSecretSafetyConfig() {
+  return {
+    redaction_patterns: unique(loadConfig().secret_safety?.redaction_patterns),
+    redaction_keys: unique(loadConfig().secret_safety?.redaction_keys)
+  };
+}
+function upsertSecretSafetyConfig(input) {
+  const config = loadConfig();
+  const next = {
+    redaction_patterns: unique([...config.secret_safety?.redaction_patterns || [], ...input.redaction_patterns || []]),
+    redaction_keys: unique([...config.secret_safety?.redaction_keys || [], ...input.redaction_keys || []])
+  };
+  saveConfig({ ...config, secret_safety: next });
+  return next;
+}
+var DEFAULT_SECRET_PATTERNS, DEFAULT_SECRET_KEY_PATTERN, NON_SECRET_USAGE_KEYS, REDACTION_PLACEHOLDER;
+var init_redaction = __esm(() => {
+  init_config2();
+  DEFAULT_SECRET_PATTERNS = [
+    { name: "aws-access-key", regex: /\b(AKIA|ASIA)[0-9A-Z]{16}\b/g, replacement: "[REDACTED_AWS_KEY]" },
+    { name: "private-key", regex: /-----BEGIN (?:RSA |EC |OPENSSH |)PRIVATE KEY-----[\s\S]*?-----END (?:RSA |EC |OPENSSH |)PRIVATE KEY-----/g, replacement: "[REDACTED_PRIVATE_KEY]" },
+    { name: "openai-token", regex: /\bsk-[A-Za-z0-9_-]{12,}\b/g, replacement: "[REDACTED_TOKEN]" },
+    { name: "npm-token", regex: /\bnpm_[A-Za-z0-9]{20,}\b/g, replacement: "[REDACTED_NPM_TOKEN]" },
+    { name: "github-fine-grained-token", regex: /\bgithub_pat_[A-Za-z0-9_]{20,}\b/g, replacement: "[REDACTED_GITHUB_TOKEN]" },
+    { name: "github-token", regex: /\bgh[opsu]_[A-Za-z0-9]{20,}\b/g, replacement: "[REDACTED_GITHUB_TOKEN]" },
+    { name: "env-secret-assignment", regex: /\b([A-Za-z0-9_]*(?:API_KEY|TOKEN|SECRET|PASSWORD)[A-Za-z0-9_]*)\s*=\s*['"]?[^'"\s]{8,}/gi, replacement: "$1=[REDACTED]" },
+    { name: "bearer-token", regex: /\b(bearer)\s+[A-Za-z0-9._~+/=-]{12,}/gi, replacement: "$1 [REDACTED]" }
+  ];
+  DEFAULT_SECRET_KEY_PATTERN = /api[_-]?key|token|secret|password/i;
+  NON_SECRET_USAGE_KEYS = new Set([
+    "tokens",
+    "total_tokens",
+    "token_count",
+    "input_tokens",
+    "output_tokens",
+    "prompt_tokens",
+    "completion_tokens",
+    "cost_tokens"
+  ]);
+  REDACTION_PLACEHOLDER = String.raw`\[REDACTED(?:_[A-Z_]+)?\]`;
+});
+
+// src/lib/secret-redaction.ts
+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
+  };
+}
+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 redactExportRecord(record) {
+  const base = redactValue(record);
+  for (const [key, value] of Object.entries(base)) {
+    if (typeof value === "string") {
+      base[key] = redactText(value);
+    }
+  }
+  return base;
+}
+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;
+}
+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 (value.startsWith("0000-") || 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 });
+  }
+  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/lib/slugs.ts
 function normalizeSlug(value) {
   return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
@@ -1862,182 +2366,82 @@ var init_integrity = __esm(() => {
   };
 });
 
-// src/lib/config.ts
-import { existsSync as existsSync3 } from "fs";
-import { dirname, join as join3 } from "path";
-function getConfigPath() {
-  return join3(getTodosGlobalDir(), "config.json");
+// src/storage/audit-history-import.ts
+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 loadConfig() {
-  if (cached)
-    return cached;
-  if (!existsSync3(getConfigPath())) {
-    cached = {};
-    return cached;
-  }
-  const config = readJsonFile(getConfigPath()) || {};
-  if (typeof config.sync_agents === "string") {
-    config.sync_agents = config.sync_agents.split(",").map((a) => a.trim()).filter(Boolean);
-  }
-  cached = config;
-  return cached;
+function divergentAuditHistoryReplayError(id) {
+  return `${AUDIT_HISTORY_DIVERGENT_REPLAY}: immutable audit_history row ${id} differs from stored row`;
 }
-function saveConfig(config) {
-  const configPath = getConfigPath();
-  ensureDir(dirname(configPath));
-  writeJsonFile(configPath, config);
-  cached = config;
-  return config;
+function forbiddenAuditHistoryTombstoneError(id) {
+  return `${AUDIT_HISTORY_TOMBSTONE_FORBIDDEN}: audit_history tombstone ${id} is not allowed`;
 }
-function getAgentPoolForProject(workingDir) {
-  const config = loadConfig();
-  if (workingDir && config.project_pools) {
-    let bestKey = null;
-    let bestLen = 0;
-    for (const key of Object.keys(config.project_pools)) {
-      if (workingDir.startsWith(key) && key.length > bestLen) {
-        bestKey = key;
-        bestLen = key.length;
-      }
-    }
-    if (bestKey && config.project_pools[bestKey]) {
-      return config.project_pools[bestKey];
-    }
+function parseAuditHistoryImportFailure(message) {
+  const divergentPrefix = `${AUDIT_HISTORY_DIVERGENT_REPLAY}: immutable audit_history row `;
+  const divergentSuffix = " differs from stored row";
+  if (message.startsWith(divergentPrefix) && message.endsWith(divergentSuffix)) {
+    return {
+      code: AUDIT_HISTORY_DIVERGENT_REPLAY,
+      auditHistoryId: message.slice(divergentPrefix.length, -divergentSuffix.length),
+      conflict: true,
+      status: 409
+    };
   }
-  return config.agent_pool || null;
-}
-function getCompletionGuardConfig(projectPath) {
-  const config = loadConfig();
-  const global = { ...GUARD_DEFAULTS, ...config.completion_guard };
-  if (projectPath && config.project_overrides?.[projectPath]?.completion_guard) {
-    return { ...global, ...config.project_overrides[projectPath].completion_guard };
+  const tombstonePrefix = `${AUDIT_HISTORY_TOMBSTONE_FORBIDDEN}: audit_history tombstone `;
+  const tombstoneSuffix = " is not allowed";
+  if (message.startsWith(tombstonePrefix) && message.endsWith(tombstoneSuffix)) {
+    return {
+      code: AUDIT_HISTORY_TOMBSTONE_FORBIDDEN,
+      auditHistoryId: message.slice(tombstonePrefix.length, -tombstoneSuffix.length),
+      conflict: false,
+      status: 400
+    };
   }
-  return global;
+  return null;
 }
-var cached = null, GUARD_DEFAULTS;
-var init_config2 = __esm(() => {
-  init_sync_utils();
-  GUARD_DEFAULTS = {
-    enabled: false,
-    min_work_seconds: 30,
-    max_completions_per_window: 5,
-    window_minutes: 10,
-    cooldown_seconds: 60
-  };
+var AUDIT_HISTORY_DIVERGENT_REPLAY = "AUDIT_HISTORY_DIVERGENT_REPLAY", AUDIT_HISTORY_TOMBSTONE_FORBIDDEN = "AUDIT_HISTORY_TOMBSTONE_FORBIDDEN", AUDIT_HISTORY_FIELDS;
+var init_audit_history_import = __esm(() => {
+  AUDIT_HISTORY_FIELDS = [
+    "id",
+    "task_id",
+    "action",
+    "field",
+    "old_value",
+    "new_value",
+    "agent_id",
+    "created_at",
+    "machine_id"
+  ];
 });
 
-// src/lib/redaction.ts
-function unique(values) {
-  return Array.from(new Set((values || []).map((value) => value.trim()).filter(Boolean)));
-}
-function cloneRegex(regex) {
-  return new RegExp(regex.source, regex.flags.includes("g") ? regex.flags : `${regex.flags}g`);
-}
-function customPatterns() {
-  return unique(loadConfig().secret_safety?.redaction_patterns).flatMap((pattern) => {
-    try {
-      return [{ name: `custom:${pattern}`, regex: new RegExp(pattern, "g") }];
-    } catch {
-      return [];
-    }
-  });
-}
-function secretPatterns() {
-  return [...customPatterns(), ...DEFAULT_SECRET_PATTERNS];
-}
-function isRedactionPlaceholderMatch(match) {
-  const trimmed = match.trim();
-  return new RegExp(`^${REDACTION_PLACEHOLDER}$`).test(trimmed) || new RegExp(`=\\s*['"]?${REDACTION_PLACEHOLDER}['"]?$`).test(trimmed);
-}
-function isRedactionPlaceholderKey(key) {
-  return new RegExp(`^${REDACTION_PLACEHOLDER}$`).test(key.trim());
-}
-function isSecretKey(key) {
-  if (isRedactionPlaceholderKey(key))
-    return false;
-  if (NON_SECRET_USAGE_KEYS.has(key.toLowerCase()))
-    return false;
-  if (DEFAULT_SECRET_KEY_PATTERN.test(key))
-    return true;
-  return unique(loadConfig().secret_safety?.redaction_keys).some((pattern) => key.toLowerCase().includes(pattern.toLowerCase()));
-}
-function redactEvidenceText(value) {
-  let redacted = value;
-  for (const pattern of secretPatterns()) {
-    const regex = cloneRegex(pattern.regex);
-    const replacement = pattern.replacement ?? "[REDACTED]";
-    redacted = typeof replacement === "string" ? redacted.replace(regex, replacement) : redacted.replace(regex, replacement);
-  }
-  return redacted;
-}
-function redactValue(value) {
-  if (typeof value === "string")
-    return redactEvidenceText(value);
+// src/task-manifest/canonical.ts
+import { createHash as createHash3 } from "crypto";
+function canonicalize(value) {
   if (Array.isArray(value))
-    return value.map(redactValue);
-  if (value && typeof value === "object") {
-    const redacted = {};
-    for (const [key, child] of Object.entries(value)) {
-      if (isSecretKey(key)) {
-        redacted[key] = "[REDACTED]";
-      } else {
-        redacted[key] = redactValue(child);
-      }
-    }
-    return redacted;
+    return value.map(canonicalize);
+  if (value !== null && typeof value === "object") {
+    return Object.fromEntries(Object.entries(value).filter(([, entry2]) => entry2 !== undefined).sort(([left], [right]) => left.localeCompare(right)).map(([key, entry2]) => [key, canonicalize(entry2)]));
   }
   return value;
 }
-function listSecretFindings(value) {
-  const findings = [];
-  for (const pattern of secretPatterns()) {
-    const matches = value.match(cloneRegex(pattern.regex))?.filter((match) => !isRedactionPlaceholderMatch(match));
-    if (matches?.length)
-      findings.push({ pattern: pattern.name, count: matches.length });
-  }
-  return findings;
+function canonicalJson(value) {
+  return JSON.stringify(canonicalize(value));
 }
-function getSecretSafetyConfig() {
-  return {
-    redaction_patterns: unique(loadConfig().secret_safety?.redaction_patterns),
-    redaction_keys: unique(loadConfig().secret_safety?.redaction_keys)
-  };
+function canonicalDigest(value) {
+  return createHash3("sha256").update(canonicalJson(value)).digest("hex");
 }
-function upsertSecretSafetyConfig(input) {
-  const config = loadConfig();
-  const next = {
-    redaction_patterns: unique([...config.secret_safety?.redaction_patterns || [], ...input.redaction_patterns || []]),
-    redaction_keys: unique([...config.secret_safety?.redaction_keys || [], ...input.redaction_keys || []])
-  };
-  saveConfig({ ...config, secret_safety: next });
-  return next;
+function deterministicUuid(namespace, ...parts) {
+  const bytes = createHash3("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)}`;
 }
-var DEFAULT_SECRET_PATTERNS, DEFAULT_SECRET_KEY_PATTERN, NON_SECRET_USAGE_KEYS, REDACTION_PLACEHOLDER;
-var init_redaction = __esm(() => {
-  init_config2();
-  DEFAULT_SECRET_PATTERNS = [
-    { name: "aws-access-key", regex: /\b(AKIA|ASIA)[0-9A-Z]{16}\b/g, replacement: "[REDACTED_AWS_KEY]" },
-    { name: "private-key", regex: /-----BEGIN (?:RSA |EC |OPENSSH |)PRIVATE KEY-----[\s\S]*?-----END (?:RSA |EC |OPENSSH |)PRIVATE KEY-----/g, replacement: "[REDACTED_PRIVATE_KEY]" },
-    { name: "openai-token", regex: /\bsk-[A-Za-z0-9_-]{12,}\b/g, replacement: "[REDACTED_TOKEN]" },
-    { name: "npm-token", regex: /\bnpm_[A-Za-z0-9]{20,}\b/g, replacement: "[REDACTED_NPM_TOKEN]" },
-    { name: "github-fine-grained-token", regex: /\bgithub_pat_[A-Za-z0-9_]{20,}\b/g, replacement: "[REDACTED_GITHUB_TOKEN]" },
-    { name: "github-token", regex: /\bgh[opsu]_[A-Za-z0-9]{20,}\b/g, replacement: "[REDACTED_GITHUB_TOKEN]" },
-    { name: "env-secret-assignment", regex: /\b([A-Za-z0-9_]*(?:API_KEY|TOKEN|SECRET|PASSWORD)[A-Za-z0-9_]*)\s*=\s*['"]?[^'"\s]{8,}/gi, replacement: "$1=[REDACTED]" },
-    { name: "bearer-token", regex: /\b(bearer)\s+[A-Za-z0-9._~+/=-]{12,}/gi, replacement: "$1 [REDACTED]" }
-  ];
-  DEFAULT_SECRET_KEY_PATTERN = /api[_-]?key|token|secret|password/i;
-  NON_SECRET_USAGE_KEYS = new Set([
-    "tokens",
-    "total_tokens",
-    "token_count",
-    "input_tokens",
-    "output_tokens",
-    "prompt_tokens",
-    "completion_tokens",
-    "cost_tokens"
-  ]);
-  REDACTION_PLACEHOLDER = String.raw`\[REDACTED(?:_[A-Z_]+)?\]`;
-});
+var init_canonical = () => {};
 
 // src/storage/postgres-adapter.ts
 import { randomUUID } from "crypto";
@@ -2069,6 +2473,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: {
@@ -2215,6 +2620,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 $4::timestamptz < $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);
   }
@@ -2484,6 +2974,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)
@@ -3598,16 +4110,17 @@ async function findCommit(sha, store) {
 async function addGitRef(input, store, context) {
   if (!await store.get("tasks", input.task_id))
     throw new Error(`Task not found: ${input.task_id}`);
+  const existing = (await store.list("refs")).filter((ref) => ref.task_id === input.task_id && ref.ref_type === input.ref_type && ref.name === input.name).sort((left, right) => left.created_at.localeCompare(right.created_at) || left.id.localeCompare(right.id))[0];
   const timestamp = new Date().toISOString();
   const gitRef = {
-    id: randomUUID(),
+    id: existing?.id ?? deterministicUuid("todos:git-ref:v1", input.task_id, input.ref_type, input.name),
     task_id: input.task_id,
     ref_type: input.ref_type,
     name: input.name,
-    url: input.url ?? null,
-    provider: input.provider ?? null,
+    url: input.url ?? existing?.url ?? null,
+    provider: input.provider ?? existing?.provider ?? null,
     metadata: input.metadata ?? {},
-    created_at: timestamp,
+    created_at: existing?.created_at ?? timestamp,
     updated_at: timestamp
   };
   await store.upsert("refs", gitRef, context);
@@ -3972,6 +4485,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]),
@@ -3980,9 +4498,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);
@@ -4016,6 +4545,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)
@@ -4122,9 +4677,12 @@ var init_postgres_adapter = __esm(() => {
   init_types();
   init_creator_identity();
   init_plan_project_link_contract();
+  init_stale_lock_handoff();
   init_postgres_sync();
   init_integrity();
   init_redaction();
+  init_audit_history_import();
+  init_canonical();
   TASK_ORDER_BY = `ORDER BY ${TASK_ORDER_TIEBREAK}`;
 });
 
@@ -4144,9 +4702,9 @@ var init_types2 = __esm(() => {
 });
 
 // src/pr-groups/ledger.ts
-import { createHash as createHash3 } from "crypto";
+import { createHash as createHash4 } from "crypto";
 function sha256(value) {
-  return createHash3("sha256").update(value).digest("hex");
+  return createHash4("sha256").update(value).digest("hex");
 }
 function stableValue(value) {
   if (Array.isArray(value))
@@ -11583,7 +12141,7 @@ var init_runner_sandbox = __esm(() => {
 });
 
 // src/lib/event-hooks.ts
-import { createHash as createHash4, randomUUID as randomUUID2 } from "crypto";
+import { createHash as createHash5, randomUUID as randomUUID2 } from "crypto";
 import { appendFileSync, mkdirSync as mkdirSync3 } from "fs";
 import { dirname as dirname3, resolve as resolve6 } from "path";
 import { createConnection } from "net";
@@ -11650,7 +12208,7 @@ function buildEnvelope(type, payload, timestamp2 = new Date().toISOString()) {
     payload: redactValue(payload ?? {}),
     source: { package: "@hasna/todos", local_only: true }
   };
-  const digest = createHash4("sha256").update(canonicalEvent(base)).digest("hex");
+  const digest = createHash5("sha256").update(canonicalEvent(base)).digest("hex");
   return { ...base, integrity: { algorithm: "sha256", digest } };
 }
 function summarize(value) {
@@ -12833,185 +13391,6 @@ var init_shared_events = __esm(() => {
   init_event_emission_safety();
 });
 
-// src/lib/secret-redaction.ts
-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
-  };
-}
-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 redactExportRecord(record) {
-  const base = redactValue(record);
-  for (const [key, value] of Object.entries(base)) {
-    if (typeof value === "string") {
-      base[key] = redactText(value);
-    }
-  }
-  return base;
-}
-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;
-}
-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/activity-audit.ts
 var exports_activity_audit = {};
 __export(exports_activity_audit, {
@@ -13204,28 +13583,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();
@@ -14192,6 +14598,7 @@ __export(exports_task_lifecycle, {
   startTask: () => startTask2,
   spawnNextRecurrence: () => spawnNextRecurrence,
   lockTask: () => lockTask2,
+  handoffStaleTaskLock: () => handoffStaleTaskLock,
   getTasksChangedSince: () => getTasksChangedSince,
   getTaskLockStatus: () => getTaskLockStatus,
   getStaleTasks: () => getStaleTasks,
@@ -14460,6 +14867,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);
@@ -14760,6 +15199,7 @@ var init_task_lifecycle = __esm(() => {
   init_task_crud();
   init_task_graph();
   init_prewrite_secrets();
+  init_stale_lock_handoff();
 });
 
 // src/db/task-crud.ts
@@ -16778,8 +17218,8 @@ var init_boards = __esm(() => {
 });
 
 // src/lib/artifact-store.ts
-import { createHash as createHash5 } from "crypto";
-import { existsSync as existsSync7, mkdirSync as mkdirSync4, readFileSync as readFileSync2, rmSync as rmSync2, statSync as statSync2, writeFileSync as writeFileSync2 } from "fs";
+import { createHash as createHash6 } from "crypto";
+import { existsSync as existsSync7, mkdirSync as mkdirSync4, readFileSync as readFileSync3, rmSync as rmSync2, statSync as statSync2, writeFileSync as writeFileSync2 } from "fs";
 import { basename, dirname as dirname4, join as join6, resolve as resolve7 } from "path";
 import { tmpdir as tmpdir2 } from "os";
 function isInMemoryDb2(path) {
@@ -16803,7 +17243,7 @@ function artifactStorePath(relativePath) {
   return join6(artifactStoreRoot(), normalized);
 }
 function sha2562(buffer) {
-  return createHash5("sha256").update(buffer).digest("hex");
+  return createHash6("sha256").update(buffer).digest("hex");
 }
 function isTextLike(buffer, path) {
   if (buffer.includes(0))
@@ -16846,7 +17286,7 @@ function storeArtifactContent(input) {
   const sourceStat = statSync2(sourcePath);
   if (!sourceStat.isFile())
     throw new Error(`Artifact path is not a file: ${sanitizePreWriteText(input.path, "artifact.path")}`);
-  const sourceBuffer = readFileSync2(sourcePath);
+  const sourceBuffer = readFileSync3(sourcePath);
   const sourceSha = sha2562(sourceBuffer);
   const textLike = isTextLike(sourceBuffer, input.path);
   let storedBuffer = sourceBuffer;
@@ -16933,7 +17373,7 @@ function verifyStoredArtifact(input) {
       message: "stored artifact content is missing"
     };
   }
-  const buffer = readFileSync2(storedPath);
+  const buffer = readFileSync3(storedPath);
   const actualSha = sha2562(buffer);
   const actualSize = buffer.length;
   const ok = actualSha === store.sha256 && actualSize === store.size_bytes;
@@ -16953,7 +17393,7 @@ function exportStoredArtifactContent(input) {
   const report = verifyStoredArtifact(input);
   if (report.status !== "ok" || !report.relative_path || !report.actual_sha256 || report.actual_size_bytes === null)
     return null;
-  const content = readFileSync2(artifactStorePath(report.relative_path));
+  const content = readFileSync3(artifactStorePath(report.relative_path));
   return {
     artifact_id: input.id,
     sha256: report.actual_sha256,
@@ -18332,6 +18772,7 @@ __export(exports_tasks, {
   insertTaskTags: () => insertTaskTags,
   importTaskBoardBundle: () => importTaskBoardBundle,
   importCalendarIcs: () => importCalendarIcs,
+  handoffStaleTaskLock: () => handoffStaleTaskLock,
   getTimeReport: () => getTimeReport,
   getTimeLogs: () => getTimeLogs,
   getTasksChangedSince: () => getTasksChangedSince,
@@ -19304,8 +19745,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 {
@@ -19340,10 +19784,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)
@@ -19441,7 +19947,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();
@@ -19488,6 +19994,7 @@ var init_sqlite_snapshot = __esm(() => {
   init_tasks();
   init_templates();
   init_storage_tombstones();
+  init_audit_history_import();
   PROJECT_COLUMNS = [
     "id",
     "name",
@@ -19752,6 +20259,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),
@@ -20468,25 +20976,25 @@ var init_sqlite = __esm(() => {
 });
 
 // src/project-registration/authority.ts
-import { createHash as createHash6 } from "crypto";
+import { createHash as createHash7 } from "crypto";
 function canonicalProjectRegistrationJson(value) {
-  return JSON.stringify(canonicalize(value));
+  return JSON.stringify(canonicalize2(value));
 }
-function canonicalize(value) {
+function canonicalize2(value) {
   if (Array.isArray(value))
-    return value.map(canonicalize);
+    return value.map(canonicalize2);
   if (!value || typeof value !== "object")
     return value;
   const out = {};
   for (const key of Object.keys(value).sort()) {
     const entry2 = value[key];
     if (entry2 !== undefined)
-      out[key] = canonicalize(entry2);
+      out[key] = canonicalize2(entry2);
   }
   return out;
 }
 function digestProjectRegistrationValue(value) {
-  return createHash6("sha256").update(canonicalProjectRegistrationJson(value)).digest("hex");
+  return createHash7("sha256").update(canonicalProjectRegistrationJson(value)).digest("hex");
 }
 function deriveTodosProjectRegistrationIdempotencyKey(input) {
   return `prk_${digestProjectRegistrationValue({
@@ -21481,31 +21989,6 @@ var init_project_registration = __esm(() => {
   init_types3();
 });
 
-// src/task-manifest/canonical.ts
-import { createHash as createHash7 } from "crypto";
-function canonicalize2(value) {
-  if (Array.isArray(value))
-    return value.map(canonicalize2);
-  if (value !== null && typeof value === "object") {
-    return Object.fromEntries(Object.entries(value).filter(([, entry2]) => entry2 !== undefined).sort(([left], [right]) => left.localeCompare(right)).map(([key, entry2]) => [key, canonicalize2(entry2)]));
-  }
-  return value;
-}
-function canonicalJson(value) {
-  return JSON.stringify(canonicalize2(value));
-}
-function canonicalDigest(value) {
-  return createHash7("sha256").update(canonicalJson(value)).digest("hex");
-}
-function deterministicUuid(namespace, ...parts) {
-  const bytes = createHash7("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)}`;
-}
-var init_canonical = () => {};
-
 // node_modules/.bun/zod@3.25.76/node_modules/zod/v3/helpers/util.js
 var util, objectUtil, ZodParsedType, getParsedType = (data) => {
   const t = typeof data;
@@ -29130,6 +29613,8 @@ function buildV1OpenApiDocument(version = getPackageVersion()) {
         ProjectTaskListEnsureResult: projectTaskListEnsureResultSchema,
         ProjectTaskListRollbackResult: projectTaskListRollbackResultSchema,
         TaskComment: taskCommentSchema,
+        StaleLockHandoffInput: staleLockHandoffInputSchema,
+        StaleLockHandoffReceipt: staleLockHandoffReceiptSchema,
         TaskGitRef: taskGitRefSchema,
         Plan: planSchema,
         PlanProjectLinkReceipt: planProjectLinkReceiptSchema,
@@ -29152,6 +29637,7 @@ function buildV1OpenApiDocument(version = getPackageVersion()) {
             plan_id: { type: "string" },
             assigned_to: { type: "string" },
             agent_id: { type: "string" },
+            created_by: { type: "string" },
             tags: { type: "array", items: { type: "string" } }
           }
         },
@@ -30337,6 +30823,51 @@ function buildV1OpenApiDocument(version = getPackageVersion()) {
           }
         }
       },
+      "/v1/tasks/{id}/stale-lock-handoff": {
+        post: {
+          operationId: "handoffStaleTaskLock",
+          summary: "Atomically transfer one exact stale task lock",
+          description: "Compares one full task UUID, current holder, and exact locked_at version, verifies the lock is strictly older than the supplied threshold, then transfers it directly and writes an immutable task-history receipt in the same backend transaction.",
+          parameters: [
+            {
+              name: "id",
+              in: "path",
+              required: true,
+              schema: { type: "string", format: "uuid" },
+              description: "Exact full task UUID. Short ids and prefixes are rejected."
+            }
+          ],
+          requestBody: {
+            required: true,
+            content: {
+              "application/json": {
+                schema: { $ref: "#/components/schemas/StaleLockHandoffInput" }
+              }
+            }
+          },
+          responses: {
+            "200": {
+              content: {
+                "application/json": {
+                  schema: {
+                    type: "object",
+                    additionalProperties: false,
+                    required: ["receipt"],
+                    properties: {
+                      receipt: { $ref: "#/components/schemas/StaleLockHandoffReceipt" }
+                    }
+                  }
+                }
+              }
+            },
+            "400": { content: { "application/json": { schema: { $ref: "#/components/schemas/ErrorResponse" } } } },
+            "403": { content: { "application/json": { schema: { $ref: "#/components/schemas/ErrorResponse" } } } },
+            "404": { content: { "application/json": { schema: { $ref: "#/components/schemas/ErrorResponse" } } } },
+            "409": { content: { "application/json": { schema: { $ref: "#/components/schemas/ErrorResponse" } } } },
+            "501": { content: { "application/json": { schema: { $ref: "#/components/schemas/ErrorResponse" } } } }
+          }
+        }
+      },
       "/v1/tasks/{id}/refs": {
         get: {
           operationId: "listTaskGitRefs",
@@ -30933,7 +31464,7 @@ function buildV1OpenApiDocument(version = getPackageVersion()) {
     }
   };
 }
-var taskSchema, projectSchema, taskManifestBindingLookupRequestSchema, taskManifestBindingLookupResultSchema, taskManifestBindingLookupResponseSchema, taskListSchema, projectTaskListEnsureReceiptSchema, projectTaskListEnsureResultSchema, projectTaskListRollbackResultSchema, taskCommentSchema, taskGitRefSchema, planSchema, planProjectLinkReceiptSchema, planProjectLinkResultSchema, planProjectLinkRollbackResultSchema, templateTaskSchema, templateSchema, templateVariableSchema, createTemplateTaskInputSchema;
+var taskSchema, projectSchema, taskManifestBindingLookupRequestSchema, taskManifestBindingLookupResultSchema, taskManifestBindingLookupResponseSchema, taskListSchema, projectTaskListEnsureReceiptSchema, projectTaskListEnsureResultSchema, projectTaskListRollbackResultSchema, taskCommentSchema, staleLockHandoffInputSchema, staleLockHandoffReceiptSchema, taskGitRefSchema, planSchema, planProjectLinkReceiptSchema, planProjectLinkResultSchema, planProjectLinkRollbackResultSchema, templateTaskSchema, templateSchema, templateVariableSchema, createTemplateTaskInputSchema;
 var init_openapi = __esm(() => {
   init_package_version();
   init_types();
@@ -30949,9 +31480,12 @@ var init_openapi = __esm(() => {
       parent_id: { type: "string", nullable: true },
       assigned_to: { type: "string", nullable: true },
       agent_id: { type: "string", nullable: true },
+      created_by: { type: "string", nullable: true },
       reason: { type: "string", nullable: true },
       tags: { type: "array", items: { type: "string" } },
       version: { type: "number" },
+      locked_by: { type: "string", nullable: true },
+      locked_at: { type: "string", format: "date-time", nullable: true },
       created_at: { type: "string" },
       updated_at: { type: "string" }
     }
@@ -31116,6 +31650,69 @@ var init_openapi = __esm(() => {
       created_at: { type: "string", format: "date-time" }
     }
   };
+  staleLockHandoffInputSchema = {
+    type: "object",
+    additionalProperties: false,
+    required: [
+      "expected_holder",
+      "expected_lock_version",
+      "stale_after_seconds",
+      "new_holder",
+      "reason"
+    ],
+    properties: {
+      expected_holder: { type: "string", minLength: 1 },
+      expected_lock_version: {
+        type: "string",
+        format: "date-time",
+        pattern: "^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}\\.\\d{3}Z$",
+        description: "Exact authoritative locked_at token read from the task; no default or normalization is applied."
+      },
+      stale_after_seconds: {
+        type: "integer",
+        minimum: 1,
+        description: "Lock age threshold supplied by the caller. The lock must be strictly older at the CAS instant."
+      },
+      new_holder: {
+        type: "string",
+        minLength: 1,
+        description: "Must match the agent bound to the authenticated API key."
+      },
+      reason: { type: "string", minLength: 1, maxLength: 4096 }
+    }
+  };
+  staleLockHandoffReceiptSchema = {
+    type: "object",
+    additionalProperties: false,
+    required: [
+      "schema_version",
+      "receipt_id",
+      "task_id",
+      "actor",
+      "previous_holder",
+      "previous_lock_version",
+      "new_holder",
+      "new_lock_version",
+      "stale_after_seconds",
+      "stale_cutoff",
+      "reason",
+      "created_at"
+    ],
+    properties: {
+      schema_version: { type: "string", enum: ["todos.stale-lock-handoff.v1"] },
+      receipt_id: { type: "string", format: "uuid" },
+      task_id: { type: "string", format: "uuid" },
+      actor: { type: "string" },
+      previous_holder: { type: "string" },
+      previous_lock_version: { type: "string", format: "date-time" },
+      new_holder: { type: "string" },
+      new_lock_version: { type: "string", format: "date-time" },
+      stale_after_seconds: { type: "integer", minimum: 1 },
+      stale_cutoff: { type: "string", format: "date-time" },
+      reason: { type: "string" },
+      created_at: { type: "string", format: "date-time" }
+    }
+  };
   taskGitRefSchema = {
     type: "object",
     additionalProperties: false,
@@ -32357,6 +32954,45 @@ async function handleV1Request(req, url, dependencies = {}) {
         return error(405, `method ${method} not allowed on /v1/tasks`);
       }
       if (action) {
+        if (action === "stale-lock-handoff") {
+          if (method !== "POST") {
+            return error(405, "method must be POST on /v1/tasks/:id/stale-lock-handoff");
+          }
+          const exactId = normalizeExactTaskId(id);
+          if (!principal.agent) {
+            return error(403, "stale-lock handoff requires an authenticated agent-bound key", {
+              code: "STALE_LOCK_HANDOFF_ACTOR_MISMATCH"
+            });
+          }
+          if (typeof store.tasks.handoffStaleLock !== "function") {
+            return error(501, "stale-lock handoff is not supported by this storage backend");
+          }
+          const body3 = await readJson3(req) ?? {};
+          const allowed = new Set([
+            "expected_holder",
+            "expected_lock_version",
+            "stale_after_seconds",
+            "new_holder",
+            "reason"
+          ]);
+          const unknown = Object.keys(body3).find((key2) => !allowed.has(key2));
+          if (unknown) {
+            return error(400, `unknown stale-lock handoff field: ${unknown}`, {
+              code: "STALE_LOCK_HANDOFF_INVALID_INPUT",
+              field: unknown
+            });
+          }
+          const receipt = await store.tasks.handoffStaleLock({
+            task_id: exactId,
+            actor: principal.agent,
+            expected_holder: body3.expected_holder,
+            expected_lock_version: body3.expected_lock_version,
+            stale_after_seconds: body3.stale_after_seconds,
+            new_holder: body3.new_holder,
+            reason: body3.reason
+          }, contextFromPrincipal(principal));
+          return json5({ receipt });
+        }
         if (action === "comments") {
           if (method === "GET") {
             if (!await store.tasks.get(id))
@@ -33145,7 +33781,24 @@ async function handleV1Request(req, url, dependencies = {}) {
       if (received === 0) {
         return error(400, "empty snapshot: provide at least one record array (tasks/projects/plans/...)");
       }
+      const forbiddenAuditTombstone = (snapshot.tombstones ?? []).find((tombstone) => tombstone.object_type === "audit_history");
+      if (forbiddenAuditTombstone) {
+        return error(400, forbiddenAuditHistoryTombstoneError(forbiddenAuditTombstone.object_id), {
+          code: AUDIT_HISTORY_TOMBSTONE_FORBIDDEN,
+          conflict: false,
+          audit_history_id: forbiddenAuditTombstone.object_id
+        });
+      }
       const result = await store.sync.importSnapshot(snapshot, contextFromPrincipal(principal));
+      const auditFailureMessage = result.errors.find((message) => parseAuditHistoryImportFailure(message) !== null);
+      if (auditFailureMessage) {
+        const failure = parseAuditHistoryImportFailure(auditFailureMessage);
+        return error(failure.status, auditFailureMessage, {
+          code: failure.code,
+          conflict: failure.conflict,
+          audit_history_id: failure.auditHistoryId
+        });
+      }
       return json5({ result, received });
     }
     return error(404, `unknown /v1 resource: ${resource ?? "(root)"}`);
@@ -33168,6 +33821,14 @@ async function handleV1Request(req, url, dependencies = {}) {
     if (e instanceof TaskNotFoundError) {
       return error(404, e.message, { code: TaskNotFoundError.code });
     }
+    if (e instanceof StaleLockHandoffError) {
+      const status2 = e.code === "STALE_LOCK_HANDOFF_INVALID_TASK_ID" || e.code === "STALE_LOCK_HANDOFF_INVALID_INPUT" ? 400 : e.code === "STALE_LOCK_HANDOFF_ACTOR_MISMATCH" ? 403 : 409;
+      return error(status2, e.message, {
+        code: e.code,
+        conflict: status2 === 409,
+        ...e.details
+      });
+    }
     if (e instanceof PlanNotFoundError) {
       return error(404, e.message, { code: PlanNotFoundError.code });
     }
@@ -33202,6 +33863,8 @@ var init_v1 = __esm(() => {
   init_redaction();
   init_project_task_list_ensure();
   init_plan_project_link();
+  init_stale_lock_handoff();
+  init_audit_history_import();
   JSON_HEADERS4 = { "Content-Type": "application/json" };
   RFC3339_DATE_TIME = /^(\d{4})-(\d{2})-(\d{2})[Tt]\d{2}:\d{2}:\d{2}(\.\d+)?([Zz]|[+-]\d{2}:\d{2})$/;
 });
@@ -50727,7 +51390,7 @@ var init_token_utils = __esm(() => {
 });
 
 // src/lib/assignee-validation.ts
-import { readFileSync as readFileSync3 } from "fs";
+import { readFileSync as readFileSync4 } from "fs";
 import { homedir as homedir3 } from "os";
 import { join as join9 } from "path";
 function defaultSeatRosterPath() {
@@ -50735,7 +51398,7 @@ function defaultSeatRosterPath() {
 }
 function loadSeatSlugs(path = defaultSeatRosterPath()) {
   try {
-    const parsed = JSON.parse(readFileSync3(path, "utf8"));
+    const parsed = JSON.parse(readFileSync4(path, "utf8"));
     const slugs = new Set;
     for (const agent of parsed.agents ?? []) {
       if (typeof agent?.slug === "string" && agent.slug.trim()) {
@@ -63967,6 +64630,7 @@ var init_http_client = __esm(() => {
 });
 
 // src/cli/cloud-router.ts
+import { randomUUID as randomUUID4 } from "crypto";
 import { resolve as resolvePath } from "path";
 function cleanMode(value) {
   const normalized = value?.trim().toLowerCase();
@@ -64367,20 +65031,28 @@ async function cloudGetTask(client, id) {
   const raw = await client.get("tasks", id);
   return raw == null ? null : unwrapTask(raw);
 }
-async function cloudCreateTask(client, input) {
+async function cloudCreateTask(client, input, verification2 = {}) {
   const expectedParentId = typeof input["parent_id"] === "string" ? input["parent_id"] : null;
-  const created = unwrapTask(await requiredRemoteRoute(client, "/v1/tasks", () => client.create("tasks", input, { retry: false }), ["PARENT_TASK_NOT_FOUND"]));
+  const expectedCreatedBy = typeof verification2.expectedCreatedBy === "string" && verification2.expectedCreatedBy.trim() ? verification2.expectedCreatedBy : null;
+  if (expectedCreatedBy !== null) {
+    await requireTaskCreatorCapability(client);
+  }
+  const created = unwrapTask(await requiredRemoteRoute(client, "/v1/tasks", () => client.transport.post("/tasks", input, {
+    idempotencyKey: randomUUID4(),
+    retry: false
+  }), ["PARENT_TASK_NOT_FOUND"]));
   if (!created || typeof created.id !== "string" || !created.id.trim()) {
     throw new Error(`REMOTE_API_INCOMPATIBLE: configured Todos authority ${remoteAuthorityBase(client)} returned a task create ` + "response without a stored task id; no success row or local SQLite fallback is permitted");
   }
   const persisted = await cloudGetTask(client, created.id);
-  if (!persisted || persisted.id !== created.id || (persisted.parent_id ?? null) !== expectedParentId) {
-    throw new Error(`TASK_CREATE_PERSISTENCE_UNVERIFIED: configured Todos authority ${remoteAuthorityBase(client)} accepted ` + `POST /v1/tasks but authoritative GET /v1/tasks/${encodeURIComponent(created.id)} did not return the same ` + "stored task id and parent_id; no success row or local SQLite fallback is permitted");
+  if (!persisted || persisted.id !== created.id || (persisted.parent_id ?? null) !== expectedParentId || expectedCreatedBy !== null && persisted.created_by !== expectedCreatedBy) {
+    const creatorDetail = expectedCreatedBy === null ? "" : ` and explicit created_by=${JSON.stringify(expectedCreatedBy)} ` + `(readback ${JSON.stringify(persisted?.created_by ?? null)})`;
+    throw new Error(`TASK_CREATE_PERSISTENCE_UNVERIFIED: configured Todos authority ${remoteAuthorityBase(client)} accepted ` + `POST /v1/tasks but authoritative GET /v1/tasks/${encodeURIComponent(created.id)} did not return the same ` + `stored task id and parent_id${creatorDetail}; no success row or local SQLite fallback is permitted`);
   }
   return persisted;
 }
 async function cloudUpdateTask(client, id, patch) {
-  return unwrapTask(await client.update("tasks", id, patch));
+  return unwrapTask(await client.transport.patch(`/tasks/${encodeURIComponent(id)}`, patch));
 }
 async function cloudDeleteTask(client, id) {
   try {
@@ -64396,6 +65068,51 @@ async function cloudTaskAction(client, id, action, body2 = {}) {
   const raw = await client.transport.post(`/tasks/${encodeURIComponent(id)}/${action}`, body2);
   return unwrapTask(raw);
 }
+function resolveOpenApiSchema(document, schema2) {
+  if (!schema2 || typeof schema2 !== "object" || Array.isArray(schema2))
+    return null;
+  const value = schema2;
+  if (typeof value["$ref"] !== "string")
+    return value;
+  const reference = value["$ref"];
+  if (!reference.startsWith("#/"))
+    return null;
+  let current = document;
+  for (const segment of reference.slice(2).split("/")) {
+    const key2 = segment.replace(/~1/g, "/").replace(/~0/g, "~");
+    if (!current || typeof current !== "object" || Array.isArray(current))
+      return null;
+    current = current[key2];
+  }
+  return current && typeof current === "object" && !Array.isArray(current) ? current : null;
+}
+function openApiSchemaProperty(document, schemaName, propertyName) {
+  const schema2 = resolveOpenApiSchema(document, {
+    $ref: `#/components/schemas/${schemaName}`
+  });
+  const properties = schema2?.["properties"];
+  if (!properties || typeof properties !== "object" || Array.isArray(properties))
+    return null;
+  const property = properties[propertyName];
+  return property && typeof property === "object" && !Array.isArray(property) ? property : null;
+}
+async function fetchTaskCreatorCapability(client) {
+  const document = await requiredRemoteRoute(client, "/v1/openapi.json", () => client.transport.get("/openapi.json"));
+  const inputProperty = openApiSchemaProperty(document, "CreateTaskInput", "created_by");
+  const outputProperty = openApiSchemaProperty(document, "Task", "created_by");
+  return inputProperty?.["type"] === "string" && outputProperty?.["type"] === "string" && outputProperty?.["nullable"] === true;
+}
+async function requireTaskCreatorCapability(client) {
+  const authority = remoteAuthorityBase(client);
+  let capability = taskCreatorCapabilityCache.get(authority);
+  if (!capability) {
+    capability = fetchTaskCreatorCapability(client);
+    taskCreatorCapabilityCache.set(authority, capability);
+  }
+  if (!await capability) {
+    throw new Error(`REMOTE_CREATED_BY_UNSUPPORTED: configured Todos authority ${authority} does not advertise created_by ` + "on both CreateTaskInput and Task in /v1/openapi.json; no task mutation was sent; deploy a compatible " + "@hasna/todos /v1 server before retrying; local SQLite fallback is disabled");
+  }
+}
 async function cloudGetStats(client) {
   const raw = await requiredRemoteRoute(client, "/v1/stats", () => client.transport.get("/stats"));
   return raw ?? {};
@@ -64591,7 +65308,7 @@ async function cloudResolveTaskListRef(client, ref, projectId) {
     return input.toLowerCase();
   return (await cloudResolveTaskList(client, ref, projectId)).id;
 }
-var UUID_RE, TRANSPORT_TOKENS, completionCapabilityCache, retryCapabilityCache, gitRefCapabilityCache, SERVER_MODE_CANDIDATES, cachedServerMode = null, PRIORITY_RANK, listTagsCapabilityCache;
+var UUID_RE, TRANSPORT_TOKENS, completionCapabilityCache, retryCapabilityCache, taskCreatorCapabilityCache, gitRefCapabilityCache, remoteCommandCapabilityCache, SERVER_MODE_CANDIDATES, cachedServerMode = null, PRIORITY_RANK, listTagsCapabilityCache;
 var init_cloud_router = __esm(() => {
   init_storage();
   init_mode();
@@ -64611,7 +65328,9 @@ var init_cloud_router = __esm(() => {
   };
   completionCapabilityCache = new Map;
   retryCapabilityCache = new Map;
+  taskCreatorCapabilityCache = new Map;
   gitRefCapabilityCache = new Map;
+  remoteCommandCapabilityCache = new Map;
   SERVER_MODE_CANDIDATES = ["postgres", "cloud", "self_hosted"];
   PRIORITY_RANK = { critical: 0, high: 1, medium: 2, low: 3 };
   listTagsCapabilityCache = new Map;
@@ -65007,7 +65726,7 @@ var init_task_crud2 = __esm(() => {
 });
 
 // src/lib/project-bootstrap.ts
-import { existsSync as existsSync9, readFileSync as readFileSync4, statSync as statSync4 } from "fs";
+import { existsSync as existsSync9, readFileSync as readFileSync5, statSync as statSync4 } from "fs";
 import { basename as basename3, dirname as dirname6, resolve as resolve9 } from "path";
 function safeStat(path) {
   try {
@@ -65041,7 +65760,7 @@ function readPackageJson(path) {
   if (!existsSync9(file))
     return null;
   try {
-    const parsed = JSON.parse(readFileSync4(file, "utf-8"));
+    const parsed = JSON.parse(readFileSync5(file, "utf-8"));
     return parsed && typeof parsed === "object" ? parsed : null;
   } catch {
     return null;
@@ -65603,7 +66322,7 @@ var init_retention_cleanup = __esm(() => {
 });
 
 // src/lib/mention-resolver.ts
-import { existsSync as existsSync11, readdirSync as readdirSync2, readFileSync as readFileSync5, statSync as statSync5 } from "fs";
+import { existsSync as existsSync11, readdirSync as readdirSync2, readFileSync as readFileSync6, statSync as statSync5 } from "fs";
 import { basename as basename4, isAbsolute, join as join10, relative as relative3, resolve as resolve10, sep as sep3 } from "path";
 function blankResolution(parsed) {
   return {
@@ -65712,7 +66431,7 @@ function resolveFile(parsed, workspace) {
     return resolution;
   }
   if (parsed.line !== undefined) {
-    const lineCount = readFileSync5(absolutePath, "utf-8").split(/\r?\n/).length;
+    const lineCount = readFileSync6(absolutePath, "utf-8").split(/\r?\n/).length;
     if (parsed.line < 1 || parsed.line > lineCount) {
       resolution.warnings.push(`line ${parsed.line} is outside the file range 1-${lineCount}`);
       return resolution;
@@ -65765,7 +66484,7 @@ function resolveSymbol(parsed, workspace, maxMatches) {
   const pattern = symbolPattern(name);
   const matches = [];
   for (const file of walkSourceFiles(workspace)) {
-    const lines = readFileSync5(file, "utf-8").split(/\r?\n/);
+    const lines = readFileSync6(file, "utf-8").split(/\r?\n/);
     for (let index = 0;index < lines.length; index += 1) {
       const line = lines[index];
       const found = pattern.exec(line);
@@ -69432,7 +70151,7 @@ var init_audit_ledger = __esm(() => {
 });
 
 // src/lib/release-compatibility.ts
-import { readFileSync as readFileSync6 } from "fs";
+import { readFileSync as readFileSync7 } from "fs";
 import { join as join11, resolve as resolve12 } from "path";
 import { Database as Database2 } from "bun:sqlite";
 function pass(id, message, details) {
@@ -69445,7 +70164,7 @@ function warn(id, message, details) {
   return { id, status: "warning", message, details };
 }
 function readPackageJson2(root) {
-  return JSON.parse(readFileSync6(join11(root, "package.json"), "utf8"));
+  return JSON.parse(readFileSync7(join11(root, "package.json"), "utf8"));
 }
 function sortedKeys(value) {
   return Object.keys(value ?? {}).sort((left, right) => left.localeCompare(right));
@@ -69826,6 +70545,8 @@ function searchTaskEntities(filters, db) {
   return tasks.filter((task2) => taskMatchesSavedFilters(task2, filters, db)).slice(0, normalizeLimit(filters.limit));
 }
 function searchProjects(filters, db) {
+  if (filters.agent_id)
+    return [];
   const params = [];
   let sql = "SELECT * FROM projects WHERE 1=1";
   if (filters.project_id) {
@@ -99368,7 +100089,7 @@ var init_agent_run_dispatcher = __esm(() => {
 });
 
 // src/lib/verification-providers.ts
-import { existsSync as existsSync12, readFileSync as readFileSync7 } from "fs";
+import { existsSync as existsSync12, readFileSync as readFileSync8 } from "fs";
 function normalizeName5(name) {
   const normalized = name.trim().toLowerCase();
   if (!/^[a-z0-9][a-z0-9_-]{0,63}$/.test(normalized)) {
@@ -99520,7 +100241,7 @@ Timed out after ${provider.timeout_ms}ms`);
   };
 }
 function runCiLogProvider(input) {
-  const text = input.log_text ?? (input.log_path && existsSync12(input.log_path) ? readFileSync7(input.log_path, "utf-8") : "");
+  const text = input.log_text ?? (input.log_path && existsSync12(input.log_path) ? readFileSync8(input.log_path, "utf-8") : "");
   return {
     status: classifyLog(text),
     attempts: 1,
@@ -102261,7 +102982,7 @@ var init_local_bridge = __esm(() => {
 
 // src/lib/local-backups.ts
 import { createHash as createHash12 } from "crypto";
-import { readFileSync as readFileSync8, writeFileSync as writeFileSync3 } from "fs";
+import { readFileSync as readFileSync9, writeFileSync as writeFileSync3 } from "fs";
 import { dirname as dirname7, resolve as resolve13 } from "path";
 import { mkdirSync as mkdirSync6 } from "fs";
 function stableJson2(value) {
@@ -102371,7 +103092,7 @@ function writeLocalBackupFile(backup, outputPath) {
   return path;
 }
 function readLocalBackupFile(path) {
-  return JSON.parse(readFileSync8(resolve13(path), "utf-8"));
+  return JSON.parse(readFileSync9(resolve13(path), "utf-8"));
 }
 function verifyLocalBackup(value, options = {}, db) {
   const verifiedAt = options.verified_at ?? now();
@@ -103822,7 +104543,7 @@ __export(exports_local_extensions, {
   discoverLocalExtensions: () => discoverLocalExtensions
 });
 import { createHash as createHash15, createVerify } from "crypto";
-import { existsSync as existsSync13, readdirSync as readdirSync3, readFileSync as readFileSync9, statSync as statSync6 } from "fs";
+import { existsSync as existsSync13, readdirSync as readdirSync3, readFileSync as readFileSync10, statSync as statSync6 } from "fs";
 import { basename as basename5, join as join12, resolve as resolve14 } from "path";
 function isObject3(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
@@ -103904,7 +104625,7 @@ function normalizeManifest(input) {
   };
 }
 function parseJson2(path) {
-  return JSON.parse(readFileSync9(path, "utf8"));
+  return JSON.parse(readFileSync10(path, "utf8"));
 }
 function sha2566(bytes) {
   return `sha256:${createHash15("sha256").update(bytes).digest("hex")}`;
@@ -104088,7 +104809,7 @@ function inspectExtensionSource(source3) {
   const manifestPath = stat.isDirectory() ? [join12(resolved, "todos.extension.json"), join12(resolved, "extension.json")].find(existsSync13) : resolved;
   if (!manifestPath)
     throw new Error(`extension directory ${source3} is missing todos.extension.json`);
-  const raw = readFileSync9(manifestPath);
+  const raw = readFileSync10(manifestPath);
   const parsed = parseJson2(manifestPath);
   const bundle = isObject3(parsed) && isObject3(parsed["manifest"]);
   const manifest = normalizeManifest(bundle ? parsed["manifest"] : parsed);
@@ -108601,7 +109322,7 @@ __export(exports_extract, {
   buildCodebaseIndex: () => buildCodebaseIndex,
   EXTRACT_TAGS: () => EXTRACT_TAGS
 });
-import { existsSync as existsSync14, readFileSync as readFileSync10, statSync as statSync7 } from "fs";
+import { existsSync as existsSync14, readFileSync as readFileSync11, statSync as statSync7 } from "fs";
 import { createHash as createHash17 } from "crypto";
 import { relative as relative5, resolve as resolve15, join as join13 } from "path";
 function stableHash(value) {
@@ -108616,7 +109337,7 @@ function readGitignorePatterns(basePath) {
   if (!existsSync14(gitignorePath))
     return [];
   try {
-    return readFileSync10(gitignorePath, "utf-8").split(`
+    return readFileSync11(gitignorePath, "utf-8").split(`
 `).map((line) => line.trim()).filter((line) => line && !line.startsWith("#") && !line.startsWith("!"));
   } catch {
     return [];
@@ -108757,7 +109478,7 @@ function buildCodebaseIndex(options) {
   for (const file of files) {
     const fullPath = statSync7(basePath).isFile() ? basePath : join13(basePath, file);
     try {
-      const source3 = readFileSync10(fullPath, "utf-8");
+      const source3 = readFileSync11(fullPath, "utf-8");
       const relPath = statSync7(basePath).isFile() ? relative5(resolve15(basePath, ".."), fullPath) : file;
       indexed.push({
         file: relPath,
@@ -108788,7 +109509,7 @@ function extractTodos(options, db) {
   for (const file of files) {
     const fullPath = statSync7(basePath).isFile() ? basePath : join13(basePath, file);
     try {
-      const source3 = readFileSync10(fullPath, "utf-8");
+      const source3 = readFileSync11(fullPath, "utf-8");
       const relPath = statSync7(basePath).isFile() ? relative5(resolve15(basePath, ".."), fullPath) : file;
       const comments = extractFromSource(source3, relPath, tags);
       allComments.push(...comments);
@@ -110330,7 +111051,7 @@ __export(exports_environment_snapshots, {
   captureEnvironmentSnapshot: () => captureEnvironmentSnapshot
 });
 import { createHash as createHash18 } from "crypto";
-import { existsSync as existsSync15, readFileSync as readFileSync11, statSync as statSync8 } from "fs";
+import { existsSync as existsSync15, readFileSync as readFileSync12, statSync as statSync8 } from "fs";
 import { hostname as hostname3, platform, arch } from "os";
 import { dirname as dirname8, join as join15, resolve as resolve16 } from "path";
 import { tmpdir as tmpdir3 } from "os";
@@ -110344,7 +111065,7 @@ function fileRecord(root, relativePath) {
   const stat = statSync8(path);
   if (!stat.isFile())
     return null;
-  const content = readFileSync11(path);
+  const content = readFileSync12(path);
   return { path: relativePath, sha256: sha2567(content), size_bytes: content.length };
 }
 function manifestRecord(root, relativePath) {