ultra-builder-pro-cli 0.11.0 → 0.12.1

package/mcp-server/lib/context-spine.cjs

@@ -4,6 +4,7 @@ const crypto = require('node:crypto');
 const fs = require('node:fs');
 const path = require('node:path');
 const { spawnSync } = require('node:child_process');
+const baselines = require('./baseline-workflow.cjs');
 
 const ROLES = new Set(['plan', 'implement', 'check', 'review']);
 const GATES = new Set([
@@ -12,6 +13,12 @@ const GATES = new Set([
 const CONTEXT_KINDS = new Set(['spec', 'source', 'test', 'docs', 'external']);
 const SLICE_KINDS = new Set(['tracer_bullet', 'expand_contract', 'integration_checkpoint']);
 const DEFAULT_BUDGET = Object.freeze({ max_tokens: 12_000, max_files: 12 });
+const ADVISORY_CONTEXT_CODES = new Set([
+  'CONTEXT_FILE_BUDGET_EXCEEDED',
+  'CONTEXT_TOKEN_BUDGET_EXCEEDED',
+  'EXECUTION_CONTEXT_BUDGET_EXCEEDED',
+  'EXECUTION_CONTEXT_BUDGET_ADVISORY',
+]);
 
 class ContextSpineError extends Error {
   constructor(code, message) {
@@ -149,8 +156,13 @@ function defaultGate(role) {
   }[role];
 }
 
-function deriveNextAction({ change, tasks, task, role, readiness, explicit }) {
-  if (readiness === 'blocked') return 'Resolve the context readiness blockers, then recompile change.context.';
+function deriveNextAction({ change, tasks, task, role, readiness, blockers = [], explicit }) {
+  if (readiness === 'blocked') {
+    if (blockers.some((blocker) => blocker.startsWith('BASELINE_'))) {
+      return 'Complete or refresh the Ultra project baseline, then recompile change.context.';
+    }
+    return 'Resolve the context readiness blockers, then recompile change.context.';
+  }
   if (explicit && String(explicit).trim()) return String(explicit).trim();
   if (change.status === 'ready') return `Run ultra-deliver for change ${change.id}.`;
   if (change.status === 'blocked') return `Resolve the blockers for change ${change.id}, then recompile context.`;
@@ -199,12 +211,19 @@ function compileRoleContext(db, { input, change, tasks, rootDir }) {
     input, inherited.execution_contract, { taskId: input.task_id },
   );
   const blockers = [];
+  const warnings = [];
+  const baselineHealth = baselines.inspectBaseline(db, { rootDir });
+  // An active change must remain executable even when adoption is incomplete or
+  // the repository has moved. Approved adoption is required at convergence and
+  // full revision/spec health is required at archive; here both are recovery
+  // guidance, not a refusal.
+  warnings.push(...baselineHealth.blockers, ...baselineHealth.warnings);
   for (const item of items) {
     if (item.required && item.status === 'missing') blockers.push(`CONTEXT_REQUIRED_REF_MISSING:${item.ref}`);
     if (item.required && item.status === 'stale') blockers.push(`CONTEXT_REQUIRED_REF_STALE:${item.ref}`);
   }
-  if (fileCount > budget.max_files) blockers.push('CONTEXT_FILE_BUDGET_EXCEEDED');
-  if (tokenEstimate > budget.max_tokens) blockers.push('CONTEXT_TOKEN_BUDGET_EXCEEDED');
+  if (fileCount > budget.max_files) warnings.push('CONTEXT_FILE_BUDGET_EXCEEDED');
+  if (tokenEstimate > budget.max_tokens) warnings.push('CONTEXT_TOKEN_BUDGET_EXCEEDED');
   if (input.task_id) {
     if (!executionContract) blockers.push('EXECUTION_CONTRACT_MISSING');
     else {
@@ -212,21 +231,29 @@ function compileRoleContext(db, { input, change, tasks, rootDir }) {
       if (!executionContract.verification_command) blockers.push('EXECUTION_VERIFICATION_COMMAND_MISSING');
       if (executionContract.slice_kind !== 'expand_contract'
         && executionContract.context_budget_percent > 40) {
-        blockers.push('EXECUTION_CONTEXT_BUDGET_EXCEEDED');
+        warnings.push('EXECUTION_CONTEXT_BUDGET_ADVISORY');
       }
     }
   }
   const readiness = blockers.length === 0 ? 'ready' : 'blocked';
   const nextAction = deriveNextAction({
-    change, tasks, task, role, readiness, explicit: input.next_action,
+    change, tasks, task, role, readiness, blockers, explicit: input.next_action,
   });
   return {
     role,
     gate,
     next_action: nextAction,
-    readiness: { status: readiness, blockers },
+    readiness: { status: readiness, blockers, warnings: [...new Set(warnings)] },
     context: { items, budget, token_estimate: tokenEstimate, file_count: fileCount },
     execution_contract: executionContract,
+    baseline: baselineHealth.baseline ? {
+      id: baselineHealth.baseline.id,
+      mode: baselineHealth.baseline.mode,
+      status: baselineHealth.baseline.status,
+      repository_revision: baselineHealth.baseline.repository_revision,
+      health: baselineHealth.status,
+      warnings: [...new Set([...baselineHealth.blockers, ...baselineHealth.warnings])],
+    } : null,
     selected_task: task,
     resume: {
       change_id: change.id,
@@ -250,6 +277,7 @@ function recommendedWorkflow(change, task, tasks, readiness) {
 }
 
 function readBreadcrumb(db, { id } = {}, { rootDir = process.cwd() } = {}) {
+  const baselineHealth = baselines.inspectBaseline(db, { rootDir });
   const change = id
     ? db.prepare('SELECT * FROM changes WHERE id = ?').get(id)
     : db.prepare(
@@ -259,10 +287,32 @@ function readBreadcrumb(db, { id } = {}, { rootDir = process.cwd() } = {}) {
     throw new ContextSpineError('CHANGE_NOT_FOUND', `change ${id} not found`);
   }
   if (!change) {
+    const baseline = baselineHealth.baseline;
+    if (baselineHealth.status !== 'pass') {
+      const nextAction = baseline
+        ? `Complete ${baseline.mode} baseline adoption ${baseline.id} through ultra-init.`
+        : 'Initialize the project and start baseline adoption with ultra-init.';
+      return {
+        change_id: null, task_id: null, role: 'plan', gate: 'alignment', readiness: 'blocked',
+        blockers: baselineHealth.blockers, warnings: baselineHealth.warnings, next_action: nextAction,
+        recommended_workflow: 'ultra-init', context_manifest_path: null,
+        context_manifest_hash: null, git_head: currentHead(rootDir),
+        baseline: baseline ? {
+          id: baseline.id, mode: baseline.mode, status: baseline.status,
+          repository_revision: baseline.repository_revision,
+        } : null,
+      };
+    }
     return {
       change_id: null, task_id: null, role: 'plan', gate: 'alignment', readiness: 'ready',
       next_action: 'Start daily work with ultra-change.', recommended_workflow: 'ultra-change',
       context_manifest_path: null, context_manifest_hash: null, git_head: currentHead(rootDir),
+      blockers: [], warnings: baselineHealth.warnings,
+      baseline: {
+        id: baselineHealth.baseline.id, mode: baselineHealth.baseline.mode,
+        status: baselineHealth.baseline.status,
+        repository_revision: baselineHealth.baseline.repository_revision,
+      },
     };
   }
   const tasks = db.prepare('SELECT * FROM tasks WHERE change_id = ? ORDER BY created_at ASC').all(change.id);
@@ -275,18 +325,26 @@ function readBreadcrumb(db, { id } = {}, { rootDir = process.cwd() } = {}) {
   const task = tasks.find((row) => row.id === taskId) || null;
   const head = currentHead(rootDir);
   const snapshotMissing = !snapshot;
-  const legacyContext = Boolean(snapshot && (!context.resume || !context.context || !context.readiness));
+  const legacyContext = Boolean(
+    snapshot && (!context.resume || !context.context || !context.readiness || !('baseline' in context)),
+  );
   const headStale = Boolean(snapshot?.git_head && head && snapshot.git_head !== head);
   const stateChanged = context.resume?.task_status !== undefined
     && context.resume.task_status !== (task?.status || null);
   const blockers = [];
+  const warnings = [...baselineHealth.blockers, ...baselineHealth.warnings];
   if (snapshotMissing) blockers.push('CONTEXT_NOT_COMPILED');
   else {
     if (legacyContext) blockers.push('CONTEXT_SNAPSHOT_UPGRADE_REQUIRED');
     if (headStale) blockers.push('CONTEXT_HEAD_STALE');
     if (stateChanged) blockers.push('CONTEXT_TASK_STATE_STALE');
     for (const blocker of parseJson(snapshot.blockers_json, [])) {
-      if (!blockers.includes(blocker)) blockers.push(blocker);
+      if (ADVISORY_CONTEXT_CODES.has(blocker) || blocker.startsWith('BASELINE_')) {
+        if (!warnings.includes(blocker)) warnings.push(blocker);
+      } else if (!blockers.includes(blocker)) blockers.push(blocker);
+    }
+    for (const warning of context.readiness?.warnings || []) {
+      if (!warnings.includes(warning)) warnings.push(warning);
     }
   }
   const readiness = blockers.length > 0 ? 'blocked' : snapshot.readiness;
@@ -302,6 +360,7 @@ function readBreadcrumb(db, { id } = {}, { rootDir = process.cwd() } = {}) {
   } else {
     nextAction = deriveNextAction({
       change, tasks, task, role: snapshot?.role || 'plan', readiness,
+      blockers,
       explicit: snapshot?.next_action,
     });
   }
@@ -315,11 +374,17 @@ function readBreadcrumb(db, { id } = {}, { rootDir = process.cwd() } = {}) {
     gate: snapshot?.gate || 'alignment',
     readiness,
     blockers,
+    warnings: [...new Set(warnings)],
     next_action: nextAction,
     recommended_workflow: recommendedWorkflow(change, task, tasks, readiness),
     context_manifest_path: snapshot?.manifest_path || null,
     context_manifest_hash: snapshot?.manifest_hash || null,
     git_head: head,
+    baseline: baselineHealth.baseline ? {
+      id: baselineHealth.baseline.id, mode: baselineHealth.baseline.mode,
+      status: baselineHealth.baseline.status,
+      repository_revision: baselineHealth.baseline.repository_revision,
+    } : null,
   };
 }
 

package/mcp-server/lib/context-spine.test.cjs

@@ -11,6 +11,21 @@ const { initStateDb } = require('./state-db.cjs');
 const { createChange } = require('./change-workflow.cjs');
 const { createTask } = require('./state-ops.cjs');
 
+test('breadcrumb routes a project without a converged baseline back to adoption', () => {
+  const rootDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ubp-spine-baseline-'));
+  const { db } = initStateDb(path.join(rootDir, '.ultra', 'state.db'));
+  try {
+    const breadcrumb = readBreadcrumb(db, {}, { rootDir });
+    assert.equal(breadcrumb.readiness, 'blocked');
+    assert.ok(breadcrumb.blockers.includes('BASELINE_MISSING'));
+    assert.equal(breadcrumb.recommended_workflow, 'ultra-init');
+    assert.match(breadcrumb.next_action, /baseline|adoption/i);
+  } finally {
+    db.close();
+    fs.rmSync(rootDir, { recursive: true, force: true });
+  }
+});
+
 test('deriveNextAction gives one state-specific action instead of a workflow dump', () => {
   const change = { id: 'context-spine', status: 'active' };
   const task = { id: 'task-1', status: 'in_progress' };

package/mcp-server/lib/doctor.cjs

@@ -8,6 +8,7 @@ const ops = require('./state-ops.cjs');
 const runtime = require('./runtime-state.cjs');
 const projector = require('./projector.cjs');
 const recovery = require('../../orchestrator/recovery.cjs');
+const baselines = require('./baseline-workflow.cjs');
 
 const SPEC_CONSUMER = 'spec-staleness';
 
@@ -48,6 +49,9 @@ function inspectSystem(db, { rootDir = process.cwd() } = {}) {
          WHERE status IN ('active', 'blocked', 'ready') AND artifact_root IS NOT NULL`,
       ).all().filter((row) => row.artifact_root && !fs.existsSync(path.resolve(rootDir, row.artifact_root))).length
     : 0;
+  const baseline = missing.length === 0
+    ? baselines.inspectBaseline(db, { rootDir })
+    : { status: 'fail', blockers: ['BASELINE_STATE_UNAVAILABLE'], warnings: [], baseline: null };
   const degraded = integrity !== 'ok' || missing.length > 0 || incidents.length > 0
     || pending.length > 0 || running.length > 0 || failed.length > 0 || orphanSessions > 0 || activeMissing > 0
     || eventCursor > projectedCursor;
@@ -63,6 +67,16 @@ function inspectSystem(db, { rootDir = process.cwd() } = {}) {
       },
       sessions: { status: orphanSessions === 0 ? 'pass' : 'fail', orphan: orphanSessions },
       change_artifacts: { status: activeMissing === 0 ? 'pass' : 'fail', missing: activeMissing },
+      baseline: {
+        status: baseline.status === 'pass' ? 'pass' : 'warning',
+        readiness: baseline.status,
+        mode: baseline.baseline?.mode || null,
+        baseline_status: baseline.baseline?.status || null,
+        id: baseline.baseline?.id || null,
+        repository_revision: baseline.baseline?.repository_revision || null,
+        blockers: baseline.blockers,
+        warnings: baseline.warnings,
+      },
       external_providers: {
         status: 'pass', ownership: 'external',
         note: 'Ultra stores provider metadata references only and never owns memory or code-graph content.',

package/mcp-server/lib/doctor.test.cjs

@@ -10,10 +10,18 @@ const { initStateDb, closeStateDb } = require('./state-db.cjs');
 const ops = require('./state-ops.cjs');
 const runtime = require('./runtime-state.cjs');
 const doctor = require('./doctor.cjs');
+const baselines = require('./baseline-workflow.cjs');
 
-function fixture() {
+function fixture({ migratedBaseline = true } = {}) {
   const rootDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ubp-doctor-'));
   const { db } = initStateDb(path.join(rootDir, '.ultra', 'state.db'));
+  if (migratedBaseline) {
+    db.prepare(
+      `INSERT INTO baselines
+       (id, project_name, mode, status, approved_by, approval_note, converged_at)
+       VALUES ('test-baseline', 'fixture', 'migrated', 'ready', 'test', 'legacy fixture', ?)`,
+    ).run(new Date().toISOString());
+  }
   return { rootDir, db };
 }
 
@@ -35,6 +43,22 @@ test('doctor reports structured health for an initialized Ultra project', async
   }
 });
 
+test('doctor reports incomplete brownfield adoption as advisory rather than authority failure', async () => {
+  const fx = fixture({ migratedBaseline: false });
+  try {
+    baselines.startBaseline(fx.db, {
+      id: 'adoption', project_name: 'legacy', mode: 'brownfield', scope: ['.'],
+    }, { rootDir: fx.rootDir, emitEvent: false });
+    const report = await doctor.runDoctor(fx.db, { rootDir: fx.rootDir });
+    assert.equal(report.status, 'healthy');
+    assert.equal(report.checks.baseline.status, 'warning');
+    assert.equal(report.checks.baseline.mode, 'brownfield');
+    assert.ok(report.checks.baseline.blockers.includes('BASELINE_NOT_READY:adopting'));
+  } finally {
+    cleanup(fx);
+  }
+});
+
 test('doctor repair is backup-first and drains projection/spec-event recovery work', async () => {
   const fx = fixture();
   try {

package/mcp-server/lib/init-project.cjs

@@ -1,8 +1,8 @@
 'use strict';
 
 // Implementation for MCP tool `task.init_project` and the CLI fallback
-// `ultra-tools init`. Copies the bundled templates/.ultra/ skeleton to the
-// target project root, injecting project metadata into tasks.json.
+// `ultra-tools task init-project`. Copies the bundled templates/.ultra/ skeleton
+// to the target project root and records project metadata in authoritative state.
 //
 // Error contract matches spec/mcp-tools.yaml#task.init_project:
 //   ULTRA_DIR_EXISTS | TEMPLATE_MISSING | TARGET_NOT_DIR | IO_ERROR
@@ -15,6 +15,8 @@ const fs = require('node:fs');
 const path = require('node:path');
 
 const { initStateDb } = require('./state-db.cjs');
+const baselines = require('./baseline-workflow.cjs');
+const runtimeState = require('./runtime-state.cjs');
 
 const REPO_ROOT = process.env.UBP_RUNTIME_ROOT
   ? path.resolve(process.env.UBP_RUNTIME_ROOT)
@@ -95,20 +97,30 @@ function copyTemplate(source, dest) {
   return files;
 }
 
-function injectTasksJson(ultraDir, { project_name, project_type, stack }) {
+function validateTasksTemplate(ultraDir) {
   const tasksFile = path.join(ultraDir, 'tasks', 'tasks.json');
   if (!fs.existsSync(tasksFile)) return;
   let data;
   try { data = JSON.parse(fs.readFileSync(tasksFile, 'utf8')); }
   catch (err) { throw new InitProjectError('IO_ERROR', `tasks.json malformed: ${err.message}`, { cause: err }); }
-  const nowIso = new Date().toISOString();
-  data.created = nowIso;
-  data.updated = nowIso;
-  data.project = data.project || {};
-  data.project.name = project_name;
-  if (project_type) data.project.type = project_type;
-  if (stack) data.project.stack = stack;
-  fs.writeFileSync(tasksFile, JSON.stringify(data, null, 2) + '\n');
+  if (!data || typeof data !== 'object' || !Array.isArray(data.tasks)) {
+    throw new InitProjectError('IO_ERROR', 'tasks.json template must contain a tasks array');
+  }
+}
+
+const IGNORED_ADOPTION_ENTRIES = new Set([
+  '.DS_Store', '.git', '.gitignore', '.ultra', 'node_modules', 'vendor', '.venv', 'venv',
+]);
+
+function detectProjectMode(absTarget, requested = 'auto') {
+  if (!['auto', 'greenfield', 'brownfield'].includes(requested)) {
+    throw new InitProjectError('VALIDATION_ERROR', `unsupported initialization mode: ${requested}`);
+  }
+  if (requested !== 'auto') return requested;
+  const meaningful = fs.readdirSync(absTarget, { withFileTypes: true })
+    .some((entry) => !IGNORED_ADOPTION_ENTRIES.has(entry.name)
+      && !entry.name.startsWith('.ultra.backup.'));
+  return meaningful ? 'brownfield' : 'greenfield';
 }
 
 function rollbackInitialization(ultraDir, backupPath) {
@@ -130,6 +142,7 @@ function initProject({
   project_name,
   project_type,
   stack,
+  mode = 'auto',
   overwrite = false,
   source_template,
 } = {}) {
@@ -139,6 +152,7 @@ function initProject({
 
   const absTarget = resolveTargetDir(target_dir);
   ensureTargetDir(absTarget);
+  const resolvedMode = detectProjectMode(absTarget, mode);
   const source = ensureTemplate(source_template);
   const ultraDir = path.join(absTarget, '.ultra');
 
@@ -155,13 +169,27 @@ function initProject({
   }
 
   let copiedFiles;
+  let baselineResult;
   try {
     fs.mkdirSync(ultraDir, { recursive: true });
     copiedFiles = copyTemplate(source, ultraDir);
-    injectTasksJson(ultraDir, { project_name, project_type, stack });
+    validateTasksTemplate(ultraDir);
     const stateDbPath = path.join(ultraDir, 'state.db');
     const { db } = initStateDb(stateDbPath);
-    db.close();
+    try {
+      baselineResult = baselines.startBaseline(db, {
+        id: 'project-baseline', project_name, project_type, stack,
+        mode: resolvedMode, repository_revision: baselines.gitHead(absTarget), scope: ['.'],
+      }, { rootDir: absTarget });
+      const job = runtimeState.enqueueProjection(db, { tool_name: 'task.init_project' });
+      const projection = runtimeState.processProjectionJobs(db, { rootDir: absTarget, limit: 1 });
+      const projected = projection.jobs.find((item) => item.id === job.id);
+      if (!projected || projected.status !== 'completed') {
+        throw new Error(projected?.error || 'initial projection did not complete');
+      }
+    } finally {
+      db.close();
+    }
   } catch (err) {
     const rollbackErrors = rollbackInitialization(ultraDir, backupPath);
     const rollbackNote = rollbackErrors.length > 0
@@ -179,10 +207,17 @@ function initProject({
     created_path: ultraDir,
     state_db_path: stateDbPath,
     status,
+    mode: resolvedMode,
+    baseline: {
+      id: baselineResult.id,
+      mode: baselineResult.mode,
+      status: baselineResult.status,
+      repository_revision: baselineResult.repository_revision,
+    },
     copied_files: copiedFiles,
   };
   if (backupPath) result.backup_path = backupPath;
   return result;
 }
 
-module.exports = { initProject, InitProjectError, DEFAULT_TEMPLATE };
+module.exports = { initProject, InitProjectError, DEFAULT_TEMPLATE, detectProjectMode };

package/mcp-server/lib/provider-refs.cjs

@@ -0,0 +1,42 @@
+'use strict';
+
+const PROVIDER_KINDS = new Set(['memory', 'code_graph']);
+const PROVIDER_FIELDS = new Set([
+  'provider', 'project', 'reference', 'revision', 'indexed_head', 'status',
+]);
+
+class ProviderRefsError extends Error {
+  constructor(code, message) {
+    super(message);
+    this.name = 'ProviderRefsError';
+    this.code = code;
+  }
+}
+
+function normalizeProviderRefs(value, ErrorClass = ProviderRefsError) {
+  if (value == null) return {};
+  if (typeof value !== 'object' || Array.isArray(value)) {
+    throw new ErrorClass('VALIDATION_ERROR', 'provider_refs must be an object');
+  }
+  const out = {};
+  for (const [kind, ref] of Object.entries(value)) {
+    if (!PROVIDER_KINDS.has(kind) || !ref || typeof ref !== 'object' || Array.isArray(ref)) {
+      throw new ErrorClass('VALIDATION_ERROR', `invalid external provider reference: ${kind}`);
+    }
+    for (const key of Object.keys(ref)) {
+      if (!PROVIDER_FIELDS.has(key)) {
+        throw new ErrorClass(
+          'PROVIDER_CONTENT_FORBIDDEN',
+          `provider_refs.${kind}.${key} is not metadata; provider content remains external`,
+        );
+      }
+    }
+    if (typeof ref.provider !== 'string' || !ref.provider.trim()) {
+      throw new ErrorClass('VALIDATION_ERROR', `provider_refs.${kind}.provider required`);
+    }
+    out[kind] = { ...ref, provider: ref.provider.trim() };
+  }
+  return out;
+}
+
+module.exports = { ProviderRefsError, normalizeProviderRefs };

package/mcp-server/lib/spec-learning.test.cjs

@@ -20,6 +20,11 @@ function fixture() {
   execFileSync('git', ['add', 'README.md'], { cwd: rootDir });
   execFileSync('git', ['commit', '-q', '-m', 'seed'], { cwd: rootDir });
   const { db } = initStateDb(path.join(rootDir, '.ultra', 'state.db'));
+  db.prepare(
+    `INSERT INTO baselines
+     (id, project_name, mode, status, approved_by, approval_note, converged_at)
+     VALUES ('test-baseline', 'fixture', 'migrated', 'ready', 'test', 'legacy fixture', ?)`,
+  ).run(new Date().toISOString());
   changes.createChange(db, {
     id: 'learning-change', title: 'Learning change', kind: 'quick',
     intent: 'Exercise guarded specification-learning transitions.',

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

@@ -9,10 +9,11 @@ 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 = '10.0';
+const EXPECTED_VERSION = '11.0';
 const KIMI_SCHEMA_VERSION = '9.1';
 
 const REQUIRED_TABLES = Object.freeze([
+  'baselines',
   'tasks',
   'events',
   'sessions',
@@ -31,6 +32,43 @@ const REQUIRED_TABLES = Object.freeze([
   'event_consumers',
 ]);
 
+function applyBaselineUpgrade(db, fromVersion) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS baselines (
+      id                  TEXT PRIMARY KEY,
+      project_name        TEXT NOT NULL,
+      project_type        TEXT,
+      stack               TEXT,
+      mode                TEXT NOT NULL CHECK (mode IN ('greenfield', 'brownfield', 'migrated')),
+      status              TEXT NOT NULL DEFAULT 'draft'
+                              CHECK (status IN ('draft', 'adopting', 'blocked', 'ready', 'superseded')),
+      repository_root     TEXT NOT NULL DEFAULT '.',
+      scope_json          TEXT NOT NULL DEFAULT '["."]',
+      repository_revision TEXT,
+      spec_refs_json      TEXT NOT NULL DEFAULT '[]',
+      evidence_json       TEXT NOT NULL DEFAULT '[]',
+      verification_json   TEXT NOT NULL DEFAULT '[]',
+      unknowns_json       TEXT NOT NULL DEFAULT '[]',
+      provider_refs_json  TEXT NOT NULL DEFAULT '{}',
+      approved_by         TEXT,
+      approval_note       TEXT,
+      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')),
+      converged_at        TEXT
+    );
+    CREATE INDEX IF NOT EXISTS baselines_status ON baselines(status, updated_at);
+  `);
+  if (fromVersion && fromVersion !== EXPECTED_VERSION) {
+    db.prepare(
+      `INSERT OR IGNORE INTO baselines
+       (id, project_name, mode, status, approved_by, approval_note, converged_at)
+       VALUES ('migrated-baseline', 'Migrated Ultra project', 'migrated', 'ready',
+               'schema-migration', 'Legacy project preserved during schema 11.0 migration',
+               strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))`,
+    ).run();
+  }
+}
+
 function readSchemaSql() {
   if (!fs.existsSync(SCHEMA_FILE)) {
     throw new Error(`state-db schema missing at ${SCHEMA_FILE}`);
@@ -223,22 +261,43 @@ function applyCompatibleUpgrades(db, fromVersion = latestSchemaVersion(db)) {
   db.transaction(() => {
     applyCompatibleColumns(db);
     const contextChanged = applyContextSpineUpgrade(db);
-    if (contextChanged || (fromVersion && fromVersion !== EXPECTED_VERSION)) {
+    const contextMigration = db.prepare(
+      "SELECT 1 FROM migration_history WHERE to_version = '10.0' AND status = 'success' LIMIT 1",
+    ).get();
+    const needsContextMigration = Boolean(
+      fromVersion && !['10.0', EXPECTED_VERSION].includes(fromVersion) && !contextMigration,
+    );
+    if (contextChanged || needsContextMigration) {
       db.prepare(
         `INSERT INTO migration_history
           (from_version, to_version, direction, status, notes)
          VALUES (?, ?, 'forward', 'success', ?)`,
       ).run(
         runtimeChanged ? KIMI_SCHEMA_VERSION : (fromVersion || 'unknown'),
-        EXPECTED_VERSION,
+        '10.0',
         'Add Context Spine role/gate readiness, execution contracts, breadcrumbs, and specification learning',
       );
     }
+    applyBaselineUpgrade(db, fromVersion);
+    const baselineMigration = db.prepare(
+      "SELECT 1 FROM migration_history WHERE to_version = '11.0' AND status = 'success' LIMIT 1",
+    ).get();
+    if (fromVersion && fromVersion !== EXPECTED_VERSION && !baselineMigration) {
+      db.prepare(
+        `INSERT INTO migration_history
+          (from_version, to_version, direction, status, notes)
+         VALUES (?, ?, 'forward', 'success', ?)`,
+      ).run(
+        fromVersion === '10.0' ? fromVersion : '10.0',
+        EXPECTED_VERSION,
+        'Add authoritative greenfield and brownfield baseline adoption, evidence, convergence, and drift state',
+      );
+    }
     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)');
     db.prepare(
       'INSERT OR IGNORE INTO schema_version (version, description) VALUES (?, ?)',
-    ).run(EXPECTED_VERSION, 'Role-scoped context snapshots, deterministic breadcrumbs, and approval-gated specification learning');
+    ).run(EXPECTED_VERSION, 'Greenfield and brownfield baseline adoption, convergence, and drift authority');
   })();
 }
 

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

@@ -123,7 +123,7 @@ test('initStateDb migrates existing runtime constraints to Kimi without losing r
     const legacy = openStateDb(file);
     const legacySchema = fs.readFileSync(SCHEMA_FILE, 'utf8').replaceAll(", 'kimi'", '');
     legacy.exec(legacySchema);
-    legacy.prepare("DELETE FROM schema_version WHERE version IN ('9.1', '10.0')").run();
+    legacy.prepare("DELETE FROM schema_version WHERE version IN ('9.1', '10.0', '11.0')").run();
     legacy.prepare(
       "INSERT INTO tasks (id, title, type, priority) VALUES ('task-old', 'Old', 'feature', 'P1')",
     ).run();
@@ -146,16 +146,21 @@ test('initStateDb migrates existing runtime constraints to Kimi without losing r
     closeStateDb(legacy);
 
     const upgraded = initStateDb(file);
-    assert.equal(upgraded.schema_version, '10.0');
+    assert.equal(upgraded.schema_version, '11.0');
     assert.equal(upgraded.db.prepare("SELECT runtime FROM sessions WHERE sid = 'session-old'").get().runtime, 'codex');
     assert.equal(upgraded.db.prepare("SELECT COUNT(*) AS n FROM telemetry WHERE session_id = 'session-old'").get().n, 1);
     assert.equal(upgraded.db.prepare("SELECT COUNT(*) AS n FROM incidents WHERE session_id = 'session-old'").get().n, 1);
     assert.deepEqual(upgraded.db.pragma('foreign_key_check'), []);
     const migrations = upgraded.db.prepare(
-      "SELECT to_version, notes FROM migration_history WHERE to_version IN ('9.1', '10.0') ORDER BY id",
+      "SELECT to_version, notes FROM migration_history WHERE to_version IN ('9.1', '10.0', '11.0') ORDER BY id",
     ).all();
     assert.ok(migrations.some((row) => row.to_version === '9.1' && /Kimi/.test(row.notes)));
     assert.ok(migrations.some((row) => row.to_version === '10.0' && /Context Spine/.test(row.notes)));
+    assert.ok(migrations.some((row) => row.to_version === '11.0' && /baseline adoption/i.test(row.notes)));
+    assert.deepEqual(
+      upgraded.db.prepare("SELECT mode, status FROM baselines WHERE id = 'migrated-baseline'").get(),
+      { mode: 'migrated', status: 'ready' },
+    );
 
     upgraded.db.prepare(
       "INSERT INTO tasks (id, title, type, priority) VALUES ('task-kimi', 'Kimi', 'feature', 'P1')",