@hasna/todos 0.11.94 → 0.12.1

package/dist/registry.js

@@ -1203,27 +1203,478 @@ var init_migrations = __esm(() => {
   ALTER TABLE plans ADD COLUMN slug TEXT;
   CREATE INDEX IF NOT EXISTS idx_plans_slug ON plans(slug);
   INSERT OR IGNORE INTO _migrations (id) VALUES (64);
+  `,
+    `
+  ALTER TABLE agents ADD COLUMN identity_id TEXT;
+  ALTER TABLE agents ADD COLUMN project_id TEXT;
+  ALTER TABLE agents ADD COLUMN runtime_instance_id TEXT;
+
+  CREATE TABLE IF NOT EXISTS agent_identity_source_mappings (
+    id TEXT PRIMARY KEY,
+    local_agent_id TEXT REFERENCES agents(id) ON DELETE RESTRICT,
+    identity_id TEXT,
+    source_authority TEXT NOT NULL CHECK(length(trim(source_authority)) > 0),
+    source_tenant_id TEXT NOT NULL CHECK(length(trim(source_tenant_id)) > 0),
+    source_namespace TEXT NOT NULL CHECK(length(trim(source_namespace)) > 0),
+    source_entity_type TEXT NOT NULL CHECK(length(trim(source_entity_type)) > 0),
+    source_record_id TEXT NOT NULL CHECK(length(trim(source_record_id)) > 0),
+    observed_label TEXT,
+    evidence TEXT NOT NULL DEFAULT '{}',
+    mapping_basis TEXT NOT NULL CHECK(mapping_basis IN ('authoritative', 'imported', 'candidate', 'name_similarity')),
+    status TEXT NOT NULL CHECK(status IN ('active', 'retired', 'quarantined', 'revoked')),
+    revision INTEGER NOT NULL CHECK(revision > 0),
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL,
+    CHECK(mapping_basis IN ('authoritative', 'imported') OR status IN ('quarantined', 'revoked')),
+    CHECK(status != 'active' OR (mapping_basis IN ('authoritative', 'imported') AND identity_id IS NOT NULL))
+  );
+  DROP INDEX IF EXISTS idx_agent_identity_source_active_unique;
+  CREATE UNIQUE INDEX IF NOT EXISTS idx_agent_identity_source_revision_unique
+    ON agent_identity_source_mappings (
+      source_authority, source_tenant_id, source_namespace, source_entity_type, source_record_id, revision
+    )
+    WHERE mapping_basis IN ('authoritative', 'imported');
+  CREATE INDEX IF NOT EXISTS idx_agent_identity_source_identity
+    ON agent_identity_source_mappings(identity_id);
+  CREATE INDEX IF NOT EXISTS idx_agent_identity_source_local
+    ON agent_identity_source_mappings(local_agent_id);
+  CREATE TABLE IF NOT EXISTS agent_identity_aliases (
+    id TEXT PRIMARY KEY,
+    local_agent_id TEXT NOT NULL REFERENCES agents(id) ON DELETE RESTRICT,
+    label TEXT NOT NULL,
+    normalized_label TEXT NOT NULL,
+    alias_kind TEXT NOT NULL CHECK(alias_kind IN ('historical', 'candidate')),
+    status TEXT NOT NULL CHECK(status IN ('active', 'quarantined', 'revoked')),
+    created_at TEXT NOT NULL,
+    UNIQUE(local_agent_id, normalized_label)
+  );
+  CREATE INDEX IF NOT EXISTS idx_agent_identity_alias_lookup
+    ON agent_identity_aliases(normalized_label, status);
+
+  CREATE TRIGGER IF NOT EXISTS trg_agents_identity_id_immutable
+  BEFORE UPDATE OF identity_id ON agents
+  WHEN OLD.identity_id IS NOT NULL AND OLD.identity_id IS NOT NEW.identity_id
+  BEGIN
+    SELECT RAISE(ABORT, 'IDENTITY_ID_IMMUTABLE');
+  END;
+
+  CREATE TRIGGER IF NOT EXISTS trg_agent_identity_mapping_identity_immutable
+  BEFORE UPDATE OF identity_id ON agent_identity_source_mappings
+  WHEN OLD.identity_id IS NOT NEW.identity_id
+  BEGIN
+    SELECT RAISE(ABORT, 'IDENTITY_ID_IMMUTABLE');
+  END;
+
+  CREATE TRIGGER IF NOT EXISTS trg_agent_identity_mapping_lineage_immutable
+  BEFORE UPDATE OF source_authority, source_tenant_id, source_namespace, source_entity_type, source_record_id
+    ON agent_identity_source_mappings
+  WHEN OLD.source_authority IS NOT NEW.source_authority
+    OR OLD.source_tenant_id IS NOT NEW.source_tenant_id
+    OR OLD.source_namespace IS NOT NEW.source_namespace
+    OR OLD.source_entity_type IS NOT NEW.source_entity_type
+    OR OLD.source_record_id IS NOT NEW.source_record_id
+  BEGIN
+    SELECT RAISE(ABORT, 'IDENTITY_SOURCE_LINEAGE_IMMUTABLE');
+  END;
+
+  CREATE TRIGGER IF NOT EXISTS trg_agent_identity_mapping_history_immutable
+  BEFORE UPDATE OF local_agent_id, observed_label, evidence, mapping_basis, status, revision, created_at
+    ON agent_identity_source_mappings
+  BEGIN
+    SELECT RAISE(ABORT, 'IDENTITY_MAPPING_HISTORY_IMMUTABLE');
+  END;
+
+  CREATE TRIGGER IF NOT EXISTS trg_agent_identity_mapping_history_append_only
+  BEFORE DELETE ON agent_identity_source_mappings
+  BEGIN
+    SELECT RAISE(ABORT, 'IDENTITY_MAPPING_HISTORY_IMMUTABLE');
+  END;
+
+  INSERT OR IGNORE INTO _migrations (id) VALUES (65);
+  `,
+    `
+  CREATE TABLE IF NOT EXISTS pr_groups (
+    schema_version INTEGER NOT NULL DEFAULT 1,
+    id TEXT PRIMARY KEY,
+    identity_key TEXT NOT NULL UNIQUE,
+    root_request_id TEXT NOT NULL,
+    repository TEXT NOT NULL,
+    state TEXT NOT NULL,
+    active_attempt_id TEXT,
+    active_generation TEXT,
+    terminal_attempt_id TEXT,
+    terminal_generation TEXT,
+    terminal_outcome TEXT,
+    terminal_head_sha TEXT,
+    terminal_at TEXT,
+    cleanup_eligible_at TEXT,
+    revision INTEGER NOT NULL DEFAULT 1,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL
+  );
+  CREATE UNIQUE INDEX IF NOT EXISTS idx_pr_groups_identity ON pr_groups(identity_key);
+  CREATE INDEX IF NOT EXISTS idx_pr_groups_root_repository ON pr_groups(root_request_id, repository);
+  CREATE INDEX IF NOT EXISTS idx_pr_groups_active_generation ON pr_groups(active_generation);
+
+  CREATE TABLE IF NOT EXISTS pr_group_attempts (
+    schema_version INTEGER NOT NULL DEFAULT 1,
+    id TEXT PRIMARY KEY,
+    group_id TEXT NOT NULL REFERENCES pr_groups(id) ON DELETE CASCADE,
+    leaf_task_id TEXT NOT NULL,
+    dispatch_attempt TEXT NOT NULL,
+    writer_generation TEXT NOT NULL,
+    previous_attempt_id TEXT REFERENCES pr_group_attempts(id) ON DELETE SET NULL,
+    worktree TEXT NOT NULL,
+    branch TEXT NOT NULL,
+    provider TEXT,
+    provider_run_id TEXT,
+    profile_alias TEXT,
+    status TEXT NOT NULL,
+    admitted_at TEXT NOT NULL,
+    started_at TEXT,
+    last_heartbeat_at TEXT,
+    handed_off_at TEXT,
+    fenced_at TEXT,
+    terminal_at TEXT,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL,
+    UNIQUE(group_id, leaf_task_id, dispatch_attempt),
+    UNIQUE(group_id, writer_generation)
+  );
+  CREATE INDEX IF NOT EXISTS idx_pr_group_attempts_group ON pr_group_attempts(group_id, created_at, id);
+  CREATE INDEX IF NOT EXISTS idx_pr_group_attempts_generation ON pr_group_attempts(group_id, writer_generation);
+
+  CREATE TABLE IF NOT EXISTS pr_group_events (
+    schema_version INTEGER NOT NULL DEFAULT 1,
+    id TEXT PRIMARY KEY,
+    group_id TEXT NOT NULL REFERENCES pr_groups(id) ON DELETE CASCADE,
+    attempt_id TEXT NOT NULL REFERENCES pr_group_attempts(id) ON DELETE CASCADE,
+    writer_generation TEXT NOT NULL,
+    sequence INTEGER NOT NULL,
+    idempotency_key TEXT NOT NULL,
+    event_type TEXT NOT NULL,
+    state TEXT NOT NULL,
+    message TEXT,
+    head_sha TEXT,
+    receipt_key TEXT,
+    outcome TEXT,
+    metadata TEXT NOT NULL DEFAULT '{}',
+    payload_hash TEXT NOT NULL,
+    created_at TEXT NOT NULL,
+    UNIQUE(group_id, sequence),
+    UNIQUE(group_id, idempotency_key),
+    UNIQUE(group_id, receipt_key)
+  );
+  CREATE INDEX IF NOT EXISTS idx_pr_group_events_group_sequence ON pr_group_events(group_id, sequence);
+  CREATE INDEX IF NOT EXISTS idx_pr_group_events_attempt ON pr_group_events(attempt_id, sequence);
+  CREATE INDEX IF NOT EXISTS idx_pr_group_events_receipt ON pr_group_events(group_id, receipt_key);
+  INSERT OR IGNORE INTO _migrations (id) VALUES (66);
+  `,
+    `
+  ALTER TABLE pr_groups ADD COLUMN leaf_task_id TEXT;
+  ALTER TABLE pr_groups ADD COLUMN branch TEXT;
+  ALTER TABLE pr_groups ADD COLUMN pr_number INTEGER;
+  ALTER TABLE pr_groups ADD COLUMN base_sha TEXT;
+  ALTER TABLE pr_groups ADD COLUMN repair_cycle_count INTEGER NOT NULL DEFAULT 0;
+  ALTER TABLE pr_groups ADD COLUMN repair_cycle_limit INTEGER NOT NULL DEFAULT 2;
+  ALTER TABLE pr_group_attempts ADD COLUMN repository TEXT;
+  ALTER TABLE pr_group_attempts ADD COLUMN pr_number INTEGER;
+  ALTER TABLE pr_group_attempts ADD COLUMN base_sha TEXT;
+  ALTER TABLE pr_group_events ADD COLUMN review_receipt_key TEXT;
+  ALTER TABLE pr_group_events ADD COLUMN conditional_merge_receipt_key TEXT;
+  ALTER TABLE pr_group_events ADD COLUMN repository TEXT;
+  ALTER TABLE pr_group_events ADD COLUMN pr_number INTEGER;
+  ALTER TABLE pr_group_events ADD COLUMN base_sha TEXT;
+  ALTER TABLE pr_group_events ADD COLUMN actor_id TEXT;
+  ALTER TABLE pr_group_events ADD COLUMN actor_run_id TEXT;
+  ALTER TABLE pr_group_events ADD COLUMN expected_reviewer_id TEXT;
+  ALTER TABLE pr_group_events ADD COLUMN expected_reviewer_run_id TEXT;
+  ALTER TABLE pr_group_events ADD COLUMN repair_cycle INTEGER;
+  ALTER TABLE pr_group_events ADD COLUMN cleanup_proof TEXT;
+
+  UPDATE pr_groups
+  SET leaf_task_id = COALESCE(leaf_task_id, (
+        SELECT attempt.leaf_task_id
+        FROM pr_group_attempts AS attempt
+        WHERE attempt.group_id = pr_groups.id
+        ORDER BY CASE WHEN attempt.id = pr_groups.active_attempt_id THEN 0 ELSE 1 END,
+                 attempt.created_at ASC, attempt.id ASC
+        LIMIT 1
+      )),
+      branch = COALESCE(branch, (
+        SELECT attempt.branch
+        FROM pr_group_attempts AS attempt
+        WHERE attempt.group_id = pr_groups.id
+        ORDER BY CASE WHEN attempt.id = pr_groups.active_attempt_id THEN 0 ELSE 1 END,
+                 attempt.created_at ASC, attempt.id ASC
+        LIMIT 1
+      ));
+
+  UPDATE pr_group_attempts
+  SET repository = COALESCE(repository, (
+        SELECT groups.repository FROM pr_groups AS groups
+        WHERE groups.id = pr_group_attempts.group_id
+      )),
+      pr_number = COALESCE(pr_number, (
+        SELECT groups.pr_number FROM pr_groups AS groups
+        WHERE groups.id = pr_group_attempts.group_id
+      )),
+      base_sha = COALESCE(base_sha, (
+        SELECT groups.base_sha FROM pr_groups AS groups
+        WHERE groups.id = pr_group_attempts.group_id
+      ));
+
+  UPDATE pr_groups
+  SET pr_number = COALESCE(pr_number, (
+        SELECT attempt.pr_number
+        FROM pr_group_attempts AS attempt
+        WHERE attempt.group_id = pr_groups.id AND attempt.pr_number IS NOT NULL
+        ORDER BY CASE WHEN attempt.id = pr_groups.active_attempt_id THEN 0 ELSE 1 END,
+                 attempt.created_at ASC, attempt.id ASC
+        LIMIT 1
+      )),
+      base_sha = COALESCE(base_sha, (
+        SELECT attempt.base_sha
+        FROM pr_group_attempts AS attempt
+        WHERE attempt.group_id = pr_groups.id AND attempt.base_sha IS NOT NULL
+        ORDER BY CASE WHEN attempt.id = pr_groups.active_attempt_id THEN 0 ELSE 1 END,
+                 attempt.created_at ASC, attempt.id ASC
+        LIMIT 1
+      ));
+
+  UPDATE pr_group_attempts
+  SET pr_number = COALESCE(pr_number, (
+        SELECT groups.pr_number FROM pr_groups AS groups
+        WHERE groups.id = pr_group_attempts.group_id
+      )),
+      base_sha = COALESCE(base_sha, (
+        SELECT groups.base_sha FROM pr_groups AS groups
+        WHERE groups.id = pr_group_attempts.group_id
+      ));
+
+  UPDATE pr_group_events
+  SET repository = COALESCE(repository, (
+        SELECT attempt.repository FROM pr_group_attempts AS attempt
+        WHERE attempt.id = pr_group_events.attempt_id
+      ), (
+        SELECT groups.repository FROM pr_groups AS groups
+        WHERE groups.id = pr_group_events.group_id
+      )),
+      pr_number = COALESCE(pr_number, (
+        SELECT attempt.pr_number FROM pr_group_attempts AS attempt
+        WHERE attempt.id = pr_group_events.attempt_id
+      ), (
+        SELECT groups.pr_number FROM pr_groups AS groups
+        WHERE groups.id = pr_group_events.group_id
+      )),
+      base_sha = COALESCE(base_sha, (
+        SELECT attempt.base_sha FROM pr_group_attempts AS attempt
+        WHERE attempt.id = pr_group_events.attempt_id
+      ), (
+        SELECT groups.base_sha FROM pr_groups AS groups
+        WHERE groups.id = pr_group_events.group_id
+      ));
+
+  INSERT OR IGNORE INTO _migrations (id)
+  SELECT 66
+  WHERE NOT EXISTS (
+    SELECT 1 FROM pr_groups WHERE leaf_task_id IS NULL OR branch IS NULL
+  )
+    AND NOT EXISTS (
+      SELECT 1 FROM pr_group_attempts WHERE repository IS NULL
+    )
+    AND NOT EXISTS (
+      SELECT 1 FROM pr_group_events WHERE repository IS NULL
+    );
+  `,
+    `
+  PRAGMA foreign_keys = OFF;
+  BEGIN IMMEDIATE;
+
+  ALTER TABLE pr_group_events RENAME TO pr_group_events_v66;
+  ALTER TABLE pr_group_attempts RENAME TO pr_group_attempts_v66;
+  ALTER TABLE pr_groups RENAME TO pr_groups_v66;
+
+  CREATE TABLE pr_groups (
+    schema_version INTEGER NOT NULL DEFAULT 1,
+    id TEXT PRIMARY KEY,
+    identity_key TEXT NOT NULL UNIQUE,
+    root_request_id TEXT NOT NULL,
+    repository TEXT NOT NULL,
+    leaf_task_id TEXT NOT NULL,
+    branch TEXT NOT NULL,
+    pr_number INTEGER,
+    base_sha TEXT,
+    state TEXT NOT NULL,
+    active_attempt_id TEXT,
+    active_generation TEXT,
+    repair_cycle_count INTEGER NOT NULL DEFAULT 0,
+    repair_cycle_limit INTEGER NOT NULL DEFAULT 2,
+    terminal_attempt_id TEXT,
+    terminal_generation TEXT,
+    terminal_outcome TEXT,
+    terminal_head_sha TEXT,
+    terminal_at TEXT,
+    cleanup_eligible_at TEXT,
+    revision INTEGER NOT NULL DEFAULT 1,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL
+  );
+
+  CREATE TABLE pr_group_attempts (
+    schema_version INTEGER NOT NULL DEFAULT 1,
+    id TEXT PRIMARY KEY,
+    group_id TEXT NOT NULL REFERENCES pr_groups(id) ON DELETE CASCADE,
+    leaf_task_id TEXT NOT NULL,
+    dispatch_attempt TEXT NOT NULL,
+    writer_generation TEXT NOT NULL,
+    previous_attempt_id TEXT REFERENCES pr_group_attempts(id) ON DELETE SET NULL,
+    worktree TEXT NOT NULL,
+    branch TEXT NOT NULL,
+    repository TEXT NOT NULL,
+    pr_number INTEGER,
+    base_sha TEXT,
+    provider TEXT,
+    provider_run_id TEXT,
+    profile_alias TEXT,
+    status TEXT NOT NULL,
+    admitted_at TEXT NOT NULL,
+    started_at TEXT,
+    last_heartbeat_at TEXT,
+    handed_off_at TEXT,
+    fenced_at TEXT,
+    terminal_at TEXT,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL,
+    UNIQUE(group_id, leaf_task_id, dispatch_attempt),
+    UNIQUE(group_id, writer_generation)
+  );
+
+  CREATE TABLE pr_group_events (
+    schema_version INTEGER NOT NULL DEFAULT 1,
+    id TEXT PRIMARY KEY,
+    group_id TEXT NOT NULL REFERENCES pr_groups(id) ON DELETE CASCADE,
+    attempt_id TEXT NOT NULL REFERENCES pr_group_attempts(id) ON DELETE CASCADE,
+    writer_generation TEXT NOT NULL,
+    sequence INTEGER NOT NULL,
+    idempotency_key TEXT NOT NULL,
+    event_type TEXT NOT NULL,
+    state TEXT NOT NULL,
+    message TEXT,
+    head_sha TEXT,
+    receipt_key TEXT UNIQUE,
+    review_receipt_key TEXT,
+    conditional_merge_receipt_key TEXT,
+    outcome TEXT,
+    repository TEXT NOT NULL,
+    pr_number INTEGER,
+    base_sha TEXT,
+    actor_id TEXT,
+    actor_run_id TEXT,
+    expected_reviewer_id TEXT,
+    expected_reviewer_run_id TEXT,
+    repair_cycle INTEGER,
+    ci_proof TEXT,
+    cleanup_proof TEXT,
+    metadata TEXT NOT NULL DEFAULT '{}',
+    payload_hash TEXT NOT NULL,
+    created_at TEXT NOT NULL,
+    UNIQUE(group_id, sequence),
+    UNIQUE(group_id, idempotency_key)
+  );
+
+  INSERT INTO pr_groups (
+    schema_version,id,identity_key,root_request_id,repository,leaf_task_id,branch,
+    pr_number,base_sha,state,active_attempt_id,active_generation,
+    repair_cycle_count,repair_cycle_limit,terminal_attempt_id,terminal_generation,
+    terminal_outcome,terminal_head_sha,terminal_at,cleanup_eligible_at,
+    revision,created_at,updated_at
+  )
+  SELECT
+    schema_version,id,identity_key,root_request_id,repository,leaf_task_id,branch,
+    pr_number,base_sha,state,active_attempt_id,active_generation,
+    repair_cycle_count,repair_cycle_limit,terminal_attempt_id,terminal_generation,
+    terminal_outcome,terminal_head_sha,terminal_at,cleanup_eligible_at,
+    revision,created_at,updated_at
+  FROM pr_groups_v66;
+
+  INSERT INTO pr_group_attempts (
+    schema_version,id,group_id,leaf_task_id,dispatch_attempt,writer_generation,
+    previous_attempt_id,worktree,branch,repository,pr_number,base_sha,
+    provider,provider_run_id,profile_alias,status,admitted_at,started_at,
+    last_heartbeat_at,handed_off_at,fenced_at,terminal_at,created_at,updated_at
+  )
+  SELECT
+    schema_version,id,group_id,leaf_task_id,dispatch_attempt,writer_generation,
+    previous_attempt_id,worktree,branch,repository,pr_number,base_sha,
+    provider,provider_run_id,profile_alias,status,admitted_at,started_at,
+    last_heartbeat_at,handed_off_at,fenced_at,terminal_at,created_at,updated_at
+  FROM pr_group_attempts_v66;
+
+  INSERT INTO pr_group_events (
+    schema_version,id,group_id,attempt_id,writer_generation,sequence,
+    idempotency_key,event_type,state,message,head_sha,receipt_key,
+    review_receipt_key,conditional_merge_receipt_key,outcome,repository,
+    pr_number,base_sha,actor_id,actor_run_id,expected_reviewer_id,
+    expected_reviewer_run_id,repair_cycle,ci_proof,cleanup_proof,
+    metadata,payload_hash,created_at
+  )
+  SELECT
+    schema_version,id,group_id,attempt_id,writer_generation,sequence,
+    idempotency_key,event_type,state,message,head_sha,receipt_key,
+    review_receipt_key,conditional_merge_receipt_key,outcome,repository,
+    pr_number,base_sha,actor_id,actor_run_id,expected_reviewer_id,
+    expected_reviewer_run_id,repair_cycle,NULL,cleanup_proof,
+    metadata,payload_hash,created_at
+  FROM pr_group_events_v66;
+
+  DROP TABLE pr_group_events_v66;
+  DROP TABLE pr_group_attempts_v66;
+  DROP TABLE pr_groups_v66;
+
+  CREATE UNIQUE INDEX idx_pr_groups_identity ON pr_groups(identity_key);
+  CREATE INDEX idx_pr_groups_root_repository ON pr_groups(root_request_id, repository);
+  CREATE INDEX idx_pr_groups_active_generation ON pr_groups(active_generation);
+  CREATE INDEX idx_pr_group_attempts_group ON pr_group_attempts(group_id, created_at, id);
+  CREATE INDEX idx_pr_group_attempts_generation ON pr_group_attempts(group_id, writer_generation);
+  CREATE INDEX idx_pr_group_events_group_sequence ON pr_group_events(group_id, sequence);
+  CREATE INDEX idx_pr_group_events_attempt ON pr_group_events(attempt_id, sequence);
+  CREATE INDEX idx_pr_group_events_receipt ON pr_group_events(receipt_key);
+
+  INSERT OR IGNORE INTO _migrations (id) VALUES (68);
+  COMMIT;
+  PRAGMA foreign_keys = ON;
   `
   ];
 });
 
 // src/db/schema.ts
 function runMigrations(db) {
+  let strictMigrationFailure = null;
+  const executeMigration = (migration, index) => {
+    try {
+      db.exec(migration);
+    } catch (error) {
+      try {
+        db.exec("ROLLBACK");
+      } catch {}
+      if (index + 1 >= 68)
+        strictMigrationFailure = error;
+    }
+  };
   try {
     const result = db.query("SELECT MAX(id) as max_id FROM _migrations").get();
     const currentLevel = result?.max_id ?? 0;
     for (let i = currentLevel;i < MIGRATIONS.length; i++) {
-      try {
-        db.exec(MIGRATIONS[i]);
-      } catch {}
+      executeMigration(MIGRATIONS[i], i);
     }
   } catch {
-    for (const migration of MIGRATIONS) {
-      try {
-        db.exec(migration);
-      } catch {}
+    for (const [index, migration] of MIGRATIONS.entries()) {
+      executeMigration(migration, index);
     }
   }
+  if (strictMigrationFailure)
+    throw strictMigrationFailure;
   ensureSchema(db);
 }
 function planSlugBase(value) {
@@ -2392,6 +2843,246 @@ function ensureSchema(db) {
     )`);
   ensureIndex("CREATE INDEX IF NOT EXISTS idx_api_keys_prefix ON api_keys(prefix)");
   ensureIndex("CREATE INDEX IF NOT EXISTS idx_api_keys_active ON api_keys(revoked_at, expires_at)");
+  ensureTable("pr_groups", `
+    CREATE TABLE pr_groups (
+      schema_version INTEGER NOT NULL DEFAULT 1,
+      id TEXT PRIMARY KEY,
+      identity_key TEXT NOT NULL UNIQUE,
+      root_request_id TEXT NOT NULL,
+      repository TEXT NOT NULL,
+      leaf_task_id TEXT NOT NULL,
+      branch TEXT NOT NULL,
+      pr_number INTEGER,
+      base_sha TEXT,
+      state TEXT NOT NULL,
+      active_attempt_id TEXT,
+      active_generation TEXT,
+      repair_cycle_count INTEGER NOT NULL DEFAULT 0,
+      repair_cycle_limit INTEGER NOT NULL DEFAULT 2,
+      terminal_attempt_id TEXT,
+      terminal_generation TEXT,
+      terminal_outcome TEXT,
+      terminal_head_sha TEXT,
+      terminal_at TEXT,
+      cleanup_eligible_at TEXT,
+      revision INTEGER NOT NULL DEFAULT 1,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    )`);
+  ensureIndex("CREATE UNIQUE INDEX IF NOT EXISTS idx_pr_groups_identity ON pr_groups(identity_key)");
+  ensureIndex("CREATE INDEX IF NOT EXISTS idx_pr_groups_root_repository ON pr_groups(root_request_id, repository)");
+  ensureIndex("CREATE INDEX IF NOT EXISTS idx_pr_groups_active_generation ON pr_groups(active_generation)");
+  ensureTable("pr_group_attempts", `
+    CREATE TABLE pr_group_attempts (
+      schema_version INTEGER NOT NULL DEFAULT 1,
+      id TEXT PRIMARY KEY,
+      group_id TEXT NOT NULL REFERENCES pr_groups(id) ON DELETE CASCADE,
+      leaf_task_id TEXT NOT NULL,
+      dispatch_attempt TEXT NOT NULL,
+      writer_generation TEXT NOT NULL,
+      previous_attempt_id TEXT REFERENCES pr_group_attempts(id) ON DELETE SET NULL,
+      worktree TEXT NOT NULL,
+      branch TEXT NOT NULL,
+      repository TEXT NOT NULL,
+      pr_number INTEGER,
+      base_sha TEXT,
+      provider TEXT,
+      provider_run_id TEXT,
+      profile_alias TEXT,
+      status TEXT NOT NULL,
+      admitted_at TEXT NOT NULL,
+      started_at TEXT,
+      last_heartbeat_at TEXT,
+      handed_off_at TEXT,
+      fenced_at TEXT,
+      terminal_at TEXT,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      UNIQUE(group_id, leaf_task_id, dispatch_attempt),
+      UNIQUE(group_id, writer_generation)
+    )`);
+  ensureIndex("CREATE INDEX IF NOT EXISTS idx_pr_group_attempts_group ON pr_group_attempts(group_id, created_at, id)");
+  ensureIndex("CREATE INDEX IF NOT EXISTS idx_pr_group_attempts_generation ON pr_group_attempts(group_id, writer_generation)");
+  ensureTable("pr_group_events", `
+    CREATE TABLE pr_group_events (
+      schema_version INTEGER NOT NULL DEFAULT 1,
+      id TEXT PRIMARY KEY,
+      group_id TEXT NOT NULL REFERENCES pr_groups(id) ON DELETE CASCADE,
+      attempt_id TEXT NOT NULL REFERENCES pr_group_attempts(id) ON DELETE CASCADE,
+      writer_generation TEXT NOT NULL,
+      sequence INTEGER NOT NULL,
+      idempotency_key TEXT NOT NULL,
+      event_type TEXT NOT NULL,
+      state TEXT NOT NULL,
+      message TEXT,
+      head_sha TEXT,
+      receipt_key TEXT UNIQUE,
+      review_receipt_key TEXT,
+      conditional_merge_receipt_key TEXT,
+      outcome TEXT,
+      repository TEXT NOT NULL,
+      pr_number INTEGER,
+      base_sha TEXT,
+      actor_id TEXT,
+      actor_run_id TEXT,
+      expected_reviewer_id TEXT,
+      expected_reviewer_run_id TEXT,
+      repair_cycle INTEGER,
+      ci_proof TEXT,
+      cleanup_proof TEXT,
+      metadata TEXT NOT NULL DEFAULT '{}',
+      payload_hash TEXT NOT NULL,
+      created_at TEXT NOT NULL,
+      UNIQUE(group_id, sequence),
+      UNIQUE(group_id, idempotency_key)
+    )`);
+  ensureIndex("CREATE INDEX IF NOT EXISTS idx_pr_group_events_group_sequence ON pr_group_events(group_id, sequence)");
+  ensureIndex("CREATE INDEX IF NOT EXISTS idx_pr_group_events_attempt ON pr_group_events(attempt_id, sequence)");
+  ensureIndex("CREATE INDEX IF NOT EXISTS idx_pr_group_events_receipt ON pr_group_events(receipt_key)");
+  ensureColumn("pr_groups", "leaf_task_id", "TEXT");
+  ensureColumn("pr_groups", "branch", "TEXT");
+  ensureColumn("pr_groups", "pr_number", "INTEGER");
+  ensureColumn("pr_groups", "base_sha", "TEXT");
+  ensureColumn("pr_groups", "repair_cycle_count", "INTEGER NOT NULL DEFAULT 0");
+  ensureColumn("pr_groups", "repair_cycle_limit", "INTEGER NOT NULL DEFAULT 2");
+  ensureColumn("pr_group_attempts", "repository", "TEXT");
+  ensureColumn("pr_group_attempts", "pr_number", "INTEGER");
+  ensureColumn("pr_group_attempts", "base_sha", "TEXT");
+  ensureColumn("pr_group_events", "review_receipt_key", "TEXT");
+  ensureColumn("pr_group_events", "conditional_merge_receipt_key", "TEXT");
+  ensureColumn("pr_group_events", "repository", "TEXT");
+  ensureColumn("pr_group_events", "pr_number", "INTEGER");
+  ensureColumn("pr_group_events", "base_sha", "TEXT");
+  ensureColumn("pr_group_events", "actor_id", "TEXT");
+  ensureColumn("pr_group_events", "actor_run_id", "TEXT");
+  ensureColumn("pr_group_events", "expected_reviewer_id", "TEXT");
+  ensureColumn("pr_group_events", "expected_reviewer_run_id", "TEXT");
+  ensureColumn("pr_group_events", "repair_cycle", "INTEGER");
+  ensureColumn("pr_group_events", "ci_proof", "TEXT");
+  ensureColumn("pr_group_events", "cleanup_proof", "TEXT");
+  try {
+    db.exec(`
+      UPDATE pr_groups
+      SET leaf_task_id = COALESCE(leaf_task_id, (
+            SELECT attempt.leaf_task_id
+            FROM pr_group_attempts AS attempt
+            WHERE attempt.group_id = pr_groups.id
+            ORDER BY CASE WHEN attempt.id = pr_groups.active_attempt_id THEN 0 ELSE 1 END,
+                     attempt.created_at ASC, attempt.id ASC
+            LIMIT 1
+          )),
+          branch = COALESCE(branch, (
+            SELECT attempt.branch
+            FROM pr_group_attempts AS attempt
+            WHERE attempt.group_id = pr_groups.id
+            ORDER BY CASE WHEN attempt.id = pr_groups.active_attempt_id THEN 0 ELSE 1 END,
+                     attempt.created_at ASC, attempt.id ASC
+            LIMIT 1
+          ));
+      UPDATE pr_group_attempts
+      SET repository = COALESCE(repository, (
+            SELECT groups.repository FROM pr_groups AS groups
+            WHERE groups.id = pr_group_attempts.group_id
+          )),
+          pr_number = COALESCE(pr_number, (
+            SELECT groups.pr_number FROM pr_groups AS groups
+            WHERE groups.id = pr_group_attempts.group_id
+          )),
+          base_sha = COALESCE(base_sha, (
+            SELECT groups.base_sha FROM pr_groups AS groups
+            WHERE groups.id = pr_group_attempts.group_id
+          ));
+      UPDATE pr_groups
+      SET pr_number = COALESCE(pr_number, (
+            SELECT attempt.pr_number
+            FROM pr_group_attempts AS attempt
+            WHERE attempt.group_id = pr_groups.id AND attempt.pr_number IS NOT NULL
+            ORDER BY CASE WHEN attempt.id = pr_groups.active_attempt_id THEN 0 ELSE 1 END,
+                     attempt.created_at ASC, attempt.id ASC
+            LIMIT 1
+          )),
+          base_sha = COALESCE(base_sha, (
+            SELECT attempt.base_sha
+            FROM pr_group_attempts AS attempt
+            WHERE attempt.group_id = pr_groups.id AND attempt.base_sha IS NOT NULL
+            ORDER BY CASE WHEN attempt.id = pr_groups.active_attempt_id THEN 0 ELSE 1 END,
+                     attempt.created_at ASC, attempt.id ASC
+            LIMIT 1
+          ));
+      UPDATE pr_group_attempts
+      SET pr_number = COALESCE(pr_number, (
+            SELECT groups.pr_number FROM pr_groups AS groups
+            WHERE groups.id = pr_group_attempts.group_id
+          )),
+          base_sha = COALESCE(base_sha, (
+            SELECT groups.base_sha FROM pr_groups AS groups
+            WHERE groups.id = pr_group_attempts.group_id
+          ));
+      UPDATE pr_group_events
+      SET repository = COALESCE(repository, (
+            SELECT attempt.repository FROM pr_group_attempts AS attempt
+            WHERE attempt.id = pr_group_events.attempt_id
+          ), (
+            SELECT groups.repository FROM pr_groups AS groups
+            WHERE groups.id = pr_group_events.group_id
+          )),
+          pr_number = COALESCE(pr_number, (
+            SELECT attempt.pr_number FROM pr_group_attempts AS attempt
+            WHERE attempt.id = pr_group_events.attempt_id
+          ), (
+            SELECT groups.pr_number FROM pr_groups AS groups
+            WHERE groups.id = pr_group_events.group_id
+          )),
+          base_sha = COALESCE(base_sha, (
+            SELECT attempt.base_sha FROM pr_group_attempts AS attempt
+            WHERE attempt.id = pr_group_events.attempt_id
+          ), (
+            SELECT groups.base_sha FROM pr_groups AS groups
+            WHERE groups.id = pr_group_events.group_id
+          ));
+      INSERT OR IGNORE INTO _migrations (id)
+      SELECT 66
+      WHERE NOT EXISTS (
+        SELECT 1 FROM pr_groups WHERE leaf_task_id IS NULL OR branch IS NULL
+      )
+        AND NOT EXISTS (
+          SELECT 1 FROM pr_group_attempts WHERE repository IS NULL
+        )
+        AND NOT EXISTS (
+          SELECT 1 FROM pr_group_events WHERE repository IS NULL
+        );
+    `);
+  } catch {}
+  const strictColumns = [
+    ["pr_groups", "leaf_task_id"],
+    ["pr_groups", "branch"],
+    ["pr_group_attempts", "repository"],
+    ["pr_group_events", "repository"]
+  ];
+  for (const [table, column] of strictColumns) {
+    const definition = db.query(`PRAGMA table_info(${table})`).all();
+    if (definition.find((entry) => entry.name === column)?.notnull !== 1) {
+      throw new Error(`PR-group schema integrity failure: ${table}.${column} is not NOT NULL`);
+    }
+  }
+  const eventColumns = db.query("PRAGMA table_info(pr_group_events)").all();
+  if (!eventColumns.some((entry) => entry.name === "ci_proof")) {
+    throw new Error("PR-group schema integrity failure: pr_group_events.ci_proof is missing");
+  }
+  const receiptIndexes = db.query("PRAGMA index_list(pr_group_events)").all();
+  const hasGlobalReceiptUniqueness = receiptIndexes.some((index) => {
+    if (index.unique !== 1)
+      return false;
+    const columns = db.query(`PRAGMA index_info(${JSON.stringify(index.name)})`).all();
+    return columns.length === 1 && columns[0]?.name === "receipt_key";
+  });
+  if (!hasGlobalReceiptUniqueness) {
+    throw new Error("PR-group schema integrity failure: receipt_key is not globally unique");
+  }
+  const strictMigration = db.query("SELECT 1 AS ok FROM _migrations WHERE id = 68").get();
+  if (strictMigration?.ok !== 1) {
+    throw new Error("PR-group schema integrity failure: migration 68 is not recorded");
+  }
 }
 function backfillTaskTags(db) {
   try {
@@ -2732,6 +3423,334 @@ var init_machines = __esm(() => {
   ];
 });
 
+// src/types/index.ts
+var TASK_STATUSES, TASK_PRIORITIES, PLAN_STATUSES, VersionConflictError, TaskNotFoundError, ProjectNotFoundError, ResourceConflictError, PlanNotFoundError, LockError, AgentNotFoundError, IdentityAliasAmbiguousError, IdentityIdImmutableError, TaskListNotFoundError, DependencyCycleError, CompletionGuardError, DISPATCH_STATUSES, DispatchNotFoundError;
+var init_types = __esm(() => {
+  TASK_STATUSES = [
+    "pending",
+    "in_progress",
+    "completed",
+    "failed",
+    "cancelled"
+  ];
+  TASK_PRIORITIES = [
+    "low",
+    "medium",
+    "high",
+    "critical"
+  ];
+  PLAN_STATUSES = ["active", "completed", "archived"];
+  VersionConflictError = class VersionConflictError extends Error {
+    taskId;
+    expectedVersion;
+    actualVersion;
+    static code = "VERSION_CONFLICT";
+    static suggestion = "Fetch the task with get_task to get the current version before updating.";
+    constructor(taskId, expectedVersion, actualVersion) {
+      super(`Version conflict for task ${taskId}: expected ${expectedVersion}, got ${actualVersion}`);
+      this.taskId = taskId;
+      this.expectedVersion = expectedVersion;
+      this.actualVersion = actualVersion;
+      this.name = "VersionConflictError";
+    }
+  };
+  TaskNotFoundError = class TaskNotFoundError extends Error {
+    taskId;
+    static code = "TASK_NOT_FOUND";
+    static suggestion = "Verify the task ID. Use list_tasks or search_tasks to find the correct ID.";
+    constructor(taskId) {
+      super(`Task not found: ${taskId}`);
+      this.taskId = taskId;
+      this.name = "TaskNotFoundError";
+    }
+  };
+  ProjectNotFoundError = class ProjectNotFoundError extends Error {
+    projectId;
+    static code = "PROJECT_NOT_FOUND";
+    static suggestion = "Use list_projects to see available projects.";
+    constructor(projectId) {
+      super(`Project not found: ${projectId}`);
+      this.projectId = projectId;
+      this.name = "ProjectNotFoundError";
+    }
+  };
+  ResourceConflictError = class ResourceConflictError extends Error {
+    code;
+    constructor(code, message) {
+      super(message);
+      this.code = code;
+      this.name = "ResourceConflictError";
+    }
+  };
+  PlanNotFoundError = class PlanNotFoundError extends Error {
+    planId;
+    static code = "PLAN_NOT_FOUND";
+    static suggestion = "Use list_plans to see available plans.";
+    constructor(planId) {
+      super(`Plan not found: ${planId}`);
+      this.planId = planId;
+      this.name = "PlanNotFoundError";
+    }
+  };
+  LockError = class LockError extends Error {
+    taskId;
+    lockedBy;
+    static code = "LOCK_ERROR";
+    static suggestion = "Wait for the lock to expire (30 min) or contact the lock holder.";
+    constructor(taskId, lockedBy) {
+      super(`Task ${taskId} is locked by ${lockedBy}`);
+      this.taskId = taskId;
+      this.lockedBy = lockedBy;
+      this.name = "LockError";
+    }
+  };
+  AgentNotFoundError = class AgentNotFoundError extends Error {
+    agentId;
+    static code = "AGENT_NOT_FOUND";
+    static suggestion = "Use register_agent to create the agent first, or list_agents to find existing ones.";
+    constructor(agentId) {
+      super(`Agent not found: ${agentId}`);
+      this.agentId = agentId;
+      this.name = "AgentNotFoundError";
+    }
+  };
+  IdentityAliasAmbiguousError = class IdentityAliasAmbiguousError extends Error {
+    code = "IDENTITY_ALIAS_AMBIGUOUS";
+    candidates;
+    constructor(subject, candidates = []) {
+      super(`Identity alias or source is ambiguous: ${subject}`);
+      this.name = "IdentityAliasAmbiguousError";
+      this.candidates = [...new Set(candidates)].sort();
+    }
+  };
+  IdentityIdImmutableError = class IdentityIdImmutableError extends Error {
+    code = "IDENTITY_ID_IMMUTABLE";
+    constructor(agentId) {
+      super(`IDENTITY_ID_IMMUTABLE: canonical identity for agent ${agentId} cannot be replaced`);
+      this.name = "IdentityIdImmutableError";
+    }
+  };
+  TaskListNotFoundError = class TaskListNotFoundError extends Error {
+    taskListId;
+    static code = "TASK_LIST_NOT_FOUND";
+    static suggestion = "Use list_task_lists to see available lists.";
+    constructor(taskListId) {
+      super(`Task list not found: ${taskListId}`);
+      this.taskListId = taskListId;
+      this.name = "TaskListNotFoundError";
+    }
+  };
+  DependencyCycleError = class DependencyCycleError extends Error {
+    taskId;
+    dependsOn;
+    static code = "DEPENDENCY_CYCLE";
+    static suggestion = "Check the dependency chain with get_task to avoid circular references.";
+    constructor(taskId, dependsOn) {
+      super(`Adding dependency ${taskId} -> ${dependsOn} would create a cycle`);
+      this.taskId = taskId;
+      this.dependsOn = dependsOn;
+      this.name = "DependencyCycleError";
+    }
+  };
+  CompletionGuardError = class CompletionGuardError extends Error {
+    reason;
+    retryAfterSeconds;
+    static code = "COMPLETION_BLOCKED";
+    static suggestion = "Wait for the cooldown period, then retry.";
+    constructor(reason, retryAfterSeconds) {
+      super(reason);
+      this.reason = reason;
+      this.retryAfterSeconds = retryAfterSeconds;
+      this.name = "CompletionGuardError";
+    }
+  };
+  DISPATCH_STATUSES = ["pending", "sent", "failed", "cancelled"];
+  DispatchNotFoundError = class DispatchNotFoundError extends Error {
+    dispatchId;
+    static code = "DISPATCH_NOT_FOUND";
+    static suggestion = "Check the dispatch ID with list_dispatches.";
+    constructor(dispatchId) {
+      super(`Dispatch not found: ${dispatchId}`);
+      this.dispatchId = dispatchId;
+      this.name = "DispatchNotFoundError";
+    }
+  };
+});
+
+// src/db/identity-mapping.ts
+function timestamp() {
+  return new Date().toISOString();
+}
+function mappingId() {
+  return crypto.randomUUID();
+}
+function normalizedAlias(label) {
+  const normalized = label.trim().toLocaleLowerCase("en-US");
+  if (!normalized)
+    throw new Error("IDENTITY_ALIAS_INVALID: label is required");
+  return normalized;
+}
+function ensureColumn(db, table, column, type) {
+  const columns = db.query(`PRAGMA table_info(${table})`).all();
+  if (!columns.some((item) => item.name === column)) {
+    db.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${type}`);
+  }
+}
+function ensureAgentIdentitySchema(db) {
+  const install = db.transaction(() => {
+    ensureColumn(db, "agents", "identity_id", "TEXT");
+    ensureColumn(db, "agents", "project_id", "TEXT");
+    ensureColumn(db, "agents", "runtime_instance_id", "TEXT");
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS agent_identity_source_mappings (
+        id TEXT PRIMARY KEY,
+        local_agent_id TEXT REFERENCES agents(id) ON DELETE RESTRICT,
+        identity_id TEXT,
+        source_authority TEXT NOT NULL CHECK(length(trim(source_authority)) > 0),
+        source_tenant_id TEXT NOT NULL CHECK(length(trim(source_tenant_id)) > 0),
+        source_namespace TEXT NOT NULL CHECK(length(trim(source_namespace)) > 0),
+        source_entity_type TEXT NOT NULL CHECK(length(trim(source_entity_type)) > 0),
+        source_record_id TEXT NOT NULL CHECK(length(trim(source_record_id)) > 0),
+        observed_label TEXT,
+        evidence TEXT NOT NULL DEFAULT '{}',
+        mapping_basis TEXT NOT NULL CHECK(mapping_basis IN ('authoritative', 'imported', 'candidate', 'name_similarity')),
+        status TEXT NOT NULL CHECK(status IN ('active', 'retired', 'quarantined', 'revoked')),
+        revision INTEGER NOT NULL CHECK(revision > 0),
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        CHECK(mapping_basis IN ('authoritative', 'imported') OR status IN ('quarantined', 'revoked')),
+        CHECK(status != 'active' OR (mapping_basis IN ('authoritative', 'imported') AND identity_id IS NOT NULL))
+      );
+    `);
+    ensureColumn(db, "agent_identity_source_mappings", "revision", "INTEGER NOT NULL DEFAULT 1");
+    ensureColumn(db, "agent_identity_source_mappings", "evidence", "TEXT NOT NULL DEFAULT '{}'");
+    db.exec(`
+      DROP INDEX IF EXISTS idx_agent_identity_source_active_unique;
+      CREATE UNIQUE INDEX IF NOT EXISTS idx_agent_identity_source_revision_unique
+        ON agent_identity_source_mappings (
+          source_authority, source_tenant_id, source_namespace, source_entity_type, source_record_id, revision
+        )
+        WHERE mapping_basis IN ('authoritative', 'imported');
+      CREATE INDEX IF NOT EXISTS idx_agent_identity_source_identity
+        ON agent_identity_source_mappings(identity_id);
+      CREATE INDEX IF NOT EXISTS idx_agent_identity_source_local
+        ON agent_identity_source_mappings(local_agent_id);
+      DROP INDEX IF EXISTS idx_agents_identity_unique;
+
+      CREATE TABLE IF NOT EXISTS agent_identity_aliases (
+        id TEXT PRIMARY KEY,
+        local_agent_id TEXT NOT NULL REFERENCES agents(id) ON DELETE RESTRICT,
+        label TEXT NOT NULL,
+        normalized_label TEXT NOT NULL,
+        alias_kind TEXT NOT NULL CHECK(alias_kind IN ('historical', 'candidate')),
+        status TEXT NOT NULL CHECK(status IN ('active', 'quarantined', 'revoked')),
+        created_at TEXT NOT NULL,
+        UNIQUE(local_agent_id, normalized_label)
+      );
+      CREATE INDEX IF NOT EXISTS idx_agent_identity_alias_lookup
+        ON agent_identity_aliases(normalized_label, status);
+
+      CREATE TRIGGER IF NOT EXISTS trg_agents_identity_id_immutable
+      BEFORE UPDATE OF identity_id ON agents
+      WHEN OLD.identity_id IS NOT NULL AND OLD.identity_id IS NOT NEW.identity_id
+      BEGIN
+        SELECT RAISE(ABORT, 'IDENTITY_ID_IMMUTABLE');
+      END;
+
+      CREATE TRIGGER IF NOT EXISTS trg_agent_identity_mapping_identity_immutable
+      BEFORE UPDATE OF identity_id ON agent_identity_source_mappings
+      WHEN OLD.identity_id IS NOT NEW.identity_id
+      BEGIN
+        SELECT RAISE(ABORT, 'IDENTITY_ID_IMMUTABLE');
+      END;
+
+      CREATE TRIGGER IF NOT EXISTS trg_agent_identity_mapping_lineage_immutable
+      BEFORE UPDATE OF source_authority, source_tenant_id, source_namespace, source_entity_type, source_record_id
+        ON agent_identity_source_mappings
+      WHEN OLD.source_authority IS NOT NEW.source_authority
+        OR OLD.source_tenant_id IS NOT NEW.source_tenant_id
+        OR OLD.source_namespace IS NOT NEW.source_namespace
+        OR OLD.source_entity_type IS NOT NEW.source_entity_type
+        OR OLD.source_record_id IS NOT NEW.source_record_id
+      BEGIN
+        SELECT RAISE(ABORT, 'IDENTITY_SOURCE_LINEAGE_IMMUTABLE');
+      END;
+
+      DROP TRIGGER IF EXISTS trg_agent_identity_mapping_history_immutable;
+      CREATE TRIGGER trg_agent_identity_mapping_history_immutable
+      BEFORE UPDATE OF local_agent_id, observed_label, evidence, mapping_basis, status, revision, created_at
+        ON agent_identity_source_mappings
+      BEGIN
+        SELECT RAISE(ABORT, 'IDENTITY_MAPPING_HISTORY_IMMUTABLE');
+      END;
+
+      DROP TRIGGER IF EXISTS trg_agent_identity_mapping_history_append_only;
+      CREATE TRIGGER trg_agent_identity_mapping_history_append_only
+      BEFORE DELETE ON agent_identity_source_mappings
+      BEGIN
+        SELECT RAISE(ABORT, 'IDENTITY_MAPPING_HISTORY_IMMUTABLE');
+      END;
+    `);
+    db.run("INSERT OR IGNORE INTO _migrations (id) VALUES (?)", [IDENTITY_MIGRATION_ID]);
+  });
+  install.immediate();
+}
+function storeAgentAliasInCurrentTransaction(agentId, label, aliasKind, status, db) {
+  const normalized = normalizedAlias(label);
+  const exists = db.query("SELECT id FROM agents WHERE id = ?").get(agentId);
+  if (!exists)
+    throw new Error(`Agent not found: ${agentId}`);
+  const existing = db.query(`
+    SELECT * FROM agent_identity_aliases
+    WHERE local_agent_id = ? AND normalized_label = ?
+  `).get(agentId, normalized);
+  if (existing) {
+    if (aliasKind === "historical" && (existing.alias_kind !== "historical" || existing.status !== "active")) {
+      db.run("UPDATE agent_identity_aliases SET label = ?, alias_kind = 'historical', status = 'active' WHERE id = ?", [label.trim(), existing.id]);
+      return db.query("SELECT * FROM agent_identity_aliases WHERE id = ?").get(existing.id);
+    }
+    return existing;
+  }
+  const id = mappingId();
+  db.run(`
+    INSERT INTO agent_identity_aliases (
+      id, local_agent_id, label, normalized_label, alias_kind, status, created_at
+    ) VALUES (?, ?, ?, ?, ?, ?, ?)
+  `, [id, agentId, label.trim(), normalized, aliasKind, status, timestamp()]);
+  return db.query("SELECT * FROM agent_identity_aliases WHERE id = ?").get(id);
+}
+function storeAgentAlias(agentId, label, aliasKind, status, db) {
+  if (db.inTransaction) {
+    return storeAgentAliasInCurrentTransaction(agentId, label, aliasKind, status, db);
+  }
+  const store = db.transaction(() => storeAgentAliasInCurrentTransaction(agentId, label, aliasKind, status, db));
+  return store.immediate();
+}
+function recordAgentAlias(agentId, label, db) {
+  return storeAgentAlias(agentId, label, "historical", "active", db);
+}
+var IDENTITY_PROJECTION_CONTRACT, IDENTITY_MIGRATION_ID = 65;
+var init_identity_mapping = __esm(() => {
+  init_types();
+  init_types();
+  IDENTITY_PROJECTION_CONTRACT = Object.freeze({
+    name: "hasna.todos.agent-identity-projection/v1",
+    version: 1,
+    foundation_repository: "hasna/identities",
+    foundation_pull_request: 14,
+    foundation_contract: "hasna.identities.agent-identity/v1",
+    foundation_version: 1,
+    foundation_commit: "14d83e3e45df5748944a871a07c4aacece893169",
+    foundation_fixture_id: "hasna.identities.agent-identity/v1/conformance/1",
+    foundation_fixture_source_path: "docs/fixtures/agent-identity-v1.conformance.json",
+    foundation_fixture_local_path: "src/db/fixtures/agent-identity-v1.conformance.json",
+    foundation_fixture_sha256: "sha256:2d22e72b7315d0b06b3c67c71674cfd8c2dff552727eea00efb325f52c9420af",
+    foundation_default_read_preference: "canonical_first",
+    consumer_rollout_default_read_preference: "legacy_first",
+    lease_fence_authority: "external Runtime Coordination"
+  });
+});
+
 // src/storage/config.ts
 var exports_config = {};
 __export(exports_config, {
@@ -2755,15 +3774,15 @@ __export(exports_config, {
   TODOS_STORAGE_FALLBACK_ENV: () => TODOS_STORAGE_FALLBACK_ENV,
   TODOS_STORAGE_ENV: () => TODOS_STORAGE_ENV,
   STORAGE_TABLES: () => STORAGE_TABLES,
-  CANONICAL_TODOS_RDS_RUNTIME_PATH: () => CANONICAL_TODOS_RDS_RUNTIME_PATH,
+  CANONICAL_TODOS_RDS_RUNTIME_PATH_ENV: () => CANONICAL_TODOS_RDS_RUNTIME_PATH_ENV,
   CANONICAL_TODOS_RDS_DATABASE: () => CANONICAL_TODOS_RDS_DATABASE,
-  CANONICAL_TODOS_RDS_CLUSTER: () => CANONICAL_TODOS_RDS_CLUSTER
+  CANONICAL_TODOS_RDS_CLUSTER_ENV: () => CANONICAL_TODOS_RDS_CLUSTER_ENV
 });
-function getCanonicalTodosRdsConfig() {
+function getCanonicalTodosRdsConfig(env = process.env) {
   return {
-    cluster: CANONICAL_TODOS_RDS_CLUSTER,
+    cluster: clean(env[CANONICAL_TODOS_RDS_CLUSTER_ENV]) ?? null,
     database: CANONICAL_TODOS_RDS_DATABASE,
-    runtimeSecretPath: CANONICAL_TODOS_RDS_RUNTIME_PATH,
+    runtimeSecretPath: clean(env[CANONICAL_TODOS_RDS_RUNTIME_PATH_ENV]) ?? null,
     primaryEnv: TODOS_STORAGE_ENV.databaseUrl,
     fallbackEnv: TODOS_STORAGE_FALLBACK_ENV.databaseUrl
   };
@@ -2896,7 +3915,7 @@ function parsePositiveInteger(value, fallback) {
   }
   return parsed;
 }
-var TODOS_STORAGE_TABLES, STORAGE_TABLES, TODOS_STORAGE_ENV, TODOS_STORAGE_FALLBACK_ENV, CANONICAL_TODOS_RDS_CLUSTER = "hasna-xyz-infra-apps-prod-postgres", CANONICAL_TODOS_RDS_DATABASE = "todos", CANONICAL_TODOS_RDS_RUNTIME_PATH = "hasna/xyz/opensource/todos/prod/rds";
+var TODOS_STORAGE_TABLES, STORAGE_TABLES, TODOS_STORAGE_ENV, TODOS_STORAGE_FALLBACK_ENV, CANONICAL_TODOS_RDS_CLUSTER_ENV = "HASNA_TODOS_RDS_CLUSTER", CANONICAL_TODOS_RDS_RUNTIME_PATH_ENV = "HASNA_TODOS_RDS_RUNTIME_PATH", CANONICAL_TODOS_RDS_DATABASE = "todos";
 var init_config = __esm(() => {
   TODOS_STORAGE_TABLES = [
     "todos_sync_records",
@@ -2958,7 +3977,7 @@ function installShadowOutboxSchema(db) {
     status TEXT NOT NULL DEFAULT 'pending',
     revision INTEGER NOT NULL DEFAULT 0
   )`);
-  ensureColumn(db, "shadow_outbox", "revision", "INTEGER NOT NULL DEFAULT 0");
+  ensureColumn2(db, "shadow_outbox", "revision", "INTEGER NOT NULL DEFAULT 0");
   db.run(`CREATE UNIQUE INDEX IF NOT EXISTS shadow_outbox_pending_uq
        ON shadow_outbox(object_type, object_id) WHERE status='pending'`);
   db.run(`CREATE INDEX IF NOT EXISTS shadow_outbox_ready_idx
@@ -2980,7 +3999,7 @@ function installShadowOutboxSchema(db) {
     }
   }
 }
-function ensureColumn(db, table, column, definition) {
+function ensureColumn2(db, table, column, definition) {
   const rows = db.query(`PRAGMA table_info(${table})`).all();
   if (rows.some((row) => row.name === column))
     return;
@@ -3108,6 +4127,7 @@ function openDatabase(path) {
   db.run("PRAGMA busy_timeout = 5000");
   db.run("PRAGMA foreign_keys = ON");
   runMigrations(db);
+  ensureAgentIdentitySchema(db);
   backfillTaskTags(db);
   backfillMachineId(db);
   maybeInstallShadowCapture(db);
@@ -3186,185 +4206,59 @@ function resolvePartialId(db, table, partialId) {
   if (rows.length === 1) {
     return rows[0].id;
   }
-  if (rows.length > 1) {
-    return null;
-  }
-  if (table === "tasks") {
-    const shortIdRows = db.query("SELECT id FROM tasks WHERE short_id = ?").all(partialId);
-    if (shortIdRows.length === 1) {
-      return shortIdRows[0].id;
-    }
-  }
-  if (table === "task_lists") {
-    const slugRow = db.query("SELECT id FROM task_lists WHERE slug = ?").get(partialId);
-    if (slugRow)
-      return slugRow.id;
-  }
-  if (table === "plans") {
-    const slug = slugifyRef(partialId);
-    if (slug) {
-      const slugRows = db.query("SELECT id FROM plans WHERE slug = ?").all(slug);
-      if (slugRows.length === 1)
-        return slugRows[0].id;
-      if (slugRows.length > 1)
-        return null;
-    }
-  }
-  if (table === "projects") {
-    const nameRow = db.query("SELECT id FROM projects WHERE lower(name) = ?").get(partialId.toLowerCase());
-    if (nameRow)
-      return nameRow.id;
-  }
-  if (table === "agents") {
-    const nameRow = db.query("SELECT id FROM agents WHERE lower(name) = ?").get(partialId.toLowerCase());
-    if (nameRow)
-      return nameRow.id;
-  }
-  return null;
-}
-var LOCK_EXPIRY_MINUTES = 30, _db = null, _dbPath = null, ALLOWED_TABLES;
-var init_database = __esm(() => {
-  init_schema();
-  init_machines();
-  ALLOWED_TABLES = new Set(["tasks", "projects", "agents", "plans", "task_lists", "task_templates", "project_knowledge_records", "project_risks", "local_retrospectives"]);
-});
-
-// src/types/index.ts
-var TASK_STATUSES, TASK_PRIORITIES, PLAN_STATUSES, VersionConflictError, TaskNotFoundError, ProjectNotFoundError, ResourceConflictError, PlanNotFoundError, LockError, AgentNotFoundError, TaskListNotFoundError, DependencyCycleError, CompletionGuardError, DISPATCH_STATUSES, DispatchNotFoundError;
-var init_types = __esm(() => {
-  TASK_STATUSES = [
-    "pending",
-    "in_progress",
-    "completed",
-    "failed",
-    "cancelled"
-  ];
-  TASK_PRIORITIES = [
-    "low",
-    "medium",
-    "high",
-    "critical"
-  ];
-  PLAN_STATUSES = ["active", "completed", "archived"];
-  VersionConflictError = class VersionConflictError extends Error {
-    taskId;
-    expectedVersion;
-    actualVersion;
-    static code = "VERSION_CONFLICT";
-    static suggestion = "Fetch the task with get_task to get the current version before updating.";
-    constructor(taskId, expectedVersion, actualVersion) {
-      super(`Version conflict for task ${taskId}: expected ${expectedVersion}, got ${actualVersion}`);
-      this.taskId = taskId;
-      this.expectedVersion = expectedVersion;
-      this.actualVersion = actualVersion;
-      this.name = "VersionConflictError";
-    }
-  };
-  TaskNotFoundError = class TaskNotFoundError extends Error {
-    taskId;
-    static code = "TASK_NOT_FOUND";
-    static suggestion = "Verify the task ID. Use list_tasks or search_tasks to find the correct ID.";
-    constructor(taskId) {
-      super(`Task not found: ${taskId}`);
-      this.taskId = taskId;
-      this.name = "TaskNotFoundError";
-    }
-  };
-  ProjectNotFoundError = class ProjectNotFoundError extends Error {
-    projectId;
-    static code = "PROJECT_NOT_FOUND";
-    static suggestion = "Use list_projects to see available projects.";
-    constructor(projectId) {
-      super(`Project not found: ${projectId}`);
-      this.projectId = projectId;
-      this.name = "ProjectNotFoundError";
-    }
-  };
-  ResourceConflictError = class ResourceConflictError extends Error {
-    code;
-    constructor(code, message) {
-      super(message);
-      this.code = code;
-      this.name = "ResourceConflictError";
-    }
-  };
-  PlanNotFoundError = class PlanNotFoundError extends Error {
-    planId;
-    static code = "PLAN_NOT_FOUND";
-    static suggestion = "Use list_plans to see available plans.";
-    constructor(planId) {
-      super(`Plan not found: ${planId}`);
-      this.planId = planId;
-      this.name = "PlanNotFoundError";
-    }
-  };
-  LockError = class LockError extends Error {
-    taskId;
-    lockedBy;
-    static code = "LOCK_ERROR";
-    static suggestion = "Wait for the lock to expire (30 min) or contact the lock holder.";
-    constructor(taskId, lockedBy) {
-      super(`Task ${taskId} is locked by ${lockedBy}`);
-      this.taskId = taskId;
-      this.lockedBy = lockedBy;
-      this.name = "LockError";
-    }
-  };
-  AgentNotFoundError = class AgentNotFoundError extends Error {
-    agentId;
-    static code = "AGENT_NOT_FOUND";
-    static suggestion = "Use register_agent to create the agent first, or list_agents to find existing ones.";
-    constructor(agentId) {
-      super(`Agent not found: ${agentId}`);
-      this.agentId = agentId;
-      this.name = "AgentNotFoundError";
-    }
-  };
-  TaskListNotFoundError = class TaskListNotFoundError extends Error {
-    taskListId;
-    static code = "TASK_LIST_NOT_FOUND";
-    static suggestion = "Use list_task_lists to see available lists.";
-    constructor(taskListId) {
-      super(`Task list not found: ${taskListId}`);
-      this.taskListId = taskListId;
-      this.name = "TaskListNotFoundError";
-    }
-  };
-  DependencyCycleError = class DependencyCycleError extends Error {
-    taskId;
-    dependsOn;
-    static code = "DEPENDENCY_CYCLE";
-    static suggestion = "Check the dependency chain with get_task to avoid circular references.";
-    constructor(taskId, dependsOn) {
-      super(`Adding dependency ${taskId} -> ${dependsOn} would create a cycle`);
-      this.taskId = taskId;
-      this.dependsOn = dependsOn;
-      this.name = "DependencyCycleError";
-    }
-  };
-  CompletionGuardError = class CompletionGuardError extends Error {
-    reason;
-    retryAfterSeconds;
-    static code = "COMPLETION_BLOCKED";
-    static suggestion = "Wait for the cooldown period, then retry.";
-    constructor(reason, retryAfterSeconds) {
-      super(reason);
-      this.reason = reason;
-      this.retryAfterSeconds = retryAfterSeconds;
-      this.name = "CompletionGuardError";
+  if (rows.length > 1) {
+    return null;
+  }
+  if (table === "tasks") {
+    const shortIdRows = db.query("SELECT id FROM tasks WHERE short_id = ?").all(partialId);
+    if (shortIdRows.length === 1) {
+      return shortIdRows[0].id;
     }
-  };
-  DISPATCH_STATUSES = ["pending", "sent", "failed", "cancelled"];
-  DispatchNotFoundError = class DispatchNotFoundError extends Error {
-    dispatchId;
-    static code = "DISPATCH_NOT_FOUND";
-    static suggestion = "Check the dispatch ID with list_dispatches.";
-    constructor(dispatchId) {
-      super(`Dispatch not found: ${dispatchId}`);
-      this.dispatchId = dispatchId;
-      this.name = "DispatchNotFoundError";
+  }
+  if (table === "task_lists") {
+    const slugRow = db.query("SELECT id FROM task_lists WHERE slug = ?").get(partialId);
+    if (slugRow)
+      return slugRow.id;
+  }
+  if (table === "plans") {
+    const slug = slugifyRef(partialId);
+    if (slug) {
+      const slugRows = db.query("SELECT id FROM plans WHERE slug = ?").all(slug);
+      if (slugRows.length === 1)
+        return slugRows[0].id;
+      if (slugRows.length > 1)
+        return null;
     }
-  };
+  }
+  if (table === "projects") {
+    const nameRow = db.query("SELECT id FROM projects WHERE lower(name) = ?").get(partialId.toLowerCase());
+    if (nameRow)
+      return nameRow.id;
+  }
+  if (table === "agents") {
+    const normalized = partialId.trim().toLowerCase();
+    const matches = db.query(`
+      SELECT id FROM agents WHERE lower(name) = ?
+      UNION
+      SELECT local_agent_id AS id FROM agent_identity_aliases
+        WHERE normalized_label = ? AND status = 'active'
+      ORDER BY id
+    `).all(normalized, normalized);
+    if (matches.length === 1)
+      return matches[0].id;
+    if (matches.length > 1) {
+      throw new IdentityAliasAmbiguousError(partialId, matches.map((match) => match.id));
+    }
+  }
+  return null;
+}
+var LOCK_EXPIRY_MINUTES = 30, _db = null, _dbPath = null, ALLOWED_TABLES;
+var init_database = __esm(() => {
+  init_schema();
+  init_machines();
+  init_identity_mapping();
+  init_types();
+  ALLOWED_TABLES = new Set(["tasks", "projects", "agents", "plans", "task_lists", "task_templates", "project_knowledge_records", "project_risks", "local_retrospectives"]);
 });
 
 // src/lib/sync-utils.ts
@@ -3706,7 +4600,7 @@ function createProject(input, db) {
   const d = db || getDatabase();
   return d.transaction(() => {
     const id = uuid();
-    const timestamp = now();
+    const timestamp2 = now();
     const derivedSlug = slugify(input.name);
     const taskListId = input.task_list_id === undefined ? `todos-${derivedSlug}` : slugify(input.task_list_id);
     if (!derivedSlug || !taskListId)
@@ -3718,7 +4612,7 @@ function createProject(input, db) {
     const taskPrefix = input.task_prefix || generatePrefix(input.name, d);
     const machineId = currentStorageMachineId(d);
     d.run(`INSERT INTO projects (id, name, path, description, task_list_id, task_prefix, task_counter, created_at, updated_at, machine_id)
-       VALUES (?, ?, ?, ?, ?, ?, 0, ?, ?, ?)`, [id, input.name, input.path, input.description || null, taskListId, taskPrefix, timestamp, timestamp, machineId]);
+       VALUES (?, ?, ?, ?, ?, ?, 0, ?, ?, ?)`, [id, input.name, input.path, input.description || null, taskListId, taskPrefix, timestamp2, timestamp2, machineId]);
     return getProject(id, d);
   })();
 }
@@ -3831,7 +4725,7 @@ function rowToSource(row) {
 function addProjectSource(input, db) {
   const d = db || getDatabase();
   const id = uuid();
-  const timestamp = now();
+  const timestamp2 = now();
   d.run(`INSERT INTO project_sources (id, project_id, type, name, uri, description, metadata, created_at, updated_at)
      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
     id,
@@ -3841,8 +4735,8 @@ function addProjectSource(input, db) {
     input.uri,
     input.description || null,
     JSON.stringify(input.metadata || {}),
-    timestamp,
-    timestamp
+    timestamp2,
+    timestamp2
   ]);
   return rowToSource(d.query("SELECT * FROM project_sources WHERE id = ?").get(id));
 }
@@ -4060,6 +4954,11 @@ function customPatterns() {
 function secretPatterns() {
   return [...customPatterns(), ...DEFAULT_SECRET_PATTERNS];
 }
+function isRedactionPlaceholderMatch(match) {
+  const placeholder = String.raw`\[REDACTED(?:_[A-Z_]+)?\]`;
+  const trimmed = match.trim();
+  return new RegExp(`^${placeholder}$`).test(trimmed) || new RegExp(`=\\s*['"]?${placeholder}['"]?$`).test(trimmed);
+}
 function isSecretKey(key) {
   if (NON_SECRET_USAGE_KEYS.has(key.toLowerCase()))
     return false;
@@ -4097,7 +4996,7 @@ function redactValue(value) {
 function listSecretFindings(value) {
   const findings = [];
   for (const pattern of secretPatterns()) {
-    const matches = value.match(cloneRegex(pattern.regex));
+    const matches = value.match(cloneRegex(pattern.regex))?.filter((match) => !isRedactionPlaceholderMatch(match));
     if (matches?.length)
       findings.push({ pattern: pattern.name, count: matches.length });
   }
@@ -4128,6 +5027,9 @@ var init_redaction = __esm(() => {
     { 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]" }
   ];
@@ -4202,7 +5104,7 @@ function upsertWorkspaceTrustProfile(input) {
   const preset = input.preset || existing?.preset || "standard";
   const presetChanged = Boolean(existing && input.preset && input.preset !== existing.preset);
   const base = presetChanged ? defaultProfile(root, preset) : existing || defaultProfile(root, preset);
-  const timestamp = new Date().toISOString();
+  const timestamp2 = new Date().toISOString();
   const profile = {
     ...base,
     ...PRESET_DEFAULTS[preset],
@@ -4215,8 +5117,8 @@ function upsertWorkspaceTrustProfile(input) {
     write_scopes: unique2(input.write_scopes ?? base.write_scopes ?? PRESET_DEFAULTS[preset].write_scopes),
     env_redactions: unique2(input.env_redactions ?? base.env_redactions ?? PRESET_DEFAULTS[preset].env_redactions),
     require_prompt_for_unsafe: input.require_prompt_for_unsafe ?? base.require_prompt_for_unsafe ?? PRESET_DEFAULTS[preset].require_prompt_for_unsafe,
-    created_at: existing?.created_at || timestamp,
-    updated_at: timestamp
+    created_at: existing?.created_at || timestamp2,
+    updated_at: timestamp2
   };
   saveConfig({
     ...config,
@@ -4417,7 +5319,7 @@ function upsertRunnerSandboxProfile(input) {
   const existing = config.runner_sandboxes?.[input.name];
   const root = normalizePath2(input.root || existing?.root || process.cwd());
   const base = existing || defaultProfile2(input.name, root);
-  const timestamp = new Date().toISOString();
+  const timestamp2 = new Date().toISOString();
   const profile = {
     ...base,
     name: input.name,
@@ -4431,8 +5333,8 @@ function upsertRunnerSandboxProfile(input) {
     network_policy: input.network_policy || base.network_policy,
     require_approval: input.require_approval ?? base.require_approval,
     audit_evidence: input.audit_evidence ?? base.audit_evidence,
-    created_at: existing?.created_at || timestamp,
-    updated_at: timestamp
+    created_at: existing?.created_at || timestamp2,
+    updated_at: timestamp2
   };
   saveConfig({
     ...config,
@@ -4549,7 +5451,7 @@ function normalizeHook(input, existing) {
     throw new Error("socket event hooks require socket_path");
   if (input.target === "script" && !input.command && !existing?.command)
     throw new Error("script event hooks require command");
-  const timestamp = new Date().toISOString();
+  const timestamp2 = new Date().toISOString();
   return {
     ...existing,
     name: safeName(input.name),
@@ -4566,8 +5468,8 @@ function normalizeHook(input, existing) {
       attempts: clampAttempts(input.retry?.attempts ?? existing?.retry?.attempts ?? 1),
       backoff_ms: Math.max(0, input.retry?.backoff_ms ?? existing?.retry?.backoff_ms ?? 0)
     },
-    created_at: existing?.created_at || timestamp,
-    updated_at: timestamp
+    created_at: existing?.created_at || timestamp2,
+    updated_at: timestamp2
   };
 }
 function clampAttempts(value) {
@@ -4581,11 +5483,11 @@ function eventMatches(hook, eventType) {
 function canonicalEvent(input) {
   return JSON.stringify(input);
 }
-function buildEnvelope(type, payload, timestamp = new Date().toISOString()) {
+function buildEnvelope(type, payload, timestamp2 = new Date().toISOString()) {
   const base = {
     id: randomUUID(),
     type,
-    timestamp,
+    timestamp: timestamp2,
     payload: redactValue(payload ?? {}),
     source: { package: "@hasna/todos", local_only: true }
   };
@@ -4999,11 +5901,11 @@ class JsonEventsStore {
     });
   }
 }
-function buildSignatureBase(timestamp, body) {
-  return `${timestamp}.${body}`;
+function buildSignatureBase(timestamp2, body) {
+  return `${timestamp2}.${body}`;
 }
-function signPayload(secret, timestamp, body) {
-  const digest = createHmac("sha256", secret).update(buildSignatureBase(timestamp, body)).digest("hex");
+function signPayload(secret, timestamp2, body) {
+  const digest = createHmac("sha256", secret).update(buildSignatureBase(timestamp2, body)).digest("hex");
   return `sha256=${digest}`;
 }
 function now2() {
@@ -5016,17 +5918,17 @@ function buildWebhookRequest(event, channel) {
   if (!channel.webhook)
     throw new Error(`Channel ${channel.id} has no webhook config`);
   const body = JSON.stringify(event);
-  const timestamp = event.time;
+  const timestamp2 = event.time;
   const headers = {
     "Content-Type": "application/json",
     "User-Agent": "@hasna/events",
     "X-Hasna-Event-Id": event.id,
     "X-Hasna-Event-Type": event.type,
-    "X-Hasna-Timestamp": timestamp,
+    "X-Hasna-Timestamp": timestamp2,
     ...channel.webhook.headers
   };
   if (channel.webhook.secret) {
-    headers["X-Hasna-Signature"] = signPayload(channel.webhook.secret, timestamp, body);
+    headers["X-Hasna-Signature"] = signPayload(channel.webhook.secret, timestamp2, body);
   }
   return { body, headers };
 }
@@ -5180,11 +6082,11 @@ class EventsClient {
     this.transportOptions = { fetchImpl: options.fetchImpl };
   }
   async addChannel(input) {
-    const timestamp = new Date().toISOString();
+    const timestamp2 = new Date().toISOString();
     return this.store.addChannel({
       ...input,
-      createdAt: input.createdAt ?? timestamp,
-      updatedAt: input.updatedAt ?? timestamp
+      createdAt: input.createdAt ?? timestamp2,
+      updatedAt: input.updatedAt ?? timestamp2
     });
   }
   async listChannels() {
@@ -5256,12 +6158,12 @@ class EventsClient {
     const match = await this.matchChannel(id, input);
     const event = match.event;
     if (options.honorFilters && !match.matched) {
-      const timestamp = new Date().toISOString();
+      const timestamp2 = new Date().toISOString();
       const result2 = createDeliveryResult(event, channel, [{
         attempt: 1,
         status: "skipped",
-        startedAt: timestamp,
-        completedAt: timestamp,
+        startedAt: timestamp2,
+        completedAt: timestamp2,
         error: match.reason
       }]);
       result2.metadata = { reason: "filter_mismatch" };
@@ -5382,7 +6284,7 @@ function createTaskList(input, db) {
   const d = db || getDatabase();
   return d.transaction(() => {
     const id = uuid();
-    const timestamp = now();
+    const timestamp2 = now();
     const slug = normalizeSlug(input.slug === undefined ? input.name : input.slug);
     if (!slug)
       throw new Error("Invalid task-list slug \u2014 must be non-empty kebab-case");
@@ -5393,7 +6295,7 @@ function createTaskList(input, db) {
       throw new ResourceConflictError("TASK_LIST_SLUG_CONFLICT", `Task list with slug "${slug}" already exists in this scope`);
     }
     d.run(`INSERT INTO task_lists (id, project_id, slug, name, description, metadata, created_at, updated_at, machine_id)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`, [id, input.project_id || null, slug, input.name, input.description || null, JSON.stringify(input.metadata || {}), timestamp, timestamp, machineId]);
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`, [id, input.project_id || null, slug, input.name, input.description || null, JSON.stringify(input.metadata || {}), timestamp2, timestamp2, machineId]);
     return getTaskList(id, d);
   })();
 }
@@ -5866,6 +6768,110 @@ var init_secret_redaction = __esm(() => {
   customRedactors = [];
 });
 
+// src/lib/prewrite-secrets.ts
+function mergeFindings(findings) {
+  const byPattern = new Map;
+  for (const finding of findings) {
+    const existing = byPattern.get(finding.pattern);
+    if (!existing) {
+      byPattern.set(finding.pattern, {
+        pattern: finding.pattern,
+        count: finding.count,
+        lines: Array.from(new Set(finding.lines)).sort((a, b) => a - b)
+      });
+      continue;
+    }
+    existing.count += finding.count;
+    existing.lines = Array.from(new Set([...existing.lines, ...finding.lines])).sort((a, b) => a - b);
+  }
+  return [...byPattern.values()].sort((left, right) => left.pattern.localeCompare(right.pattern));
+}
+function redactPreWriteText(value) {
+  return redactText(redactEvidenceText(value));
+}
+function scanPreWriteText(value, context = "text") {
+  const redacted = redactPreWriteText(value);
+  if (redacted === value) {
+    return {
+      schema_version: PREWRITE_SECRET_SCAN_SCHEMA,
+      clean: true,
+      context,
+      findings: []
+    };
+  }
+  const structural = scanTextForSecrets(value).matches.map((match) => ({
+    pattern: match.pattern,
+    count: 1,
+    lines: match.line ? [match.line] : []
+  }));
+  const configured = listSecretFindings(value).map((finding) => ({
+    pattern: finding.pattern,
+    count: finding.count,
+    lines: []
+  }));
+  return {
+    schema_version: PREWRITE_SECRET_SCAN_SCHEMA,
+    clean: false,
+    context,
+    findings: mergeFindings([...structural, ...configured])
+  };
+}
+function assertPreWriteTextClean(value, context = "text") {
+  const scan = scanPreWriteText(value, context);
+  if (!scan.clean)
+    throw new PreWriteSecretError(context, scan.findings);
+}
+function sanitizePreWriteText(value, context = "text", options = {}) {
+  const mode = options.mode ?? "redact";
+  if (mode === "block") {
+    assertPreWriteTextClean(value, context);
+    return value;
+  }
+  return redactPreWriteText(value);
+}
+function sanitizePreWriteValue(value, context = "value", options = {}) {
+  if (typeof value === "string")
+    return sanitizePreWriteText(value, context, options);
+  if (Array.isArray(value)) {
+    return value.map((item, index) => sanitizePreWriteValue(item, `${context}[${index}]`, options));
+  }
+  if (value && typeof value === "object") {
+    const sanitized = {};
+    for (const [key, child] of Object.entries(value)) {
+      const safeKey = sanitizePreWriteText(key, `${context}.$key`, options);
+      sanitized[safeKey] = sanitizePreWriteValue(child, `${context}.${safeKey}`, options);
+    }
+    return redactValue(sanitized);
+  }
+  return value;
+}
+function sanitizePreWriteJsonString(value, context = "json") {
+  if (value === undefined || value === null)
+    return null;
+  try {
+    return JSON.stringify(sanitizePreWriteValue(JSON.parse(value), context));
+  } catch {
+    return sanitizePreWriteText(value, context);
+  }
+}
+var PREWRITE_SECRET_SCAN_SCHEMA, PreWriteSecretError;
+var init_prewrite_secrets = __esm(() => {
+  init_redaction();
+  init_secret_redaction();
+  PREWRITE_SECRET_SCAN_SCHEMA = ["todos", "prewrite_secret_scan", "v1"].join(".");
+  PreWriteSecretError = class PreWriteSecretError extends Error {
+    context;
+    findings;
+    constructor(context, findings) {
+      const summary = findings.map((finding) => `${finding.pattern}:${finding.count}`).join(", ");
+      super(`Secret pattern detected before persistence in ${context}: ${summary}`);
+      this.name = "PreWriteSecretError";
+      this.context = context;
+      this.findings = findings;
+    }
+  };
+});
+
 // src/lib/activity-audit.ts
 var exports_activity_audit = {};
 __export(exports_activity_audit, {
@@ -5914,6 +6920,9 @@ function logActivity(input, db) {
   const id = uuid();
   const ts = input.created_at ?? now();
   const machineId = input.machine_id ?? getMachineId2();
+  const oldValue = input.old_value == null ? null : sanitizePreWriteText(input.old_value, "activity.old_value");
+  const newValue = input.new_value == null ? null : sanitizePreWriteText(input.new_value, "activity.new_value");
+  const metadata = sanitizePreWriteValue(input.metadata ?? {}, "activity.metadata");
   d.run(`INSERT INTO activity_log (
       id, entity_type, entity_id, action, field, old_value, new_value,
       actor_id, session_id, machine_id, metadata, created_at
@@ -5923,12 +6932,12 @@ function logActivity(input, db) {
     input.entity_id,
     input.action,
     input.field ?? null,
-    input.old_value ?? null,
-    input.new_value ?? null,
+    oldValue,
+    newValue,
     input.actor_id ?? null,
     input.session_id ?? null,
     machineId,
-    JSON.stringify(input.metadata ?? {}),
+    JSON.stringify(metadata),
     ts
   ]);
   return getActivityRecord(id, d);
@@ -6039,6 +7048,7 @@ var ACTIVITY_LOG_SCHEMA = "todos.activity_log.v1", ACTIVITY_ENTITY_TYPES;
 var init_activity_audit = __esm(() => {
   init_database();
   init_secret_redaction();
+  init_prewrite_secrets();
   ACTIVITY_ENTITY_TYPES = [
     "task",
     "project",
@@ -6051,13 +7061,18 @@ var init_activity_audit = __esm(() => {
 });
 
 // src/db/audit.ts
+function sanitizeHistoryValue(value, context) {
+  return value === undefined || value === null ? null : sanitizePreWriteText(String(value), context);
+}
 function logTaskChange(taskId, action, field2, oldValue, newValue, agentId, db) {
   const d = db || getDatabase();
   const id = uuid();
-  const timestamp = now();
+  const timestamp2 = now();
   const machineId = currentStorageMachineId(d);
+  const safeOldValue = sanitizeHistoryValue(oldValue, "task_history.old_value");
+  const safeNewValue = sanitizeHistoryValue(newValue, "task_history.new_value");
   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, field2 || null, oldValue ?? null, newValue ?? null, agentId || null, timestamp, machineId]);
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`, [id, taskId, action, field2 || null, safeOldValue, safeNewValue, agentId || null, timestamp2, machineId]);
   try {
     const { logActivity: logActivity2 } = (init_activity_audit(), __toCommonJS(exports_activity_audit));
     logActivity2({
@@ -6065,12 +7080,12 @@ function logTaskChange(taskId, action, field2, oldValue, newValue, agentId, db)
       entity_id: taskId,
       action,
       field: field2,
-      old_value: oldValue ?? null,
-      new_value: newValue ?? null,
+      old_value: safeOldValue,
+      new_value: safeNewValue,
       actor_id: agentId ?? undefined
     }, d);
   } catch {}
-  return { id, task_id: taskId, action, field: field2 || null, old_value: oldValue ?? null, new_value: newValue ?? null, agent_id: agentId || null, created_at: timestamp, machine_id: machineId };
+  return { id, task_id: taskId, action, field: field2 || null, old_value: safeOldValue, new_value: safeNewValue, agent_id: agentId || null, created_at: timestamp2, machine_id: machineId };
 }
 function getTaskHistory(taskId, db) {
   const d = db || getDatabase();
@@ -6109,6 +7124,7 @@ function getRecap(hours = 8, projectId, db) {
 var init_audit = __esm(() => {
   init_database();
   init_storage_tombstones();
+  init_prewrite_secrets();
 });
 
 // src/db/webhooks.ts
@@ -6341,27 +7357,27 @@ function getChecklist(taskId, db) {
 function addChecklistItem(input, db) {
   const d = db || getDatabase();
   const id = uuid();
-  const timestamp = now();
+  const timestamp2 = now();
   let position = input.position;
   if (position === undefined) {
     const maxRow = d.query("SELECT MAX(position) as max_pos FROM task_checklists WHERE task_id = ?").get(input.task_id);
     position = (maxRow?.max_pos ?? -1) + 1;
   }
-  d.run("INSERT INTO task_checklists (id, task_id, position, text, checked, created_at, updated_at) VALUES (?, ?, ?, ?, 0, ?, ?)", [id, input.task_id, position, input.text, timestamp, timestamp]);
+  d.run("INSERT INTO task_checklists (id, task_id, position, text, checked, created_at, updated_at) VALUES (?, ?, ?, ?, 0, ?, ?)", [id, input.task_id, position, input.text, timestamp2, timestamp2]);
   return rowToItem(d.query("SELECT * FROM task_checklists WHERE id = ?").get(id));
 }
 function checkChecklistItem(id, checked, db) {
   const d = db || getDatabase();
-  const timestamp = now();
-  const result = d.run("UPDATE task_checklists SET checked = ?, updated_at = ? WHERE id = ?", [checked ? 1 : 0, timestamp, id]);
+  const timestamp2 = now();
+  const result = d.run("UPDATE task_checklists SET checked = ?, updated_at = ? WHERE id = ?", [checked ? 1 : 0, timestamp2, id]);
   if (result.changes === 0)
     return null;
   return rowToItem(d.query("SELECT * FROM task_checklists WHERE id = ?").get(id));
 }
 function updateChecklistItemText(id, text, db) {
   const d = db || getDatabase();
-  const timestamp = now();
-  const result = d.run("UPDATE task_checklists SET text = ?, updated_at = ? WHERE id = ?", [text, timestamp, id]);
+  const timestamp2 = now();
+  const result = d.run("UPDATE task_checklists SET text = ?, updated_at = ? WHERE id = ?", [text, timestamp2, id]);
   if (result.changes === 0)
     return null;
   return rowToItem(d.query("SELECT * FROM task_checklists WHERE id = ?").get(id));
@@ -6483,6 +7499,50 @@ var init_recurrence = __esm(() => {
   };
 });
 
+// src/lib/template-semantics.ts
+function resolveTemplateVariables(templateVars, provided) {
+  const merged = { ...provided };
+  for (const variable of templateVars) {
+    if (merged[variable.name] === undefined && variable.default !== undefined) {
+      merged[variable.name] = variable.default;
+    }
+  }
+  const missing = templateVars.filter((variable) => variable.required && merged[variable.name] === undefined).map((variable) => variable.name);
+  if (missing.length > 0) {
+    throw new Error(`Missing required template variable(s): ${missing.join(", ")}`);
+  }
+  return merged;
+}
+function substituteTemplateVariables(text, variables) {
+  let result = text;
+  for (const [key, value] of Object.entries(variables)) {
+    result = result.replace(new RegExp(`\\{${key}\\}`, "g"), value);
+  }
+  return result;
+}
+function evaluateTemplateCondition(condition, variables) {
+  if (!condition || condition.trim() === "")
+    return true;
+  const trimmed = condition.trim();
+  const equal = trimmed.match(/^\{([^}]+)\}\s*==\s*(.+)$/);
+  if (equal)
+    return (variables[equal[1]] ?? "") === equal[2].trim();
+  const unequal = trimmed.match(/^\{([^}]+)\}\s*!=\s*(.+)$/);
+  if (unequal)
+    return (variables[unequal[1]] ?? "") !== unequal[2].trim();
+  const falsy = trimmed.match(/^!\{([^}]+)\}$/);
+  if (falsy) {
+    const value = variables[falsy[1]];
+    return !value || value === "" || value === "false";
+  }
+  const truthy = trimmed.match(/^\{([^}]+)\}$/);
+  if (truthy) {
+    const value = variables[truthy[1]];
+    return !!value && value !== "" && value !== "false";
+  }
+  return true;
+}
+
 // src/db/templates.ts
 function rowToTemplate(row) {
   return {
@@ -6558,6 +7618,14 @@ function deleteTemplate(id, db) {
     payload: template,
     version: template.version
   }, d);
+  for (const task of getTemplateTasks(resolved, d)) {
+    recordStorageTombstone({
+      object_type: "template_tasks",
+      object_id: task.id,
+      payload: task,
+      version: 1
+    }, d);
+  }
   return d.run("DELETE FROM task_templates WHERE id = ?", [resolved]).changes > 0;
 }
 function updateTemplate(id, updates, db) {
@@ -6689,34 +7757,7 @@ function getTemplateTasks(templateId, db) {
   return rows.map(rowToTemplateTask);
 }
 function evaluateCondition(condition, variables) {
-  if (!condition || condition.trim() === "")
-    return true;
-  const trimmed = condition.trim();
-  const eqMatch = trimmed.match(/^\{([^}]+)\}\s*==\s*(.+)$/);
-  if (eqMatch) {
-    const varName = eqMatch[1];
-    const expected = eqMatch[2].trim();
-    return (variables[varName] ?? "") === expected;
-  }
-  const neqMatch = trimmed.match(/^\{([^}]+)\}\s*!=\s*(.+)$/);
-  if (neqMatch) {
-    const varName = neqMatch[1];
-    const expected = neqMatch[2].trim();
-    return (variables[varName] ?? "") !== expected;
-  }
-  const falsyMatch = trimmed.match(/^!\{([^}]+)\}$/);
-  if (falsyMatch) {
-    const varName = falsyMatch[1];
-    const val = variables[varName];
-    return !val || val === "" || val === "false";
-  }
-  const truthyMatch = trimmed.match(/^\{([^}]+)\}$/);
-  if (truthyMatch) {
-    const varName = truthyMatch[1];
-    const val = variables[varName];
-    return !!val && val !== "" && val !== "false";
-  }
-  return true;
+  return evaluateTemplateCondition(condition, variables);
 }
 function exportTemplate(id, db) {
   const d = db || getDatabase();
@@ -6789,29 +7830,10 @@ function listTemplateVersions(id, db) {
   return d.query("SELECT * FROM template_versions WHERE template_id = ? ORDER BY version DESC").all(resolved);
 }
 function resolveVariables(templateVars, provided) {
-  const merged = { ...provided };
-  for (const v of templateVars) {
-    if (merged[v.name] === undefined && v.default !== undefined) {
-      merged[v.name] = v.default;
-    }
-  }
-  const missing = [];
-  for (const v of templateVars) {
-    if (v.required && merged[v.name] === undefined) {
-      missing.push(v.name);
-    }
-  }
-  if (missing.length > 0) {
-    throw new Error(`Missing required template variable(s): ${missing.join(", ")}`);
-  }
-  return merged;
+  return resolveTemplateVariables(templateVars, provided);
 }
 function substituteVars(text, variables) {
-  let result = text;
-  for (const [key, val] of Object.entries(variables)) {
-    result = result.replace(new RegExp(`\\{${key}\\}`, "g"), val);
-  }
-  return result;
+  return substituteTemplateVariables(text, variables);
 }
 function tasksFromTemplate(templateId, projectId, variables, taskListId, db, _visitedTemplateIds) {
   const d = db || getDatabase();
@@ -7133,9 +8155,9 @@ function startTask(id, agentId, db) {
     throw new Error(`Task is blocked by ${blocking.length} unfinished dependency(ies): ${blockerIds}`);
   }
   const cutoff = lockExpiryCutoff();
-  const timestamp = now();
+  const timestamp2 = now();
   const result = d.run(`UPDATE tasks SET status = 'in_progress', assigned_to = ?, locked_by = ?, locked_at = ?, started_at = COALESCE(started_at, ?), version = version + 1, updated_at = ?
-     WHERE id = ? AND status IN ('pending', 'in_progress') AND (locked_by IS NULL OR locked_by = ? OR locked_at < ?)`, [agentId, agentId, timestamp, timestamp, timestamp, id, agentId, cutoff]);
+     WHERE id = ? AND status IN ('pending', 'in_progress') AND (locked_by IS NULL OR locked_by = ? OR locked_at < ?)`, [agentId, agentId, timestamp2, timestamp2, timestamp2, id, agentId, cutoff]);
   if (result.changes === 0) {
     const current = getTask(id, d);
     if (!current)
@@ -7147,7 +8169,7 @@ function startTask(id, agentId, db) {
     throw new Error(`Task ${id} could not be started because it changed during claim`);
   }
   logTaskChange(id, "start", "status", "pending", "in_progress", agentId, d);
-  const startedTask = { ...task, status: "in_progress", assigned_to: agentId, locked_by: agentId, locked_at: timestamp, started_at: task.started_at || timestamp, version: task.version + 1, updated_at: timestamp };
+  const startedTask = { ...task, status: "in_progress", assigned_to: agentId, locked_by: agentId, locked_at: timestamp2, started_at: task.started_at || timestamp2, version: task.version + 1, updated_at: timestamp2 };
   const payload = taskEventData(startedTask, { agent_id: agentId });
   dispatchWebhook2("task.started", payload, d).catch(() => {});
   emitLocalEventHooksQuiet({ type: "task.started", payload, databasePath });
@@ -7170,7 +8192,13 @@ function completeTask(id, agentId, db, options) {
     throw new LockError(id, task.locked_by);
   }
   checkCompletionGuard(task, agentId || null, d);
-  const evidence = options ? { files_changed: options.files_changed, test_results: options.test_results, commit_hash: options.commit_hash, notes: options.notes, attachment_ids: options.attachment_ids } : undefined;
+  const evidence = options ? sanitizePreWriteValue({
+    files_changed: options.files_changed,
+    test_results: options.test_results,
+    commit_hash: options.commit_hash,
+    notes: options.notes,
+    attachment_ids: options.attachment_ids
+  }, "task.completion_evidence") : undefined;
   const hasEvidence = evidence && (evidence.files_changed || evidence.test_results || evidence.commit_hash || evidence.notes || evidence.attachment_ids);
   const completionMeta = {};
   if (hasEvidence)
@@ -7179,21 +8207,21 @@ function completeTask(id, agentId, db, options) {
     completionMeta._completion = { confidence: options.confidence };
   }
   const hasMeta = Object.keys(completionMeta).length > 0;
-  const timestamp = options?.completed_at || now();
+  const timestamp2 = options?.completed_at || now();
   const confidence = options?.confidence !== undefined ? options.confidence : task.confidence;
   const versionBeforeStatus = task.version + (hasMeta ? 1 : 0);
   const finalVersion = versionBeforeStatus + 1;
   const tx = d.transaction(() => {
     if (hasMeta) {
-      const meta2 = { ...task.metadata, ...completionMeta };
-      const metaResult = d.run("UPDATE tasks SET metadata = ?, version = version + 1, updated_at = ? WHERE id = ? AND version = ?", [JSON.stringify(meta2), timestamp, id, task.version]);
+      const meta2 = sanitizePreWriteValue({ ...task.metadata, ...completionMeta }, "task.metadata");
+      const metaResult = d.run("UPDATE tasks SET metadata = ?, version = version + 1, updated_at = ? WHERE id = ? AND version = ?", [JSON.stringify(meta2), timestamp2, id, task.version]);
       if (metaResult.changes === 0) {
         const current = getTask(id, d);
         throw new VersionConflictError(id, task.version, current?.version ?? -1);
       }
     }
     const statusResult = d.run(`UPDATE tasks SET status = 'completed', locked_by = NULL, locked_at = NULL, completed_at = ?, confidence = ?, version = version + 1, updated_at = ?
-       WHERE id = ? AND version = ?`, [timestamp, confidence, timestamp, id, versionBeforeStatus]);
+       WHERE id = ? AND version = ?`, [timestamp2, confidence, timestamp2, id, versionBeforeStatus]);
     if (statusResult.changes === 0) {
       const current = getTask(id, d);
       throw new VersionConflictError(id, versionBeforeStatus, current?.version ?? -1);
@@ -7206,20 +8234,20 @@ function completeTask(id, agentId, db, options) {
     status: "completed",
     locked_by: null,
     locked_at: null,
-    completed_at: timestamp,
+    completed_at: timestamp2,
     confidence,
     version: finalVersion,
-    updated_at: timestamp,
+    updated_at: timestamp2,
     metadata: hasMeta ? { ...task.metadata, ...completionMeta } : task.metadata
   };
-  const completionPayload = taskEventData(completedTaskForEvent, { agent_id: agentId, completed_at: timestamp });
+  const completionPayload = taskEventData(completedTaskForEvent, { agent_id: agentId, completed_at: timestamp2 });
   dispatchWebhook2("task.completed", completionPayload, d).catch(() => {});
   emitLocalEventHooksQuiet({ type: "task.completed", payload: completionPayload, databasePath });
-  emitSharedTaskEventQuiet({ type: "task.completed", task: completedTaskForEvent, data: { agent_id: agentId, completed_at: timestamp }, databasePath });
+  emitSharedTaskEventQuiet({ type: "task.completed", task: completedTaskForEvent, data: { agent_id: agentId, completed_at: timestamp2 }, databasePath });
   let spawnedTask = null;
   if (task.recurrence_rule && !options?.skip_recurrence) {
     try {
-      spawnedTask = spawnNextRecurrence(task, d, timestamp);
+      spawnedTask = spawnNextRecurrence(task, d, timestamp2);
     } catch (e) {
       spawnedTask = null;
       console.warn(`[tasks] failed to spawn next recurrence for ${id}: ${e instanceof Error ? e.message : String(e)}`);
@@ -7269,7 +8297,7 @@ function completeTask(id, agentId, db, options) {
         emitSharedTaskEventQuiet({ type: "task.unblocked", task: depTask, data: { unblocked_by: id }, databasePath });
     }
   }
-  return { ...task, status: "completed", locked_by: null, locked_at: null, completed_at: timestamp, confidence, version: finalVersion, updated_at: timestamp, metadata: meta };
+  return { ...task, status: "completed", locked_by: null, locked_at: null, completed_at: timestamp2, confidence, version: finalVersion, updated_at: timestamp2, metadata: meta };
 }
 function lockTask(id, agentId, db) {
   const d = db || getDatabase();
@@ -7283,15 +8311,15 @@ function lockTask(id, agentId, db) {
     };
   }
   if (task.locked_by === agentId && !isLockExpired(task.locked_at)) {
-    const timestamp2 = now();
-    d.run(`UPDATE tasks SET locked_at = ?, updated_at = ?, version = version + 1 WHERE id = ? AND locked_by = ?`, [timestamp2, timestamp2, id, agentId]);
+    const timestamp3 = now();
+    d.run(`UPDATE tasks SET locked_at = ?, updated_at = ?, version = version + 1 WHERE id = ? AND locked_by = ?`, [timestamp3, timestamp3, id, agentId]);
     logTaskChange(id, "lock_renew", "locked_by", agentId, agentId, agentId, d);
-    return { success: true, locked_by: agentId, locked_at: timestamp2, expires_at: lockExpiresAt(timestamp2) };
+    return { success: true, locked_by: agentId, locked_at: timestamp3, expires_at: lockExpiresAt(timestamp3) };
   }
   const cutoff = lockExpiryCutoff();
-  const timestamp = now();
+  const timestamp2 = now();
   const result = d.run(`UPDATE tasks SET locked_by = ?, locked_at = ?, version = version + 1, updated_at = ?
-     WHERE id = ? AND status NOT IN ('completed', 'cancelled') AND (locked_by IS NULL OR locked_by = ? OR locked_at < ?)`, [agentId, timestamp, timestamp, id, agentId, cutoff]);
+     WHERE id = ? AND status NOT IN ('completed', 'cancelled') AND (locked_by IS NULL OR locked_by = ? OR locked_at < ?)`, [agentId, timestamp2, timestamp2, id, agentId, cutoff]);
   if (result.changes === 0) {
     const current = getTask(id, d);
     if (!current)
@@ -7316,7 +8344,7 @@ function lockTask(id, agentId, db) {
     };
   }
   logTaskChange(id, "lock", "locked_by", task.locked_by, agentId, agentId, d);
-  return { success: true, locked_by: agentId, locked_at: timestamp, expires_at: lockExpiresAt(timestamp) };
+  return { success: true, locked_by: agentId, locked_at: timestamp2, expires_at: lockExpiresAt(timestamp2) };
 }
 function unlockTask(id, agentId, db) {
   const d = db || getDatabase();
@@ -7326,9 +8354,9 @@ function unlockTask(id, agentId, db) {
   if (agentId && task.locked_by && task.locked_by !== agentId) {
     throw new LockError(id, task.locked_by);
   }
-  const timestamp = now();
+  const timestamp2 = now();
   d.run(`UPDATE tasks SET locked_by = NULL, locked_at = NULL, version = version + 1, updated_at = ?
-     WHERE id = ?`, [timestamp, id]);
+     WHERE id = ?`, [timestamp2, id]);
   return true;
 }
 function getTaskLockStatus(id, db) {
@@ -7453,20 +8481,23 @@ function failTask(id, agentId, reason, options, db) {
   const task = getTask(id, d);
   if (!task)
     throw new TaskNotFoundError(id);
+  const safeReason = sanitizePreWriteText(reason || "Unknown failure", "task.failure.reason");
+  const safeErrorCode = options?.error_code ? sanitizePreWriteText(options.error_code, "task.failure.error_code") : null;
   const meta = {
     ...task.metadata,
     _failure: {
-      reason: reason || "Unknown failure",
-      error_code: options?.error_code || null,
+      reason: safeReason,
+      error_code: safeErrorCode,
       failed_by: agentId || null,
       failed_at: now(),
       retry_requested: options?.retry || false
     }
   };
-  const timestamp = now();
+  const safeMeta = sanitizePreWriteValue(meta, "task.failure.metadata");
+  const timestamp2 = now();
   const failTx = d.transaction(() => {
     const res = d.run(`UPDATE tasks SET status = 'failed', locked_by = NULL, locked_at = NULL, metadata = ?, version = version + 1, updated_at = ?
-       WHERE id = ? AND version = ?`, [JSON.stringify(meta), timestamp, id, task.version]);
+       WHERE id = ? AND version = ?`, [JSON.stringify(safeMeta), timestamp2, id, task.version]);
     if (res.changes === 0) {
       const current = getTask(id, d);
       throw new VersionConflictError(id, task.version, current?.version ?? -1);
@@ -7478,22 +8509,22 @@ function failTask(id, agentId, reason, options, db) {
     status: "failed",
     locked_by: null,
     locked_at: null,
-    metadata: meta,
+    metadata: safeMeta,
     version: task.version + 1,
-    updated_at: timestamp
+    updated_at: timestamp2
   };
   logTaskChange(id, "fail", "status", task.status, "failed", agentId || null, d);
-  const failurePayload = taskEventData(failedTask, { reason, error_code: options?.error_code, agent_id: agentId });
+  const failurePayload = taskEventData(failedTask, { reason: safeReason, error_code: safeErrorCode, agent_id: agentId });
   dispatchWebhook2("task.failed", failurePayload, d).catch(() => {});
   emitLocalEventHooksQuiet({ type: "task.failed", payload: failurePayload, databasePath });
-  emitSharedTaskEventQuiet({ type: "task.failed", task: failedTask, data: { reason, error_code: options?.error_code, agent_id: agentId }, severity: "warning", databasePath });
+  emitSharedTaskEventQuiet({ type: "task.failed", task: failedTask, data: { reason: safeReason, error_code: safeErrorCode, agent_id: agentId }, severity: "warning", databasePath });
   let retryTask;
   if (options?.retry) {
     const retryCount = (task.retry_count || 0) + 1;
     const maxRetries = task.max_retries || 3;
     if (retryCount > maxRetries) {
       d.run("UPDATE tasks SET metadata = ? WHERE id = ?", [
-        JSON.stringify({ ...meta, _retry_exhausted: { retry_count: retryCount - 1, max_retries: maxRetries } }),
+        JSON.stringify(sanitizePreWriteValue({ ...safeMeta, _retry_exhausted: { retry_count: retryCount - 1, max_retries: maxRetries } }, "task.retry_exhausted.metadata")),
         id
       ]);
     } else {
@@ -7512,7 +8543,7 @@ function failTask(id, agentId, reason, options, db) {
         plan_id: task.plan_id ?? undefined,
         assigned_to: task.assigned_to ?? undefined,
         tags: task.tags,
-        metadata: { ...task.metadata, _retry: { original_id: task.id, retry_count: retryCount, max_retries: maxRetries, retry_after: retryAfter, failure_reason: reason } },
+        metadata: { ...task.metadata, _retry: { original_id: task.id, retry_count: retryCount, max_retries: maxRetries, retry_after: retryAfter, failure_reason: safeReason } },
         estimated_minutes: task.estimated_minutes ?? undefined,
         recurrence_rule: task.recurrence_rule ?? undefined,
         due_at: retryAfter
@@ -7554,15 +8585,15 @@ function stealTask(agentId, opts, db) {
   const priorityOrder = { critical: 0, high: 1, medium: 2, low: 3 };
   staleTasks.sort((a, b) => (priorityOrder[a.priority] ?? 9) - (priorityOrder[b.priority] ?? 9));
   const target = staleTasks[0];
-  const timestamp = now();
+  const timestamp2 = now();
   const cutoff = new Date(Date.now() - staleMinutes * 60 * 1000).toISOString();
   const result = d.run(`UPDATE tasks SET assigned_to = ?, locked_by = ?, locked_at = ?, updated_at = ?, version = version + 1
-     WHERE id = ? AND status = 'in_progress' AND (updated_at < ? OR (locked_at IS NOT NULL AND locked_at < ?))`, [agentId, agentId, timestamp, timestamp, target.id, cutoff, cutoff]);
+     WHERE id = ? AND status = 'in_progress' AND (updated_at < ? OR (locked_at IS NOT NULL AND locked_at < ?))`, [agentId, agentId, timestamp2, timestamp2, target.id, cutoff, cutoff]);
   if (result.changes === 0)
     return null;
   logTaskChange(target.id, "steal", "assigned_to", target.assigned_to, agentId, agentId, d);
   logTaskChange(target.id, "steal", "locked_by", target.locked_by, agentId, agentId, d);
-  const stolenTask = { ...target, assigned_to: agentId, locked_by: agentId, locked_at: timestamp, updated_at: timestamp, version: target.version + 1 };
+  const stolenTask = { ...target, assigned_to: agentId, locked_by: agentId, locked_at: timestamp2, updated_at: timestamp2, version: target.version + 1 };
   const payload = taskEventData(stolenTask, { agent_id: agentId, stolen_from: target.assigned_to });
   dispatchWebhook2("task.assigned", payload, d).catch(() => {});
   emitLocalEventHooksQuiet({ type: "task.assigned", payload, databasePath });
@@ -7623,6 +8654,7 @@ var init_task_lifecycle = __esm(() => {
   init_templates();
   init_task_crud();
   init_task_graph();
+  init_prewrite_secrets();
 });
 
 // src/db/task-crud.ts
@@ -7660,9 +8692,29 @@ function addMetadataConditions(metadata, conditions, params) {
     params.push(value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean" ? value : JSON.stringify(value));
   }
 }
+function sanitizeCreateTaskInput(input) {
+  return {
+    ...input,
+    title: sanitizePreWriteText(input.title, "task.title"),
+    description: input.description !== undefined ? sanitizePreWriteText(input.description, "task.description") : undefined,
+    tags: input.tags !== undefined ? sanitizePreWriteValue(input.tags, "task.tags") : undefined,
+    metadata: input.metadata !== undefined ? sanitizePreWriteValue(input.metadata, "task.metadata") : undefined,
+    reason: input.reason !== undefined ? sanitizePreWriteText(input.reason, "task.reason") : undefined
+  };
+}
+function sanitizeUpdateTaskInput(input) {
+  return {
+    ...input,
+    title: input.title !== undefined ? sanitizePreWriteText(input.title, "task.title") : undefined,
+    description: input.description !== undefined ? sanitizePreWriteText(input.description, "task.description") : undefined,
+    tags: input.tags !== undefined ? sanitizePreWriteValue(input.tags, "task.tags") : undefined,
+    metadata: input.metadata !== undefined ? sanitizePreWriteValue(input.metadata, "task.metadata") : undefined
+  };
+}
 function createTask(input, db) {
+  input = sanitizeCreateTaskInput(input);
   const d = db || getDatabase();
-  const timestamp = now();
+  const timestamp2 = now();
   const tags = input.tags || [];
   const machineId = currentStorageMachineId(d);
   const assignedBy = input.assigned_by || input.agent_id;
@@ -7689,8 +8741,8 @@ function createTask(input, db) {
         input.working_dir || null,
         JSON.stringify(tags),
         JSON.stringify(input.metadata || {}),
-        timestamp,
-        timestamp,
+        timestamp2,
+        timestamp2,
         input.due_at || null,
         input.estimated_minutes || null,
         input.sla_minutes ?? null,
@@ -8014,10 +9066,11 @@ function updateTask(id, input, db) {
   if (task.version !== input.version) {
     throw new VersionConflictError(id, input.version, task.version);
   }
-  const timestamp = now();
-  const completionTimestamp = input.completed_at ?? timestamp;
+  input = sanitizeUpdateTaskInput(input);
+  const timestamp2 = now();
+  const completionTimestamp = input.completed_at ?? timestamp2;
   const sets = ["version = version + 1", "updated_at = ?"];
-  const params = [timestamp];
+  const params = [timestamp2];
   if (input.title !== undefined) {
     sets.push("title = ?");
     params.push(input.title);
@@ -8166,7 +9219,7 @@ function updateTask(id, input, db) {
     tags: input.tags ?? task.tags,
     metadata: input.metadata ?? task.metadata,
     version: task.version + 1,
-    updated_at: timestamp,
+    updated_at: timestamp2,
     locked_by: completedNow ? null : task.locked_by,
     locked_at: completedNow ? null : task.locked_at,
     completed_at: completedNow ? completionTimestamp : reopened ? null : input.completed_at !== undefined ? input.completed_at : task.completed_at,
@@ -8178,7 +9231,7 @@ function updateTask(id, input, db) {
     retry_after: input.retry_after !== undefined ? input.retry_after : task.retry_after,
     requires_approval: input.requires_approval !== undefined ? input.requires_approval : task.requires_approval,
     approved_by: input.approved_by ?? task.approved_by,
-    approved_at: input.approved_by ? timestamp : task.approved_at
+    approved_at: input.approved_by ? timestamp2 : task.approved_at
   };
   const databasePath = databasePathFromDatabase(d);
   if (input.assigned_to !== undefined && input.assigned_to !== task.assigned_to) {
@@ -8227,6 +9280,7 @@ var init_task_crud = __esm(() => {
   init_webhooks();
   init_checklists();
   init_storage_tombstones();
+  init_prewrite_secrets();
 });
 
 // src/db/task-status.ts
@@ -8358,10 +9412,10 @@ function redistributeStaleTasks(agentId, options, db) {
   const maxAge = options?.max_age_minutes ?? 60;
   const stale = getStaleTasks(maxAge, options?.project_id ? { project_id: options.project_id } : undefined, d);
   const limited = options?.limit ? stale.slice(0, options.limit) : stale;
-  const timestamp = now();
+  const timestamp2 = now();
   const released = [];
   for (const t of limited) {
-    d.run(`UPDATE tasks SET locked_by = NULL, locked_at = NULL, status = 'pending', version = version + 1, updated_at = ? WHERE id = ?`, [timestamp, t.id]);
+    d.run(`UPDATE tasks SET locked_by = NULL, locked_at = NULL, status = 'pending', version = version + 1, updated_at = ? WHERE id = ?`, [timestamp2, t.id]);
     released.push({ ...t, locked_by: null, locked_at: null, status: "pending" });
   }
   const claimed = released.length > 0 ? claimNextTask(agentId, options?.project_id ? { project_id: options.project_id } : undefined, d) : null;
@@ -8833,7 +9887,7 @@ function resolveCreateSlug(input, projectId, db) {
 function createPlan(input, db) {
   const d = db || getDatabase();
   const id = uuid();
-  const timestamp = now();
+  const timestamp2 = now();
   const projectId = input.project_id || null;
   const slug = resolveCreateSlug(input, projectId, d);
   const machineId = currentStorageMachineId(d);
@@ -8847,8 +9901,8 @@ function createPlan(input, db) {
     input.name,
     input.description || null,
     input.status || "active",
-    timestamp,
-    timestamp,
+    timestamp2,
+    timestamp2,
     machineId
   ]);
   return getPlan(id, d);
@@ -8985,7 +10039,7 @@ function maybeFilter(value) {
 function createTaskBoard(input, db) {
   const d = db || getDatabase();
   const id = uuid();
-  const timestamp = now();
+  const timestamp2 = now();
   const scope = input.scope || "tasks";
   const lanes = normalizeLanes(scope, input.lanes);
   d.run(`INSERT INTO task_boards (id, name, scope, project_id, task_list_id, plan_id, agent_id, lanes, filters, created_at, updated_at)
@@ -8999,8 +10053,8 @@ function createTaskBoard(input, db) {
     input.agent_id || null,
     JSON.stringify(lanes),
     JSON.stringify(input.filters || {}),
-    timestamp,
-    timestamp
+    timestamp2,
+    timestamp2
   ]);
   return getTaskBoard(id, d);
 }
@@ -9401,14 +10455,14 @@ function storeArtifactContent(input) {
     return null;
   const sourceStat = statSync2(sourcePath);
   if (!sourceStat.isFile())
-    throw new Error(`Artifact path is not a file: ${input.path}`);
+    throw new Error(`Artifact path is not a file: ${sanitizePreWriteText(input.path, "artifact.path")}`);
   const sourceBuffer = readFileSync3(sourcePath);
   const sourceSha = sha256(sourceBuffer);
   const textLike = isTextLike(sourceBuffer, input.path);
   let storedBuffer = sourceBuffer;
   let redactionStatus = textLike ? "clean" : "binary_or_unknown";
   if (textLike) {
-    const redactedText = redactEvidenceText(sourceBuffer.toString("utf8"));
+    const redactedText = sanitizePreWriteText(sourceBuffer.toString("utf8"), "artifact.content");
     storedBuffer = Buffer.from(redactedText);
     if (!storedBuffer.equals(sourceBuffer))
       redactionStatus = "redacted";
@@ -9442,7 +10496,7 @@ function storeArtifactContent(input) {
         expires_at: retentionDays === null ? null : retentionExpiresAt(createdAt, retentionDays)
       },
       source: {
-        path: input.path,
+        path: sanitizePreWriteText(input.path, "artifact.source_path"),
         size_bytes: sourceBuffer.length,
         sha256: sourceSha
       }
@@ -9622,6 +10676,7 @@ var DEFAULT_DELETED_RETENTION_DAYS = 30;
 var init_artifact_store = __esm(() => {
   init_database();
   init_redaction();
+  init_prewrite_secrets();
 });
 
 // src/db/comments.ts
@@ -9631,17 +10686,17 @@ function addComment(input, db) {
     throw new TaskNotFoundError(input.task_id);
   }
   const id = uuid();
-  const timestamp = now();
+  const timestamp2 = now();
   d.run(`INSERT INTO task_comments (id, task_id, agent_id, session_id, content, type, progress_pct, created_at)
      VALUES (?, ?, ?, ?, ?, ?, ?, ?)`, [
     id,
     input.task_id,
     input.agent_id || null,
     input.session_id || null,
-    redactEvidenceText(input.content),
+    sanitizePreWriteText(input.content, "comment.content"),
     input.type || "comment",
     input.progress_pct ?? null,
-    timestamp
+    timestamp2
   ]);
   return getComment(id, d);
 }
@@ -9665,21 +10720,21 @@ var init_comments = __esm(() => {
   init_types();
   init_database();
   init_tasks();
-  init_redaction();
+  init_prewrite_secrets();
 });
 
 // src/db/task-files.ts
 function addTaskFile(input, db) {
   const d = db || getDatabase();
   const id = uuid();
-  const timestamp = now();
+  const timestamp2 = now();
   const existing = d.query("SELECT id FROM task_files WHERE task_id = ? AND path = ?").get(input.task_id, input.path);
   if (existing) {
-    d.run("UPDATE task_files SET status = ?, agent_id = ?, note = ?, updated_at = ? WHERE id = ?", [input.status || "active", input.agent_id || null, input.note || null, timestamp, existing.id]);
+    d.run("UPDATE task_files SET status = ?, agent_id = ?, note = ?, updated_at = ? WHERE id = ?", [input.status || "active", input.agent_id || null, input.note || null, timestamp2, existing.id]);
     return getTaskFile(existing.id, d);
   }
   d.run(`INSERT INTO task_files (id, task_id, path, status, agent_id, note, created_at, updated_at)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?)`, [id, input.task_id, input.path, input.status || "active", input.agent_id || null, input.note || null, timestamp, timestamp]);
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?)`, [id, input.task_id, input.path, input.status || "active", input.agent_id || null, input.note || null, timestamp2, timestamp2]);
   return getTaskFile(id, d);
 }
 function getTaskFile(id, db) {
@@ -9696,8 +10751,8 @@ function findTasksByFile(path, db) {
 }
 function updateTaskFileStatus(taskId, path, status, agentId, db) {
   const d = db || getDatabase();
-  const timestamp = now();
-  d.run("UPDATE task_files SET status = ?, agent_id = COALESCE(?, agent_id), updated_at = ? WHERE task_id = ? AND path = ?", [status, agentId || null, timestamp, taskId, path]);
+  const timestamp2 = now();
+  d.run("UPDATE task_files SET status = ?, agent_id = COALESCE(?, agent_id), updated_at = ? WHERE task_id = ? AND path = ?", [status, agentId || null, timestamp2, taskId, path]);
   const row = d.query("SELECT * FROM task_files WHERE task_id = ? AND path = ?").get(taskId, path);
   return row;
 }
@@ -9742,8 +10797,16 @@ function rowToVerification(row) {
 function linkTaskToCommit(input, db) {
   const d = db || getDatabase();
   const existing = d.query("SELECT * FROM task_commits WHERE task_id = ? AND sha = ?").get(input.task_id, input.sha);
-  const ciJson = input.ci_snapshot ? JSON.stringify(input.ci_snapshot) : null;
-  const traceJson = input.traceability ? JSON.stringify(input.traceability) : null;
+  const ciJson = input.ci_snapshot ? JSON.stringify(sanitizePreWriteValue(input.ci_snapshot, "commit.ci_snapshot")) : null;
+  const traceJson = input.traceability ? JSON.stringify(sanitizePreWriteValue(input.traceability, "commit.traceability")) : null;
+  const message = input.message ? sanitizePreWriteText(input.message, "commit.message") : null;
+  const author = input.author ? sanitizePreWriteText(input.author, "commit.author") : null;
+  const filesChanged = input.files_changed ? JSON.stringify(sanitizePreWriteValue(input.files_changed, "commit.files_changed")) : null;
+  const branch = input.branch ? sanitizePreWriteText(input.branch, "commit.branch") : null;
+  const prUrl = input.pr_url ? sanitizePreWriteText(input.pr_url, "commit.pr_url") : null;
+  const prState = input.pr_state ? sanitizePreWriteText(input.pr_state, "commit.pr_state") : null;
+  const releaseTag = input.release_tag ? sanitizePreWriteText(input.release_tag, "commit.release_tag") : null;
+  const repoPath = input.repo_path ? sanitizePreWriteText(input.repo_path, "commit.repo_path") : null;
   if (existing) {
     d.run(`UPDATE task_commits SET
         message = COALESCE(?, message),
@@ -9759,17 +10822,17 @@ function linkTaskToCommit(input, db) {
         repo_path = COALESCE(?, repo_path),
         traceability = COALESCE(?, traceability)
        WHERE id = ?`, [
-      input.message ?? null,
-      input.author ?? null,
-      input.files_changed ? JSON.stringify(input.files_changed) : null,
+      message,
+      author,
+      filesChanged,
       input.committed_at ?? null,
-      input.branch ?? null,
-      input.pr_url ?? null,
+      branch,
+      prUrl,
       input.pr_number ?? null,
-      input.pr_state ?? null,
+      prState,
       ciJson,
-      input.release_tag ?? null,
-      input.repo_path ?? null,
+      releaseTag,
+      repoPath,
       traceJson,
       existing.id
     ]);
@@ -9783,17 +10846,17 @@ function linkTaskToCommit(input, db) {
     id,
     input.task_id,
     input.sha,
-    input.message ?? null,
-    input.author ?? null,
-    input.files_changed ? JSON.stringify(input.files_changed) : null,
+    message,
+    author,
+    filesChanged,
     input.committed_at ?? null,
-    input.branch ?? null,
-    input.pr_url ?? null,
+    branch,
+    prUrl,
     input.pr_number ?? null,
-    input.pr_state ?? null,
+    prState,
     ciJson,
-    input.release_tag ?? null,
-    input.repo_path ?? null,
+    releaseTag,
+    repoPath,
     traceJson ?? "{}",
     now()
   ]);
@@ -9822,13 +10885,16 @@ function addTaskVerification(input, db) {
   const d = db || getDatabase();
   const id = uuid();
   const runAt = input.run_at || now();
+  const command = sanitizePreWriteText(input.command, "verification.command");
+  const outputSummary = input.output_summary ? sanitizePreWriteText(input.output_summary, "verification.output_summary") : null;
+  const artifactPath = input.artifact_path ? sanitizePreWriteText(input.artifact_path, "verification.artifact_path") : null;
   d.run("INSERT INTO task_verifications (id, task_id, command, status, output_summary, artifact_path, agent_id, run_at, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)", [
     id,
     input.task_id,
-    input.command,
+    command,
     input.status || "unknown",
-    input.output_summary ?? null,
-    input.artifact_path ?? null,
+    outputSummary,
+    artifactPath,
     input.agent_id ?? null,
     runAt,
     now()
@@ -9858,6 +10924,7 @@ function getTaskTraceability(taskId, db) {
 }
 var init_task_commits = __esm(() => {
   init_database();
+  init_prewrite_secrets();
 });
 
 // src/db/task-runs.ts
@@ -9968,7 +11035,7 @@ function startTaskRun(input, db) {
   if (!getTask(input.task_id, d))
     throw new TaskNotFoundError(input.task_id);
   const id = input.id ?? uuid();
-  const timestamp = input.started_at || now();
+  const timestamp2 = input.started_at || now();
   if (input.claim && input.agent_id) {
     startTask(input.task_id, input.agent_id, d);
   }
@@ -9976,12 +11043,12 @@ function startTaskRun(input, db) {
     id,
     input.task_id,
     input.agent_id ?? null,
-    input.title ? redactEvidenceText(input.title) : null,
-    input.summary ? redactEvidenceText(input.summary) : null,
-    JSON.stringify(redactValue(input.metadata || {})),
-    timestamp,
-    timestamp,
-    timestamp
+    input.title ? sanitizePreWriteText(input.title, "run.title") : null,
+    input.summary ? sanitizePreWriteText(input.summary, "run.summary") : null,
+    JSON.stringify(sanitizePreWriteValue(input.metadata || {}, "run.metadata")),
+    timestamp2,
+    timestamp2,
+    timestamp2
   ]);
   addTaskRunEvent({
     run_id: id,
@@ -9989,7 +11056,7 @@ function startTaskRun(input, db) {
     message: input.summary || input.title || "run started",
     data: { title: input.title, claim: Boolean(input.claim) },
     agent_id: input.agent_id,
-    created_at: timestamp
+    created_at: timestamp2
   }, d);
   if (input.claim && input.agent_id) {
     addTaskRunEvent({
@@ -9998,7 +11065,7 @@ function startTaskRun(input, db) {
       message: `claimed by ${input.agent_id}`,
       data: { agent_id: input.agent_id },
       agent_id: input.agent_id,
-      created_at: timestamp
+      created_at: timestamp2
     }, d);
   }
   const run = getTaskRun(id, d);
@@ -10013,7 +11080,7 @@ function beginTaskRunTransaction(input, db) {
   const d = db || getDatabase();
   if (!getTask(input.task_id, d))
     throw new TaskNotFoundError(input.task_id);
-  const timestamp = input.started_at || now();
+  const timestamp2 = input.started_at || now();
   const key = normalizeTransactionKey(input);
   const existing = findTaskRunByTransactionKey(key, input.task_id, d);
   const dryRun = !input.apply;
@@ -10022,7 +11089,7 @@ function beginTaskRunTransaction(input, db) {
       schema_version: LOOP_RUN_TRANSACTION_SCHEMA_VERSION,
       local_only: true,
       dry_run: dryRun,
-      processed_at: timestamp,
+      processed_at: timestamp2,
       action: "matched",
       key,
       run: summarizeTaskRun(existing),
@@ -10035,7 +11102,7 @@ function beginTaskRunTransaction(input, db) {
       schema_version: LOOP_RUN_TRANSACTION_SCHEMA_VERSION,
       local_only: true,
       dry_run: true,
-      processed_at: timestamp,
+      processed_at: timestamp2,
       action: "preview",
       key,
       run: null,
@@ -10043,14 +11110,14 @@ function beginTaskRunTransaction(input, db) {
       commands: loopRunCommands(null, key)
     };
   }
-  const metadata = redactValue({
+  const metadata = sanitizePreWriteValue({
     ...input.metadata || {},
     loop_transaction: {
       schema_version: LOOP_RUN_TRANSACTION_SCHEMA_VERSION,
       idempotency_key: key,
       loop_id: input.loop_id ?? null,
       loop_run_id: input.loop_run_id ?? null,
-      first_seen_at: timestamp
+      first_seen_at: timestamp2
     },
     idempotency_key: key
   });
@@ -10064,8 +11131,8 @@ function beginTaskRunTransaction(input, db) {
       input.loop_id ?? null,
       input.loop_run_id ?? null,
       JSON.stringify(metadata),
-      timestamp,
-      timestamp
+      timestamp2,
+      timestamp2
     ]);
     const transaction = getTaskRunTransactionByKey(key, input.task_id, d);
     if (!transaction)
@@ -10083,16 +11150,16 @@ function beginTaskRunTransaction(input, db) {
       summary: input.summary,
       metadata,
       claim: input.claim,
-      started_at: timestamp
+      started_at: timestamp2
     }, d);
-    d.run("UPDATE task_run_transactions SET run_id = ?, loop_id = COALESCE(?, loop_id), loop_run_id = COALESCE(?, loop_run_id), metadata = ?, updated_at = ? WHERE id = ?", [run.id, input.loop_id ?? null, input.loop_run_id ?? null, JSON.stringify(metadata), timestamp, transaction.id]);
+    d.run("UPDATE task_run_transactions SET run_id = ?, loop_id = COALESCE(?, loop_id), loop_run_id = COALESCE(?, loop_run_id), metadata = ?, updated_at = ? WHERE id = ?", [run.id, input.loop_id ?? null, input.loop_run_id ?? null, JSON.stringify(metadata), timestamp2, transaction.id]);
     return { run, action: "created" };
   })();
   return {
     schema_version: LOOP_RUN_TRANSACTION_SCHEMA_VERSION,
     local_only: true,
     dry_run: false,
-    processed_at: timestamp,
+    processed_at: timestamp2,
     action: created.action,
     key,
     run: summarizeTaskRun(created.run),
@@ -10107,19 +11174,19 @@ function addTaskRunEvent(input, db) {
   if (!run)
     throw new Error(`Run not found: ${input.run_id}`);
   const id = uuid();
-  const timestamp = input.created_at || now();
+  const timestamp2 = input.created_at || now();
   d.run("INSERT INTO task_run_events (id, run_id, task_id, event_type, message, data, agent_id, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)", [
     id,
     run.id,
     run.task_id,
     input.event_type,
-    input.message ? redactEvidenceText(input.message) : null,
-    JSON.stringify(redactValue(input.data || {})),
+    input.message ? sanitizePreWriteText(input.message, "run_event.message") : null,
+    JSON.stringify(sanitizePreWriteValue(input.data || {}, "run_event.data")),
     input.agent_id ?? run.agent_id,
-    timestamp
+    timestamp2
   ]);
   if (input.event_type === "comment" && input.message) {
-    addComment({ task_id: run.task_id, content: redactEvidenceText(input.message), type: "comment", agent_id: input.agent_id ?? run.agent_id ?? undefined }, d);
+    addComment({ task_id: run.task_id, content: sanitizePreWriteText(input.message, "run_event.comment"), type: "comment", agent_id: input.agent_id ?? run.agent_id ?? undefined }, d);
   }
   return rowToEvent(d.query("SELECT * FROM task_run_events WHERE id = ?").get(id));
 }
@@ -10131,10 +11198,10 @@ function addTaskRunCommand(input, db) {
     throw new Error(`Run not found: ${input.run_id}`);
   const id = uuid();
   const status = input.status || "unknown";
-  const timestamp = now();
-  const command = redactEvidenceText(input.command);
-  const outputSummary = input.output_summary ? redactEvidenceText(input.output_summary) : null;
-  const artifactPath = input.artifact_path ? redactEvidenceText(input.artifact_path) : null;
+  const timestamp2 = now();
+  const command = sanitizePreWriteText(input.command, "run_command.command");
+  const outputSummary = input.output_summary ? sanitizePreWriteText(input.output_summary, "run_command.output_summary") : null;
+  const artifactPath = input.artifact_path ? sanitizePreWriteText(input.artifact_path, "run_command.artifact_path") : null;
   d.run("INSERT INTO task_run_commands (id, run_id, task_id, command, status, exit_code, output_summary, artifact_path, agent_id, started_at, completed_at, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)", [
     id,
     run.id,
@@ -10146,8 +11213,8 @@ function addTaskRunCommand(input, db) {
     artifactPath,
     input.agent_id ?? run.agent_id,
     input.started_at ?? null,
-    input.completed_at ?? timestamp,
-    timestamp
+    input.completed_at ?? timestamp2,
+    timestamp2
   ]);
   addTaskVerification({
     task_id: run.task_id,
@@ -10156,7 +11223,7 @@ function addTaskRunCommand(input, db) {
     output_summary: outputSummary ?? undefined,
     artifact_path: artifactPath ?? undefined,
     agent_id: input.agent_id ?? run.agent_id ?? undefined,
-    run_at: input.completed_at ?? timestamp
+    run_at: input.completed_at ?? timestamp2
   }, d);
   addTaskRunEvent({
     run_id: run.id,
@@ -10175,7 +11242,7 @@ function addTaskRunCommand(input, db) {
       }
     },
     agent_id: input.agent_id ?? run.agent_id ?? undefined,
-    created_at: timestamp
+    created_at: timestamp2
   }, d);
   return d.query("SELECT * FROM task_run_commands WHERE id = ?").get(id);
 }
@@ -10189,7 +11256,7 @@ function addTaskRunFile(input, db) {
     task_id: run.task_id,
     path: input.path,
     status: input.status || "modified",
-    note: input.note ? redactEvidenceText(input.note) : undefined,
+    note: input.note ? sanitizePreWriteText(input.note, "run_file.note") : undefined,
     agent_id: input.agent_id ?? run.agent_id ?? undefined
   }, d);
   addTaskRunEvent({
@@ -10208,19 +11275,19 @@ function addTaskRunArtifact(input, db) {
   if (!run)
     throw new Error(`Run not found: ${input.run_id}`);
   const id = uuid();
-  const timestamp = now();
-  const path = redactEvidenceText(input.path);
-  const description = input.description ? redactEvidenceText(input.description) : null;
-  const metadata = redactValue(input.metadata || {});
+  const timestamp2 = now();
+  const path = sanitizePreWriteText(input.path, "run_artifact.path");
+  const description = input.description ? sanitizePreWriteText(input.description, "run_artifact.description") : null;
+  const metadata = sanitizePreWriteValue(input.metadata || {}, "run_artifact.metadata");
   let sizeBytes = input.size_bytes ?? null;
   let digest = input.sha256 ?? null;
-  const stored = input.store_content !== false ? storeArtifactContent({ path: input.path, metadata, retention_days: input.retention_days, created_at: timestamp }) : null;
+  const stored = input.store_content !== false ? storeArtifactContent({ path: input.path, metadata, retention_days: input.retention_days, created_at: timestamp2 }) : null;
   if (stored) {
     sizeBytes = stored.size_bytes;
     digest = stored.sha256;
     metadata["artifact_store"] = stored.store;
   } else if (input.store_content === true) {
-    throw new Error(`Artifact file not found: ${input.path}`);
+    throw new Error(`Artifact file not found: ${path}`);
   }
   d.run("INSERT INTO task_run_artifacts (id, run_id, task_id, path, artifact_type, description, size_bytes, sha256, metadata, agent_id, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)", [
     id,
@@ -10233,7 +11300,7 @@ function addTaskRunArtifact(input, db) {
     digest,
     JSON.stringify(metadata),
     input.agent_id ?? run.agent_id,
-    timestamp
+    timestamp2
   ]);
   addTaskRunEvent({
     run_id: run.id,
@@ -10241,7 +11308,7 @@ function addTaskRunArtifact(input, db) {
     message: description || path,
     data: { path, artifact_type: input.artifact_type, size_bytes: sizeBytes, sha256: digest, stored: Boolean(stored) },
     agent_id: input.agent_id ?? run.agent_id ?? undefined,
-    created_at: timestamp
+    created_at: timestamp2
   }, d);
   return rowToArtifact(d.query("SELECT * FROM task_run_artifacts WHERE id = ?").get(id));
 }
@@ -10261,28 +11328,28 @@ function finishTaskRun(input, db) {
   const run = getTaskRun(runId, d);
   if (!run)
     throw new Error(`Run not found: ${input.run_id}`);
-  const timestamp = input.completed_at || now();
-  const summary = input.summary ? redactEvidenceText(input.summary) : null;
-  d.run("UPDATE task_runs SET status = ?, summary = COALESCE(?, summary), completed_at = ?, updated_at = ? WHERE id = ?", [input.status, summary, timestamp, timestamp, run.id]);
+  const timestamp2 = input.completed_at || now();
+  const summary = input.summary ? sanitizePreWriteText(input.summary, "run.summary") : null;
+  d.run("UPDATE task_runs SET status = ?, summary = COALESCE(?, summary), completed_at = ?, updated_at = ? WHERE id = ?", [input.status, summary, timestamp2, timestamp2, run.id]);
   addTaskRunEvent({
     run_id: run.id,
     event_type: input.status,
     message: summary || `run ${input.status}`,
     data: { status: input.status },
     agent_id: input.agent_id ?? run.agent_id ?? undefined,
-    created_at: timestamp
+    created_at: timestamp2
   }, d);
   const updated = getTaskRun(run.id, d);
   emitLocalEventHooksQuiet({
     type: `run.${input.status}`,
-    payload: { id: updated.id, task_id: updated.task_id, agent_id: updated.agent_id, status: updated.status, summary: updated.summary, completed_at: timestamp },
+    payload: { id: updated.id, task_id: updated.task_id, agent_id: updated.agent_id, status: updated.status, summary: updated.summary, completed_at: timestamp2 },
     databasePath: databasePathFromDatabase(d)
   });
   return updated;
 }
 function finishTaskRunTransaction(input, db) {
   const d = db || getDatabase();
-  const timestamp = input.completed_at || now();
+  const timestamp2 = input.completed_at || now();
   const status = input.status || "completed";
   const key = input.key ? normalizeTransactionKey({ key: input.key }) : "";
   const run = input.run_id ? getTaskRun(resolveTaskRunId(input.run_id, d), d) : key ? findTaskRunByTransactionKey(key, input.task_id, d) : null;
@@ -10300,7 +11367,7 @@ function finishTaskRunTransaction(input, db) {
       schema_version: LOOP_RUN_TRANSACTION_SCHEMA_VERSION,
       local_only: true,
       dry_run: dryRun,
-      processed_at: timestamp,
+      processed_at: timestamp2,
       action: conflict ? "conflict" : "matched",
       key: resolvedKey,
       run: summarizeTaskRun(run),
@@ -10313,10 +11380,10 @@ function finishTaskRunTransaction(input, db) {
       schema_version: LOOP_RUN_TRANSACTION_SCHEMA_VERSION,
       local_only: true,
       dry_run: true,
-      processed_at: timestamp,
+      processed_at: timestamp2,
       action: "preview",
       key: resolvedKey,
-      run: summarizeTaskRun({ ...run, status, summary: input.summary ?? run.summary, completed_at: timestamp, updated_at: timestamp }),
+      run: summarizeTaskRun({ ...run, status, summary: input.summary ?? run.summary, completed_at: timestamp2, updated_at: timestamp2 }),
       warnings: [],
       commands: loopRunCommands(run, resolvedKey)
     };
@@ -10326,13 +11393,13 @@ function finishTaskRunTransaction(input, db) {
     status,
     summary: input.summary,
     agent_id: input.agent_id,
-    completed_at: timestamp
+    completed_at: timestamp2
   }, d);
   return {
     schema_version: LOOP_RUN_TRANSACTION_SCHEMA_VERSION,
     local_only: true,
     dry_run: false,
-    processed_at: timestamp,
+    processed_at: timestamp2,
     action: "finished",
     key: resolvedKey,
     run: summarizeTaskRun(finished),
@@ -10362,7 +11429,7 @@ var init_task_runs = __esm(() => {
   init_artifact_store();
   init_event_emission_safety();
   init_event_hooks();
-  init_redaction();
+  init_prewrite_secrets();
   init_types();
   init_comments();
   init_database();
@@ -10490,7 +11557,7 @@ function inWindow(event, query) {
 function createCalendarItem(input, db) {
   const d = db || getDatabase();
   const id = uuid();
-  const timestamp = now();
+  const timestamp2 = now();
   const kind = input.kind || "work_block";
   d.run(`INSERT INTO local_calendar_items (
       id, kind, title, description, starts_at, ends_at, timezone, project_id, task_id, plan_id, run_id,
@@ -10509,8 +11576,8 @@ function createCalendarItem(input, db) {
     input.run_id || null,
     input.recurrence_rule || null,
     JSON.stringify(input.metadata || {}),
-    timestamp,
-    timestamp
+    timestamp2,
+    timestamp2
   ]);
   return getCalendarItem(id, d);
 }
@@ -10756,7 +11823,7 @@ var init_tasks = __esm(() => {
 // package.json
 var package_default = {
   name: "@hasna/todos",
-  version: "0.11.94",
+  version: "0.12.1",
   description: "Universal task management for AI coding agents - CLI + MCP server + interactive TUI",
   type: "module",
   main: "dist/index.js",
@@ -11390,12 +12457,66 @@ function contract(input) {
     }
   };
 }
+function closedContract(input) {
+  return {
+    ...input,
+    additionalProperties: false,
+    evolution: {
+      additionalFields: "forbidden",
+      removingRequiredFields: "breaking",
+      changingRequiredFieldTypes: "breaking",
+      nullableToNonNullable: "breaking"
+    }
+  };
+}
 var idField = field("string", "Stable UUID or short identifier.");
 var nullableIdField = field(["string", "null"], "Stable identifier when attached to another object.", true);
 var isoDateField = field("string", "ISO-8601 timestamp string.");
 var nullableIsoDateField = field(["string", "null"], "ISO-8601 timestamp string, or null when not set.", true);
 var metadataField = field("object", "JSON object metadata. Unknown keys are extension data.");
 var tagsField = field("array", "Array of string tags.");
+var TODOS_AUTHORITATIVE_JSON_PROJECTIONS = [
+  closedContract({
+    id: "pr_group_ci_proof",
+    name: "Authoritative PR Group CI Proof",
+    description: "Closed successful provider-CI evidence bound to one repository, PR, base, and exact head before conditional merge authorization.",
+    surfaces: ["api", "sdk"],
+    stability: "stable",
+    required: {
+      provider: field("string", "Authoritative CI provider identity."),
+      provider_run_id: field("string", "Provider-owned CI run or check-suite identity."),
+      status: field("string", "Terminal successful CI status."),
+      repository: field("string", "Canonical repository identity."),
+      pr_number: field("integer", "Concrete pull-request number."),
+      base_sha: field("string", "Exact base commit SHA."),
+      head_sha: field("string", "Exact reviewed and merge-authorized head commit SHA.")
+    },
+    optional: {}
+  }),
+  closedContract({
+    id: "pr_group_state_view",
+    name: "Authoritative PR Group State View",
+    description: "Closed package-owned projection for immutable task-to-PR lineage, repair accounting, append-only receipts, adapters, and diagnostics.",
+    surfaces: ["cli", "api", "sdk"],
+    stability: "stable",
+    required: {
+      schema_version: field("integer", "PR-group ledger schema version."),
+      authoritative: field("boolean", "Always true for package-owned ledger projections."),
+      authority: field("string", "Authority kind: local or remote."),
+      group: field("object", "Immutable PR-group lineage and current durable state."),
+      attempts: field("array", "Bounded writer-generation attempt history."),
+      latest_event: field(["object", "null"], "Latest append-only lifecycle event, or null.", true),
+      review_receipts: field("array", "Exact-head review receipts."),
+      conditional_merge_receipts: field("array", "Sequence-aware conditional merge receipts."),
+      merge_receipts: field("array", "Exact-head merge outcome receipts."),
+      cleanup_receipts: field("array", "Durable cleanup authorization receipts."),
+      cleanup_eligible: field("boolean", "Whether the complete cleanup proof has been accepted."),
+      adapters: field("object", "Closed WorkRun, EvidenceRef, ProofBundle, and DecisionEnvelope projections."),
+      diagnostics: field("object", "Bounded-projection completeness and limit diagnostics.")
+    },
+    optional: {}
+  })
+];
 var TODOS_JSON_CONTRACTS = [
   contract({
     id: "task",
@@ -13417,7 +14538,7 @@ function matchesType(value, expected) {
   return actual === "integer" && expected.includes("number");
 }
 function getJsonContract(contractId) {
-  return TODOS_JSON_CONTRACTS.find((contractItem) => contractItem.id === contractId) ?? null;
+  return [...TODOS_JSON_CONTRACTS, ...TODOS_AUTHORITATIVE_JSON_PROJECTIONS].find((contractItem) => contractItem.id === contractId) ?? null;
 }
 function validateJsonContract(contractId, value) {
   const contractItem = getJsonContract(contractId);
@@ -13427,6 +14548,7 @@ function validateJsonContract(contractId, value) {
   const record = value && typeof value === "object" && !Array.isArray(value) ? value : {};
   const missingRequired = [];
   const typeMismatches = [];
+  const unknownFields = contractItem.additionalProperties ? [] : Object.keys(record).filter((fieldName) => !(fieldName in contractItem.required) && !(fieldName in contractItem.optional));
   for (const [fieldName, fieldContract] of Object.entries(contractItem.required)) {
     if (!(fieldName in record)) {
       missingRequired.push(fieldName);
@@ -13439,7 +14561,7 @@ function validateJsonContract(contractId, value) {
     }
   }
   return {
-    ok: missingRequired.length === 0 && typeMismatches.length === 0,
+    ok: missingRequired.length === 0 && typeMismatches.length === 0 && unknownFields.length === 0,
     contractId,
     missingRequired,
     typeMismatches
@@ -13451,7 +14573,8 @@ function createJsonContractsManifest(options = {}) {
     schemaVersion: 1,
     generatedAt: options.generatedAt ?? new Date().toISOString(),
     package: source2(version),
-    contracts: TODOS_JSON_CONTRACTS
+    contracts: TODOS_JSON_CONTRACTS,
+    authoritativeProjections: TODOS_AUTHORITATIVE_JSON_PROJECTIONS
   };
 }
 var TODOS_JSON_CONTRACTS_MANIFEST = createJsonContractsManifest({
@@ -13467,6 +14590,7 @@ init_tasks();
 init_artifact_store();
 init_sync_utils();
 init_redaction();
+init_prewrite_secrets();
 var TODOS_LOCAL_BRIDGE_KIND = "hasna.todos.local-bridge";
 var TODOS_LOCAL_BRIDGE_SCHEMA_VERSION = 1;
 var dataKeys = [
@@ -13583,6 +14707,24 @@ var tableByKey = {
   local_calendar_items: "local_calendar_items"
 };
 var jsonColumns = new Set(["metadata", "tags", "data", "files_changed", "filters", "lanes"]);
+var structuralColumns = new Set([
+  "id",
+  "task_id",
+  "run_id",
+  "project_id",
+  "plan_id",
+  "task_list_id",
+  "parent_id",
+  "cycle_id",
+  "depends_on",
+  "external_project_id",
+  "external_task_id",
+  "short_id",
+  "sha",
+  "machine_id",
+  "version",
+  "schema_version"
+]);
 function packageSource(version) {
   return {
     packageName: "@hasna/todos",
@@ -13677,7 +14819,7 @@ function createLocalBridgeBundle(options = {}, db) {
   const runRows = queryByTaskIds(d, "SELECT * FROM task_runs WHERE task_id IN (__TASK_IDS__) ORDER BY started_at, created_at", taskIds);
   const runIds = runRows.map((row) => String(row.id));
   const project = options.project_id ? d.query("SELECT * FROM projects WHERE id = ?").get(options.project_id) : null;
-  const data = redactValue({
+  const rawData = {
     projects: options.project_id ? project ? [project] : [] : d.query("SELECT * FROM projects ORDER BY name").all(),
     task_lists: (options.project_id ? d.query("SELECT * FROM task_lists WHERE project_id = ? ORDER BY name").all(options.project_id) : d.query("SELECT * FROM task_lists ORDER BY name").all()).map(rowToTaskList2),
     plans: options.project_id ? d.query("SELECT * FROM plans WHERE project_id = ? ORDER BY created_at").all(options.project_id) : d.query("SELECT * FROM plans ORDER BY created_at").all(),
@@ -13695,7 +14837,8 @@ function createLocalBridgeBundle(options = {}, db) {
     saved_views: (options.project_id ? d.query("SELECT * FROM saved_search_views WHERE json_extract(filters, '$.project_id') = ? ORDER BY name").all(options.project_id) : d.query("SELECT * FROM saved_search_views ORDER BY name").all()).map(rowToSavedView),
     task_boards: (options.project_id ? d.query("SELECT * FROM task_boards WHERE project_id = ? ORDER BY name").all(options.project_id) : d.query("SELECT * FROM task_boards ORDER BY name").all()).map(rowToTaskBoard2),
     local_calendar_items: (options.project_id ? d.query("SELECT * FROM local_calendar_items WHERE project_id = ? ORDER BY starts_at, created_at").all(options.project_id) : d.query("SELECT * FROM local_calendar_items ORDER BY starts_at, created_at").all()).map(rowToCalendarItem2)
-  });
+  };
+  const data = options.redaction === "unsafe_plaintext" ? rawData : sanitizePreWriteValue(redactValue(rawData), "local_bridge.export");
   const artifactContents = data.run_artifacts.map((artifact) => exportStoredArtifactContent({
     id: artifact.id,
     path: artifact.path,
@@ -13783,6 +14926,13 @@ function prepareValue(column, value) {
     return JSON.stringify(value ?? (column === "tags" || column === "files_changed" ? [] : {}));
   return value === undefined ? null : value;
 }
+function sanitizeImportRecord(tableKey, row) {
+  const sanitized = {};
+  for (const [column, value] of Object.entries(row)) {
+    sanitized[column] = structuralColumns.has(column) ? value : sanitizePreWriteValue(value, `local_bridge.${tableKey}.${column}`);
+  }
+  return sanitized;
+}
 function slugifyPlanValue(value) {
   return typeof value === "string" ? value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") : "";
 }
@@ -13817,10 +14967,11 @@ function insertRecord(db, tableKey, row) {
   const table = tableByKey[tableKey];
   const columns = insertColumns[tableKey];
   const placeholders = columns.map(() => "?").join(", ");
-  const params = columns.map((column) => prepareValue(column, row[column]));
+  const safeRow = sanitizeImportRecord(tableKey, row);
+  const params = columns.map((column) => prepareValue(column, safeRow[column]));
   const result = db.run(`INSERT OR IGNORE INTO ${table} (${columns.join(", ")}) VALUES (${placeholders})`, params);
   if (tableKey === "tasks" && result.changes > 0) {
-    const tags = parseJsonArray2(row.tags);
+    const tags = parseJsonArray2(safeRow.tags);
     const stmt = db.prepare("INSERT OR IGNORE INTO task_tags (task_id, tag) VALUES (?, ?)");
     for (const tag of tags) {
       if (tag)
@@ -17281,14 +18432,14 @@ function getTaskContract(taskId, db) {
 }
 function requestTaskReview(input, db) {
   const task2 = taskOrThrow(input.task_id, db);
-  const timestamp = now();
+  const timestamp2 = now();
   const previous = readReview(task2.id, task2.metadata);
   const entry = {
     state: "requested",
     actor: input.requester,
     notes: input.notes ?? null,
     changes_requested: [],
-    at: timestamp
+    at: timestamp2
   };
   const review = {
     task_id: task2.id,
@@ -17297,7 +18448,7 @@ function requestTaskReview(input, db) {
     reviewer: input.reviewer ?? previous.reviewer,
     notes: input.notes ?? previous.notes,
     changes_requested: [],
-    requested_at: timestamp,
+    requested_at: timestamp2,
     reviewed_at: null,
     history: [...previous.history, entry]
   };
@@ -17306,7 +18457,7 @@ function requestTaskReview(input, db) {
 }
 function recordTaskReview(input, db) {
   const task2 = taskOrThrow(input.task_id, db);
-  const timestamp = now();
+  const timestamp2 = now();
   const previous = readReview(task2.id, task2.metadata);
   const changes = cleanList(input.changes_requested);
   const entry = {
@@ -17314,7 +18465,7 @@ function recordTaskReview(input, db) {
     actor: input.reviewer,
     notes: input.notes ?? null,
     changes_requested: changes,
-    at: timestamp
+    at: timestamp2
   };
   const review = {
     task_id: task2.id,
@@ -17324,7 +18475,7 @@ function recordTaskReview(input, db) {
     notes: input.notes ?? previous.notes,
     changes_requested: input.state === "changes_requested" ? changes : [],
     requested_at: previous.requested_at,
-    reviewed_at: timestamp,
+    reviewed_at: timestamp2,
     history: [...previous.history, entry]
   };
   writeMetadata(task2.id, { ...task2.metadata, [REVIEW_KEY]: review }, db);
@@ -17399,7 +18550,7 @@ function taskOrThrow2(taskId, db) {
   return task2;
 }
 function normalizeRule(input, existing) {
-  const timestamp = now();
+  const timestamp2 = now();
   const name = input.name.trim();
   if (!name)
     throw new Error("Review routing rule name is required");
@@ -17411,8 +18562,8 @@ function normalizeRule(input, existing) {
     tags: input.tags === undefined ? existing?.tags ?? [] : cleanList2(input.tags),
     priorities: input.priorities === undefined ? existing?.priorities ?? [] : cleanPriorityList(input.priorities),
     project_id: input.project_id ?? existing?.project_id ?? null,
-    created_at: existing?.created_at ?? timestamp,
-    updated_at: timestamp
+    created_at: existing?.created_at ?? timestamp2,
+    updated_at: timestamp2
   };
 }
 function readQueue(task2) {
@@ -17620,7 +18771,7 @@ function requestReviewQueue(input, db) {
     notes: input.notes ?? input.reason
   }, d);
   const updatedTask = taskOrThrow2(task2.id, d);
-  const timestamp = now();
+  const timestamp2 = now();
   const previous = readQueue(updatedTask);
   const queue = {
     schema_version: 1,
@@ -17633,10 +18784,10 @@ function requestReviewQueue(input, db) {
     notes: input.notes ?? previous?.notes ?? null,
     changes_requested: [],
     routing_rule: route.rule,
-    requested_at: timestamp,
+    requested_at: timestamp2,
     claimed_at: null,
     decided_at: null,
-    updated_at: timestamp,
+    updated_at: timestamp2,
     history: appendHistory(previous ?? {
       schema_version: 1,
       state: "requested",
@@ -17651,7 +18802,7 @@ function requestReviewQueue(input, db) {
       requested_at: null,
       claimed_at: null,
       decided_at: null,
-      updated_at: timestamp,
+      updated_at: timestamp2,
       history: []
     }, "requested", input.requester, input.notes ?? input.reason)
   };
@@ -17663,14 +18814,14 @@ function claimReviewItem(input, db) {
   const previous = derivedQueue(task2, d);
   if (!previous)
     throw new Error(`Task is not in a review queue: ${task2.id}`);
-  const timestamp = now();
+  const timestamp2 = now();
   const queue = {
     ...previous,
     state: "claimed",
     reviewer: input.reviewer,
     claimed_by: input.reviewer,
-    claimed_at: timestamp,
-    updated_at: timestamp,
+    claimed_at: timestamp2,
+    updated_at: timestamp2,
     history: appendHistory(previous, "claimed", input.reviewer, input.note)
   };
   return writeQueue(task2, queue, input.reviewer, "claimed", d);
@@ -17683,15 +18834,15 @@ function approveReviewItem(input, db) {
     throw new Error(`Task is not in a review queue: ${task2.id}`);
   recordTaskReview({ task_id: task2.id, state: "approved", reviewer: input.reviewer, notes: input.note }, d);
   const updatedTask = taskOrThrow2(task2.id, d);
-  const timestamp = now();
+  const timestamp2 = now();
   const queue = {
     ...previous,
     state: "approved",
     reviewer: input.reviewer,
     claimed_by: previous.claimed_by ?? input.reviewer,
     changes_requested: [],
-    decided_at: timestamp,
-    updated_at: timestamp,
+    decided_at: timestamp2,
+    updated_at: timestamp2,
     history: appendHistory(previous, "approved", input.reviewer, input.note)
   };
   return writeQueue(updatedTask, queue, input.reviewer, "approved", d);
@@ -17711,15 +18862,15 @@ function returnReviewItem(input, db) {
     changes_requested: changes
   }, d);
   const updatedTask = taskOrThrow2(task2.id, d);
-  const timestamp = now();
+  const timestamp2 = now();
   const queue = {
     ...previous,
     state: "returned",
     reviewer: input.reviewer,
     claimed_by: previous.claimed_by ?? input.reviewer,
     changes_requested: changes,
-    decided_at: timestamp,
-    updated_at: timestamp,
+    decided_at: timestamp2,
+    updated_at: timestamp2,
     history: appendHistory(previous, "returned", input.reviewer, input.note)
   };
   return writeQueue(updatedTask, queue, input.reviewer, "returned", d);
@@ -17732,15 +18883,15 @@ function reopenReviewItem(input, db) {
     throw new Error(`Task is not in a review queue: ${task2.id}`);
   recordTaskReview({ task_id: task2.id, state: "reopened", reviewer: input.reviewer, notes: input.note }, d);
   const updatedTask = taskOrThrow2(task2.id, d);
-  const timestamp = now();
+  const timestamp2 = now();
   const queue = {
     ...previous,
     state: "reopened",
     reviewer: input.reviewer,
     claimed_by: null,
     changes_requested: [],
-    decided_at: timestamp,
-    updated_at: timestamp,
+    decided_at: timestamp2,
+    updated_at: timestamp2,
     history: appendHistory(previous, "reopened", input.reviewer, input.note)
   };
   return writeQueue(updatedTask, queue, input.reviewer, "reopened", d);
@@ -17785,7 +18936,7 @@ init_plans();
 init_task_runs();
 init_config2();
 var LOCAL_ROADMAP_SCHEMA_VERSION = 1;
-function timestamp() {
+function timestamp2() {
   return new Date().toISOString();
 }
 function newId(prefix) {
@@ -17876,7 +19027,7 @@ function createRoadmap(input) {
   if (!name)
     throw new Error("Roadmap name is required");
   const store = readStore();
-  const now3 = timestamp();
+  const now3 = timestamp2();
   const roadmap = {
     id: newId("roadmap"),
     name,
@@ -17918,7 +19069,7 @@ function updateRoadmap(idOrName, input) {
     owner: input.owner === undefined ? existing.owner : cleanString(input.owner),
     agent_id: input.agent_id === undefined ? existing.agent_id : cleanString(input.agent_id),
     release: input.release === undefined ? existing.release : cleanString(input.release),
-    updated_at: timestamp()
+    updated_at: timestamp2()
   };
   store.roadmaps[id] = updated;
   writeStore(store);
@@ -17948,7 +19099,7 @@ function createMilestone(input) {
   const title = input.title.trim();
   if (!title)
     throw new Error("Milestone title is required");
-  const now3 = timestamp();
+  const now3 = timestamp2();
   const milestone = {
     id: newId("milestone"),
     roadmap_id: roadmapId,
@@ -17995,7 +19146,7 @@ function updateMilestone(idOrTitle, input) {
     run_ids: input.run_ids === undefined ? existing.run_ids : cleanList3(input.run_ids),
     release: input.release === undefined ? existing.release : cleanString(input.release),
     tags: input.tags === undefined ? existing.tags : cleanList3(input.tags),
-    updated_at: timestamp()
+    updated_at: timestamp2()
   };
   store.milestones[id] = updated;
   writeStore(store);
@@ -18010,11 +19161,11 @@ function deleteMilestone(idOrTitle) {
   delete store.milestones[id];
   const roadmap = store.roadmaps[milestone.roadmap_id];
   if (roadmap)
-    store.roadmaps[roadmap.id] = { ...roadmap, milestone_ids: roadmap.milestone_ids.filter((item) => item !== id), updated_at: timestamp() };
+    store.roadmaps[roadmap.id] = { ...roadmap, milestone_ids: roadmap.milestone_ids.filter((item) => item !== id), updated_at: timestamp2() };
   for (const key of Object.keys(store.releases)) {
     const release = store.releases[key];
     if (release.milestone_ids.includes(id))
-      store.releases[key] = { ...release, milestone_ids: release.milestone_ids.filter((item) => item !== id), updated_at: timestamp() };
+      store.releases[key] = { ...release, milestone_ids: release.milestone_ids.filter((item) => item !== id), updated_at: timestamp2() };
   }
   writeStore(store);
   return true;
@@ -18027,7 +19178,7 @@ function upsertReleaseGroup(input) {
     throw new Error("Release group name is required");
   const key = releaseKey(roadmapId, name);
   const existing = store.releases[key];
-  const now3 = timestamp();
+  const now3 = timestamp2();
   const release = {
     name,
     version: input.version === undefined ? existing?.version ?? null : cleanString(input.version),
@@ -18096,7 +19247,7 @@ function exportRoadmapBundle(idOrName) {
     schema_version: LOCAL_ROADMAP_SCHEMA_VERSION,
     kind: "hasna.todos.roadmap-bundle",
     local_only: true,
-    exported_at: timestamp(),
+    exported_at: timestamp2(),
     roadmap,
     milestones: roadmap.milestone_ids.map((milestoneId) => store.milestones[milestoneId]).filter(isMilestone),
     releases: listReleaseGroups(roadmap.id)
@@ -18747,7 +19898,7 @@ function issueToTask(issue, opts) {
 }
 
 // src/db/inbox.ts
-init_task_runs();
+init_prewrite_secrets();
 init_database();
 init_tasks();
 function parseMetadata3(value) {
@@ -18768,7 +19919,7 @@ function compactWhitespace(value) {
 }
 function fingerprintInboxInput(input) {
   const sourceType = input.source_type || detectInboxSourceType(input.body, input.source_url);
-  const normalized = compactWhitespace(redactEvidenceText(input.body)).slice(0, 8000);
+  const normalized = compactWhitespace(sanitizePreWriteText(input.body, "inbox.fingerprint")).slice(0, 8000);
   return createHash6("sha256").update(`${sourceType}
 ${input.source_url || ""}
 ${normalized}`).digest("hex");
@@ -18797,34 +19948,20 @@ function deriveInboxTitle(body, sourceType, sourceUrl) {
   return `${prefix}: ${compactWhitespace(firstUseful).slice(0, 90)}`;
 }
 function redactedMetadata(value) {
-  const redacted = {};
-  for (const [key, child] of Object.entries(value)) {
-    if (/api[_-]?key|token|secret|password/i.test(key)) {
-      redacted[key] = "[REDACTED]";
-    } else if (typeof child === "string") {
-      redacted[key] = redactEvidenceText(child);
-    } else if (child && typeof child === "object" && !Array.isArray(child)) {
-      redacted[key] = redactedMetadata(child);
-    } else if (Array.isArray(child)) {
-      redacted[key] = child.map((item) => typeof item === "string" ? redactEvidenceText(item) : item);
-    } else {
-      redacted[key] = child;
-    }
-  }
-  return redacted;
+  return sanitizePreWriteValue(value, "inbox.metadata");
 }
 function createInboxItem(input, db) {
   const d = db || getDatabase();
-  const body = redactEvidenceText(input.body);
+  const body = sanitizePreWriteText(input.body, "inbox.body");
   const sourceType = input.source_type || detectInboxSourceType(body, input.source_url);
-  const title = redactEvidenceText(input.title || deriveInboxTitle(body, sourceType, input.source_url));
+  const title = sanitizePreWriteText(input.title || deriveInboxTitle(body, sourceType, input.source_url), "inbox.title");
   const fingerprint = fingerprintInboxInput({ body, source_type: sourceType, source_url: input.source_url });
   const existing = d.query("SELECT * FROM inbox_items WHERE fingerprint = ?").get(fingerprint);
   if (existing) {
     const item = rowToInboxItem(existing);
     return { item, task: item.task_id ? getTask(item.task_id, d) : null, duplicate: true };
   }
-  const timestamp2 = now();
+  const timestamp3 = now();
   let task2 = null;
   const metadata = {
     ...input.metadata || {},
@@ -18836,8 +19973,8 @@ function createInboxItem(input, db) {
       title,
       description: [
         `**Inbox source:** ${sourceType}`,
-        input.source_name ? `**Source name:** ${redactEvidenceText(input.source_name)}` : null,
-        input.source_url ? `**Source URL:** ${redactEvidenceText(input.source_url)}` : null,
+        input.source_name ? `**Source name:** ${sanitizePreWriteText(input.source_name, "inbox.source_name")}` : null,
+        input.source_url ? `**Source URL:** ${sanitizePreWriteText(input.source_url, "inbox.source_url")}` : null,
         `**Captured context:**
 \`\`\`
 ${body.slice(0, 4000)}
@@ -18858,15 +19995,15 @@ ${body.slice(0, 4000)}
     id,
     task2?.id ?? null,
     sourceType,
-    input.source_name ? redactEvidenceText(input.source_name) : null,
-    input.source_url ? redactEvidenceText(input.source_url) : null,
+    input.source_name ? sanitizePreWriteText(input.source_name, "inbox.source_name") : null,
+    input.source_url ? sanitizePreWriteText(input.source_url, "inbox.source_url") : null,
     title,
     body,
     fingerprint,
     input.status || "triaged",
     JSON.stringify(redactedMetadata(metadata)),
-    timestamp2,
-    timestamp2
+    timestamp3,
+    timestamp3
   ]);
   return { item: getInboxItem(id, d), task: task2, duplicate: false };
 }
@@ -18920,7 +20057,7 @@ function rowToRelationship(row) {
 function addTaskRelationship(input, db) {
   const d = db || getDatabase();
   const id = uuid();
-  const timestamp2 = now();
+  const timestamp3 = now();
   if (input.source_task_id === input.target_task_id) {
     throw new Error("Cannot create a relationship between a task and itself");
   }
@@ -18946,7 +20083,7 @@ function addTaskRelationship(input, db) {
     input.relationship_type,
     JSON.stringify(input.metadata || {}),
     input.created_by || null,
-    timestamp2
+    timestamp3
   ]);
   return getTaskRelationship(id, d);
 }
@@ -20175,15 +21312,15 @@ function storedReportSummary(report) {
     occurred_at: report.occurred_at ?? null
   };
 }
-function testerMetadata(report, fingerprint2, previous, timestamp2) {
+function testerMetadata(report, fingerprint2, previous, timestamp3) {
   const occurrenceCount = typeof previous?.["occurrence_count"] === "number" ? previous["occurrence_count"] + 1 : 1;
   const previousRecent = previous?.["recent_reports"];
   const recent = Array.isArray(previousRecent) ? previousRecent : [];
   return {
     schema_version: TESTERS_ISSUE_REPORT_SCHEMA_VERSION,
     fingerprint: fingerprint2,
-    first_seen_at: asString3(previous?.["first_seen_at"]) || timestamp2,
-    last_seen_at: timestamp2,
+    first_seen_at: asString3(previous?.["first_seen_at"]) || timestamp3,
+    last_seen_at: timestamp3,
     occurrence_count: occurrenceCount,
     latest_report: storedReportSummary(report),
     recent_reports: [...recent.slice(-4), storedReportSummary(report)]
@@ -20223,7 +21360,7 @@ function commandsFor(task2) {
     `todos dedupe scan --threshold 0.8 --json`
   ];
 }
-function updateExistingTask(task2, report, fingerprint2, input, timestamp2, db) {
+function updateExistingTask(task2, report, fingerprint2, input, timestamp3, db) {
   if (input.update_existing === false)
     return { action: "matched", task: task2 };
   const previous = asObject3(task2.metadata["tester_issue_report"]);
@@ -20243,7 +21380,7 @@ function updateExistingTask(task2, report, fingerprint2, input, timestamp2, db)
       ...sourceMetadata(report),
       external_ref: fingerprint2,
       tester_issue_fingerprint: fingerprint2,
-      tester_issue_report: testerMetadata(report, fingerprint2, previous, timestamp2)
+      tester_issue_report: testerMetadata(report, fingerprint2, previous, timestamp3)
     },
     ...input.assigned_to !== undefined ? { assigned_to: input.assigned_to } : {},
     task_type: task2.task_type || "bug"
@@ -20252,7 +21389,7 @@ function updateExistingTask(task2, report, fingerprint2, input, timestamp2, db)
 }
 function upsertTesterIssueReport(input, db) {
   const d = db || getDatabase();
-  const timestamp2 = now();
+  const timestamp3 = now();
   const warnings = [];
   const report = normalizeTesterIssueReport(input.report, input.default_priority || "medium");
   const fingerprint2 = fingerprintTesterIssueReport(report);
@@ -20263,7 +21400,7 @@ function upsertTesterIssueReport(input, db) {
       schema_version: TESTERS_ISSUE_REPORT_RESULT_SCHEMA_VERSION,
       local_only: true,
       dry_run: true,
-      processed_at: timestamp2,
+      processed_at: timestamp3,
       action,
       fingerprint: fingerprint2,
       report,
@@ -20273,12 +21410,12 @@ function upsertTesterIssueReport(input, db) {
     };
   }
   if (existing) {
-    const updated = updateExistingTask(existing, report, fingerprint2, input, timestamp2, d);
+    const updated = updateExistingTask(existing, report, fingerprint2, input, timestamp3, d);
     return {
       schema_version: TESTERS_ISSUE_REPORT_RESULT_SCHEMA_VERSION,
       local_only: true,
       dry_run: false,
-      processed_at: timestamp2,
+      processed_at: timestamp3,
       action: updated.action,
       fingerprint: fingerprint2,
       report,
@@ -20298,7 +21435,7 @@ function upsertTesterIssueReport(input, db) {
       ...sourceMetadata(report),
       external_ref: fingerprint2,
       tester_issue_fingerprint: fingerprint2,
-      tester_issue_report: testerMetadata(report, fingerprint2, null, timestamp2),
+      tester_issue_report: testerMetadata(report, fingerprint2, null, timestamp3),
       tester_issue_report_raw: redactValue({
         ...report,
         evidence: report.evidence ? {
@@ -20317,7 +21454,7 @@ function upsertTesterIssueReport(input, db) {
     schema_version: TESTERS_ISSUE_REPORT_RESULT_SCHEMA_VERSION,
     local_only: true,
     dry_run: false,
-    processed_at: timestamp2,
+    processed_at: timestamp3,
     action: "created",
     fingerprint: fingerprint2,
     report,
@@ -20414,10 +21551,10 @@ function parseQuietHours(value, timezone = "local") {
   parseClock(end);
   return { start, end, timezone };
 }
-function isQuietTime(quiet, timestamp2) {
+function isQuietTime(quiet, timestamp3) {
   if (!quiet)
     return false;
-  const date = new Date(timestamp2);
+  const date = new Date(timestamp3);
   if (Number.isNaN(date.getTime()))
     return false;
   const minutes = quiet.timezone === "utc" ? date.getUTCHours() * 60 + date.getUTCMinutes() : date.getHours() * 60 + date.getMinutes();
@@ -20436,7 +21573,7 @@ function normalizeRule2(input, existing) {
     throw new Error(`unsupported terminal notification severity: ${severity}`);
   if (!VALID_FORMATS.has(format))
     throw new Error(`unsupported terminal notification format: ${format}`);
-  const timestamp2 = new Date().toISOString();
+  const timestamp3 = new Date().toISOString();
   return {
     ...existing,
     name: safeName2(input.name),
@@ -20451,8 +21588,8 @@ function normalizeRule2(input, existing) {
     project_ids: normalizeList(input.project_ids) ?? existing?.project_ids,
     contains: normalizeList(input.contains) ?? existing?.contains,
     quiet_hours: input.quiet_hours ?? existing?.quiet_hours,
-    created_at: existing?.created_at || timestamp2,
-    updated_at: timestamp2
+    created_at: existing?.created_at || timestamp3,
+    updated_at: timestamp3
   };
 }
 function eventSeverity(eventType) {
@@ -20513,7 +21650,7 @@ function removeTerminalNotificationRule(name) {
   return true;
 }
 function evaluateTerminalWatchRules(input, rules = listTerminalNotificationRules()) {
-  const timestamp2 = input.timestamp || new Date().toISOString();
+  const timestamp3 = input.timestamp || new Date().toISOString();
   const payload = redactValue(input.payload || {});
   return rules.map((rule) => {
     const skipped = [];
@@ -20534,7 +21671,7 @@ function evaluateTerminalWatchRules(input, rules = listTerminalNotificationRules
       skipped.push("project does not match rule");
     if (!containsMatches(rule.contains, payload))
       skipped.push("payload text does not match rule");
-    if (isQuietTime(rule.quiet_hours, timestamp2))
+    if (isQuietTime(rule.quiet_hours, timestamp3))
       skipped.push("quiet hours active");
     const matched = skipped.length === 0;
     const title = asString4(payload["title"]) || asString4(payload["name"]) || input.type;
@@ -20545,7 +21682,7 @@ function evaluateTerminalWatchRules(input, rules = listTerminalNotificationRules
       severity,
       title,
       message: `${input.type}: ${title}`,
-      timestamp: timestamp2,
+      timestamp: timestamp3,
       task_id: taskId,
       project_id: asString4(payload["project_id"]),
       agent_id: asString4(payload["agent_id"]) || asString4(payload["assigned_to"]),
@@ -20601,10 +21738,10 @@ function parseClock2(value) {
     throw new Error("quiet hours must use HH:MM-HH:MM");
   return Number(match[1]) * 60 + Number(match[2]);
 }
-function quietActive(quiet, timestamp2) {
+function quietActive(quiet, timestamp3) {
   if (!quiet)
     return false;
-  const date = new Date(timestamp2);
+  const date = new Date(timestamp3);
   if (Number.isNaN(date.getTime()))
     return false;
   const current = quiet.timezone === "utc" ? date.getUTCHours() * 60 + date.getUTCMinutes() : date.getHours() * 60 + date.getMinutes();
@@ -21538,6 +22675,7 @@ function renderLocalReportMarkdown(report) {
 // src/lib/local-encryption.ts
 init_config2();
 init_redaction();
+init_prewrite_secrets();
 import { createCipheriv, createDecipheriv, createHash as createHash8, randomBytes, scryptSync, timingSafeEqual as timingSafeEqual2 } from "crypto";
 var TODOS_ENCRYPTED_VALUE_KIND = "hasna.todos.encrypted-value";
 var TODOS_ENCRYPTED_BRIDGE_KIND = "hasna.todos.encrypted-bridge";
@@ -21597,7 +22735,7 @@ function upsertEncryptionProfile(input) {
   const name = normalizeProfileName(input.name);
   const config = loadConfig();
   const existing = config.encryption_profiles?.[name];
-  const timestamp2 = now3();
+  const timestamp3 = now3();
   const profile = {
     name,
     algorithm: "aes-256-gcm",
@@ -21605,8 +22743,8 @@ function upsertEncryptionProfile(input) {
     key_env: input.key_env?.trim() || existing?.key_env || DEFAULT_ENCRYPTION_KEY_ENV,
     salt: input.salt || existing?.salt || randomBase64(16),
     description: input.description ?? existing?.description,
-    created_at: existing?.created_at || timestamp2,
-    updated_at: timestamp2
+    created_at: existing?.created_at || timestamp3,
+    updated_at: timestamp3
   };
   if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(profile.key_env))
     throw new Error("key_env must be a valid environment variable name");
@@ -21704,6 +22842,9 @@ function looksSensitiveKey(key) {
   return /api[_-]?key|token|secret|password|credential|evidence|artifact|output|summary|metadata/i.test(key);
 }
 function encryptSensitiveFields(value, options = {}) {
+  if (typeof value === "string") {
+    return scanPreWriteText(value, "encrypted_export.string").clean ? value : encryptValue(value, options);
+  }
   if (!value || typeof value !== "object")
     return value;
   if (Array.isArray(value))
@@ -21782,14 +22923,15 @@ function applyExportProfile(data, options = {}) {
   const warnings = [];
   if (profile === "plaintext") {
     if (!options.acknowledge_plaintext) {
-      warnings.push("Export profile 'plaintext' includes unredacted data; pass acknowledge_plaintext=true to confirm.");
+      throw new Error("Export profile 'plaintext' includes unredacted data; pass acknowledge_plaintext=true to confirm, or use the redacted/encrypted profiles.");
     }
+    warnings.push("Export profile 'plaintext' includes unredacted data; prefer encrypted exports for sensitive task evidence.");
     return { profile, data, warnings };
   }
   if (profile === "encrypted") {
     return { profile, data: encryptSensitiveFields(data, { profile: DEFAULT_ENCRYPTION_PROFILE, env: options.env }), warnings };
   }
-  return { profile, data: redactValue(data), warnings };
+  return { profile, data: sanitizePreWriteValue(redactValue(data), "export.redacted"), warnings };
 }
 
 // src/contracts.ts