@zq-silk/yui 0.13.9 → 0.14.0

package/dist/storage/sqliteSchema.js

@@ -22,15 +22,15 @@
  * by SQLite (DDL is transactional) and re-applied on the next open.
  */
 import { createHash } from "node:crypto";
-/** The SQLite layout version (state.json layout 6 -> SQLite layout 7, per §8.1). */
-export const SQLITE_LAYOUT_VERSION = 7;
+/** The current SQLite layout version. */
+export const SQLITE_LAYOUT_VERSION = 8;
 /** The aggregate version of the normalized SQLite schema. */
-export const SQLITE_AGGREGATE_VERSION = 1;
+export const SQLITE_AGGREGATE_VERSION = 2;
 /** The current schema migration version. */
-export const SQLITE_SCHEMA_VERSION = 18;
+export const SQLITE_SCHEMA_VERSION = 1;
 /** Telemetry retention bounds (§4.4). Open question 3 in §11; defaults from the design. */
 export const TELEMETRY_KEEP_PER_GENERATION = 200;
-export const TELEMETRY_RUN_CAP = 50_000;
+export const TELEMETRY_TURN_CAP = 50_000;
 /**
  * Version 1 migration: creates every table and index.
  *
@@ -38,11 +38,10 @@ export const TELEMETRY_RUN_CAP = 50_000;
  * the store; `journal_mode=WAL` is a persistent database property set on open.
  * The migration itself only contains schema objects.
  *
- * This released SQL string, including its comments, is checksummed persistent
- * history and must remain byte-for-byte unchanged. The `operator-notification`
- * projection kind it creates is retained only for old layout-7 Homes.
+ * This is the direct current baseline for a new Home. Its checksum rejects any
+ * database initialized from a different physical contract.
  */
