ultra-builder-pro-cli 0.24.2 → 0.25.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 = '22.0';
+const EXPECTED_VERSION = '23.0';
 const KIMI_SCHEMA_VERSION = '9.1';
 const CONTEXT_SCHEMA_VERSION = '10.0';
 const BASELINE_SCHEMA_VERSION = '11.0';
@@ -24,6 +24,7 @@ const DECISION_COMPLETION_SCHEMA_VERSION = '19.0';
 const ARTIFACT_REGISTRY_SCHEMA_VERSION = '20.0';
 const KERNEL_SCHEMA_VERSION = '21.0';
 const CHECKPOINT_NATIVE_SCHEMA_VERSION = '22.0';
+const SEMANTIC_KERNEL_SCHEMA_VERSION = '23.0';
 
 const MIGRATED_GAPS = Object.freeze([{
   id: 'legacy-rebaseline-required',
@@ -306,9 +307,154 @@ function applyChangeColumns(db) {
     db, 'changes', columns, 'alignment_thread_id',
     'TEXT REFERENCES decision_threads(id) ON DELETE SET NULL',
   ) || changed;
+  changed = addColumnIfMissing(
+    db, 'changes', columns, 'supersedes_id',
+    'TEXT REFERENCES changes(id) ON DELETE SET NULL',
+  ) || changed;
   return changed;
 }
 
+function upgradeSemanticKernelConstraints(db) {
+  const tables = new Set(tableNames(db));
+  if (!tables.has('changes') || !tables.has('tasks')) return false;
+  const taskColumns = columnNames(db, 'tasks');
+  const preservesLegacyComplexityHint = taskColumns.has('complexity_hint');
+  const changesSql = db.prepare(
+    "SELECT sql FROM sqlite_master WHERE type = 'table' AND name = 'changes'",
+  ).get()?.sql || '';
+  const tasksSql = db.prepare(
+    "SELECT sql FROM sqlite_master WHERE type = 'table' AND name = 'tasks'",
+  ).get()?.sql || '';
+  const current = /length\s*\(\s*trim\s*\(\s*kind\s*\)\s*\)\s+BETWEEN\s+1\s+AND\s+80/i
+    .test(changesSql)
+    && /length\s*\(\s*trim\s*\(\s*type\s*\)\s*\)\s+BETWEEN\s+1\s+AND\s+80/i
+      .test(tasksSql)
+    && /length\s*\(\s*trim\s*\(\s*priority\s*\)\s*\)\s+BETWEEN\s+1\s+AND\s+80/i
+      .test(tasksSql)
+    && /length\s*\(\s*trim\s*\(\s*slice_kind\s*\)\s*\)\s+BETWEEN\s+1\s+AND\s+80/i
+      .test(tasksSql)
+    && columnNames(db, 'changes').has('supersedes_id');
+  if (current) return false;
+
+  const foreignKeys = db.pragma('foreign_keys', { simple: true });
+  db.pragma('foreign_keys = OFF');
+  try {
+    db.transaction(() => {
+      db.exec(`
+        DROP TABLE IF EXISTS changes_semantic_kernel_upgrade;
+        CREATE TABLE changes_semantic_kernel_upgrade (
+          id TEXT PRIMARY KEY,
+          title TEXT NOT NULL,
+          kind TEXT NOT NULL CHECK (length(trim(kind)) BETWEEN 1 AND 80),
+          status TEXT NOT NULL DEFAULT 'active'
+            CHECK (status IN ('active', 'blocked', 'ready', 'archived', 'cancelled')),
+          intent TEXT NOT NULL,
+          docs_impact_json TEXT NOT NULL DEFAULT '{"status":"unknown","files":[],"rationale":null}',
+          provider_refs_json TEXT NOT NULL DEFAULT '{}',
+          baseline_bypass_json TEXT,
+          contract_json TEXT NOT NULL DEFAULT '{}',
+          classification_json TEXT NOT NULL DEFAULT '{}',
+          research_disposition_json TEXT NOT NULL DEFAULT '{}',
+          alignment_thread_id TEXT REFERENCES decision_threads(id) ON DELETE SET NULL,
+          base_commit TEXT,
+          supersedes_id TEXT REFERENCES changes_semantic_kernel_upgrade(id) ON DELETE SET NULL,
+          artifact_root TEXT NOT NULL,
+          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')),
+          closed_at TEXT
+        );
+        INSERT INTO changes_semantic_kernel_upgrade (
+          id, title, kind, status, intent, docs_impact_json, provider_refs_json,
+          baseline_bypass_json, contract_json, classification_json,
+          research_disposition_json, alignment_thread_id, base_commit,
+          supersedes_id, artifact_root, created_at, updated_at, closed_at
+        )
+        SELECT
+          id, title, kind, status, intent, docs_impact_json, provider_refs_json,
+          baseline_bypass_json, contract_json, classification_json,
+          research_disposition_json, alignment_thread_id, base_commit,
+          supersedes_id, artifact_root, created_at, updated_at, closed_at
+        FROM changes;
+
+        DROP TABLE IF EXISTS tasks_semantic_kernel_upgrade;
+        CREATE TABLE tasks_semantic_kernel_upgrade (
+          id TEXT PRIMARY KEY,
+          title TEXT NOT NULL,
+          type TEXT NOT NULL CHECK (length(trim(type)) BETWEEN 1 AND 80),
+          priority TEXT NOT NULL CHECK (length(trim(priority)) BETWEEN 1 AND 80),
+          complexity INTEGER CHECK (complexity BETWEEN 1 AND 10),
+          estimated_days REAL CHECK (estimated_days IS NULL OR estimated_days > 0),
+          status TEXT NOT NULL DEFAULT 'pending'
+            CHECK (status IN ('pending', 'in_progress', 'completed', 'blocked', 'expanded')),
+          deps TEXT,
+          files_modified TEXT,
+          session_id TEXT,
+          stale INTEGER NOT NULL DEFAULT 0 CHECK (stale IN (0, 1)),
+          ${preservesLegacyComplexityHint ? 'complexity_hint TEXT,' : ''}
+          tag TEXT,
+          trace_to TEXT,
+          outcome TEXT,
+          slice_kind TEXT CHECK (
+            slice_kind IS NULL OR length(trim(slice_kind)) BETWEEN 1 AND 80
+          ),
+          public_seam TEXT,
+          verification_command TEXT,
+          acceptance_json TEXT NOT NULL DEFAULT '[]',
+          context_refs_json TEXT NOT NULL DEFAULT '[]',
+          docs_impact_json TEXT NOT NULL DEFAULT '{"status":"unknown","files":[],"rationale":null}',
+          ownership_json TEXT NOT NULL DEFAULT '{}',
+          context_file TEXT,
+          completion_commit TEXT,
+          change_id TEXT REFERENCES changes_semantic_kernel_upgrade(id) ON DELETE SET NULL,
+          parent_id TEXT REFERENCES tasks_semantic_kernel_upgrade(id) ON DELETE SET NULL,
+          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'))
+        );
+        INSERT INTO tasks_semantic_kernel_upgrade (
+          id, title, type, priority, complexity, estimated_days, status, deps,
+          files_modified, session_id, stale,
+          ${preservesLegacyComplexityHint ? 'complexity_hint,' : ''}
+          tag, trace_to, outcome, slice_kind,
+          public_seam, verification_command, acceptance_json, context_refs_json,
+          docs_impact_json, ownership_json, context_file, completion_commit,
+          change_id, parent_id, created_at, updated_at
+        )
+        SELECT
+          id, title, type, priority, complexity, estimated_days, status, deps,
+          files_modified, session_id, stale,
+          ${preservesLegacyComplexityHint ? 'complexity_hint,' : ''}
+          tag, trace_to, outcome, slice_kind,
+          public_seam, verification_command, acceptance_json, context_refs_json,
+          docs_impact_json, ownership_json, context_file, completion_commit,
+          change_id, parent_id, created_at, updated_at
+        FROM tasks;
+
+        DROP TABLE tasks;
+        DROP TABLE changes;
+        ALTER TABLE changes_semantic_kernel_upgrade RENAME TO changes;
+        ALTER TABLE tasks_semantic_kernel_upgrade RENAME TO tasks;
+        CREATE INDEX changes_status ON changes(status, created_at);
+        CREATE INDEX changes_kind ON changes(kind, created_at);
+        CREATE INDEX tasks_status ON tasks(status);
+        CREATE INDEX tasks_tag ON tasks(tag);
+        CREATE INDEX tasks_session ON tasks(session_id) WHERE session_id IS NOT NULL;
+        CREATE INDEX tasks_stale ON tasks(stale) WHERE stale = 1;
+        CREATE INDEX tasks_parent ON tasks(parent_id) WHERE parent_id IS NOT NULL;
+        CREATE INDEX tasks_change ON tasks(change_id) WHERE change_id IS NOT NULL;
+      `);
+      const violations = db.pragma('foreign_key_check');
+      if (violations.length > 0) {
+        throw new Error(
+          `semantic kernel migration produced ${violations.length} foreign key violation(s)`,
+        );
+      }
+    })();
+  } finally {
+    db.pragma(`foreign_keys = ${foreignKeys ? 'ON' : 'OFF'}`);
+  }
+  return true;
+}
+
 function applySemanticAuthorityColumns(db) {
   let changed = false;
   if (tableNames(db).includes('workflow_steps')) {
@@ -416,7 +562,7 @@ function applyCompatibleColumns(db) {
   }
   const taskAdditions = [
     ['outcome', 'TEXT'],
-    ['slice_kind', "TEXT CHECK (slice_kind IS NULL OR slice_kind IN ('tracer_bullet', 'expand_contract', 'integration_checkpoint'))"],
+    ['slice_kind', 'TEXT CHECK (slice_kind IS NULL OR length(trim(slice_kind)) BETWEEN 1 AND 80)'],
     ['public_seam', 'TEXT'],
     ['verification_command', 'TEXT'],
     ['acceptance_json', "TEXT NOT NULL DEFAULT '[]'"],
@@ -486,7 +632,7 @@ function migrateAdaptiveWorkflowRuns(db, fromVersion = latestSchemaVersion(db))
   if ([
     ADAPTIVE_SCHEMA_VERSION, DECISION_COMPLETION_SCHEMA_VERSION,
     ARTIFACT_REGISTRY_SCHEMA_VERSION, KERNEL_SCHEMA_VERSION,
-    CHECKPOINT_NATIVE_SCHEMA_VERSION,
+    CHECKPOINT_NATIVE_SCHEMA_VERSION, SEMANTIC_KERNEL_SCHEMA_VERSION,
   ].includes(fromVersion) || existing) {
     return false;
   }
@@ -1007,6 +1153,11 @@ function applyCompatibleUpgrades(db, fromVersion = latestSchemaVersion(db), { le
   }
   const gitStateChangedFrom = upgradeBaselineWorktreeConstraint(db, fromVersion);
   const decisionCompletionChanged = upgradeDecisionThreadLifecycle(db);
+  db.transaction(() => {
+    applyCompatibleColumns(db);
+    applyChangeColumns(db);
+  })();
+  const semanticKernelChanged = upgradeSemanticKernelConstraints(db);
   db.transaction(() => {
     applyCompatibleColumns(db);
     const contextChanged = applyContextSpineUpgrade(db);
@@ -1020,6 +1171,7 @@ function applyCompatibleUpgrades(db, fromVersion = latestSchemaVersion(db), { le
         DIALOGUE_SCHEMA_VERSION, GIT_AUTHORITY_SCHEMA_VERSION, ADAPTIVE_SCHEMA_VERSION,
         DECISION_COMPLETION_SCHEMA_VERSION, ARTIFACT_REGISTRY_SCHEMA_VERSION,
         KERNEL_SCHEMA_VERSION, CHECKPOINT_NATIVE_SCHEMA_VERSION,
+        SEMANTIC_KERNEL_SCHEMA_VERSION,
       ].includes(fromVersion)
         && !contextMigration,
     );
@@ -1049,6 +1201,7 @@ function applyCompatibleUpgrades(db, fromVersion = latestSchemaVersion(db), { le
       GIT_AUTHORITY_SCHEMA_VERSION, ADAPTIVE_SCHEMA_VERSION,
       DECISION_COMPLETION_SCHEMA_VERSION, ARTIFACT_REGISTRY_SCHEMA_VERSION,
       KERNEL_SCHEMA_VERSION, CHECKPOINT_NATIVE_SCHEMA_VERSION,
+      SEMANTIC_KERNEL_SCHEMA_VERSION,
     ].includes(fromVersion)
       && !baselineMigration) {
       db.prepare(
@@ -1123,6 +1276,7 @@ function applyCompatibleUpgrades(db, fromVersion = latestSchemaVersion(db), { le
       DIALOGUE_SCHEMA_VERSION, GIT_AUTHORITY_SCHEMA_VERSION, ADAPTIVE_SCHEMA_VERSION,
       DECISION_COMPLETION_SCHEMA_VERSION, ARTIFACT_REGISTRY_SCHEMA_VERSION,
       KERNEL_SCHEMA_VERSION, CHECKPOINT_NATIVE_SCHEMA_VERSION,
+      SEMANTIC_KERNEL_SCHEMA_VERSION,
     ].includes(fromVersion) && !workflowMigration) {
       db.prepare(
         `INSERT INTO migration_history
@@ -1141,7 +1295,7 @@ function applyCompatibleUpgrades(db, fromVersion = latestSchemaVersion(db), { le
       AUTHORITY_SCHEMA_VERSION, SEMANTIC_SCHEMA_VERSION, DIALOGUE_SCHEMA_VERSION,
       GIT_AUTHORITY_SCHEMA_VERSION, ADAPTIVE_SCHEMA_VERSION, DECISION_COMPLETION_SCHEMA_VERSION,
       ARTIFACT_REGISTRY_SCHEMA_VERSION, KERNEL_SCHEMA_VERSION,
-      CHECKPOINT_NATIVE_SCHEMA_VERSION,
+      CHECKPOINT_NATIVE_SCHEMA_VERSION, SEMANTIC_KERNEL_SCHEMA_VERSION,
     ].includes(fromVersion) && !authorityMigration) {
       db.prepare(
         `INSERT INTO migration_history
@@ -1160,7 +1314,7 @@ function applyCompatibleUpgrades(db, fromVersion = latestSchemaVersion(db), { le
       SEMANTIC_SCHEMA_VERSION, DIALOGUE_SCHEMA_VERSION, GIT_AUTHORITY_SCHEMA_VERSION,
       ADAPTIVE_SCHEMA_VERSION, DECISION_COMPLETION_SCHEMA_VERSION,
       ARTIFACT_REGISTRY_SCHEMA_VERSION, KERNEL_SCHEMA_VERSION,
-      CHECKPOINT_NATIVE_SCHEMA_VERSION,
+      CHECKPOINT_NATIVE_SCHEMA_VERSION, SEMANTIC_KERNEL_SCHEMA_VERSION,
     ].includes(fromVersion) && !semanticMigration) {
       db.prepare(
         `INSERT INTO migration_history
@@ -1179,6 +1333,7 @@ function applyCompatibleUpgrades(db, fromVersion = latestSchemaVersion(db), { le
       DIALOGUE_SCHEMA_VERSION, GIT_AUTHORITY_SCHEMA_VERSION, ADAPTIVE_SCHEMA_VERSION,
       DECISION_COMPLETION_SCHEMA_VERSION, ARTIFACT_REGISTRY_SCHEMA_VERSION,
       KERNEL_SCHEMA_VERSION, CHECKPOINT_NATIVE_SCHEMA_VERSION,
+      SEMANTIC_KERNEL_SCHEMA_VERSION,
     ].includes(fromVersion)
       && !dialogueMigration) {
       db.prepare(
@@ -1197,7 +1352,7 @@ function applyCompatibleUpgrades(db, fromVersion = latestSchemaVersion(db), { le
     if (fromVersion && ![
       GIT_AUTHORITY_SCHEMA_VERSION, ADAPTIVE_SCHEMA_VERSION, DECISION_COMPLETION_SCHEMA_VERSION,
       ARTIFACT_REGISTRY_SCHEMA_VERSION, KERNEL_SCHEMA_VERSION,
-      CHECKPOINT_NATIVE_SCHEMA_VERSION,
+      CHECKPOINT_NATIVE_SCHEMA_VERSION, SEMANTIC_KERNEL_SCHEMA_VERSION,
     ].includes(fromVersion)
       && !gitStateMigration) {
       db.prepare(
@@ -1217,7 +1372,7 @@ function applyCompatibleUpgrades(db, fromVersion = latestSchemaVersion(db), { le
     if (fromVersion && ![
       ADAPTIVE_SCHEMA_VERSION, DECISION_COMPLETION_SCHEMA_VERSION,
       ARTIFACT_REGISTRY_SCHEMA_VERSION, KERNEL_SCHEMA_VERSION,
-      CHECKPOINT_NATIVE_SCHEMA_VERSION,
+      CHECKPOINT_NATIVE_SCHEMA_VERSION, SEMANTIC_KERNEL_SCHEMA_VERSION,
     ].includes(fromVersion) && !adaptiveMigration) {
       db.prepare(
         `INSERT INTO migration_history
@@ -1237,6 +1392,7 @@ function applyCompatibleUpgrades(db, fromVersion = latestSchemaVersion(db), { le
     if (fromVersion && ![
       DECISION_COMPLETION_SCHEMA_VERSION, ARTIFACT_REGISTRY_SCHEMA_VERSION,
       KERNEL_SCHEMA_VERSION, CHECKPOINT_NATIVE_SCHEMA_VERSION,
+      SEMANTIC_KERNEL_SCHEMA_VERSION,
     ].includes(fromVersion) && !completionMigration) {
       db.prepare(
         `INSERT INTO migration_history
@@ -1256,6 +1412,7 @@ function applyCompatibleUpgrades(db, fromVersion = latestSchemaVersion(db), { le
     if (fromVersion && fromVersion !== ARTIFACT_REGISTRY_SCHEMA_VERSION
       && fromVersion !== KERNEL_SCHEMA_VERSION
       && fromVersion !== CHECKPOINT_NATIVE_SCHEMA_VERSION
+      && fromVersion !== SEMANTIC_KERNEL_SCHEMA_VERSION
       && !artifactRegistryMigration) {
       db.prepare(
         `INSERT INTO migration_history
@@ -1275,6 +1432,7 @@ function applyCompatibleUpgrades(db, fromVersion = latestSchemaVersion(db), { le
     if (fromVersion
       && fromVersion !== KERNEL_SCHEMA_VERSION
       && fromVersion !== CHECKPOINT_NATIVE_SCHEMA_VERSION
+      && fromVersion !== SEMANTIC_KERNEL_SCHEMA_VERSION
       && !kernelMigration) {
       db.prepare(
         `INSERT INTO migration_history
@@ -1291,6 +1449,7 @@ function applyCompatibleUpgrades(db, fromVersion = latestSchemaVersion(db), { le
     ).get();
     if (fromVersion
       && fromVersion !== CHECKPOINT_NATIVE_SCHEMA_VERSION
+      && fromVersion !== SEMANTIC_KERNEL_SCHEMA_VERSION
       && !checkpointNativeMigration) {
       db.prepare(
         `INSERT INTO migration_history
@@ -1302,6 +1461,24 @@ function applyCompatibleUpgrades(db, fromVersion = latestSchemaVersion(db), { le
         'Bind Baseline research to Stage Checkpoints and add byte digests for Context Envelopes and Worker Packets',
       );
     }
+    const semanticKernelMigration = db.prepare(
+      "SELECT 1 FROM migration_history WHERE to_version = '23.0' AND status = 'success' LIMIT 1",
+    ).get();
+    if (fromVersion
+      && fromVersion !== SEMANTIC_KERNEL_SCHEMA_VERSION
+      && !semanticKernelMigration) {
+      db.prepare(
+        `INSERT INTO migration_history
+          (from_version, to_version, direction, status, notes)
+         VALUES (?, ?, 'forward', 'success', ?)`,
+      ).run(
+        CHECKPOINT_NATIVE_SCHEMA_VERSION,
+        SEMANTIC_KERNEL_SCHEMA_VERSION,
+        semanticKernelChanged
+          ? 'Move Task and Change business vocabulary out of SQLite enums and add immutable Change successor linkage'
+          : 'Record semantic-kernel vocabulary and Change successor authority',
+      );
+    }
     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);
@@ -1309,7 +1486,7 @@ function applyCompatibleUpgrades(db, fromVersion = latestSchemaVersion(db), { le
       'INSERT OR IGNORE INTO schema_version (version, description) VALUES (?, ?)',
     ).run(
       EXPECTED_VERSION,
-      'Checkpoint-native baseline authority plus byte-bound Context Envelopes and Worker Packets',
+      'Persistence and safety kernel with open semantic vocabulary and immutable Change successors',
     );
   })();
 }
@@ -1343,6 +1520,7 @@ function initStateDb(dbPath) {
         DIALOGUE_SCHEMA_VERSION, GIT_AUTHORITY_SCHEMA_VERSION, ADAPTIVE_SCHEMA_VERSION,
         DECISION_COMPLETION_SCHEMA_VERSION, ARTIFACT_REGISTRY_SCHEMA_VERSION,
         KERNEL_SCHEMA_VERSION, CHECKPOINT_NATIVE_SCHEMA_VERSION,
+        SEMANTIC_KERNEL_SCHEMA_VERSION,
       ].includes(fromVersion);
     backupPath = migrationBackup(db, dbPath, fromVersion, existing);
     // This must precede every ALTER, table rebuild, or index creation. Runtime

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

@@ -13,8 +13,14 @@ const fs = require('node:fs');
 const path = require('node:path');
 const { spawnSync } = require('node:child_process');
 
+const canonical = require('./canonical-json.cjs');
 const { openStateDb } = require('./state-db.cjs');
+const {
+  TASK_CONTRACT_DEFINE_FIELDS,
+  TASK_CONTRACT_PATCH_FIELDS,
+} = require('./task-contract.cjs');
 const { isSupportedRuntime } = require('../../adapters/_shared/runtime-assets.cjs');
+const closeJournal = require('../../orchestrator/session-close-journal.cjs');
 
 const STATUS_TRANSITIONS = Object.freeze({
   pending:     new Set(['in_progress', 'blocked', 'expanded']),
@@ -35,10 +41,8 @@ const TASK_FIELDS = Object.freeze([
 ]);
 
 const PATCHABLE_FIELDS = Object.freeze([
-  'priority', 'complexity', 'estimated_days', 'deps', 'files_modified',
-  'session_id', 'stale', 'tag', 'trace_to',
-  'outcome', 'slice_kind', 'public_seam', 'verification_command',
-  'acceptance', 'context_refs', 'docs_impact', 'ownership',
+  ...TASK_CONTRACT_PATCH_FIELDS,
+  'session_id', 'stale', 'tag',
   'context_file', 'completion_commit',
   'change_id',
 ]);
@@ -48,11 +52,7 @@ const STALE_RECONCILIATION_FIELDS = Object.freeze([
   'verification_command', 'acceptance', 'context_refs', 'docs_impact', 'ownership',
 ]);
 
-const TASK_CONTRACT_PATCH_FIELDS = new Set([
-  'priority', 'complexity', 'estimated_days', 'deps', 'files_modified', 'tag',
-  'trace_to', 'outcome', 'slice_kind', 'public_seam', 'verification_command',
-  'acceptance', 'context_refs', 'docs_impact', 'ownership',
-]);
+const TASK_CONTRACT_PATCH_FIELD_SET = new Set(TASK_CONTRACT_PATCH_FIELDS);
 
 const SESSION_PATCHABLE = Object.freeze([
   'pid', 'status', 'lease_expires_at', 'heartbeat_at', 'worktree_path', 'artifact_dir',
@@ -142,7 +142,7 @@ function rowToTask(row) {
     delete out[column];
   }
   if (out.stale !== undefined && out.stale !== null) {
-    out.stale = Boolean(out.stale);
+    if (out.stale === 0 || out.stale === 1) out.stale = Boolean(out.stale);
   }
   return out;
 }
@@ -197,11 +197,17 @@ function normalizeContextRefs(value) {
         `context_refs[${index}].freshness_policy must be digest, existence, or advisory`,
       );
     }
+    if (item.required !== undefined && typeof item.required !== 'boolean') {
+      throw new StateOpsError(
+        'VALIDATION_ERROR',
+        `context_refs[${index}].required must be a boolean`,
+      );
+    }
     const normalized = {
       ref,
       reason,
       kind,
-      required: item.required !== false,
+      required: item.required === undefined ? true : item.required,
       freshness_policy: freshnessPolicy,
     };
     if (expectedDigest !== null) normalized.expected_digest = String(expectedDigest);
@@ -254,7 +260,7 @@ function normalizeOwnership(value) {
 function taskContractBlockers(task) {
   const blockers = [];
   if (!String(task?.outcome || '').trim()) blockers.push('TASK_OUTCOME_MISSING');
-  if (!['tracer_bullet', 'expand_contract', 'integration_checkpoint'].includes(task?.slice_kind)) {
+  if (!String(task?.slice_kind || '').trim()) {
     blockers.push('TASK_SLICE_KIND_MISSING');
   }
   if (!String(task?.public_seam || '').trim()) blockers.push('TASK_PUBLIC_SEAM_MISSING');
@@ -548,8 +554,6 @@ function patchTask(db, id, patch = {}) {
     params.push(id);
     db.prepare(`UPDATE tasks SET ${sets.join(', ')} WHERE id = ?`).run(...params);
     const updated = readTask(db, id);
-    if (clearingStale) assertTaskExecutionContract(updated);
-
     if (nextStatus && nextStatus !== current.status) {
       appendEventInTx(db, {
         type: current.status === 'completed' && nextStatus === 'in_progress'
@@ -566,7 +570,9 @@ function patchTask(db, id, patch = {}) {
         },
       });
     }
-    const contractFields = Object.keys(patch).filter((field) => TASK_CONTRACT_PATCH_FIELDS.has(field));
+    const contractFields = Object.keys(patch).filter(
+      (field) => TASK_CONTRACT_PATCH_FIELD_SET.has(field),
+    );
     if (contractFields.length > 0) {
       appendEventInTx(db, {
         type: clearingStale ? 'task_contract_reconciled' : 'task_contract_updated',
@@ -597,37 +603,214 @@ function updateTaskStatus(db, id, nextStatus) {
   return patchTask(db, id, { status: nextStatus });
 }
 
-function deleteTask(db, id, { force = false } = {}) {
+function deleteTask(db, id, { force = false, rootDir = null } = {}) {
   return tx(db, () => {
-    const t = readTask(db, id);
-    if (!t) throw new StateOpsError('TASK_NOT_FOUND', `no task ${id}`);
-    if (t.session_id && !force) {
-      throw new StateOpsError('SESSION_ACTIVE', `task ${id} has session ${t.session_id}; pass force=true to override`);
+    const task = readTask(db, id);
+    if (!task) throw new StateOpsError('TASK_NOT_FOUND', `no task ${id}`);
+    const lifecycleEvents = db.prepare(
+      'SELECT type FROM events WHERE task_id = ? ORDER BY id',
+    ).all(id).map((row) => row.type).filter((type) => (
+      [
+        'task_started',
+        'task_completed',
+        'task_blocked',
+        'task_reopened',
+        'task_stale_marked',
+        'task_expanded',
+      ].includes(type)
+      || type.startsWith('session_')
+      || type.startsWith('worker_packet_')
+      || type.startsWith('task_failure')
+      || type.startsWith('task_circuit')
+      || type.includes('checkpoint')
+      || type.startsWith('workflow_')
+    ));
+    const references = [
+      ['sessions', db.prepare(
+        'SELECT COUNT(*) AS count FROM sessions WHERE task_id = ?',
+      ).get(id).count],
+      ['children', db.prepare(
+        'SELECT COUNT(*) AS count FROM tasks WHERE parent_id = ?',
+      ).get(id).count],
+      ['dependencies', db.prepare(
+        `SELECT COUNT(*) AS count FROM tasks
+         WHERE deps IS NOT NULL AND json_valid(deps)
+           AND EXISTS (SELECT 1 FROM json_each(tasks.deps) WHERE value = ?)`,
+      ).get(id).count],
+      ['worker_packets', db.prepare(
+        `SELECT COUNT(*) AS count FROM worker_packets
+         WHERE scope_type = 'task' AND scope_id = ?`,
+      ).get(id).count],
+      ['artifacts', db.prepare(
+        `SELECT COUNT(*) AS count FROM artifacts
+         WHERE task_id = ? OR (owner_type = 'task' AND owner_id = ?)`,
+      ).get(id, id).count],
+      ['artifact_edges', db.prepare(
+        `SELECT COUNT(*) AS count FROM artifact_edges
+         WHERE (source_type = 'task' AND source_id = ?)
+            OR (target_type = 'task' AND target_id = ?)`,
+      ).get(id, id).count],
+      ['stage_checkpoints', db.prepare(
+        `SELECT COUNT(*) AS count FROM stage_checkpoints
+         WHERE scope_type = 'task' AND scope_id = ?`,
+      ).get(id).count],
+      ['context_envelopes', db.prepare(
+        `SELECT COUNT(*) AS count FROM context_envelopes
+         WHERE scope_type = 'task' AND scope_id = ?`,
+      ).get(id).count],
+      ['workflow_runs', db.prepare(
+        'SELECT COUNT(*) AS count FROM workflow_runs WHERE task_id = ?',
+      ).get(id).count],
+      ['context_snapshots', db.prepare(
+        'SELECT COUNT(*) AS count FROM context_snapshots WHERE task_id = ?',
+      ).get(id).count],
+      ['incidents', db.prepare(
+        'SELECT COUNT(*) AS count FROM incidents WHERE task_id = ?',
+      ).get(id).count],
+      ['spec_learning_candidates', db.prepare(
+        'SELECT COUNT(*) AS count FROM spec_learning_candidates WHERE task_id = ?',
+      ).get(id).count],
+      ['trace_links', db.prepare(
+        'SELECT COUNT(*) AS count FROM trace_links WHERE task_id = ?',
+      ).get(id).count],
+      ['circuit_breaker', db.prepare(
+        'SELECT COUNT(*) AS count FROM circuit_breaker WHERE task_id = ?',
+      ).get(id).count],
+      ['session_close_journal', rootDir && closeJournal.findForTask(rootDir, id) ? 1 : 0],
+    ].filter(([, count]) => count > 0)
+      .map(([kind, count]) => ({ kind, count }));
+    if (references.length > 0) {
+      throw new StateOpsError(
+        'TASK_DELETE_REFERENCED',
+        `task ${id} cannot be deleted because durable authority still references it`,
+        { details: { task_id: id, references } },
+      );
+    }
+    if (!force && (
+      task.status !== 'pending' || task.session_id || task.completion_commit
+      || lifecycleEvents.length > 0
+    )) {
+      throw new StateOpsError(
+        'TASK_DELETE_NOT_DRAFT',
+        `task ${id} is not an unowned pending draft`,
+        {
+          details: {
+            task_id: id,
+            status: task.status,
+            session_id: task.session_id,
+            completion_commit: task.completion_commit,
+            lifecycle_events: [...new Set(lifecycleEvents)],
+          },
+        },
+      );
     }
     db.prepare('DELETE FROM tasks WHERE id = ?').run(id);
-    return { ok: true };
+    const contract = Object.fromEntries(
+      TASK_CONTRACT_DEFINE_FIELDS
+        .filter((field) => task[field] !== undefined && task[field] !== null)
+        .map((field) => [field, task[field]]),
+    );
+    const tombstone = appendEventInTx(db, {
+      type: 'task_deleted',
+      task_id: id,
+      change_id: task.change_id,
+      payload: {
+        id: task.id,
+        title: task.title,
+        type: task.type,
+        priority: task.priority,
+        reason: 'task_contract_remove',
+        contract_digest: canonical.digest(contract),
+      },
+    });
+    return { ok: true, tombstone };
   });
 }
 
 // ─── events ──────────────────────────────────────────────────────────────
 
+const EVENT_FIELDS = new Set([
+  'type', 'task_id', 'change_id', 'session_id', 'runtime', 'payload',
+]);
+
+function eventText(value, field, { nullable = false } = {}) {
+  if (value === null && nullable) return null;
+  if (typeof value !== 'string' || value.trim() === '') {
+    throw new StateOpsError(
+      'VALIDATION_ERROR',
+      `${field} must be a non-empty string${nullable ? ' or null' : ''}`,
+    );
+  }
+  return value.trim();
+}
+
+function assertJsonValue(value, field, seen = new Set()) {
+  if (value === null || typeof value === 'string' || typeof value === 'boolean') return;
+  if (typeof value === 'number') {
+    if (Number.isFinite(value)) return;
+    throw new StateOpsError('VALIDATION_ERROR', `${field} must contain valid JSON values`);
+  }
+  if (typeof value !== 'object') {
+    throw new StateOpsError('VALIDATION_ERROR', `${field} must contain valid JSON values`);
+  }
+  if (seen.has(value)) {
+    throw new StateOpsError('VALIDATION_ERROR', `${field} must not contain circular references`);
+  }
+  if (!Array.isArray(value)) {
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null) {
+      throw new StateOpsError('VALIDATION_ERROR', `${field} must contain only JSON objects`);
+    }
+  }
+  seen.add(value);
+  if (Array.isArray(value)) {
+    value.forEach((item, index) => assertJsonValue(item, `${field}[${index}]`, seen));
+  } else {
+    Object.entries(value).forEach(([key, item]) => (
+      assertJsonValue(item, `${field}.${key}`, seen)
+    ));
+  }
+  seen.delete(value);
+}
+
 function appendEventInTx(db, event) {
-  if (!event || !event.type) {
-    throw new StateOpsError('VALIDATION_ERROR', 'event.type is required');
+  if (!event || typeof event !== 'object' || Array.isArray(event)) {
+    throw new StateOpsError('VALIDATION_ERROR', 'event must be an object');
+  }
+  const unknown = Object.keys(event).filter((field) => !EVENT_FIELDS.has(field));
+  if (unknown.length > 0) {
+    throw new StateOpsError('VALIDATION_ERROR', `event.${unknown[0]} is not allowed`);
   }
-  if (event.runtime != null && !isSupportedRuntime(event.runtime)) {
-    throw new StateOpsError('VALIDATION_ERROR', `unsupported runtime: ${event.runtime}`);
+  const type = eventText(event.type, 'event.type');
+  const taskId = event.task_id === undefined
+    ? null : eventText(event.task_id, 'event.task_id', { nullable: true });
+  const changeId = event.change_id === undefined
+    ? null : eventText(event.change_id, 'event.change_id', { nullable: true });
+  const sessionId = event.session_id === undefined
+    ? null : eventText(event.session_id, 'event.session_id', { nullable: true });
+  const runtime = event.runtime === undefined
+    ? null : eventText(event.runtime, 'event.runtime', { nullable: true });
+  if (runtime !== null && !isSupportedRuntime(runtime)) {
+    throw new StateOpsError('VALIDATION_ERROR', `unsupported runtime: ${runtime}`);
+  }
+  let payloadJson = null;
+  if (event.payload !== undefined) {
+    if (!event.payload || typeof event.payload !== 'object' || Array.isArray(event.payload)) {
+      throw new StateOpsError('VALIDATION_ERROR', 'event.payload must be a JSON object');
+    }
+    assertJsonValue(event.payload, 'event.payload');
+    payloadJson = JSON.stringify(event.payload);
   }
   const result = db.prepare(
     `INSERT INTO events (type, task_id, change_id, session_id, runtime, payload_json)
      VALUES (?, ?, ?, ?, ?, ?)`,
   ).run(
-    event.type,
-    event.task_id ?? null,
-    event.change_id ?? null,
-    event.session_id ?? null,
-    event.runtime ?? null,
-    event.payload === undefined ? null : JSON.stringify(event.payload),
+    type,
+    taskId,
+    changeId,
+    sessionId,
+    runtime,
+    payloadJson,
   );
   const row = db.prepare('SELECT id, ts FROM events WHERE id = ?').get(result.lastInsertRowid);
   return { event_id: Number(row.id), ts: row.ts };