ultra-builder-pro-cli 0.12.1 → 0.14.0

package/adapters/opencode.js

@@ -304,135 +304,45 @@ function pluginSource() {
 import fs from "node:fs";
 import path from "node:path";
 import { execFileSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
 
-const TERMINAL = new Set(["committed", "completed", "done", "cancelled"]);
 const TASKS_PROJECTION = ".ultra/tasks/tasks.json";
+const NODE_BINARY = ${JSON.stringify(process.execPath)};
+const PLUGIN_DIR = path.dirname(fileURLToPath(import.meta.url));
+const BREADCRUMB_CLI = path.resolve(
+  PLUGIN_DIR, "..", ${JSON.stringify(BUNDLE_DIR)}, "runtime", "breadcrumb.cjs",
+);
 
-function gitHead(root) {
-  try {
-    return execFileSync("git", ["rev-parse", "HEAD"], {
-      cwd: root, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"],
-    }).trim();
-  } catch {
-    return null;
-  }
-}
-
-function findUltraContext(directory) {
+function findUltraRoot(directory) {
   let current = path.resolve(directory);
   while (true) {
     const ultra = path.join(current, ".ultra");
-    const currentHead = gitHead(current);
-    const workflowFile = path.join(ultra, "workflow-state.json");
-    const statePresent = fs.existsSync(path.join(ultra, "state.db"));
-    let workflow = null;
-    if (fs.existsSync(workflowFile)) {
-      try {
-        const state = JSON.parse(fs.readFileSync(workflowFile, "utf8"));
-        workflow = state && !TERMINAL.has(state.status) ? state : null;
-      } catch (error) {
-        process.stderr.write(\`[ultra-builder-pro] cannot read \${workflowFile}: \${error.message}\\n\`);
-      }
-    }
-    const changes = [];
-    const changeRoot = path.join(ultra, "changes", "active");
-    if (fs.existsSync(changeRoot)) {
-      for (const entry of fs.readdirSync(changeRoot, { withFileTypes: true })) {
-        if (!entry.isDirectory()) continue;
-        const manifestPath = path.join(changeRoot, entry.name, "context-manifest.json");
-        if (!fs.existsSync(manifestPath)) continue;
-        try {
-          const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
-          if (manifest?.change) {
-            const compiledHead = manifest.git?.head ?? null;
-            const legacyContext = manifest.schema_version !== "2.0" || !manifest.baseline;
-            const headStale = Boolean(compiledHead && currentHead && compiledHead !== currentHead);
-            const blockers = Array.isArray(manifest.readiness?.blockers)
-              ? [...manifest.readiness.blockers]
-              : [];
-            const warnings = Array.isArray(manifest.readiness?.warnings)
-              ? [...manifest.readiness.warnings]
-              : [];
-            if (headStale && !blockers.includes("CONTEXT_HEAD_STALE")) blockers.push("CONTEXT_HEAD_STALE");
-            if (legacyContext && !blockers.includes("CONTEXT_SNAPSHOT_UPGRADE_REQUIRED")) {
-              blockers.unshift("CONTEXT_SNAPSHOT_UPGRADE_REQUIRED");
-            }
-            changes.push({
-            id: manifest.change.id,
-            kind: manifest.change.kind,
-            status: manifest.change.status,
-            role: manifest.role ?? "plan",
-            gate: manifest.gate ?? "alignment",
-            nextAction: legacyContext
-              ? "Recompile change.context to upgrade this legacy context snapshot."
-              : headStale
-              ? "Git HEAD changed after context compilation; recompile change.context."
-              : (manifest.next_action ?? "Inspect Ultra status."),
-            readiness: legacyContext || headStale ? "blocked" : (manifest.readiness?.status ?? "ready"),
-            blockers,
-            warnings,
-            baseline: manifest.baseline ?? null,
-            taskId: manifest.selected_task?.id ?? manifest.resume?.task_id ?? null,
-            taskStatus: manifest.selected_task?.status ?? manifest.resume?.task_status ?? null,
-            tokenEstimate: manifest.context?.token_estimate ?? 0,
-            manifestPath: path.relative(current, manifestPath),
-          });
-          }
-        } catch (error) {
-          process.stderr.write(\`[ultra-builder-pro] cannot read \${manifestPath}: \${error.message}\\n\`);
-        }
-      }
-    }
-    if (statePresent || workflow || changes.length > 0) {
-      return { root: current, workflow, changes, statePresent };
-    }
+    if (fs.existsSync(ultra) && fs.statSync(ultra).isDirectory()) return current;
     const parent = path.dirname(current);
     if (parent === current) return null;
     current = parent;
   }
 }
 
-function contextText(active) {
-  const lines = [];
-  if (active.workflow) {
-    const state = active.workflow;
-    lines.push(
-      "[Ultra active workflow]",
-      \`Project: \${active.root}\`,
-      \`Command: \${state.command ?? "unknown"}\`,
-      \`Task: \${state.task_id ?? state.task ?? "unknown"}\`,
-      \`Step: \${state.step ?? "unknown"}\`,
-      \`Status: \${state.status ?? "active"}\`,
-    );
-  }
-  if (active.changes.length > 0) {
-    const change = active.changes[0];
-    lines.push(
-      "[Ultra context spine]",
-      \`Project: \${active.root}\`,
-      \`Change: \${change.id} (\${change.kind ?? "unknown"}, \${change.status ?? "active"})\`,
-      \`Task: \${change.taskId ?? "none"} (\${change.taskStatus ?? "none"})\`,
-      \`Role: \${change.role}\`,
-      \`Gate: \${change.gate}\`,
-      \`Readiness: \${change.readiness}\`,
-      ...(change.blockers.length > 0 ? [\`Blockers: \${change.blockers.join(", ")}\`] : []),
-      ...(change.warnings.length > 0 ? [\`Warnings: \${change.warnings.join(", ")}\`] : []),
-      \`Next: \${change.nextAction}\`,
-      \`Context manifest: \${change.manifestPath}\`,
-    );
-    if (active.changes.length > 1) lines.push(
-      \`Active change count: \${active.changes.length}; resolve scope with change.list before mutation.\`,
-    );
-  }
-  if (!active.workflow && active.changes.length === 0) {
-    lines.push(
-      "[Ultra baseline]",
-      \`Project: \${active.root}\`,
-      "No active continuous change. Run ultra-status; resume ultra-init when the baseline is missing, incomplete, or stale, otherwise start ultra-change.",
-    );
+function readUltraContext(directory) {
+  const root = findUltraRoot(directory);
+  if (!root) return null;
+  try {
+    const raw = execFileSync(NODE_BINARY, [BREADCRUMB_CLI, root], {
+      cwd: root,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"],
+      timeout: 5000,
+    });
+    const value = JSON.parse(raw);
+    if (!value?.breadcrumb || typeof value.text !== "string" || !value.text) {
+      throw new Error("canonical breadcrumb response is incomplete");
+    }
+    return { root, breadcrumb: value.breadcrumb, text: value.text };
+  } catch (error) {
+    process.stderr.write(\`[ultra-builder-pro] cannot read canonical breadcrumb: \${error.message}\\n\`);
+    return { root, breadcrumb: null, text: null };
   }
-  lines.push("Authority: .ultra/state.db; JSON/Markdown remain projections or evidence artifacts.");
-  return lines.join("\\n");
 }
 
 function targetPaths(tool, args) {
@@ -456,19 +366,19 @@ function isTasksProjection(active, candidate) {
 
 export const UltraBuilderProPlugin = async ({ directory, worktree }) => {
   const root = worktree || directory;
-  let active = findUltraContext(root);
-  const refresh = () => { active = findUltraContext(root); };
+  let active = readUltraContext(root);
+  const refresh = () => { active = readUltraContext(root); };
   return {
     event: async ({ event }) => {
       if (["session.created", "session.compacted", "session.idle"].includes(event?.type)) refresh();
     },
     "experimental.chat.system.transform": async (_input, output) => {
       refresh();
-      if (active) output.system.push(contextText(active));
+      if (active?.text) output.system.push(active.text);
     },
     "experimental.session.compacting": async (_input, output) => {
       refresh();
-      if (active) output.context.push(contextText(active));
+      if (active?.text) output.context.push(active.text);
     },
     "tool.execute.before": async (input, output) => {
       refresh();

package/adapters/tests/claude.test.cjs

@@ -70,8 +70,9 @@ test('Claude plugin collaboration and learn workflows are safe native plugin ass
     assert.match(codexCollab, /-s read-only/);
     assert.match(codexCollab, /--ephemeral/);
     assert.match(codexCollab, /--ignore-user-config/);
-    assert.match(verify, /-s read-only/);
-    assert.match(verify, /--ephemeral/);
+    assert.match(verify, /Keep the current host responsible/);
+    assert.match(verify, /installed collaboration companion/);
+    assert.doesNotMatch(verify, /codex exec|claude --safe-mode/);
     assert.match(verify, /scripts\/verify_wait\.py/);
     assert.match(review, /Claude Code Task workers/);
     assert.match(review, /scripts\/review_wait\.py/);

package/adapters/tests/codex-hook.test.cjs

@@ -6,6 +6,10 @@ const fs = require('node:fs');
 const os = require('node:os');
 const path = require('node:path');
 const { spawnSync } = require('node:child_process');
+const { initStateDb, closeStateDb } = require('../../mcp-server/lib/state-db.cjs');
+const { createChange } = require('../../mcp-server/lib/change-workflow.cjs');
+const { createTask } = require('../../mcp-server/lib/state-ops.cjs');
+const { compileRoleContext } = require('../../mcp-server/lib/context-spine.cjs');
 
 const REPO_ROOT = path.resolve(__dirname, '..', '..');
 const ADAPTER = path.join(REPO_ROOT, 'hooks', 'adapters', 'codex.py');
@@ -19,6 +23,35 @@ function run(feature, payload) {
   });
 }
 
+function seedContext(project, taskId = 'task-7') {
+  const state = initStateDb(path.join(project, '.ultra', 'state.db'));
+  state.db.prepare(
+    `INSERT INTO baselines
+     (id, project_name, mode, status, approved_by, approval_note, converged_at)
+     VALUES ('baseline', 'fixture', 'greenfield', 'ready', 'test', 'fixture', ?)`,
+  ).run(new Date().toISOString());
+  const { change } = createChange(state.db, {
+    id: 'hook-change', title: 'Hook change', kind: 'quick',
+    intent: 'Inject the authoritative task.',
+    docs_impact: { status: 'none', rationale: 'fixture' },
+  }, { rootDir: project });
+  const task = createTask(state.db, {
+    id: taskId, title: 'Hook task', type: 'bugfix', priority: 'P0', change_id: change.id,
+  });
+  compileRoleContext(state.db, {
+    input: {
+      task_id: task.id, role: 'implement', gate: 'implementation',
+      execution_contract: {
+        slice_kind: 'tracer_bullet', public_seam: 'hook injection',
+        verification_command: 'node --test adapters/tests/codex-hook.test.cjs',
+      },
+      next_action: 'Continue the authoritative hook task.',
+    },
+    change, tasks: [task], rootDir: project,
+  });
+  closeStateDb(state.db);
+}
+
 test('Codex hook adapter rejects retired generic policy hooks', () => {
   const result = run('block_dangerous_commands.py', {
     session_id: 'session-1',
@@ -36,10 +69,7 @@ test('Codex hook adapter rejects retired generic policy hooks', () => {
 test('Codex hook adapter injects only an active Ultra task boundary before edits', () => {
   const project = fs.mkdtempSync(path.join(os.tmpdir(), 'ubp-codex-hook-'));
   try {
-    fs.mkdirSync(path.join(project, '.ultra'));
-    fs.writeFileSync(path.join(project, '.ultra', 'workflow-state.json'), JSON.stringify({
-      command: 'ultra-dev', task_id: 'task-7', step: '4.5', status: 'review_pending',
-    }));
+    seedContext(project);
     const result = run('active_task_context.py', {
       session_id: 'session-2',
       cwd: project,
@@ -78,9 +108,6 @@ test('Codex hook adapter denies apply_patch writes to tasks.json during an activ
   const project = fs.mkdtempSync(path.join(os.tmpdir(), 'ubp-codex-hook-deny-'));
   try {
     fs.mkdirSync(path.join(project, '.ultra'));
-    fs.writeFileSync(path.join(project, '.ultra', 'workflow-state.json'), JSON.stringify({
-      command: 'ultra-plan', task_id: 'plan', step: 'persist', status: 'active',
-    }));
     const result = run('active_task_context.py', {
       session_id: 'session-deny',
       cwd: project,

package/adapters/tests/codex.test.cjs

@@ -9,6 +9,7 @@ const { spawnSync } = require('node:child_process');
 const yaml = require('js-yaml');
 const { Client } = require('@modelcontextprotocol/sdk/client/index.js');
 const { StdioClientTransport } = require('@modelcontextprotocol/sdk/client/stdio.js');
+const { initStateDb, closeStateDb } = require('../../mcp-server/lib/state-db.cjs');
 
 const codex = require('../codex.js');
 const { parse: parseFrontmatter } = require('../_shared/frontmatter.cjs');
@@ -127,8 +128,13 @@ test('every generated skill is Codex-valid, UI-visible, and free of Claude host
       assert.doesNotMatch(text, /[\u3400-\u9fff]|ultra-review-findings-v1|Context7|Exa MCP|confidence\s*>=?\s*\d+/iu);
 
       const openai = yaml.load(fs.readFileSync(path.join(skillDir, 'agents', 'openai.yaml'), 'utf8'));
+      const openaiSource = fs.readFileSync(path.join(skillDir, 'agents', 'openai.yaml'), 'utf8');
       assert.ok(openai.interface.display_name);
       assert.ok(openai.interface.short_description);
+      assert.ok(openai.interface.short_description.length >= 25, name);
+      assert.ok(openai.interface.short_description.length <= 64, name);
+      assert.match(openaiSource, /short_description:\s+['"]/);
+      assert.match(openaiSource, /default_prompt:\s+['"]/);
       assert.match(openai.interface.default_prompt, new RegExp(`\\$ultra-builder-pro:${name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}`));
       assert.equal(openai.policy.allow_implicit_invocation, false);
       if (MCP_DEPENDENT_SKILLS.includes(name)) {
@@ -147,14 +153,15 @@ test('every generated skill is Codex-valid, UI-visible, and free of Claude host
     assert.match(cc, /claude --safe-mode/);
 
     const verify = fs.readFileSync(path.join(layout.pluginRoot, 'skills', 'ultra-verify', 'SKILL.md'), 'utf8');
-    assert.match(verify, /Codex owns the task/);
-    assert.match(verify, /claude --safe-mode/);
-    assert.match(verify, /codex-analysis\.md/);
-    assert.doesNotMatch(verify, /codex-output\.md|Claude synthesizes|Claude-only/);
+    assert.match(verify, /Keep the current host responsible/);
+    assert.match(verify, /installed collaboration companion/);
+    assert.match(verify, /host-analysis\.md/);
+    assert.doesNotMatch(verify, /codex exec|claude --safe-mode|Claude synthesizes|Claude-only/);
 
     const waiter = fs.readFileSync(path.join(layout.pluginRoot, 'skills', 'ultra-verify', 'scripts', 'verify_wait.py'), 'utf8');
-    assert.match(waiter, /ADVISOR = "claude"/);
-    assert.match(waiter, /OUTPUT_FILE = "claude-output\.md"/);
+    assert.match(waiter, /--advisor/);
+    assert.match(waiter, /advisor-output\.md/);
+    assert.doesNotMatch(waiter, /^ADVISOR\s*=|^OUTPUT_FILE\s*=/m);
 
     const review = fs.readFileSync(path.join(layout.pluginRoot, 'skills', 'ultra-review', 'SKILL.md'), 'utf8');
     assert.match(review, /native Codex custom agents/);
@@ -230,6 +237,7 @@ test('plugin declares current Codex hooks and a project-local Ultra MCP server',
 
     for (const rel of [
       'runtime/index.cjs',
+      'runtime/breadcrumb.cjs',
       'runtime/launch.cjs',
       'runtime/ultra-tools.cjs',
       'runtime/build/Release/better_sqlite3.node',
@@ -263,6 +271,13 @@ test('bundled plugin MCP runs outside the source checkout and keeps state in the
   let client;
   try {
     install(layout);
+    const seededState = initStateDb(path.join(projectDir, '.ultra', 'state.db'));
+    seededState.db.prepare(
+      `INSERT INTO baselines
+       (id, project_name, mode, status, approved_by, approval_note, converged_at)
+       VALUES ('test-baseline', 'codex-bundle', 'greenfield', 'ready', 'test', 'smoke fixture', ?)`,
+    ).run(new Date().toISOString());
+    closeStateDb(seededState.db);
     const mcp = JSON.parse(fs.readFileSync(path.join(layout.pluginRoot, '.mcp.json'), 'utf8'));
     const server = mcp.mcpServers['ultra-builder-pro'];
     const env = { ...process.env };

package/adapters/tests/kimi-hook.test.cjs

@@ -6,6 +6,10 @@ const fs = require('node:fs');
 const os = require('node:os');
 const path = require('node:path');
 const { spawnSync } = require('node:child_process');
+const { initStateDb, closeStateDb } = require('../../mcp-server/lib/state-db.cjs');
+const { createChange } = require('../../mcp-server/lib/change-workflow.cjs');
+const { createTask } = require('../../mcp-server/lib/state-ops.cjs');
+const { compileRoleContext } = require('../../mcp-server/lib/context-spine.cjs');
 
 const REPO_ROOT = path.resolve(__dirname, '..', '..');
 const ADAPTER = path.join(REPO_ROOT, 'hooks', 'adapters', 'kimi.py');
@@ -18,6 +22,35 @@ function run(feature, payload, args = []) {
   });
 }
 
+function seedContext(project, taskId = 'task-7') {
+  const state = initStateDb(path.join(project, '.ultra', 'state.db'));
+  state.db.prepare(
+    `INSERT INTO baselines
+     (id, project_name, mode, status, approved_by, approval_note, converged_at)
+     VALUES ('baseline', 'fixture', 'greenfield', 'ready', 'test', 'fixture', ?)`,
+  ).run(new Date().toISOString());
+  const { change } = createChange(state.db, {
+    id: 'hook-change', title: 'Hook change', kind: 'quick',
+    intent: 'Inject the authoritative task.',
+    docs_impact: { status: 'none', rationale: 'fixture' },
+  }, { rootDir: project });
+  const task = createTask(state.db, {
+    id: taskId, title: 'Hook task', type: 'bugfix', priority: 'P0', change_id: change.id,
+  });
+  compileRoleContext(state.db, {
+    input: {
+      task_id: task.id, role: 'implement', gate: 'implementation',
+      execution_contract: {
+        slice_kind: 'tracer_bullet', public_seam: 'hook injection',
+        verification_command: 'node --test adapters/tests/kimi-hook.test.cjs',
+      },
+      next_action: 'Continue the authoritative hook task.',
+    },
+    change, tasks: [task], rootDir: project,
+  });
+  closeStateDb(state.db);
+}
+
 test('Kimi hook adapter rejects non-workflow policy hooks without blocking the host', () => {
   const result = run('block_dangerous_commands.py', {
     session_id: 'session-1',
@@ -33,10 +66,7 @@ test('Kimi hook adapter rejects non-workflow policy hooks without blocking the h
 test('Kimi hook adapter translates active edit context to the native message field', () => {
   const project = fs.mkdtempSync(path.join(os.tmpdir(), 'ubp-kimi-hook-'));
   try {
-    fs.mkdirSync(path.join(project, '.ultra'));
-    fs.writeFileSync(path.join(project, '.ultra', 'workflow-state.json'), JSON.stringify({
-      command: 'ultra-dev', task_id: 'task-7', step: '4.5', status: 'review_pending',
-    }));
+    seedContext(project);
     const result = run('active_task_context.py', {
       session_id: 'session-2',
       cwd: project,
@@ -57,9 +87,6 @@ test('Kimi hook adapter emits the native deny contract for projection writes', (
   const project = fs.mkdtempSync(path.join(os.tmpdir(), 'ubp-kimi-hook-deny-'));
   try {
     fs.mkdirSync(path.join(project, '.ultra'));
-    fs.writeFileSync(path.join(project, '.ultra', 'workflow-state.json'), JSON.stringify({
-      command: 'ultra-plan', task_id: 'plan', step: 'persist', status: 'active',
-    }));
     const result = run('active_task_context.py', {
       session_id: 'session-deny',
       cwd: project,

package/adapters/tests/opencode.test.cjs

@@ -11,6 +11,9 @@ const { pathToFileURL } = require('node:url');
 const opencode = require('../opencode.js');
 const { parse: parseFm } = require('../_shared/frontmatter.cjs');
 const { skillsForRuntime } = require('../_shared/runtime-assets.cjs');
+const { initStateDb, closeStateDb } = require('../../mcp-server/lib/state-db.cjs');
+const changes = require('../../mcp-server/lib/change-workflow.cjs');
+const { createTask } = require('../../mcp-server/lib/state-ops.cjs');
 
 const REPO_ROOT = path.resolve(__dirname, '..', '..');
 
@@ -69,10 +72,10 @@ test('install performs content-level OpenCode adaptation for commands, skills, r
     assert.match(review, /OpenCode `task` tool/);
     assert.match(review, /scripts\/review_wait\.py/);
     assert.match(codexCollab, /OpenCode remains primary/);
-    assert.match(verify, /OpenCode writes the first analysis/);
-    assert.match(verify, /opencode-analysis\.md/);
-    assert.match(verify, /codex exec -s read-only/);
-    assert.match(verify, /--ignore-user-config/);
+    assert.match(verify, /Keep OpenCode responsible/);
+    assert.match(verify, /host-analysis\.md/);
+    assert.match(verify, /installed collaboration companion/);
+    assert.doesNotMatch(verify, /codex exec|claude --safe-mode/);
     assert.doesNotMatch(plan, /LEGACY_STATE_MIGRATION_REQUIRED|v4\.4|v4\.5/);
     assert.match(plan, /never read or\s+write .*tasks\.json/i);
     assert.doesNotMatch(plan, /ultra-tools task create/);
@@ -176,93 +179,29 @@ test('install writes a schema-safe opencode.json and keeps ownership outside hos
     assert.match(plugin, /\.ultra[\\/]tasks[\\/]tasks\.json/);
     assert.match(plugin, /throw new Error/);
     assert.match(plugin, /session\.compacted/);
+    assert.match(plugin, /breadcrumb\.cjs/);
+    assert.doesNotMatch(plugin, /workflow-state\.json|context-manifest\.json/);
     assert.doesNotMatch(plugin, /memory\.(?:retain|recall|reflect)|journal|observation|prompt[_ -]?capture/);
-    assert.match(plugin, /Ultra context spine/);
+    assert.match(plugin, /canonical breadcrumb/);
     assert.doesNotMatch(plugin, /providerMetadata|External providers/);
   } finally {
     fs.rmSync(target, { recursive: true, force: true });
   }
 });
 
-test('OpenCode context covers active changes and projection writes are blocked for Ultra projects', async () => {
+test('OpenCode routes a missing authority to init and always protects task projections', async () => {
   const target = mkTarget();
   const project = mkTarget();
   try {
     opencode.install({ configDir: target, repoRoot: REPO_ROOT });
-    const pluginFile = path.join(target, 'plugins', 'ultra-builder-pro.js');
-    const module = await import(pathToFileURL(pluginFile).href);
-    const plugin = await module.UltraBuilderProPlugin({ directory: project });
-
     fs.mkdirSync(path.join(project, '.ultra'), { recursive: true });
-    fs.writeFileSync(path.join(project, '.ultra', 'state.db'), 'owned-by-ultra');
-    execFileSync('git', ['init'], { cwd: project, stdio: 'ignore' });
-    fs.writeFileSync(path.join(project, 'app.txt'), 'initial\n');
-    execFileSync('git', ['add', 'app.txt'], { cwd: project, stdio: 'ignore' });
-    execFileSync('git', ['-c', 'user.name=Ultra Tests', '-c', 'user.email=ultra@example.invalid', 'commit', '-m', 'initial'], {
-      cwd: project, stdio: 'ignore',
-    });
-    const compiledHead = execFileSync('git', ['rev-parse', 'HEAD'], { cwd: project, encoding: 'utf8' }).trim();
-    const changeRoot = path.join(project, '.ultra', 'changes', 'active', 'daily-fix');
-    fs.mkdirSync(changeRoot, { recursive: true });
-    fs.writeFileSync(path.join(changeRoot, 'context-manifest.json'), JSON.stringify({
-      schema_version: '2.0',
-      baseline: { id: 'project-baseline', mode: 'brownfield', status: 'ready', repository_revision: compiledHead },
-      change: { id: 'daily-fix', title: 'Daily fix', kind: 'quick', status: 'active', intent: 'Fix drift' },
-      role: 'implement',
-      gate: 'implementation',
-      next_action: 'Run the exact regression test.',
-      readiness: {
-        status: 'ready', blockers: [], warnings: ['CONTEXT_FILE_BUDGET_EXCEEDED'],
-      },
-      git: { head: compiledHead },
-      selected_task: { id: 'daily-task', status: 'in_progress' },
-      context: { token_estimate: 1200, budget: { max_tokens: 8000, max_files: 8 } },
-      providers: { memory: { provider: 'cloud-mem', status: 'available' } },
-    }));
-
+    const module = await import(`${pathToFileURL(path.join(target, 'plugins', 'ultra-builder-pro.js')).href}?baseline`);
+    const plugin = await module.UltraBuilderProPlugin({ directory: project });
     const output = { system: [] };
     await plugin['experimental.chat.system.transform']({}, output);
-    assert.match(output.system.join('\n'), /Ultra context spine/);
-    assert.match(output.system.join('\n'), /daily-fix/);
-    assert.match(output.system.join('\n'), /daily-task/);
-    assert.match(output.system.join('\n'), /Role: implement/);
-    assert.match(output.system.join('\n'), /Gate: implementation/);
-    assert.match(output.system.join('\n'), /Readiness: ready/);
-    assert.match(output.system.join('\n'), /Warnings: CONTEXT_FILE_BUDGET_EXCEEDED/);
-    assert.match(output.system.join('\n'), /Run the exact regression test/);
-    assert.doesNotMatch(output.system.join('\n'), /Fix drift|cloud-mem/);
-
-    const manifestFile = path.join(changeRoot, 'context-manifest.json');
-    const legacyManifest = JSON.parse(fs.readFileSync(manifestFile, 'utf8'));
-    legacyManifest.schema_version = '1.0';
-    fs.writeFileSync(manifestFile, JSON.stringify(legacyManifest));
-    const legacyOutput = { system: [] };
-    await plugin['experimental.chat.system.transform']({}, legacyOutput);
-    assert.match(legacyOutput.system.join('\n'), /CONTEXT_SNAPSHOT_UPGRADE_REQUIRED/);
-    legacyManifest.schema_version = '2.0';
-    fs.writeFileSync(manifestFile, JSON.stringify(legacyManifest));
-
-    delete legacyManifest.baseline;
-    fs.writeFileSync(manifestFile, JSON.stringify(legacyManifest));
-    const missingBaselineOutput = { system: [] };
-    await plugin['experimental.chat.system.transform']({}, missingBaselineOutput);
-    assert.match(missingBaselineOutput.system.join('\n'), /CONTEXT_SNAPSHOT_UPGRADE_REQUIRED/);
-    legacyManifest.baseline = {
-      id: 'project-baseline', mode: 'brownfield', status: 'ready', repository_revision: compiledHead,
-    };
-    fs.writeFileSync(manifestFile, JSON.stringify(legacyManifest));
-
-    fs.writeFileSync(path.join(project, 'app.txt'), 'changed\n');
-    execFileSync('git', ['add', 'app.txt'], { cwd: project, stdio: 'ignore' });
-    execFileSync('git', ['-c', 'user.name=Ultra Tests', '-c', 'user.email=ultra@example.invalid', 'commit', '-m', 'change'], {
-      cwd: project, stdio: 'ignore',
-    });
-    const staleOutput = { system: [] };
-    await plugin['experimental.chat.system.transform']({}, staleOutput);
-    assert.match(staleOutput.system.join('\n'), /Readiness: blocked/);
-    assert.match(staleOutput.system.join('\n'), /CONTEXT_HEAD_STALE/);
-    assert.match(staleOutput.system.join('\n'), /recompile change\.context/);
-
+    const text = output.system.join('\n');
+    assert.match(text, /STATE_DB_MISSING/);
+    assert.match(text, /ultra-init/);
     await assert.rejects(
       plugin['tool.execute.before'](
         { tool: 'apply_patch' },
@@ -276,22 +215,69 @@ test('OpenCode context covers active changes and projection writes are blocked f
   }
 });
 
-test('OpenCode does not assume a project baseline is ready when no active change manifest exists', async () => {
+test('OpenCode injects the DB breadcrumb and ignores conflicting workflow projections', async () => {
   const target = mkTarget();
   const project = mkTarget();
+  let state;
   try {
     opencode.install({ configDir: target, repoRoot: REPO_ROOT });
-    fs.mkdirSync(path.join(project, '.ultra'), { recursive: true });
-    fs.writeFileSync(path.join(project, '.ultra', 'state.db'), 'owned-by-ultra');
-    const module = await import(`${pathToFileURL(path.join(target, 'plugins', 'ultra-builder-pro.js')).href}?baseline`);
+    execFileSync('git', ['init'], { cwd: project, stdio: 'ignore' });
+    fs.writeFileSync(path.join(project, 'app.txt'), 'initial\n');
+    execFileSync('git', ['add', 'app.txt'], { cwd: project, stdio: 'ignore' });
+    execFileSync('git', ['-c', 'user.name=Ultra Tests', '-c', 'user.email=ultra@example.invalid', 'commit', '-m', 'initial'], {
+      cwd: project, stdio: 'ignore',
+    });
+    state = initStateDb(path.join(project, '.ultra', 'state.db'));
+    state.db.prepare(
+      `INSERT INTO baselines
+       (id, project_name, mode, status, approved_by, approval_note, converged_at)
+       VALUES ('baseline-db', 'fixture', 'greenfield', 'ready', 'test', 'fixture', ?)`,
+    ).run(new Date().toISOString());
+    const { change } = changes.createChange(state.db, {
+      id: 'db-authority-change', title: 'DB authority', kind: 'quick',
+      intent: 'Use one authoritative injected state.',
+      docs_impact: { status: 'none', rationale: 'test fixture' },
+    }, { rootDir: project });
+    const task = createTask(state.db, {
+      id: 'db-authority-task', title: 'Use DB authority', type: 'bugfix', priority: 'P0',
+      change_id: change.id,
+    });
+    changes.compileContext(state.db, {
+        id: change.id,
+        task_id: task.id,
+        role: 'implement',
+        gate: 'implementation',
+        execution_contract: {
+          slice_kind: 'tracer_bullet', public_seam: 'OpenCode injection',
+          verification_command: 'node --test adapters/tests/opencode.test.cjs',
+        },
+        next_action: 'Verify the DB-only OpenCode injection.',
+    }, { rootDir: project });
+
+    fs.writeFileSync(path.join(project, '.ultra', 'workflow-state.json'), JSON.stringify({
+      command: 'ultra-dev', task_id: 'projection-task', status: 'active', step: 'wrong',
+    }));
+    const projectionRoot = path.join(project, '.ultra', 'changes', 'active', 'projection-change');
+    fs.mkdirSync(projectionRoot, { recursive: true });
+    fs.writeFileSync(path.join(projectionRoot, 'context-manifest.json'), JSON.stringify({
+      schema_version: '2.0',
+      baseline: { id: 'projection-baseline', mode: 'brownfield', status: 'ready' },
+      change: { id: 'projection-change', kind: 'quick', status: 'active' },
+      selected_task: { id: 'projection-task', status: 'in_progress' },
+      readiness: { status: 'ready', blockers: [], warnings: [] },
+    }));
+
+    const module = await import(`${pathToFileURL(path.join(target, 'plugins', 'ultra-builder-pro.js')).href}?db-authority`);
     const plugin = await module.UltraBuilderProPlugin({ directory: project });
     const output = { system: [] };
     await plugin['experimental.chat.system.transform']({}, output);
     const text = output.system.join('\n');
-    assert.match(text, /ultra-status/);
-    assert.match(text, /ultra-init/);
-    assert.doesNotMatch(text, /Start daily work with the ultra-change workflow/);
+    assert.match(text, /Change: db-authority-change/);
+    assert.match(text, /Task: db-authority-task/);
+    assert.match(text, /Role: implement/);
+    assert.doesNotMatch(text, /projection-change|projection-task|projection-baseline/);
   } finally {
+    if (state) closeStateDb(state.db);
     fs.rmSync(target, { recursive: true, force: true });
     fs.rmSync(project, { recursive: true, force: true });
   }

package/commands/ultra-init.md

@@ -1,6 +1,6 @@
 ---
 description: Initialize a new project or adopt an existing repository into authoritative Ultra baseline state
-argument-hint: "[name] [type] [stack] [auto|greenfield|brownfield]"
+argument-hint: "[name] [type] [stack] [auto|greenfield|brownfield] [--scope <path>]"
 workflow-ref: "@skills/ultra-init/SKILL.md"
 ---