-const MIGRATION_1_SQL = `
+const BASELINE_CORE_SQL = `
 -- Global catalog and coordination (§4.1) -------------------------------------
 
 CREATE TABLE IF NOT EXISTS home_meta (
@@ -182,10 +181,14 @@ CREATE TABLE IF NOT EXISTS mailboxes (
   next_sequence INTEGER NOT NULL,
   processing    TEXT,
   pending       TEXT,
+  recent_dedupe_keys TEXT NOT NULL DEFAULT '[]',
   UNIQUE (target_kind, task_id, role_name)
 );
 CREATE UNIQUE INDEX IF NOT EXISTS idx_mailboxes_target_key
   ON mailboxes(target_key);
+CREATE INDEX IF NOT EXISTS idx_mailboxes_ready
+  ON mailboxes(target_key)
+  WHERE processing IS NOT NULL OR json_type(pending) <> 'null';
 
 -- Task-partitioned tables (§4.3). Every task-local read constrains task_id. ----
 
@@ -232,22 +235,22 @@ CREATE TABLE IF NOT EXISTS work_item_candidates (
   PRIMARY KEY (task_id, candidate_id)
 );
 
-CREATE TABLE IF NOT EXISTS agent_runs (
+CREATE TABLE IF NOT EXISTS turns (
   task_id    TEXT NOT NULL,
-  run_id     TEXT NOT NULL,
+  turn_id    TEXT NOT NULL,
   role_name  TEXT NOT NULL,
   status     TEXT NOT NULL,
   payload    TEXT NOT NULL,
   updated_at TEXT NOT NULL,
-  PRIMARY KEY (task_id, run_id)
+  PRIMARY KEY (task_id, turn_id)
 );
-CREATE INDEX IF NOT EXISTS idx_agent_runs_role_status ON agent_runs(task_id, role_name, status);
+CREATE INDEX IF NOT EXISTS idx_turns_role_status ON turns(task_id, role_name, status);
 
--- Active-run pointers (getActiveAgentRun / execution-lane runs).
-CREATE TABLE IF NOT EXISTS active_runs (
+-- Active-Turn pointers (getActiveTurn / execution-lane Turns).
+CREATE TABLE IF NOT EXISTS active_turns (
   task_id    TEXT NOT NULL,
   pointer    TEXT NOT NULL,
-  run_id     TEXT NOT NULL,
+  turn_id    TEXT NOT NULL,
   payload    TEXT NOT NULL,
   updated_at TEXT NOT NULL,
   PRIMARY KEY (task_id, pointer)
@@ -303,6 +306,9 @@ CREATE TABLE IF NOT EXISTS input_requests (
   PRIMARY KEY (task_id, input_id)
 );
 CREATE INDEX IF NOT EXISTS idx_input_open ON input_requests(task_id, status) WHERE status <> 'resolved';
+CREATE INDEX IF NOT EXISTS idx_input_requests_open_hot
+  ON input_requests(task_id, input_id)
+  WHERE status = 'open';
 
 CREATE TABLE IF NOT EXISTS decisions (
   task_id     TEXT NOT NULL,
@@ -344,30 +350,27 @@ CREATE TABLE IF NOT EXISTS task_projections (
 CREATE TABLE IF NOT EXISTS telemetry (
   task_id     TEXT NOT NULL,
   role_name   TEXT NOT NULL,
-  run_id      TEXT NOT NULL,
+  turn_id     TEXT NOT NULL,
   generation  TEXT NOT NULL,
   progress_id TEXT NOT NULL,
   sequence    INTEGER,
   payload     TEXT NOT NULL,
   received_at TEXT NOT NULL,
-  PRIMARY KEY (task_id, role_name, run_id, generation, progress_id)
+  PRIMARY KEY (task_id, role_name, turn_id, generation, progress_id)
 ) WITHOUT ROWID;
-CREATE INDEX IF NOT EXISTS idx_telemetry_run ON telemetry(task_id, run_id);
+CREATE INDEX IF NOT EXISTS idx_telemetry_turn ON telemetry(task_id, turn_id);
 `;
-/**
- * Migration 2: post-baseline task-scoped record families. This single
- * migration creates the DurableJob, CapabilityGrant, and ReleaseWorkflow
- * tables so a fresh database receives the complete merged schema atomically.
- */
-const MIGRATION_2_SQL = `
+/** Task-scoped execution and release record families. */
+const BASELINE_JOB_AND_RELEASE_SQL = `
 CREATE TABLE IF NOT EXISTS durable_jobs (
-  job_id           TEXT PRIMARY KEY,
+  job_id           TEXT NOT NULL,
   task_id          TEXT NOT NULL,
   idempotency_key  TEXT,
   status           TEXT NOT NULL,
   payload          TEXT NOT NULL,
   created_at       TEXT NOT NULL,
-  updated_at       TEXT NOT NULL
+  updated_at       TEXT NOT NULL,
+  PRIMARY KEY (task_id, job_id)
 );
 CREATE INDEX IF NOT EXISTS idx_durable_jobs_task ON durable_jobs(task_id);
 CREATE INDEX IF NOT EXISTS idx_durable_jobs_status ON durable_jobs(status);
@@ -389,12 +392,8 @@ CREATE TABLE IF NOT EXISTS release_workflows (
   PRIMARY KEY (task_id, workflow_id)
 );
 `;
-/**
- * Migration 3: Job caller key hashes (task-14, rr13). Durable SHA-256 hashes of
- * the caller key bound to each launched Session, used to fail-closed verify a
- * DurableJob's caller against durable Run state.
- */
-const MIGRATION_3_SQL = `
+/** Durable caller-key hashes used to verify DurableJob ownership. */
+const BASELINE_JOB_CALLER_SQL = `
 CREATE TABLE IF NOT EXISTS job_caller_key_hashes (
   task_id    TEXT NOT NULL,
   role_name  TEXT NOT NULL,
@@ -405,48 +404,17 @@ CREATE TABLE IF NOT EXISTS job_caller_key_hashes (
 );
 `;
 /**
- * Migration 4: DurableJob IDs are Task-local.  Migration 2 accidentally made
- * job_id the global primary key, so two Tasks allocating their first `job-1`
- * could overwrite one another through the upsert path.  Rebuild the table with
- * the actual record identity `(task_id, job_id)` and restore its indexes.
- * Never edit migration 2's checksum: existing Homes reach this repair through
- * this adjacent schema migration.
- */
-const MIGRATION_4_SQL = `
-CREATE TABLE durable_jobs_v4 (
-  job_id           TEXT NOT NULL,
-  task_id          TEXT NOT NULL,
-  idempotency_key  TEXT,
-  status           TEXT NOT NULL,
-  payload          TEXT NOT NULL,
-  created_at       TEXT NOT NULL,
-  updated_at       TEXT NOT NULL,
-  PRIMARY KEY (task_id, job_id)
-);
-INSERT INTO durable_jobs_v4
-  (job_id, task_id, idempotency_key, status, payload, created_at, updated_at)
-SELECT job_id, task_id, idempotency_key, status, payload, created_at, updated_at
-FROM durable_jobs;
-DROP TABLE durable_jobs;
-ALTER TABLE durable_jobs_v4 RENAME TO durable_jobs;
-CREATE INDEX idx_durable_jobs_task ON durable_jobs(task_id);
-CREATE INDEX idx_durable_jobs_status ON durable_jobs(status);
-CREATE UNIQUE INDEX idx_durable_jobs_idempotency
-  ON durable_jobs(task_id, idempotency_key) WHERE idempotency_key IS NOT NULL;
-`;
-/**
- * Migration 5: telemetry aggregate (Issue 09). The `telemetry` table (migration
- * 1, §4.4) stores the bounded latest-per-key progress window; this companion
- * table holds the authoritative per-Run/generation summary (count, first/last,
+ * The `telemetry` table stores the bounded latest-per-key progress window; this companion
+ * table holds the authoritative per-Turn/generation summary (count, first/last,
  * max sequence, error count) so aggregates stay accurate after the window is
  * pruned. Triggers maintain it on telemetry INSERT/UPDATE; DELETE intentionally
  * leaves it untouched because pruned rows were still observed.
  */
-const MIGRATION_5_SQL = `
+const BASELINE_TELEMETRY_AGGREGATE_SQL = `
 CREATE TABLE IF NOT EXISTS telemetry_aggregate (
   task_id      TEXT NOT NULL,
   role_name    TEXT NOT NULL,
-  run_id       TEXT NOT NULL,
+  turn_id      TEXT NOT NULL,
   generation   TEXT NOT NULL,
   first_at     TEXT NOT NULL,
   last_at      TEXT NOT NULL,
@@ -454,21 +422,21 @@ CREATE TABLE IF NOT EXISTS telemetry_aggregate (
   max_sequence INTEGER,
   error_count  INTEGER NOT NULL DEFAULT 0,
   updated_at   TEXT NOT NULL,
-  PRIMARY KEY (task_id, role_name, run_id, generation)
+  PRIMARY KEY (task_id, role_name, turn_id, generation)
 ) WITHOUT ROWID;
 
 CREATE TRIGGER IF NOT EXISTS telemetry_ai AFTER INSERT ON telemetry
 BEGIN
   INSERT INTO telemetry_aggregate
-    (task_id, role_name, run_id, generation, first_at, last_at, count, max_sequence, error_count, updated_at)
+    (task_id, role_name, turn_id, generation, first_at, last_at, count, max_sequence, error_count, updated_at)
   VALUES
-    (NEW.task_id, NEW.role_name, NEW.run_id, NEW.generation, NEW.received_at, NEW.received_at, 1, NEW.sequence,
+    (NEW.task_id, NEW.role_name, NEW.turn_id, NEW.generation, NEW.received_at, NEW.received_at, 1, NEW.sequence,
      CASE WHEN json_valid(NEW.payload)
           AND (COALESCE(json_extract(NEW.payload, '$.error'), '') <> ''
                OR COALESCE(json_extract(NEW.payload, '$.errorKind'), '') <> '')
          THEN 1 ELSE 0 END,
      NEW.received_at)
-  ON CONFLICT(task_id, role_name, run_id, generation) DO UPDATE SET
+  ON CONFLICT(task_id, role_name, turn_id, generation) DO UPDATE SET
     first_at = MIN(telemetry_aggregate.first_at, excluded.first_at),
     last_at = MAX(telemetry_aggregate.last_at, excluded.last_at),
     count = telemetry_aggregate.count + 1,
@@ -489,15 +457,15 @@ BEGIN
       THEN NEW.sequence ELSE max_sequence END,
     updated_at = NEW.received_at
   WHERE task_id = NEW.task_id AND role_name = NEW.role_name
-    AND run_id = NEW.run_id AND generation = NEW.generation;
+    AND turn_id = NEW.turn_id AND generation = NEW.generation;
 END;
 `;
 /**
- * Migration 6: Issue 06 ReviewFinding ledger. Cross-Round semantic review
+ * Cross-Round semantic review
  * findings with stable keys and Leader dispositions. Failed execution attempts
  * never create rows; only completed Rounds feed the ledger.
  */
-const MIGRATION_6_SQL = `
+const BASELINE_REVIEW_FINDING_SQL = `
 CREATE TABLE IF NOT EXISTS review_findings (
   task_id     TEXT NOT NULL,
   finding_id  TEXT NOT NULL,
@@ -511,13 +479,13 @@ CREATE INDEX IF NOT EXISTS idx_review_findings_task ON review_findings(task_id);
 CREATE INDEX IF NOT EXISTS idx_review_findings_stable_key ON review_findings(task_id, stable_key);
 `;
 /**
- * Version 5 migration: session owner physical identity records (Issue 03).
+ * Session owner physical identity records.
  *
  * One row per runtime generation, keyed by launch id. The payload column
  * stores the full versioned JSON record; typed columns support the
  * reconciliation queries (task/role lookup, PID liveness).
  */
-const MIGRATION_7_SQL = `
+const BASELINE_SESSION_OWNER_SQL = `
 CREATE TABLE IF NOT EXISTS session_owners (
   launch_id          TEXT PRIMARY KEY,
   scope              TEXT NOT NULL CHECK (scope IN ('task','global')),
@@ -533,14 +501,14 @@ CREATE INDEX IF NOT EXISTS idx_session_owners_task
   ON session_owners(task_id, role_name);
 `;
 /**
- * Migration 8: Resource GC registry (Issue 10).
+ * Resource GC registry.
  *
  * GC-owned table for resource lifecycle records.  The registry is GC's own
  * state — it is not part of the aggregate and never participates in aggregate
  * versioning.  Records are stored as full versioned JSON in `payload`, with
  * typed columns for the fields GC queries (disposition, kind, task_id).
  */
-const MIGRATION_8_SQL = `
+const BASELINE_RESOURCE_REGISTRY_SQL = `
 CREATE TABLE IF NOT EXISTS resource_registry (
   id          TEXT PRIMARY KEY,
   kind        TEXT NOT NULL,
@@ -557,14 +525,14 @@ CREATE INDEX IF NOT EXISTS idx_resource_registry_task
   ON resource_registry(task_id);
 `;
 /**
- * Migration 9: GateArtifact storage (Issue 08). Content-addressed gate
+ * Content-addressed GateArtifact storage. Content-addressed gate
  * evidence records with per-step logs stored as BLOBs. The artifact key is
  * the SHA-256 of the identity tuple (Project + commit + plan digest +
  * toolchain digest + L2 boundary), so the same tuple always maps to one row.
  * Typed columns support the reuse lookup paths (exact-commit L2 search,
  * Project-level prune) without scanning payloads.
  */
-const MIGRATION_9_SQL = `
+const BASELINE_GATE_ARTIFACT_SQL = `
 CREATE TABLE IF NOT EXISTS gate_artifacts (
   key               TEXT PRIMARY KEY,
   project_id        TEXT NOT NULL,
@@ -597,29 +565,8 @@ CREATE TABLE IF NOT EXISTS gate_artifact_logs (
   FOREIGN KEY (artifact_key) REFERENCES gate_artifacts(key) ON DELETE CASCADE
 );
 `;
-/**
- * Migration 10: bounded ready-mailbox lookup for the Controller hot path.
- *
- * Historical empty mailboxes remain durable, but only mailboxes with a
- * processing or pending batch require scheduling.  The partial index contains
- * exactly that unsettled set in target-key order, so the Controller's recovery
- * query is O(log H + ready) instead of scanning every historical mailbox.
- */
-const MIGRATION_10_SQL = `
-CREATE INDEX IF NOT EXISTS idx_mailboxes_ready
-  ON mailboxes(target_key)
-  WHERE processing IS NOT NULL OR pending IS NOT NULL;
-`;
-/**
- * Migration 11: bounded current-Session projection for runtime cleanup.
- *
- * RoleSessionSet payloads remain authoritative. This table contains only the
- * current active Agent Session while it is non-stopped, so terminal Session
- * history cannot enlarge Controller cleanup discovery. Runtime writes maintain
- * it in the same transaction as the source payload; this migration performs
- * the one-time deterministic backfill for existing layout-7 Homes.
- */
-const MIGRATION_11_SQL = `
+/** Bounded current-Session projection for runtime cleanup. */
+const BASELINE_RUNTIME_SESSION_SQL = `
 CREATE TABLE IF NOT EXISTS runtime_session_candidates (
   scope               TEXT NOT NULL CHECK (scope IN ('task','global')),
   task_id             TEXT NOT NULL,
@@ -628,7 +575,6 @@ CREATE TABLE IF NOT EXISTS runtime_session_candidates (
   adapter_id          TEXT NOT NULL,
   native_session_id   TEXT NOT NULL,
   launch_id           TEXT,
-  status              TEXT NOT NULL CHECK (status IN ('reserved','ready','running','broken')),
   session_updated_at  TEXT NOT NULL,
   cleanup_required    INTEGER NOT NULL CHECK (cleanup_required IN (0,1)),
   PRIMARY KEY (scope, task_id, role_name),
@@ -637,234 +583,20 @@ CREATE TABLE IF NOT EXISTS runtime_session_candidates (
     OR (scope = 'global' AND task_id = '')
   ),
   CHECK (
-    cleanup_required = CASE
-      WHEN status NOT IN ('stopped','broken')
-        AND (status = 'running' OR launch_id IS NOT NULL)
-      THEN 1 ELSE 0
-    END
+    cleanup_required = CASE WHEN launch_id IS NOT NULL THEN 1 ELSE 0 END
   )
 );
 
 CREATE INDEX IF NOT EXISTS idx_runtime_session_cleanup_required
   ON runtime_session_candidates(scope, task_id, role_name)
   WHERE cleanup_required = 1;
-
-INSERT INTO runtime_session_candidates (
-  scope, task_id, role_name, agent_id, adapter_id, native_session_id,
-  launch_id, status, session_updated_at, cleanup_required
-)
-SELECT
-  'task', source.task_id, source.role_name,
-  json_extract(active.value, '$.agentId'),
-  json_extract(active.value, '$.adapterId'),
-  json_extract(active.value, '$.nativeSessionId'),
-  json_extract(active.value, '$.launchId'),
-  json_extract(active.value, '$.status'),
-  json_extract(active.value, '$.updatedAt'),
-  CASE
-    WHEN json_extract(active.value, '$.status') NOT IN ('stopped','broken')
-      AND (
-        json_extract(active.value, '$.status') = 'running'
-        OR json_type(active.value, '$.launchId') = 'text'
-      )
-    THEN 1 ELSE 0
-  END
-FROM role_session_sets AS source
-JOIN json_each(source.payload, '$.sessions') AS active
-  ON active.key = json_extract(source.payload, '$.activeAgentId')
-WHERE json_extract(active.value, '$.status') <> 'stopped';
-
-INSERT INTO runtime_session_candidates (
-  scope, task_id, role_name, agent_id, adapter_id, native_session_id,
-  launch_id, status, session_updated_at, cleanup_required
-)
-SELECT
-  'global', '', source.name,
-  json_extract(active.value, '$.agentId'),
-  json_extract(active.value, '$.adapterId'),
-  json_extract(active.value, '$.nativeSessionId'),
-  json_extract(active.value, '$.launchId'),
-  json_extract(active.value, '$.status'),
-  json_extract(active.value, '$.updatedAt'),
-  CASE
-    WHEN json_extract(active.value, '$.status') NOT IN ('stopped','broken')
-      AND (
-        json_extract(active.value, '$.status') = 'running'
-        OR json_type(active.value, '$.launchId') = 'text'
-      )
-    THEN 1 ELSE 0
-  END
-FROM global_role_session_sets AS source
-JOIN json_each(source.payload, '$.sessions') AS active
-  ON active.key = json_extract(source.payload, '$.activeAgentId')
-WHERE json_extract(active.value, '$.status') <> 'stopped';
-`;
-/**
- * Migration 12: bounded open-InputRequest lookup for Controller deadlines.
- *
- * The baseline index's historical predicate predates the current
- * open/answered/cancelled status contract and retains terminal rows. This
- * partial index contains only the live InputRequest set, so deadline arming and
- * targeted auto-resolution never scan terminal request history.
- */
-const MIGRATION_12_SQL = `
-CREATE INDEX IF NOT EXISTS idx_input_requests_open_hot
-  ON input_requests(task_id, input_id)
-  WHERE status = 'open';
-`;
-/**
- * Migration 13: durable pending native Turn-completion hot projection.
- *
- * A Task Role may have an unsettled Turn completion after the native Session
- * has ended.  That completion is independent lifecycle state, so it cannot be
- * discovered through the current-Session projection (which intentionally
- * removes stopped Sessions).  Keep one typed row per Task Role and maintain it
- * in the same transaction as `role_session_sets`; deadline discovery can then
- * read this table without parsing a RoleSessionSet or its historical Sessions.
- */
-const MIGRATION_13_SQL = `
-CREATE TABLE IF NOT EXISTS pending_runtime_turn_completions (
-  task_id           TEXT NOT NULL,
-  role_name         TEXT NOT NULL,
-  schema_version    INTEGER NOT NULL CHECK (schema_version = 1),
-  agent_id          TEXT NOT NULL,
-  native_session_id TEXT NOT NULL,
-  turn_id           TEXT NOT NULL,
-  run_id            TEXT NOT NULL,
-  summary           TEXT NOT NULL,
-  observed_at       TEXT NOT NULL,
-  due_at            TEXT NOT NULL,
-  PRIMARY KEY (task_id, role_name),
-  CHECK (due_at >= observed_at),
-  FOREIGN KEY (task_id, role_name)
-    REFERENCES role_session_sets(task_id, role_name) ON DELETE CASCADE
-);
-
-CREATE INDEX IF NOT EXISTS idx_pending_runtime_turn_completions_due
-  ON pending_runtime_turn_completions(task_id, due_at, role_name);
-
-INSERT INTO pending_runtime_turn_completions (
-  task_id, role_name, schema_version, agent_id, native_session_id,
-  turn_id, run_id, summary, observed_at, due_at
-)
-SELECT
-  source.task_id,
-  source.role_name,
-  json_extract(source.payload, '$.pendingTurnCompletion.schemaVersion'),
-  json_extract(source.payload, '$.pendingTurnCompletion.agentId'),
-  json_extract(source.payload, '$.pendingTurnCompletion.nativeSessionId'),
-  json_extract(source.payload, '$.pendingTurnCompletion.turnId'),
-  json_extract(source.payload, '$.pendingTurnCompletion.runId'),
-  json_extract(source.payload, '$.pendingTurnCompletion.summary'),
-  json_extract(source.payload, '$.pendingTurnCompletion.observedAt'),
-  json_extract(source.payload, '$.pendingTurnCompletion.dueAt')
-FROM role_session_sets AS source
-WHERE json_type(source.payload, '$.pendingTurnCompletion') = 'object';
-`;
-/** Migration 14: WorkMailbox v2 lanes and the single durable model-input delivery. */
-const MIGRATION_14_SQL = `
-ALTER TABLE mailboxes ADD COLUMN input_delivery TEXT;
-
-UPDATE mailboxes
-SET processing = CASE
-  WHEN processing IS NULL THEN NULL
-  ELSE json_set(
-    processing,
-    '$.lane', 'normal',
-    '$.batch.sources', json_array('migration-v1'),
-    '$.batch.dedupeKeys', json_array(
-      'mailbox-v1:' || target_key || ':'
-      || json_extract(processing, '$.batch.fromSequence') || '-'
-      || json_extract(processing, '$.batch.toSequence')
-    ),
-    '$.batch.deliveryModes', json_array('followup')
-  )
-END;
-
-UPDATE mailboxes
-SET input_delivery = json_object(
-  'attemptId', json_extract(processing, '$.batchId'),
-  'lane', 'normal',
-  'mode', 'followup',
-  'batch', json(json_extract(processing, '$.batch')),
-  'owner', json_extract(processing, '$.owner'),
-  'status', 'delivery-unknown',
-  'startedAt', json_extract(processing, '$.startedAt'),
-  'pushedAt', json_extract(processing, '$.startedAt'),
-  'unknownReason', 'migrated-unconfirmed-provider-acceptance',
-  'executionRef', json(json_extract(processing, '$.executionRef')),
-  'providerFence', json_object(
-    'conversationId', (
-      SELECT json_extract(
-        json_extract(role_session_sets.payload, '$.sessions'),
-        '$.' || json_quote(json_extract(role_session_sets.payload, '$.activeAgentId'))
-          || '.nativeSessionId'
-      )
-      FROM role_session_sets
-      WHERE role_session_sets.task_id = mailboxes.task_id
-        AND role_session_sets.role_name = mailboxes.role_name
-    ),
-    'activationId', COALESCE((
-      SELECT json_extract(
-        json_extract(role_session_sets.payload, '$.sessions'),
-        '$.' || json_quote(json_extract(role_session_sets.payload, '$.activeAgentId'))
-          || '.launchId'
-      )
-      FROM role_session_sets
-      WHERE role_session_sets.task_id = mailboxes.task_id
-        AND role_session_sets.role_name = mailboxes.role_name
-    ), (
-      SELECT json_extract(role_session_sets.payload, '$.inFlight.receiptId')
-      FROM role_session_sets
-      WHERE role_session_sets.task_id = mailboxes.task_id
-        AND role_session_sets.role_name = mailboxes.role_name
-    ))
-  )
-)
-WHERE target_kind = 'role'
-  AND json_extract(processing, '$.batchId') LIKE 'agent-input:%';
-
-UPDATE mailboxes
-SET processing = NULL
-WHERE input_delivery IS NOT NULL;
-
-UPDATE mailboxes
-SET pending = json_object(
-  'normal', CASE
-    WHEN pending IS NULL THEN json('null')
-    ELSE json(json_set(
-      pending,
-      '$.sources', json_array('migration-v1'),
-      '$.dedupeKeys', json_array(
-        'mailbox-v1:' || target_key || ':'
-        || json_extract(pending, '$.fromSequence') || '-'
-        || json_extract(pending, '$.toSequence')
-      ),
-      '$.deliveryModes', json_array('followup')
-    ))
-  END,
-  'userCorrection', json('null'),
-  'cursors', json_object('normal', 0, 'userCorrection', 0),
-  'recentDedupeKeys', json_array()
-);
-
-DROP INDEX idx_mailboxes_ready;
-CREATE INDEX idx_mailboxes_ready
-  ON mailboxes(target_key)
-  WHERE processing IS NOT NULL
-     OR input_delivery IS NOT NULL
-     OR json_type(pending, '$.normal') <> 'null'
-     OR json_type(pending, '$.userCorrection') <> 'null';
-
-DROP TABLE pending_runtime_turn_completions;
-DROP TABLE IF EXISTS mailbox_signals;
 `;
 /**
- * Migration 15: Issue 11 external publication evidence. Records are immutable;
+ * External publication evidence. Records are immutable;
  * a corrected MR/PR state appends a superseding record with the same
  * external_key, so only the unsuperseded root is globally unique.
  */
-const MIGRATION_15_SQL = `
+const BASELINE_PUBLICATION_REFERENCE_SQL = `
 CREATE TABLE IF NOT EXISTS publication_references (
   task_id         TEXT NOT NULL,
   publication_id  TEXT NOT NULL,
@@ -895,7 +627,7 @@ CREATE INDEX IF NOT EXISTS idx_publication_references_external
 CREATE UNIQUE INDEX IF NOT EXISTS idx_publication_references_external_root
   ON publication_references(external_key) WHERE supersedes IS NULL;
 `;
-const MIGRATION_16_SQL = `
+const BASELINE_TASK_WAKE_SQL = `
 -- Durable Leader wake ledger (Issue 04 long-term design). A wake is a
 -- notification envelope, not a context dump: the record holds the aggregated
 -- reason tags and the delta window; the Agent reads delta content on demand.
@@ -904,7 +636,7 @@ CREATE TABLE IF NOT EXISTS task_wakes (
   wake_id     TEXT NOT NULL,
   seq         INTEGER NOT NULL,
   status      TEXT NOT NULL CHECK (status IN ('dispatched','consumed')),
-  run_id      TEXT,
+  turn_id     TEXT,
   from_cursor TEXT NOT NULL,
   to_cursor   TEXT NOT NULL,
   reasons     TEXT NOT NULL,
@@ -915,8 +647,8 @@ CREATE TABLE IF NOT EXISTS task_wakes (
 );
 CREATE INDEX IF NOT EXISTS idx_task_wakes_seq ON task_wakes(task_id, seq);
 `;
-/** Migration 17: immutable, Task-scoped ContextSnapshot records. */
-const MIGRATION_17_SQL = `
+/** Immutable, Task-scoped ContextSnapshot records. */
+const BASELINE_CONTEXT_SNAPSHOT_SQL = `
 CREATE TABLE IF NOT EXISTS context_snapshots (
   task_id     TEXT NOT NULL,
   snapshot_id TEXT NOT NULL,
@@ -934,82 +666,23 @@ CREATE TABLE IF NOT EXISTS context_snapshots (
 CREATE UNIQUE INDEX IF NOT EXISTS idx_context_snapshots_scope_sequence
   ON context_snapshots(task_id, scope, COALESCE(scope_ref, ''), sequence);
 `;
-/**
- * Migration 18: align the current-Session hot projection with Session v4.
- *
- * Session existence now has one lifecycle: active or ended. Ended Sessions do
- * not belong in this bounded projection, so row presence itself means active;
- * the projection carries no independently writable lifecycle status. Host
- * cleanup is derived solely from whether the Session still names a Host
- * activation. Valid earlier live rows are projected into that contract;
- * terminal broken rows disappear with the rest of ended Session history.
- */
-const MIGRATION_18_SQL = `
-DROP INDEX idx_runtime_session_cleanup_required;
-ALTER TABLE runtime_session_candidates RENAME TO runtime_session_candidates_v11;
-
-CREATE TABLE runtime_session_candidates (
-  scope               TEXT NOT NULL CHECK (scope IN ('task','global')),
-  task_id             TEXT NOT NULL,
-  role_name           TEXT NOT NULL,
-  agent_id            TEXT NOT NULL,
-  adapter_id          TEXT NOT NULL,
-  native_session_id   TEXT NOT NULL,
-  launch_id           TEXT,
-  session_updated_at  TEXT NOT NULL,
-  cleanup_required    INTEGER NOT NULL CHECK (cleanup_required IN (0,1)),
-  PRIMARY KEY (scope, task_id, role_name),
-  CHECK (
-    (scope = 'task' AND length(task_id) > 0)
-    OR (scope = 'global' AND task_id = '')
-  ),
-  CHECK (
-    cleanup_required = CASE WHEN launch_id IS NOT NULL THEN 1 ELSE 0 END
-  )
-);
-
-INSERT INTO runtime_session_candidates (
-  scope, task_id, role_name, agent_id, adapter_id, native_session_id,
-  launch_id, session_updated_at, cleanup_required
-)
-SELECT
-  scope, task_id, role_name, agent_id, adapter_id, native_session_id,
-  launch_id, session_updated_at,
-  CASE WHEN launch_id IS NOT NULL THEN 1 ELSE 0 END
-FROM runtime_session_candidates_v11
-WHERE status IN ('reserved','ready','running');
-
-DROP TABLE runtime_session_candidates_v11;
-
-CREATE INDEX idx_runtime_session_cleanup_required
-  ON runtime_session_candidates(scope, task_id, role_name)
-  WHERE cleanup_required = 1;
-`;
-/**
- * The single forward migration history for current SQLite Homes. New durable
- * layout, aggregate, and record changes belong here and must be expressible as
- * one atomic in-place transaction. The separate logical migration registry is
- * only the bridge from valid pre-SQLite Homes and is allowed to rebuild them.
- */
+const MIGRATION_1_SQL = [
+    BASELINE_CORE_SQL,
+    BASELINE_JOB_AND_RELEASE_SQL,
+    BASELINE_JOB_CALLER_SQL,
+    BASELINE_TELEMETRY_AGGREGATE_SQL,
+    BASELINE_REVIEW_FINDING_SQL,
+    BASELINE_SESSION_OWNER_SQL,
+    BASELINE_RESOURCE_REGISTRY_SQL,
+    BASELINE_GATE_ARTIFACT_SQL,
+    BASELINE_RUNTIME_SESSION_SQL,
+    BASELINE_PUBLICATION_REFERENCE_SQL,
+    BASELINE_TASK_WAKE_SQL,
+    BASELINE_CONTEXT_SNAPSHOT_SQL
+].join("\n");
+/** Future compatible releases append new migrations after this baseline. */
 const MIGRATIONS = [
-    { version: 1, axis: "layout", sql: MIGRATION_1_SQL },
-    { version: 2, axis: "record", recordKind: "durableJob+capability-grant+release-workflow", sql: MIGRATION_2_SQL },
-    { version: 3, axis: "record", recordKind: "jobCallerKeyHash", sql: MIGRATION_3_SQL },
-    { version: 4, axis: "record", recordKind: "durableJob", sql: MIGRATION_4_SQL },
-    { version: 5, axis: "record", recordKind: "telemetryAggregate", sql: MIGRATION_5_SQL },
-    { version: 6, axis: "record", recordKind: "reviewFinding", sql: MIGRATION_6_SQL },
-    { version: 7, axis: "record", recordKind: "sessionOwner", sql: MIGRATION_7_SQL },
-    { version: 8, axis: "record", recordKind: "resource-registry", sql: MIGRATION_8_SQL },
-    { version: 9, axis: "record", recordKind: "gateArtifact", sql: MIGRATION_9_SQL },
-    { version: 10, axis: "layout", sql: MIGRATION_10_SQL },
-    { version: 11, axis: "layout", sql: MIGRATION_11_SQL },
-    { version: 12, axis: "layout", sql: MIGRATION_12_SQL },
-    { version: 13, axis: "layout", sql: MIGRATION_13_SQL },
-    { version: 14, axis: "record", recordKind: "workMailbox", sql: MIGRATION_14_SQL },
-    { version: 15, axis: "record", recordKind: "publicationReference", sql: MIGRATION_15_SQL },
-    { version: 16, axis: "record", recordKind: "taskWake", sql: MIGRATION_16_SQL },
-    { version: 17, axis: "record", recordKind: "contextSnapshot", sql: MIGRATION_17_SQL },
-    { version: 18, axis: "layout", sql: MIGRATION_18_SQL }
+    { version: 1, axis: "layout", sql: MIGRATION_1_SQL }
 ];
 /** Current hot-path indexes whose absence would invalidate a current Home. */
 const REQUIRED_SCHEMA_INDEXES = [
@@ -1024,7 +697,7 @@ function checksum(sql) {
  * A SQLite Home is only safe to open when its migration ledger proves exactly
  * which schema definition was applied.  The ledger is durable metadata, not a
  * best-effort cache: a missing row, a changed checksum, or an unknown version
- * must stop startup before any pending migration is run.
+ * must stop startup before any pending schema step is applied.
  */
 export class SqliteSchemaMigrationError extends Error {
     constructor(detail, subject = "metadata") {
@@ -1127,82 +800,7 @@ function validateSchemaObjects(db) {
         }
     }
 }
-/** Validate migration 13's source invariant before creating its hot table. */
-function validatePendingProjectionBackfillSources(db) {
-    const existing = db.prepare(`SELECT name
-     FROM sqlite_master
-     WHERE name IN (
-       'pending_runtime_turn_completions',
-       'idx_pending_runtime_turn_completions_due'
-     )
-     LIMIT 1`).get();
-    if (existing !== undefined) {
-        throw new SqliteSchemaMigrationError(`schema object '${existing.name}' exists before migration 13 is recorded`, "backfill");
-    }
-    const mismatch = db.prepare(`SELECT task_id, role_name
-     FROM role_session_sets
-     WHERE COALESCE(json_type(payload, '$.pendingTurnCompletion'), 'missing')
-             NOT IN ('null', 'object')
-        OR (
-          json_type(payload, '$.pendingTurnCompletion') = 'object'
-          AND (
-            json_extract(payload, '$.owner.scope') <> 'task'
-            OR json_extract(payload, '$.owner.taskId') IS NULL
-            OR json_extract(payload, '$.owner.taskId') <> task_id
-            OR json_extract(payload, '$.owner.roleName') IS NULL
-            OR json_extract(payload, '$.owner.roleName') <> role_name
-            OR json_extract(payload, '$.pendingTurnCompletion.taskId') IS NULL
-            OR json_extract(payload, '$.pendingTurnCompletion.taskId') <> task_id
-            OR json_extract(payload, '$.pendingTurnCompletion.roleName') IS NULL
-            OR json_extract(payload, '$.pendingTurnCompletion.roleName') <> role_name
-            OR json_extract(payload, '$.pendingTurnCompletion.schemaVersion') IS NOT 1
-            OR COALESCE(json_type(payload, '$.pendingTurnCompletion.agentId'), 'missing') <> 'text'
-            OR COALESCE(json_type(payload, '$.pendingTurnCompletion.nativeSessionId'), 'missing') <> 'text'
-            OR COALESCE(json_type(payload, '$.pendingTurnCompletion.turnId'), 'missing') <> 'text'
-            OR COALESCE(json_type(payload, '$.pendingTurnCompletion.runId'), 'missing') <> 'text'
-            OR COALESCE(json_type(payload, '$.pendingTurnCompletion.summary'), 'missing') <> 'text'
-            OR COALESCE(json_type(payload, '$.pendingTurnCompletion.observedAt'), 'missing') <> 'text'
-            OR COALESCE(json_type(payload, '$.pendingTurnCompletion.dueAt'), 'missing') <> 'text'
-            OR COALESCE(json_type(payload, '$.inFlight'), 'missing') <> 'object'
-            OR COALESCE(json_type(payload, '$.activeAgentId'), 'missing') <> 'text'
-            OR COALESCE(json_type(payload, '$.inFlight.agentId'), 'missing') <> 'text'
-            OR COALESCE(json_type(payload, '$.inFlight.runId'), 'missing') <> 'text'
-            OR json_extract(payload, '$.activeAgentId')
-                 <> json_extract(payload, '$.pendingTurnCompletion.agentId')
-            OR json_extract(payload, '$.inFlight.agentId')
-                 <> json_extract(payload, '$.pendingTurnCompletion.agentId')
-            OR json_extract(payload, '$.inFlight.runId')
-                 <> json_extract(payload, '$.pendingTurnCompletion.runId')
-            OR COALESCE(json_type(payload, '$.inFlight.pushedAt'), 'missing') <> 'text'
-            OR COALESCE(
-                 json_type(
-                   payload,
-                   '$.sessions.' || json_quote(
-                     json_extract(payload, '$.pendingTurnCompletion.agentId')
-                   ) || '.nativeSessionId'
-                 ),
-                 'missing'
-               ) <> 'text'
-            OR json_extract(
-                 payload,
-                 '$.sessions.' || json_quote(
-                   json_extract(payload, '$.pendingTurnCompletion.agentId')
-                 ) || '.nativeSessionId'
-               ) <> json_extract(payload, '$.pendingTurnCompletion.nativeSessionId')
-            OR json_extract(payload, '$.pendingTurnCompletion.dueAt')
-                 < json_extract(payload, '$.pendingTurnCompletion.observedAt')
-          )
-        )
-     LIMIT 1`).get();
-    if (mismatch !== undefined) {
-        throw new SqliteSchemaMigrationError(`pending Turn completion source is invalid for ${mismatch.task_id}/${mismatch.role_name}`, "backfill");
-    }
-}
-/**
- * Inspect a database's checksummed migration prefix without changing it.
- * Pending versions are a supported upgrade state; malformed, gapped, changed,
- * or future ledger entries remain explicit integrity failures.
- */
+/** Inspect a recognized migration prefix without changing it. */
 export function inspectSqliteSchemaMigrations(db) {
     const ledgerWasCreated = ensureMigrationLedger(db, "validate");
     const applied = validateAppliedMigrations(db, ledgerWasCreated);
@@ -1241,14 +839,11 @@ export function migrateSqliteSchema(db, options) {
         // skipping a later schema/data step.
         const applied = validateAppliedMigrations(db, ledgerWasCreated);
         const pending = MIGRATIONS.filter((migration) => !applied.has(migration.version));
-        if (options.mode === "validate" && pending.length > 0) {
-            throw new SqliteSchemaMigrationError(`pending SQLite schema migration ${pending[0].version}; `
-                + "run the explicit storage upgrade before opening this database", "admission");
+        if (!ledgerWasCreated && pending.length > 0 && options.mode === "validate") {
+            throw new SqliteSchemaMigrationError(`SQLite schema ${applied.size} requires an explicit upgrade to ${SQLITE_SCHEMA_VERSION}`, "admission");
         }
         const newlyApplied = [];
         for (const migration of pending) {
-            if (migration.version === 13)
-                validatePendingProjectionBackfillSources(db);
             db.exec(migration.sql);
             db.prepare(`INSERT INTO schema_migrations (version, axis, record_kind, applied_at, checksum)
          VALUES (?, ?, ?, ?, ?)`).run(migration.version, migration.axis, migration.recordKind ?? null, new Date().toISOString(), checksum(migration.sql));
@@ -1288,8 +883,8 @@ export const SQLITE_SCHEMA_TABLES = [
     "work_items",
     "work_item_candidates",
     "context_snapshots",
-    "agent_runs",
-    "active_runs",
+    "turns",
+    "active_turns",
     "review_rounds",
     "review_findings",
     "change_sets",
@@ -1305,6 +900,7 @@ export const SQLITE_SCHEMA_TABLES = [
     "capability_grants",
     "release_workflows",
     "publication_references",
+    "task_wakes",
     "session_owners",
     "runtime_session_candidates",
     "resource_registry",