ultra-builder-pro-cli 0.19.1 → 0.21.1

package/mcp-server/lib/state-db.cjs

@@ -9,7 +9,7 @@ const REPO_ROOT = process.env.UBP_RUNTIME_ROOT
   ? path.resolve(process.env.UBP_RUNTIME_ROOT)
   : path.resolve(__dirname, '..', '..');
 const SCHEMA_FILE = path.join(REPO_ROOT, 'spec', 'schemas', 'state-db.sql');
-const EXPECTED_VERSION = '18.0';
+const EXPECTED_VERSION = '20.0';
 const KIMI_SCHEMA_VERSION = '9.1';
 const CONTEXT_SCHEMA_VERSION = '10.0';
 const BASELINE_SCHEMA_VERSION = '11.0';
@@ -19,6 +19,9 @@ const AUTHORITY_SCHEMA_VERSION = '14.0';
 const SEMANTIC_SCHEMA_VERSION = '15.0';
 const DIALOGUE_SCHEMA_VERSION = '16.0';
 const GIT_AUTHORITY_SCHEMA_VERSION = '17.0';
+const ADAPTIVE_SCHEMA_VERSION = '18.0';
+const DECISION_COMPLETION_SCHEMA_VERSION = '19.0';
+const ARTIFACT_REGISTRY_SCHEMA_VERSION = '20.0';
 
 const MIGRATED_GAPS = Object.freeze([{
   id: 'legacy-rebaseline-required',
@@ -42,6 +45,7 @@ const REQUIRED_TABLES = Object.freeze([
   'circuit_breaker',
   'changes',
   'artifacts',
+  'artifact_edges',
   'context_snapshots',
   'spec_learning_candidates',
   'trace_links',
@@ -54,6 +58,93 @@ const REQUIRED_TABLES = Object.freeze([
   'decision_items',
 ]);
 
+class ActiveSessionLeaseConflictError extends Error {
+  constructor(conflicts) {
+    super(
+      'state.db has duplicate active task leases; resolve the conflicting sessions before upgrade: '
+      + conflicts.map((row) => `${row.task_id}=[${row.session_ids.join(',')}]`).join('; '),
+    );
+    this.name = 'ActiveSessionLeaseConflictError';
+    this.code = 'ACTIVE_SESSION_LEASE_CONFLICT';
+    this.details = { conflicts };
+  }
+}
+
+class ArtifactAuthorityConflictError extends Error {
+  constructor(conflicts) {
+    super(
+      'state.db has duplicate active artifact authority for canonical paths: '
+      + conflicts.map((row) => `${row.path}=[${row.artifact_ids.join(',')}]`).join('; '),
+    );
+    this.name = 'ArtifactAuthorityConflictError';
+    this.code = 'ARTIFACT_AUTHORITY_CONFLICT';
+    this.details = { conflicts };
+  }
+}
+
+function canonicalArtifactPath(value) {
+  const raw = String(value || '').trim().replaceAll('\\', '/');
+  if (!raw || path.posix.isAbsolute(raw)) {
+    throw new ArtifactAuthorityConflictError([{
+      path: raw || '(empty)',
+      artifact_ids: [],
+      reason: 'invalid_path',
+    }]);
+  }
+  const normalized = path.posix.normalize(raw).replace(/^\.\//, '');
+  if (normalized === '..' || normalized.startsWith('../') || normalized.includes('/../')) {
+    throw new ArtifactAuthorityConflictError([{
+      path: raw,
+      artifact_ids: [],
+      reason: 'path_escape',
+    }]);
+  }
+  return normalized;
+}
+
+function activeArtifactPathConflicts(db) {
+  if (!tableNames(db).includes('artifacts')) return [];
+  const columns = columnNames(db, 'artifacts');
+  if (!columns.has('id') || !columns.has('path')) return [];
+  const hasStatus = columns.has('status');
+  const rows = db.prepare(
+    `SELECT id, path FROM artifacts${hasStatus ? " WHERE status <> 'archived'" : ''}
+     ORDER BY id`,
+  ).all();
+  const grouped = new Map();
+  for (const row of rows) {
+    const canonical = canonicalArtifactPath(row.path);
+    const ids = grouped.get(canonical) || [];
+    ids.push(row.id);
+    grouped.set(canonical, ids);
+  }
+  return [...grouped.entries()]
+    .filter(([, ids]) => ids.length > 1)
+    .map(([artifactPath, ids]) => ({ path: artifactPath, artifact_ids: ids }));
+}
+
+function assertNoDuplicateActiveArtifactPaths(db) {
+  const conflicts = activeArtifactPathConflicts(db);
+  if (conflicts.length > 0) throw new ArtifactAuthorityConflictError(conflicts);
+  return true;
+}
+
+function normalizeStoredArtifactPaths(db) {
+  if (!tableNames(db).includes('artifacts')) return false;
+  assertNoDuplicateActiveArtifactPaths(db);
+  const rows = db.prepare('SELECT id, path FROM artifacts ORDER BY id').all();
+  let changed = false;
+  const update = db.prepare('UPDATE artifacts SET path = ? WHERE id = ?');
+  for (const row of rows) {
+    const canonical = canonicalArtifactPath(row.path);
+    if (canonical !== row.path) {
+      update.run(canonical, row.id);
+      changed = true;
+    }
+  }
+  return changed;
+}
+
 function applyBaselineUpgrade(db, { legacyState = false } = {}) {
   db.exec(`
     CREATE TABLE IF NOT EXISTS baselines (
@@ -235,6 +326,7 @@ function tableNames(db) {
 }
 
 function applySchema(db) {
+  assertNoDuplicateActiveSessionLeases(db);
   runScript(db, readSchemaSql());
 }
 
@@ -328,7 +420,12 @@ function migrateAdaptiveWorkflowRuns(db, fromVersion = latestSchemaVersion(db))
   const existing = db.prepare(
     "SELECT 1 FROM migration_history WHERE to_version = '18.0' AND status = 'success' LIMIT 1",
   ).get();
-  if (fromVersion === EXPECTED_VERSION || existing) return false;
+  if ([
+    ADAPTIVE_SCHEMA_VERSION, DECISION_COMPLETION_SCHEMA_VERSION,
+    ARTIFACT_REGISTRY_SCHEMA_VERSION,
+  ].includes(fromVersion) || existing) {
+    return false;
+  }
 
   const obsoleteSteps = Object.freeze({
     init: ['establish-baseline'],
@@ -455,6 +552,95 @@ function baselineSupportsUnbornGit(db) {
   return typeof row?.sql === 'string' && row.sql.includes("'unborn'");
 }
 
+function decisionThreadsSupportCompletion(db) {
+  const row = db.prepare(
+    "SELECT sql FROM sqlite_master WHERE type = 'table' AND name = 'decision_threads'",
+  ).get();
+  if (typeof row?.sql !== 'string' || !row.sql.includes("'completed'")) return false;
+  return columnNames(db, 'decision_threads').has('completed_at');
+}
+
+function upgradeDecisionThreadLifecycle(db) {
+  if (!tableNames(db).includes('decision_threads') || decisionThreadsSupportCompletion(db)) {
+    return false;
+  }
+  const foreignKeys = db.pragma('foreign_keys', { simple: true });
+  db.pragma('foreign_keys = OFF');
+  try {
+    db.transaction(() => {
+      db.exec(`
+        DROP TABLE IF EXISTS decision_threads_completion_upgrade;
+        CREATE TABLE decision_threads_completion_upgrade (
+          id                 TEXT PRIMARY KEY,
+          purpose            TEXT NOT NULL,
+          mode               TEXT NOT NULL DEFAULT 'guided'
+                               CHECK (mode IN ('guided', 'fast', 'autonomous', 'diagnostic')),
+          status             TEXT NOT NULL DEFAULT 'active'
+                               CHECK (status IN ('active', 'checkpoint_ready', 'completed', 'confirmed', 'cancelled')),
+          baseline_id        TEXT REFERENCES baselines(id) ON DELETE SET NULL,
+          change_id          TEXT REFERENCES changes(id) ON DELETE CASCADE,
+          workflow_run_id    TEXT REFERENCES workflow_runs(id) ON DELETE CASCADE,
+          summary_json       TEXT NOT NULL DEFAULT '{}',
+          checkpoint_json    TEXT NOT NULL DEFAULT '{}',
+          started_at         TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
+          updated_at         TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
+          completed_at       TEXT,
+          confirmed_at       TEXT,
+          CHECK (baseline_id IS NOT NULL OR change_id IS NOT NULL OR workflow_run_id IS NOT NULL)
+        );
+        INSERT INTO decision_threads_completion_upgrade (
+          id, purpose, mode, status, baseline_id, change_id, workflow_run_id,
+          summary_json, checkpoint_json, started_at, updated_at, completed_at, confirmed_at
+        )
+        SELECT
+          id, purpose, mode, status, baseline_id, change_id, workflow_run_id,
+          summary_json, checkpoint_json, started_at, updated_at, NULL, confirmed_at
+        FROM decision_threads;
+        DROP TABLE decision_threads;
+        ALTER TABLE decision_threads_completion_upgrade RENAME TO decision_threads;
+        CREATE INDEX decision_threads_status
+          ON decision_threads(status, updated_at);
+        CREATE INDEX decision_threads_authority
+          ON decision_threads(baseline_id, change_id, workflow_run_id, status);
+      `);
+      db.prepare(
+        `UPDATE decision_threads
+         SET status = 'completed',
+             summary_json = CASE
+               WHEN summary_json = '{}' THEN ?
+               ELSE json_set(summary_json, '$.completion_kind', 'migrated_settled_thread')
+             END,
+             completed_at = updated_at
+         WHERE status = 'active'
+           AND EXISTS (
+             SELECT 1 FROM decision_items WHERE decision_items.thread_id = decision_threads.id
+           )
+           AND NOT EXISTS (
+             SELECT 1 FROM decision_items
+             WHERE decision_items.thread_id = decision_threads.id AND status = 'open'
+           )
+           AND NOT EXISTS (
+             SELECT 1 FROM decision_items
+             WHERE decision_items.thread_id = decision_threads.id
+               AND blocking = 1 AND status = 'deferred'
+           )`,
+      ).run(JSON.stringify({
+        text: 'Existing normalized decision state was completed during schema migration.',
+        completion_kind: 'migrated_settled_thread',
+      }));
+      const violations = db.pragma('foreign_key_check');
+      if (violations.length > 0) {
+        throw new Error(
+          `decision completion migration produced ${violations.length} foreign key violation(s)`,
+        );
+      }
+    })();
+  } finally {
+    db.pragma(`foreign_keys = ${foreignKeys ? 'ON' : 'OFF'}`);
+  }
+  return true;
+}
+
 function upgradeBaselineWorktreeConstraint(db, fromVersion = latestSchemaVersion(db)) {
   if (!tableNames(db).includes('baselines') || baselineSupportsUnbornGit(db)) return false;
   const previousVersion = fromVersion || 'unknown';
@@ -530,6 +716,7 @@ function upgradeBaselineWorktreeConstraint(db, fromVersion = latestSchemaVersion
 }
 
 function upgradeRuntimeConstraints(db, fromVersion = latestSchemaVersion(db)) {
+  assertNoDuplicateActiveSessionLeases(db);
   if (tableSupportsKimi(db, 'events') && tableSupportsKimi(db, 'sessions')) return false;
   const previousVersion = fromVersion || 'unknown';
   const foreignKeys = db.pragma('foreign_keys', { simple: true });
@@ -581,6 +768,8 @@ function upgradeRuntimeConstraints(db, fromVersion = latestSchemaVersion(db)) {
         ALTER TABLE sessions_runtime_upgrade RENAME TO sessions;
         CREATE INDEX sessions_active ON sessions(status, task_id);
         CREATE INDEX sessions_lease ON sessions(lease_expires_at) WHERE status = 'running';
+        CREATE UNIQUE INDEX sessions_one_active_task
+          ON sessions(task_id) WHERE status = 'running';
       `);
       db.prepare(
         `INSERT INTO migration_history
@@ -602,7 +791,129 @@ function upgradeRuntimeConstraints(db, fromVersion = latestSchemaVersion(db)) {
   return true;
 }
 
+function activeSessionLeaseConflicts(db) {
+  if (!tableNames(db).includes('sessions')) return [];
+  const columns = columnNames(db, 'sessions');
+  if (!['sid', 'task_id', 'status'].every((name) => columns.has(name))) return [];
+  const rows = db.prepare(
+    `SELECT task_id, sid
+     FROM sessions
+     WHERE status = 'running'
+     ORDER BY task_id, sid`,
+  ).all();
+  const byTask = new Map();
+  for (const row of rows) {
+    const ids = byTask.get(row.task_id) || [];
+    ids.push(row.sid);
+    byTask.set(row.task_id, ids);
+  }
+  return [...byTask.entries()]
+    .filter(([, sessionIds]) => sessionIds.length > 1)
+    .map(([taskId, sessionIds]) => ({
+      task_id: taskId,
+      lease_count: sessionIds.length,
+      session_ids: sessionIds,
+    }));
+}
+
+function assertNoDuplicateActiveSessionLeases(db) {
+  const conflicts = activeSessionLeaseConflicts(db);
+  if (conflicts.length > 0) throw new ActiveSessionLeaseConflictError(conflicts);
+  return true;
+}
+
+function ensureActiveSessionLeaseIndex(db) {
+  if (!tableNames(db).includes('sessions')) return false;
+  assertNoDuplicateActiveSessionLeases(db);
+  const existing = db.prepare(
+    "SELECT 1 AS present FROM sqlite_master WHERE type = 'index' AND name = 'sessions_one_active_task'",
+  ).get();
+  if (existing) return false;
+  db.exec(
+    `CREATE UNIQUE INDEX sessions_one_active_task
+     ON sessions(task_id) WHERE status = 'running'`,
+  );
+  return true;
+}
+
+function applyArtifactRegistryUpgrade(db) {
+  if (!tableNames(db).includes('artifacts')) return false;
+  assertNoDuplicateActiveArtifactPaths(db);
+  const columns = columnNames(db, 'artifacts');
+  let changed = false;
+  if (![
+    'owner_type', 'owner_id', 'digest', 'before_digest', 'after_digest',
+    'provenance_json', 'managed',
+  ].every((column) => columns.has(column))) {
+    db.exec(`
+      DROP TABLE IF EXISTS artifacts_registry_upgrade;
+      CREATE TABLE artifacts_registry_upgrade (
+        id              TEXT PRIMARY KEY,
+        owner_type      TEXT NOT NULL
+                          CHECK (owner_type IN ('project', 'baseline', 'change', 'task', 'workflow')),
+        owner_id        TEXT NOT NULL,
+        change_id       TEXT REFERENCES changes(id) ON DELETE SET NULL,
+        task_id         TEXT REFERENCES tasks(id) ON DELETE SET NULL,
+        kind            TEXT NOT NULL,
+        path            TEXT NOT NULL,
+        digest          TEXT,
+        content_hash    TEXT,
+        before_digest   TEXT,
+        after_digest    TEXT,
+        provenance_json TEXT NOT NULL DEFAULT '{}',
+        metadata_json   TEXT,
+        managed         INTEGER NOT NULL DEFAULT 0 CHECK (managed IN (0, 1)),
+        status          TEXT NOT NULL DEFAULT 'current'
+                          CHECK (status IN ('current', 'stale', 'terminal', 'archived')),
+        created_at      TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
+        updated_at      TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
+        UNIQUE(owner_type, owner_id, kind, path)
+      );
+      INSERT INTO artifacts_registry_upgrade
+        (id, owner_type, owner_id, change_id, task_id, kind, path, digest,
+         content_hash, before_digest, after_digest, provenance_json,
+         metadata_json, managed, status, created_at, updated_at)
+      SELECT id,
+             CASE WHEN task_id IS NOT NULL THEN 'task' ELSE 'change' END,
+             CASE WHEN task_id IS NOT NULL THEN task_id ELSE change_id END,
+             change_id, task_id, kind, path, content_hash, content_hash,
+             NULL, content_hash, '{"migration":"schema-20.0"}',
+             metadata_json, 0, status, created_at, updated_at
+      FROM artifacts;
+      DROP TABLE artifacts;
+      ALTER TABLE artifacts_registry_upgrade RENAME TO artifacts;
+    `);
+    changed = true;
+  }
+  if (normalizeStoredArtifactPaths(db)) changed = true;
+  db.exec(`
+    CREATE INDEX IF NOT EXISTS artifacts_change ON artifacts(change_id, kind);
+    CREATE INDEX IF NOT EXISTS artifacts_owner ON artifacts(owner_type, owner_id, status);
+    CREATE INDEX IF NOT EXISTS artifacts_path ON artifacts(path, status);
+    CREATE UNIQUE INDEX IF NOT EXISTS artifacts_one_active_path
+      ON artifacts(path) WHERE status <> 'archived';
+    CREATE TABLE IF NOT EXISTS artifact_edges (
+      id          INTEGER PRIMARY KEY AUTOINCREMENT,
+      source_type TEXT NOT NULL
+                    CHECK (source_type IN ('artifact', 'project', 'baseline', 'change', 'task', 'workflow', 'external')),
+      source_id   TEXT NOT NULL,
+      target_type TEXT NOT NULL
+                    CHECK (target_type IN ('artifact', 'project', 'baseline', 'change', 'task', 'workflow', 'external')),
+      target_id   TEXT NOT NULL,
+      relation    TEXT NOT NULL,
+      created_at  TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
+      UNIQUE(source_type, source_id, target_type, target_id, relation)
+    );
+    CREATE INDEX IF NOT EXISTS artifact_edges_source
+      ON artifact_edges(source_type, source_id);
+    CREATE INDEX IF NOT EXISTS artifact_edges_target
+      ON artifact_edges(target_type, target_id);
+  `);
+  return changed;
+}
+
 function applyCompatibleUpgrades(db, fromVersion = latestSchemaVersion(db), { legacyState = false } = {}) {
+  assertNoDuplicateActiveSessionLeases(db);
   const runtimeChanged = upgradeRuntimeConstraints(db, fromVersion);
   if (tableNames(db).includes('baselines') && !baselineSupportsUnbornGit(db)) {
     db.transaction(() => {
@@ -611,6 +922,7 @@ function applyCompatibleUpgrades(db, fromVersion = latestSchemaVersion(db), { le
     })();
   }
   const gitStateChangedFrom = upgradeBaselineWorktreeConstraint(db, fromVersion);
+  const decisionCompletionChanged = upgradeDecisionThreadLifecycle(db);
   db.transaction(() => {
     applyCompatibleColumns(db);
     const contextChanged = applyContextSpineUpgrade(db);
@@ -621,7 +933,8 @@ function applyCompatibleUpgrades(db, fromVersion = latestSchemaVersion(db), { le
       fromVersion && ![
         CONTEXT_SCHEMA_VERSION, BASELINE_SCHEMA_VERSION, ADOPTION_SCHEMA_VERSION,
         WORKFLOW_SCHEMA_VERSION, AUTHORITY_SCHEMA_VERSION, SEMANTIC_SCHEMA_VERSION,
-        DIALOGUE_SCHEMA_VERSION, GIT_AUTHORITY_SCHEMA_VERSION, EXPECTED_VERSION,
+        DIALOGUE_SCHEMA_VERSION, GIT_AUTHORITY_SCHEMA_VERSION, ADAPTIVE_SCHEMA_VERSION,
+        DECISION_COMPLETION_SCHEMA_VERSION, ARTIFACT_REGISTRY_SCHEMA_VERSION,
       ].includes(fromVersion)
         && !contextMigration,
     );
@@ -640,13 +953,15 @@ function applyCompatibleUpgrades(db, fromVersion = latestSchemaVersion(db), { le
     applyBaselineColumns(db);
     applyChangeColumns(db);
     applySemanticAuthorityColumns(db);
+    const artifactRegistryChanged = applyArtifactRegistryUpgrade(db);
     const baselineMigration = db.prepare(
       "SELECT 1 FROM migration_history WHERE to_version = '11.0' AND status = 'success' LIMIT 1",
     ).get();
     if (fromVersion && ![
       BASELINE_SCHEMA_VERSION, ADOPTION_SCHEMA_VERSION, WORKFLOW_SCHEMA_VERSION,
       AUTHORITY_SCHEMA_VERSION, SEMANTIC_SCHEMA_VERSION, DIALOGUE_SCHEMA_VERSION,
-      GIT_AUTHORITY_SCHEMA_VERSION, EXPECTED_VERSION,
+      GIT_AUTHORITY_SCHEMA_VERSION, ADAPTIVE_SCHEMA_VERSION,
+      DECISION_COMPLETION_SCHEMA_VERSION, ARTIFACT_REGISTRY_SCHEMA_VERSION,
     ].includes(fromVersion)
       && !baselineMigration) {
       db.prepare(
@@ -715,7 +1030,11 @@ function applyCompatibleUpgrades(db, fromVersion = latestSchemaVersion(db), { le
     const workflowMigration = db.prepare(
       "SELECT 1 FROM migration_history WHERE to_version = '13.0' AND status = 'success' LIMIT 1",
     ).get();
-    if (fromVersion && fromVersion !== EXPECTED_VERSION && !workflowMigration) {
+    if (fromVersion && ![
+      WORKFLOW_SCHEMA_VERSION, AUTHORITY_SCHEMA_VERSION, SEMANTIC_SCHEMA_VERSION,
+      DIALOGUE_SCHEMA_VERSION, GIT_AUTHORITY_SCHEMA_VERSION, ADAPTIVE_SCHEMA_VERSION,
+      DECISION_COMPLETION_SCHEMA_VERSION, ARTIFACT_REGISTRY_SCHEMA_VERSION,
+    ].includes(fromVersion) && !workflowMigration) {
       db.prepare(
         `INSERT INTO migration_history
           (from_version, to_version, direction, status, notes)
@@ -729,7 +1048,11 @@ function applyCompatibleUpgrades(db, fromVersion = latestSchemaVersion(db), { le
     const authorityMigration = db.prepare(
       "SELECT 1 FROM migration_history WHERE to_version = '14.0' AND status = 'success' LIMIT 1",
     ).get();
-    if (fromVersion && fromVersion !== EXPECTED_VERSION && !authorityMigration) {
+    if (fromVersion && ![
+      AUTHORITY_SCHEMA_VERSION, SEMANTIC_SCHEMA_VERSION, DIALOGUE_SCHEMA_VERSION,
+      GIT_AUTHORITY_SCHEMA_VERSION, ADAPTIVE_SCHEMA_VERSION, DECISION_COMPLETION_SCHEMA_VERSION,
+      ARTIFACT_REGISTRY_SCHEMA_VERSION,
+    ].includes(fromVersion) && !authorityMigration) {
       db.prepare(
         `INSERT INTO migration_history
           (from_version, to_version, direction, status, notes)
@@ -743,7 +1066,11 @@ function applyCompatibleUpgrades(db, fromVersion = latestSchemaVersion(db), { le
     const semanticMigration = db.prepare(
       "SELECT 1 FROM migration_history WHERE to_version = '15.0' AND status = 'success' LIMIT 1",
     ).get();
-    if (fromVersion && fromVersion !== EXPECTED_VERSION && !semanticMigration) {
+    if (fromVersion && ![
+      SEMANTIC_SCHEMA_VERSION, DIALOGUE_SCHEMA_VERSION, GIT_AUTHORITY_SCHEMA_VERSION,
+      ADAPTIVE_SCHEMA_VERSION, DECISION_COMPLETION_SCHEMA_VERSION,
+      ARTIFACT_REGISTRY_SCHEMA_VERSION,
+    ].includes(fromVersion) && !semanticMigration) {
       db.prepare(
         `INSERT INTO migration_history
           (from_version, to_version, direction, status, notes)
@@ -757,7 +1084,10 @@ function applyCompatibleUpgrades(db, fromVersion = latestSchemaVersion(db), { le
     const dialogueMigration = db.prepare(
       "SELECT 1 FROM migration_history WHERE to_version = '16.0' AND status = 'success' LIMIT 1",
     ).get();
-    if (fromVersion && ![DIALOGUE_SCHEMA_VERSION, EXPECTED_VERSION].includes(fromVersion)
+    if (fromVersion && ![
+      DIALOGUE_SCHEMA_VERSION, GIT_AUTHORITY_SCHEMA_VERSION, ADAPTIVE_SCHEMA_VERSION,
+      DECISION_COMPLETION_SCHEMA_VERSION, ARTIFACT_REGISTRY_SCHEMA_VERSION,
+    ].includes(fromVersion)
       && !dialogueMigration) {
       db.prepare(
         `INSERT INTO migration_history
@@ -772,7 +1102,10 @@ function applyCompatibleUpgrades(db, fromVersion = latestSchemaVersion(db), { le
     const gitStateMigration = db.prepare(
       "SELECT 1 FROM migration_history WHERE to_version = '17.0' AND status = 'success' LIMIT 1",
     ).get();
-    if (fromVersion && ![GIT_AUTHORITY_SCHEMA_VERSION, EXPECTED_VERSION].includes(fromVersion)
+    if (fromVersion && ![
+      GIT_AUTHORITY_SCHEMA_VERSION, ADAPTIVE_SCHEMA_VERSION, DECISION_COMPLETION_SCHEMA_VERSION,
+      ARTIFACT_REGISTRY_SCHEMA_VERSION,
+    ].includes(fromVersion)
       && !gitStateMigration) {
       db.prepare(
         `INSERT INTO migration_history
@@ -788,26 +1121,65 @@ function applyCompatibleUpgrades(db, fromVersion = latestSchemaVersion(db), { le
     const adaptiveMigration = db.prepare(
       "SELECT 1 FROM migration_history WHERE to_version = '18.0' AND status = 'success' LIMIT 1",
     ).get();
-    if (fromVersion && fromVersion !== EXPECTED_VERSION && !adaptiveMigration) {
+    if (fromVersion && ![
+      ADAPTIVE_SCHEMA_VERSION, DECISION_COMPLETION_SCHEMA_VERSION,
+      ARTIFACT_REGISTRY_SCHEMA_VERSION,
+    ].includes(fromVersion) && !adaptiveMigration) {
       db.prepare(
         `INSERT INTO migration_history
           (from_version, to_version, direction, status, notes)
          VALUES (?, ?, 'forward', 'success', ?)`,
       ).run(
         fromVersion === GIT_AUTHORITY_SCHEMA_VERSION ? fromVersion : GIT_AUTHORITY_SCHEMA_VERSION,
-        EXPECTED_VERSION,
+        ADAPTIVE_SCHEMA_VERSION,
         adaptiveChanged
           ? 'Migrate active rigid workflows to adaptive capability transitions and independent initialization'
           : 'Add adaptive capability transitions and independent initialization authority',
       );
     }
+    const completionMigration = db.prepare(
+      "SELECT 1 FROM migration_history WHERE to_version = '19.0' AND status = 'success' LIMIT 1",
+    ).get();
+    if (fromVersion && ![
+      DECISION_COMPLETION_SCHEMA_VERSION, ARTIFACT_REGISTRY_SCHEMA_VERSION,
+    ].includes(fromVersion) && !completionMigration) {
+      db.prepare(
+        `INSERT INTO migration_history
+          (from_version, to_version, direction, status, notes)
+         VALUES (?, ?, 'forward', 'success', ?)`,
+      ).run(
+        ADAPTIVE_SCHEMA_VERSION,
+        DECISION_COMPLETION_SCHEMA_VERSION,
+        decisionCompletionChanged
+          ? 'Add non-ceremonial decision completion and migrate settled active threads'
+          : 'Add non-ceremonial decision completion authority',
+      );
+    }
+    const artifactRegistryMigration = db.prepare(
+      "SELECT 1 FROM migration_history WHERE to_version = '20.0' AND status = 'success' LIMIT 1",
+    ).get();
+    if (fromVersion && fromVersion !== ARTIFACT_REGISTRY_SCHEMA_VERSION
+      && !artifactRegistryMigration) {
+      db.prepare(
+        `INSERT INTO migration_history
+          (from_version, to_version, direction, status, notes)
+         VALUES (?, ?, 'forward', 'success', ?)`,
+      ).run(
+        DECISION_COMPLETION_SCHEMA_VERSION,
+        ARTIFACT_REGISTRY_SCHEMA_VERSION,
+        artifactRegistryChanged
+          ? 'Migrate legacy change artifacts into the typed artifact registry and dependency graph'
+          : 'Add the typed artifact registry, dependency graph, and orphan diagnostics',
+      );
+    }
     db.exec('CREATE INDEX IF NOT EXISTS tasks_change ON tasks(change_id) WHERE change_id IS NOT NULL');
     db.exec('CREATE INDEX IF NOT EXISTS events_change ON events(change_id, id)');
+    ensureActiveSessionLeaseIndex(db);
     db.prepare(
       'INSERT OR IGNORE INTO schema_version (version, description) VALUES (?, ?)',
     ).run(
       EXPECTED_VERSION,
-      'Adaptive capability transitions, independent initialization, and recoverable workflow migration',
+      'Typed artifact registry, normalized dependency edges, and orphan diagnostics',
     );
   })();
 }
@@ -834,13 +1206,22 @@ function initStateDb(dbPath) {
     db = openStateDb(dbPath);
     const existing = new Set(tableNames(db));
     const fromVersion = latestSchemaVersion(db);
+    assertNoDuplicateActiveArtifactPaths(db);
     const legacyState = existing.size > 0
       && ![
         WORKFLOW_SCHEMA_VERSION, AUTHORITY_SCHEMA_VERSION, SEMANTIC_SCHEMA_VERSION,
-        DIALOGUE_SCHEMA_VERSION, GIT_AUTHORITY_SCHEMA_VERSION, EXPECTED_VERSION,
+        DIALOGUE_SCHEMA_VERSION, GIT_AUTHORITY_SCHEMA_VERSION, ADAPTIVE_SCHEMA_VERSION,
+        DECISION_COMPLETION_SCHEMA_VERSION, ARTIFACT_REGISTRY_SCHEMA_VERSION,
       ].includes(fromVersion);
     backupPath = migrationBackup(db, dbPath, fromVersion, existing);
+    // This must precede every ALTER, table rebuild, or index creation. Runtime
+    // constraint upgrades rebuild sessions and would otherwise surface a
+    // generic SQLITE_CONSTRAINT instead of the complete authority conflict.
+    assertNoDuplicateActiveSessionLeases(db);
     applyCompatibleColumns(db);
+    if (existing.has('artifacts')) {
+      db.transaction(() => applyArtifactRegistryUpgrade(db))();
+    }
     const missing = REQUIRED_TABLES.filter((t) => !existing.has(t));
     if (missing.length > 0) {
       applySchema(db);
@@ -884,4 +1265,7 @@ module.exports = {
   tableNames,
   runScript,
   MIGRATED_GAPS,
+  ActiveSessionLeaseConflictError,
+  activeSessionLeaseConflicts,
+  assertNoDuplicateActiveSessionLeases,
 };