ultra-builder-pro-cli 0.10.0 → 0.12.1

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')",

package/mcp-server/server.cjs

@@ -28,6 +28,7 @@ const parser = require('./lib/prd-parser.cjs');
 const expander = require('./lib/task-expander.cjs');
 const planStore = require('./lib/plan-store.cjs');
 const { initProject } = require('./lib/init-project.cjs');
+const baselines = require('./lib/baseline-workflow.cjs');
 const changes = require('./lib/change-workflow.cjs');
 const runtimeState = require('./lib/runtime-state.cjs');
 const doctor = require('./lib/doctor.cjs');
@@ -67,6 +68,13 @@ const PLAN_TOOLS = Object.freeze([
   'plan.get',
 ]);
 
+const BASELINE_TOOLS = Object.freeze([
+  'baseline.start',
+  'baseline.record',
+  'baseline.get',
+  'baseline.converge',
+]);
+
 const CHANGE_TOOLS = Object.freeze([
   'change.create',
   'change.update',
@@ -85,18 +93,20 @@ const SYSTEM_TOOLS = Object.freeze([
 ]);
 
 const REGISTERED_TOOLS = Object.freeze([
-  ...TASK_TOOLS, ...SESSION_TOOLS, ...PLAN_TOOLS, ...CHANGE_TOOLS, ...SYSTEM_TOOLS,
+  ...TASK_TOOLS, ...SESSION_TOOLS, ...PLAN_TOOLS, ...BASELINE_TOOLS, ...CHANGE_TOOLS,
+  ...SYSTEM_TOOLS,
 ]);
 
 const STATELESS_TOOLS = new Set(['task.init_project']);
 
-// init_project mutates the filesystem of an unrelated project, not state.db —
-// do NOT run the projector (it would overwrite the freshly-copied template).
+// init_project owns its target project's schema, baseline seed, and first
+// projection internally. Do not enqueue a second projection on the caller DB.
 const MUTATING_TOOLS = new Set([
   'task.create', 'task.update', 'task.delete', 'task.append_event', 'task.switch_tag',
   'task.parse_prd', 'task.expand',
   'session.spawn', 'session.close', 'session.heartbeat',
   'plan.export',
+  'baseline.start', 'baseline.record', 'baseline.converge',
   'change.create', 'change.update', 'change.context', 'change.converge', 'change.archive',
   'change.learning_propose', 'change.learning_resolve',
 ]);
@@ -352,6 +362,39 @@ async function dispatchTool(name, input, db, ctx = {}) {
       }
       return { plan: planStore.selectSection(loaded, input.section) };
     }
+    case 'baseline.start': {
+      return {
+        baseline: baselines.startBaseline(
+          db, input, { rootDir: ctx.rootDir || process.cwd() },
+        ),
+      };
+    }
+    case 'baseline.record': {
+      return {
+        baseline: baselines.recordBaseline(
+          db, input, { rootDir: ctx.rootDir || process.cwd() },
+        ),
+      };
+    }
+    case 'baseline.get': {
+      const baseline = baselines.readBaseline(db, input.id);
+      if (!baseline) {
+        const err = new Error(input.id ? `baseline ${input.id} not found` : 'current baseline not found');
+        err.code = 'BASELINE_NOT_FOUND';
+        throw err;
+      }
+      return {
+        baseline,
+        health: baselines.inspectBaseline(db, {
+          rootDir: ctx.rootDir || process.cwd(), id: input.id,
+        }),
+      };
+    }
+    case 'baseline.converge': {
+      return baselines.convergeBaseline(
+        db, input, { rootDir: ctx.rootDir || process.cwd() },
+      );
+    }
     case 'change.create': {
       const { randomUUID } = require('node:crypto');
       const id = input.id || `chg-${randomUUID().slice(0, 12)}`;
@@ -598,6 +641,8 @@ module.exports = {
   dispatchTool,
   TASK_TOOLS,
   SESSION_TOOLS,
+  PLAN_TOOLS,
+  BASELINE_TOOLS,
   CHANGE_TOOLS,
   SYSTEM_TOOLS,
   REGISTERED_TOOLS,

package/mcp-server/tests/init-project.test.cjs

@@ -5,9 +5,11 @@ const assert = require('node:assert/strict');
 const fs = require('node:fs');
 const os = require('node:os');
 const path = require('node:path');
+const { execFileSync } = require('node:child_process');
 const Database = require('better-sqlite3');
 
 const { initProject, InitProjectError, DEFAULT_TEMPLATE } = require('../lib/init-project.cjs');
+const { EXPECTED_VERSION } = require('../lib/state-db.cjs');
 
 function mkTempDir(prefix = 'ubp-init-test-') {
   return fs.mkdtempSync(path.join(os.tmpdir(), prefix));
@@ -27,6 +29,7 @@ test('initProject copies bundled template into .ultra/', () => {
       stack: 'node',
     });
     assert.equal(r.status, 'created');
+    assert.equal(r.mode, 'greenfield');
     assert.equal(r.created_path, path.join(target, '.ultra'));
     assert.ok(r.copied_files.includes('tasks/tasks.json'));
     assert.ok(r.copied_files.includes('specs/product.md'));
@@ -36,9 +39,11 @@ test('initProject copies bundled template into .ultra/', () => {
     assert.ok(fs.existsSync(r.state_db_path));
     const db = new Database(r.state_db_path, { readonly: true });
     try {
-      const version = db.prepare("SELECT version FROM schema_version WHERE version = '9.1'").get();
-      assert.equal(version.version, '9.1');
+      const version = db.prepare('SELECT version FROM schema_version WHERE version = ?').get(EXPECTED_VERSION);
+      assert.equal(version.version, EXPECTED_VERSION);
       assert.ok(db.prepare("SELECT name FROM sqlite_master WHERE name = 'changes'").get());
+      const baseline = db.prepare('SELECT mode, status, project_name FROM baselines').get();
+      assert.deepEqual(baseline, { mode: 'greenfield', status: 'draft', project_name: 'demo' });
     } finally {
       db.close();
     }
@@ -46,7 +51,42 @@ test('initProject copies bundled template into .ultra/', () => {
   } finally { cleanup(target); }
 });
 
-test('initProject injects project metadata into tasks.json', () => {
+test('initProject auto-detects existing source as brownfield and starts adoption', () => {
+  const target = mkTempDir();
+  try {
+    fs.mkdirSync(path.join(target, 'src'));
+    fs.writeFileSync(path.join(target, 'package.json'), '{"name":"legacy-app"}\n');
+    fs.writeFileSync(path.join(target, 'src', 'index.js'), 'module.exports = true;\n');
+    const result = initProject({ target_dir: target, project_name: 'legacy-app' });
+    assert.equal(result.mode, 'brownfield');
+    const db = new Database(result.state_db_path, { readonly: true });
+    try {
+      const baseline = db.prepare('SELECT mode, status, scope_json FROM baselines').get();
+      assert.equal(baseline.mode, 'brownfield');
+      assert.equal(baseline.status, 'adopting');
+      assert.deepEqual(JSON.parse(baseline.scope_json), ['.']);
+    } finally {
+      db.close();
+    }
+  } finally { cleanup(target); }
+});
+
+test('maintenance CLI forwards an explicit initialization mode', () => {
+  const target = mkTempDir();
+  try {
+    fs.writeFileSync(path.join(target, 'README.md'), '# Intentional greenfield notes\n');
+    const output = execFileSync(process.execPath, [
+      path.resolve(__dirname, '..', '..', 'ultra-tools', 'cli.cjs'),
+      'task', 'init-project', '--target-dir', target, '--project-name', 'explicit-mode',
+      '--mode', 'greenfield',
+    ], { encoding: 'utf8' });
+    const envelope = JSON.parse(output);
+    assert.equal(envelope.ok, true);
+    assert.equal(envelope.data.mode, 'greenfield');
+  } finally { cleanup(target); }
+});
+
+test('initProject keeps project metadata in authoritative baseline state and tasks.json as a projection', () => {
   const target = mkTempDir();
   try {
     initProject({
@@ -56,11 +96,17 @@ test('initProject injects project metadata into tasks.json', () => {
       stack: 'next',
     });
     const tasksJson = JSON.parse(fs.readFileSync(path.join(target, '.ultra', 'tasks', 'tasks.json'), 'utf8'));
-    assert.equal(tasksJson.project.name, 'meta-demo');
-    assert.equal(tasksJson.project.type, 'web');
-    assert.equal(tasksJson.project.stack, 'next');
-    assert.ok(tasksJson.created.length > 0);
-    assert.ok(tasksJson.updated.length > 0);
+    assert.equal(tasksJson.schema_version, '4.5');
+    assert.equal(tasksJson.source, '.ultra/state.db');
+    assert.deepEqual(tasksJson.tasks, []);
+    assert.equal('project' in tasksJson, false);
+    const db = new Database(path.join(target, '.ultra', 'state.db'), { readonly: true });
+    try {
+      const baseline = db.prepare('SELECT project_name, project_type, stack FROM baselines').get();
+      assert.deepEqual(baseline, { project_name: 'meta-demo', project_type: 'web', stack: 'next' });
+    } finally {
+      db.close();
+    }
   } finally { cleanup(target); }
 });
 

package/mcp-server/tests/server-contract.test.cjs

@@ -14,12 +14,23 @@ const { StdioClientTransport } = require('@modelcontextprotocol/sdk/client/stdio
 const REPO_ROOT = path.resolve(__dirname, '..', '..');
 const SERVER = path.join(REPO_ROOT, 'mcp-server', 'server.cjs');
 const PACKAGE_VERSION = require(path.join(REPO_ROOT, 'package.json')).version;
+const { initStateDb, closeStateDb } = require('../lib/state-db.cjs');
 
 function tmpProject() {
   const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'ubp-mcp-'));
   return { dir, dbPath: path.join(dir, '.ultra', 'state.db') };
 }
 
+function seedMigratedBaseline(project) {
+  const { db } = initStateDb(project.dbPath);
+  db.prepare(
+    `INSERT OR IGNORE 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());
+  closeStateDb(db);
+}
+
 async function withClient({ dir, dbPath }, fn, extraEnv = {}) {
   const transport = new StdioClientTransport({
     command: process.execPath,
@@ -74,6 +85,10 @@ test('listTools returns workflow tools and exposes no Ultra memory API', async (
       const list = await client.listTools();
       const names = list.tools.map((t) => t.name).sort();
       assert.deepEqual(names, [
+        'baseline.converge',
+        'baseline.get',
+        'baseline.record',
+        'baseline.start',
         'change.archive',
         'change.breadcrumb',
         'change.context',
@@ -118,9 +133,78 @@ test('listTools returns workflow tools and exposes no Ultra memory API', async (
   }
 });
 
+test('baseline MCP tools adopt and converge an existing checkout without storing provider payloads', async () => {
+  const proj = tmpProject();
+  try {
+    fs.mkdirSync(path.join(proj.dir, '.ultra', 'specs'), { recursive: true });
+    fs.mkdirSync(path.join(proj.dir, 'src'), { recursive: true });
+    fs.writeFileSync(path.join(proj.dir, '.ultra', 'specs', 'product.md'), '# Product\n\nObserved behavior.\n');
+    fs.writeFileSync(path.join(proj.dir, '.ultra', 'specs', 'architecture.md'), '# Architecture\n\nCurrent boundary.\n');
+    fs.writeFileSync(path.join(proj.dir, 'src', 'index.js'), 'module.exports = true;\n');
+    require('node:child_process').execFileSync('git', ['init', '-q'], { cwd: proj.dir });
+    require('node:child_process').execFileSync('git', ['config', 'user.email', 'test@ubp.dev'], { cwd: proj.dir });
+    require('node:child_process').execFileSync('git', ['config', 'user.name', 'ubp-test'], { cwd: proj.dir });
+    require('node:child_process').execFileSync('git', ['add', '.'], { cwd: proj.dir });
+    require('node:child_process').execFileSync('git', ['commit', '-q', '-m', 'seed'], { cwd: proj.dir });
+    const revision = require('node:child_process').execFileSync(
+      'git', ['rev-parse', 'HEAD'], { cwd: proj.dir, encoding: 'utf8' },
+    ).trim();
+
+    await withClient(proj, async (client) => {
+      const started = readToolPayload(await client.callTool({
+        name: 'baseline.start',
+        arguments: {
+          id: 'mcp-baseline', project_name: 'fixture', mode: 'brownfield',
+          repository_revision: revision, scope: ['.'],
+        },
+      }));
+      assert.equal(started.baseline.status, 'adopting');
+
+      const recorded = readToolPayload(await client.callTool({
+        name: 'baseline.record',
+        arguments: {
+          id: 'mcp-baseline', repository_revision: revision,
+          spec_refs: [
+            { kind: 'product', path: '.ultra/specs/product.md' },
+            { kind: 'architecture', path: '.ultra/specs/architecture.md' },
+          ],
+          evidence: [{ kind: 'source', ref: 'src/index.js', summary: 'Current entry point.' }],
+          verification: [{
+            name: 'smoke', command: 'node -e "require(\'./src\')"', status: 'pass', evidence: 'exit 0',
+          }],
+          unknowns: [],
+          provider_refs: {
+            code_graph: { provider: 'codebase-memory-mcp', project: 'fixture', status: 'fresh' },
+          },
+        },
+      }));
+      assert.match(recorded.baseline.spec_refs[0].digest, /^[0-9a-f]{64}$/);
+
+      const converged = readToolPayload(await client.callTool({
+        name: 'baseline.converge',
+        arguments: {
+          id: 'mcp-baseline', expected_revision: revision, approved_by: 'owner',
+          approval_note: 'The baseline matches the current checkout.', accept_known_red: false,
+        },
+      }));
+      assert.equal(converged.ready, true);
+      assert.equal(converged.baseline.status, 'ready');
+
+      const got = readToolPayload(await client.callTool({
+        name: 'baseline.get', arguments: {},
+      }));
+      assert.equal(got.baseline.id, 'mcp-baseline');
+      assert.equal(JSON.stringify(got.baseline).includes('captured prompt'), false);
+    });
+  } finally {
+    fs.rmSync(proj.dir, { recursive: true, force: true });
+  }
+});
+
 test('change.create + change.context expose a continuous change unit with external provider references', async () => {
   const proj = tmpProject();
   try {
+    seedMigratedBaseline(proj);
     fs.writeFileSync(path.join(proj.dir, 'README.md'), '# project\n');
     await withClient(proj, async (client) => {
       const created = await client.callTool({
@@ -172,6 +256,7 @@ test('change.create + change.context expose a continuous change unit with extern
 test('spec-learning MCP tools persist an approval-gated candidate and projection', async () => {
   const proj = tmpProject();
   try {
+    seedMigratedBaseline(proj);
     await withClient(proj, async (client) => {
       await client.callTool({
         name: 'change.create',
@@ -233,6 +318,7 @@ test('spec-learning MCP tools persist an approval-gated candidate and projection
 test('system.doctor returns structured provider ownership and projection health', async () => {
   const proj = tmpProject();
   try {
+    seedMigratedBaseline(proj);
     await withClient(proj, async (client) => {
       await client.callTool({
         name: 'task.create',
@@ -515,11 +601,22 @@ test('task.init_project creates .ultra/ skeleton in a fresh target directory', a
       assert.equal(payload.status, 'created');
       assert.equal(payload.created_path, path.join(freshTarget, '.ultra'));
       assert.equal(payload.state_db_path, path.join(freshTarget, '.ultra', 'state.db'));
+      assert.equal(payload.mode, 'greenfield');
+      assert.equal(payload.baseline.status, 'draft');
       assert.ok(fs.existsSync(payload.state_db_path));
       assert.ok(payload.copied_files.includes('tasks/tasks.json'));
       const tasksJson = JSON.parse(fs.readFileSync(path.join(payload.created_path, 'tasks', 'tasks.json'), 'utf8'));
-      assert.equal(tasksJson.project.name, 'mcp-init');
-      assert.equal(tasksJson.project.type, 'cli');
+      assert.equal(tasksJson.source, '.ultra/state.db');
+      assert.deepEqual(tasksJson.tasks, []);
+      const state = new Database(payload.state_db_path, { readonly: true });
+      try {
+        assert.deepEqual(
+          state.prepare('SELECT project_name, project_type, mode FROM baselines').get(),
+          { project_name: 'mcp-init', project_type: 'cli', mode: 'greenfield' },
+        );
+      } finally {
+        state.close();
+      }
     });
   } finally {
     fs.rmSync(proj.dir, { recursive: true, force: true });