ultra-builder-pro-cli 0.13.0 → 0.15.0

package/adapters/tests/kimi.test.cjs

@@ -1,259 +0,0 @@
-'use strict';
-
-const { test } = require('node:test');
-const assert = require('node:assert/strict');
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-
-const kimi = require('../kimi.js');
-const {
-  CORE_PUBLIC_SKILLS,
-  WORKFLOW_HOOK_FILES,
-  skillsForRuntime,
-} = require('../_shared/runtime-assets.cjs');
-
-const REPO_ROOT = path.resolve(__dirname, '..', '..');
-const PLUGIN_ID = 'ultra-builder-pro';
-
-function mkTarget() {
-  return fs.mkdtempSync(path.join(os.tmpdir(), 'ubp-kimi-'));
-}
-
-function layout(home) {
-  return {
-    pluginRoot: path.join(home, 'plugins', 'managed', PLUGIN_ID),
-    registryFile: path.join(home, 'plugins', 'installed.json'),
-  };
-}
-
-function readJson(file) {
-  return JSON.parse(fs.readFileSync(file, 'utf8'));
-}
-
-test('install builds and registers one Kimi-native plugin without changing config.toml', () => {
-  const home = mkTarget();
-  const { pluginRoot, registryFile } = layout(home);
-  const configFile = path.join(home, 'config.toml');
-  const userConfig = '[[hooks]]\nevent = "Stop"\ncommand = "/user/hook.sh"\n';
-  try {
-    fs.writeFileSync(configFile, userConfig);
-    const report = kimi.install({ configDir: home, repoRoot: REPO_ROOT });
-
-    assert.equal(report.target, pluginRoot);
-    assert.equal(fs.readFileSync(configFile, 'utf8'), userConfig);
-    assert.ok(fs.existsSync(path.join(pluginRoot, '.ubp-managed')));
-    assert.ok(fs.existsSync(path.join(pluginRoot, 'provenance.json')));
-
-    const registry = readJson(registryFile);
-    assert.equal(registry.version, 1);
-    assert.equal(registry.plugins.length, 1);
-    assert.deepEqual(registry.plugins[0], {
-      id: PLUGIN_ID,
-      root: pluginRoot,
-      source: 'local-path',
-      enabled: true,
-      installedAt: registry.plugins[0].installedAt,
-      updatedAt: registry.plugins[0].updatedAt,
-      originalSource: REPO_ROOT,
-    });
-  } finally {
-    fs.rmSync(home, { recursive: true, force: true });
-  }
-});
-
-test('Kimi manifest exposes native skills, commands, hooks, session bootstrap, and MCP', () => {
-  const home = mkTarget();
-  const { pluginRoot } = layout(home);
-  try {
-    kimi.install({ configDir: home, repoRoot: REPO_ROOT });
-    const manifest = readJson(path.join(pluginRoot, 'kimi.plugin.json'));
-
-    assert.equal(manifest.name, PLUGIN_ID);
-    assert.deepEqual(manifest.skills, ['./skills']);
-    assert.deepEqual(manifest.commands, ['./commands']);
-    assert.deepEqual(manifest.sessionStart, { skill: 'using-ultra-builder-pro' });
-    assert.equal(manifest.agents, undefined, 'Kimi 0.26/0.27 has no custom-agent manifest field');
-    assert.deepEqual(manifest.mcpServers[PLUGIN_ID], {
-      transport: 'stdio',
-      command: process.platform === 'win32' ? 'node.exe' : 'env',
-      args: process.platform === 'win32'
-        ? ['./runtime/launch.cjs']
-        : ['node', './runtime/launch.cjs'],
-      enabled: true,
-    });
-
-    const hookText = JSON.stringify(manifest.hooks);
-    assert.match(hookText, /hooks\/adapters\/kimi\.py/);
-    for (const hook of WORKFLOW_HOOK_FILES.filter((value) => value !== 'context_spine.py')) {
-      assert.match(hookText, new RegExp(hook.replace('.', '\\.')));
-    }
-    assert.ok(fs.existsSync(path.join(pluginRoot, 'hooks', 'context_spine.py')));
-    assert.doesNotMatch(hookText, /memory|recall|journal|prompt[_ -]?capture|block_dangerous|post_edit_guard/i);
-
-    const commands = fs.readdirSync(path.join(pluginRoot, 'commands')).sort();
-    assert.deepEqual(commands, CORE_PUBLIC_SKILLS.map((name) => `${name}.md`).sort());
-    const commandText = fs.readFileSync(path.join(pluginRoot, 'commands', 'ultra-init.md'), 'utf8');
-    assert.match(commandText, /Use the registered `ultra-init` skill/);
-    assert.match(commandText, /\$ARGUMENTS/);
-  } finally {
-    fs.rmSync(home, { recursive: true, force: true });
-  }
-});
-
-test('Kimi assets are allowlisted and adapted to native tools and paths', () => {
-  const home = mkTarget();
-  const { pluginRoot } = layout(home);
-  try {
-    kimi.install({ configDir: home, repoRoot: REPO_ROOT });
-
-    const skills = fs.readdirSync(path.join(pluginRoot, 'skills'), { withFileTypes: true })
-      .filter((entry) => entry.isDirectory()
-        && fs.existsSync(path.join(pluginRoot, 'skills', entry.name, 'SKILL.md')))
-      .map((entry) => entry.name)
-      .sort();
-    assert.deepEqual(skills, [...skillsForRuntime('kimi'), 'using-ultra-builder-pro'].sort());
-
-    const learn = fs.readFileSync(path.join(pluginRoot, 'skills', 'learn', 'SKILL.md'), 'utf8');
-    const review = fs.readFileSync(path.join(pluginRoot, 'skills', 'ultra-review', 'SKILL.md'), 'utf8');
-    const init = fs.readFileSync(path.join(pluginRoot, 'skills', 'ultra-init', 'SKILL.md'), 'utf8');
-    const bootstrap = fs.readFileSync(
-      path.join(pluginRoot, 'skills', 'using-ultra-builder-pro', 'SKILL.md'),
-      'utf8',
-    );
-    assert.match(learn, /`~\/.kimi-code\/skills`/);
-    assert.doesNotMatch(learn, /_unverified|learned-[^\s/]*-unverified/i);
-    assert.match(review, /Kimi `AgentSwarm`/);
-    assert.match(review, /\$KIMI_PLUGIN_ROOT\/agents\//);
-    assert.match(review, /scripts\/review_wait\.py/);
-    assert.match(review, /spec_fidelity/);
-    assert.match(review, /engineering_standards/);
-    assert.doesNotMatch(review, /background mode|run_in_background/);
-    assert.match(init, /task\.init_project/);
-    assert.doesNotMatch(init, /Claude Code|OpenCode|Codex/);
-    assert.match(bootstrap, /\.ultra\/state\.db/);
-    assert.match(bootstrap, /external providers/);
-    assert.match(fs.readFileSync(path.join(pluginRoot, 'skills', 'codex-collab', 'SKILL.md'), 'utf8'), /--ephemeral/);
-
-    const allPromptAssets = [];
-    for (const root of ['commands', 'skills', 'agents']) {
-      const pending = [path.join(pluginRoot, root)];
-      while (pending.length) {
-        const current = pending.pop();
-        for (const entry of fs.readdirSync(current, { withFileTypes: true })) {
-          const file = path.join(current, entry.name);
-          if (entry.isDirectory()) pending.push(file);
-          else if (entry.isFile() && /\.(?:md|json)$/.test(entry.name)) allPromptAssets.push(file);
-        }
-      }
-    }
-    const foreign = /~\/.claude|~\/.codex|~\/.config\/opencode|CLAUDE\.md|TaskCreate|TaskUpdate|TaskList|AskUserQuestion|run_in_background:\s*true|\$CLAUDE_PLUGIN_ROOT|Kimi `Shell`/;
-    for (const file of allPromptAssets) {
-      const text = fs.readFileSync(file, 'utf8');
-      assert.doesNotMatch(text, foreign, file);
-      assert.doesNotMatch(text, /(^|[\s`("'])\/ultra-(?!builder-pro:)[a-z]/m, file);
-      assert.doesNotMatch(text, /[\u3400-\u9fff]|ultra-review-findings-v1|Context7|Exa MCP|confidence\s*>=?\s*\d+/iu, file);
-    }
-  } finally {
-    fs.rmSync(home, { recursive: true, force: true });
-  }
-});
-
-test('reinstall preserves unrelated records and existing Kimi capability choices', () => {
-  const home = mkTarget();
-  const { registryFile } = layout(home);
-  try {
-    fs.mkdirSync(path.dirname(registryFile), { recursive: true });
-    fs.writeFileSync(registryFile, JSON.stringify({
-      version: 1,
-      plugins: [{
-        id: 'mine', root: '/tmp/mine', source: 'local-path', enabled: true,
-        installedAt: '2026-01-01T00:00:00.000Z', originalSource: '/tmp/mine',
-      }],
-    }, null, 2));
-
-    kimi.install({ configDir: home, repoRoot: REPO_ROOT });
-    const first = readJson(registryFile);
-    const ultra = first.plugins.find((entry) => entry.id === PLUGIN_ID);
-    ultra.enabled = false;
-    ultra.capabilities = { mcpServers: { [PLUGIN_ID]: { enabled: false } } };
-    fs.writeFileSync(registryFile, JSON.stringify(first, null, 2));
-
-    kimi.install({ configDir: home, repoRoot: REPO_ROOT });
-    const second = readJson(registryFile);
-    assert.deepEqual(second.plugins.map((entry) => entry.id).sort(), ['mine', PLUGIN_ID]);
-    const refreshed = second.plugins.find((entry) => entry.id === PLUGIN_ID);
-    assert.equal(refreshed.installedAt, ultra.installedAt);
-    assert.equal(refreshed.enabled, false);
-    assert.deepEqual(refreshed.capabilities, ultra.capabilities);
-  } finally {
-    fs.rmSync(home, { recursive: true, force: true });
-  }
-});
-
-test('uninstall removes only the owned Kimi plugin record and managed root', () => {
-  const home = mkTarget();
-  const { pluginRoot, registryFile } = layout(home);
-  try {
-    kimi.install({ configDir: home, repoRoot: REPO_ROOT });
-    const registry = readJson(registryFile);
-    registry.plugins.unshift({
-      id: 'mine', root: '/tmp/mine', source: 'local-path', enabled: true,
-      installedAt: '2026-01-01T00:00:00.000Z', originalSource: '/tmp/mine',
-    });
-    fs.writeFileSync(registryFile, JSON.stringify(registry, null, 2));
-
-    kimi.uninstall({ configDir: home });
-    assert.equal(fs.existsSync(pluginRoot), false);
-    assert.deepEqual(readJson(registryFile).plugins.map((entry) => entry.id), ['mine']);
-  } finally {
-    fs.rmSync(home, { recursive: true, force: true });
-  }
-});
-
-test('install and uninstall refuse to replace or remove an unmanaged Kimi root', () => {
-  const home = mkTarget();
-  const { pluginRoot, registryFile } = layout(home);
-  try {
-    fs.mkdirSync(pluginRoot, { recursive: true });
-    fs.writeFileSync(path.join(pluginRoot, 'user.txt'), 'keep');
-    assert.throws(
-      () => kimi.install({ configDir: home, repoRoot: REPO_ROOT }),
-      /unmanaged Kimi plugin/,
-    );
-
-    fs.mkdirSync(path.dirname(registryFile), { recursive: true });
-    fs.writeFileSync(registryFile, JSON.stringify({
-      version: 1,
-      plugins: [{
-        id: PLUGIN_ID, root: pluginRoot, source: 'local-path', enabled: true,
-        installedAt: '2026-01-01T00:00:00.000Z', originalSource: '/tmp/foreign',
-      }],
-    }));
-    assert.throws(() => kimi.uninstall({ configDir: home }), /unmanaged Kimi plugin/);
-    assert.equal(fs.readFileSync(path.join(pluginRoot, 'user.txt'), 'utf8'), 'keep');
-  } finally {
-    fs.rmSync(home, { recursive: true, force: true });
-  }
-});
-
-test('doctor validates registration and provenance without mutating the Kimi home', () => {
-  const home = mkTarget();
-  const { registryFile } = layout(home);
-  try {
-    kimi.install({ configDir: home, repoRoot: REPO_ROOT });
-    const before = fs.readFileSync(registryFile);
-    const healthy = kimi.doctor({ configDir: home, repoRoot: REPO_ROOT });
-    assert.equal(healthy.status, 'healthy', JSON.stringify(healthy, null, 2));
-    assert.deepEqual(fs.readFileSync(registryFile), before);
-
-    const registry = readJson(registryFile);
-    registry.plugins[0].enabled = false;
-    fs.writeFileSync(registryFile, JSON.stringify(registry, null, 2));
-    const degraded = kimi.doctor({ configDir: home, repoRoot: REPO_ROOT });
-    assert.equal(degraded.status, 'degraded');
-    assert.ok(degraded.issues.some((issue) => issue.code === 'PLUGIN_REGISTRATION_INVALID'));
-  } finally {
-    fs.rmSync(home, { recursive: true, force: true });
-  }
-});

package/adapters/tests/opencode.test.cjs

@@ -1,371 +0,0 @@
-'use strict';
-
-const { test } = require('node:test');
-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 { pathToFileURL } = require('node:url');
-
-const opencode = require('../opencode.js');
-const { parse: parseFm } = require('../_shared/frontmatter.cjs');
-const { skillsForRuntime } = require('../_shared/runtime-assets.cjs');
-
-const REPO_ROOT = path.resolve(__dirname, '..', '..');
-
-function mkTarget() {
-  return fs.mkdtempSync(path.join(os.tmpdir(), 'ubp-opencode-'));
-}
-
-test('install builds a native OpenCode plugin and copies only allowlisted skills', () => {
-  const target = mkTarget();
-  try {
-    const r = opencode.install({ configDir: target, repoRoot: REPO_ROOT });
-    assert.ok(r.copied.commands.includes('ultra-init.md'));
-    assert.ok(r.copied.skills.some((p) => p.includes('ultra-init/SKILL.md')));
-    assert.ok(r.copied.plugins.includes('ultra-builder-pro.js'));
-    assert.ok(fs.existsSync(path.join(target, 'plugins', 'ultra-builder-pro.js')));
-    assert.deepEqual(
-      fs.readdirSync(path.join(target, 'skills'), { withFileTypes: true })
-        .filter((entry) => entry.isDirectory())
-        .map((entry) => entry.name)
-        .sort(),
-      skillsForRuntime('opencode').sort(),
-    );
-
-    // OpenCode commands expose only fields accepted by the native command contract.
-    const dst = fs.readFileSync(path.join(target, 'commands', 'ultra-init.md'), 'utf8');
-    const { fm: dstFm } = parseFm(dst);
-    assert.deepEqual(Object.keys(dstFm), ['description']);
-
-    // forge an upper-case key to prove the transform works
-    const hack = path.join(target, 'commands', 'upper.md');
-    fs.writeFileSync(hack, '---\nDescription: mixed\n---\nbody\n');
-    opencode.install({ configDir: target, repoRoot: REPO_ROOT });
-    // reinstall re-runs the transform; the hack was outside commands/ in repo so
-    // install doesn't touch it; we verify transform via a direct call:
-    const { lowercaseKeys } = require('../_shared/frontmatter.cjs');
-    assert.deepEqual(lowercaseKeys({ Description: 'x', Tags: ['A'] }), { description: 'x', tags: ['A'] });
-  } finally {
-    fs.rmSync(target, { recursive: true, force: true });
-  }
-});
-
-test('install performs content-level OpenCode adaptation for commands, skills, references, and agents', () => {
-  const target = mkTarget();
-  try {
-    opencode.install({ configDir: target, repoRoot: REPO_ROOT });
-
-    const plan = fs.readFileSync(path.join(target, 'skills', 'ultra-plan', 'SKILL.md'), 'utf8');
-    const learn = fs.readFileSync(path.join(target, 'skills', 'learn', 'SKILL.md'), 'utf8');
-    const review = fs.readFileSync(path.join(target, 'skills', 'ultra-review', 'SKILL.md'), 'utf8');
-    const codexCollab = fs.readFileSync(path.join(target, 'skills', 'codex-collab', 'SKILL.md'), 'utf8');
-    const verify = fs.readFileSync(path.join(target, 'skills', 'ultra-verify', 'SKILL.md'), 'utf8');
-
-    assert.deepEqual(Object.keys(parseFm(plan).fm), ['name', 'description']);
-    assert.match(learn, /`~\/.config\/opencode\/skills`/);
-    assert.doesNotMatch(learn, /_unverified|learned-[^\s/]*-unverified/i);
-    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.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/);
-
-    const markdown = [];
-    for (const root of ['commands', 'skills', 'agents']) {
-      const pending = [path.join(target, root)];
-      while (pending.length) {
-        const current = pending.pop();
-        for (const entry of fs.readdirSync(current, { withFileTypes: true })) {
-          const file = path.join(current, entry.name);
-          if (entry.isDirectory()) pending.push(file);
-          else if (entry.isFile() && entry.name.endsWith('.md')) markdown.push(file);
-        }
-      }
-    }
-    const incompatible = /~\/.claude|CLAUDE\.md|AskUserQuestion|TaskCreate|TaskUpdate|TaskList|run_in_background:\s*true|--yolo|--full-auto|\/codex:|ask\.question|review\.run/;
-    for (const file of markdown) {
-      const text = fs.readFileSync(file, 'utf8');
-      assert.doesNotMatch(text, incompatible, file);
-      assert.doesNotMatch(text, /[\u3400-\u9fff]|ultra-review-findings-v1|Context7|Exa MCP|confidence\s*>=?\s*\d+/iu, file);
-    }
-  } finally {
-    fs.rmSync(target, { recursive: true, force: true });
-  }
-});
-
-test('install translates Claude agent metadata to native OpenCode agent contracts', () => {
-  const target = mkTarget();
-  try {
-    opencode.install({ configDir: target, repoRoot: REPO_ROOT });
-
-    const reviewTests = parseFm(
-      fs.readFileSync(path.join(target, 'agents', 'review-tests.md'), 'utf8'),
-    ).fm;
-    assert.equal(reviewTests.mode, 'subagent');
-    assert.equal(reviewTests.steps, 18);
-    assert.equal(reviewTests.name, undefined);
-    assert.equal(reviewTests.model, undefined);
-    assert.equal(reviewTests.maxturns, undefined);
-    assert.equal(reviewTests.tools, undefined);
-    assert.equal(reviewTests.skills, undefined);
-    assert.deepEqual(reviewTests.permission, {
-      read: 'allow',
-      edit: 'allow',
-      glob: 'allow',
-      grep: 'allow',
-      list: 'allow',
-      bash: 'allow',
-      task: 'deny',
-      external_directory: 'deny',
-      todowrite: 'deny',
-      question: 'deny',
-      webfetch: 'deny',
-      websearch: 'deny',
-      codesearch: 'deny',
-      lsp: 'deny',
-      doom_loop: 'deny',
-      skill: {
-        '*': 'deny',
-        'testing-rules': 'allow',
-      },
-    });
-
-    const tddRunner = parseFm(
-      fs.readFileSync(path.join(target, 'agents', 'tdd-runner.md'), 'utf8'),
-    ).fm;
-    assert.equal(tddRunner.permission.edit, 'deny');
-    assert.deepEqual(tddRunner.permission.skill, {
-      '*': 'deny',
-      'testing-rules': 'allow',
-    });
-
-    const debuggerAgent = parseFm(
-      fs.readFileSync(path.join(target, 'agents', 'debugger.md'), 'utf8'),
-    ).fm;
-    assert.equal(debuggerAgent.steps, 40);
-    assert.equal(debuggerAgent.permission.skill, 'deny');
-  } finally {
-    fs.rmSync(target, { recursive: true, force: true });
-  }
-});
-
-test('install writes a schema-safe opencode.json and keeps ownership outside host config', () => {
-  const target = mkTarget();
-  try {
-    opencode.install({ configDir: target, repoRoot: REPO_ROOT });
-    const config = JSON.parse(fs.readFileSync(path.join(target, 'opencode.json'), 'utf8'));
-    assert.ok(config.mcp);
-    assert.ok(config.mcp[opencode.MCP_SERVER_NAME]);
-    assert.equal(config.mcp[opencode.MCP_SERVER_NAME].type, 'local');
-    assert.equal(config.mcp[opencode.MCP_SERVER_NAME].enabled, true);
-    assert.ok(Array.isArray(config.mcp[opencode.MCP_SERVER_NAME].command));
-    assert.equal('_ubp_manifest' in config, false);
-    assert.ok(fs.existsSync(path.join(target, opencode.BUNDLE_DIR, '.ubp-managed')));
-
-    const plugin = fs.readFileSync(path.join(target, 'plugins', 'ultra-builder-pro.js'), 'utf8');
-    assert.match(plugin, /experimental\.chat\.system\.transform/);
-    assert.match(plugin, /experimental\.session\.compacting/);
-    assert.match(plugin, /tool\.execute\.before/);
-    assert.match(plugin, /\.ultra[\\/]tasks[\\/]tasks\.json/);
-    assert.match(plugin, /throw new Error/);
-    assert.match(plugin, /session\.compacted/);
-    assert.doesNotMatch(plugin, /memory\.(?:retain|recall|reflect)|journal|observation|prompt[_ -]?capture/);
-    assert.match(plugin, /Ultra context spine/);
-    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 () => {
-  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 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/);
-
-    await assert.rejects(
-      plugin['tool.execute.before'](
-        { tool: 'apply_patch' },
-        { args: { patch: '*** Begin Patch\n*** Update File: .ultra/tasks/tasks.json\n*** End Patch' } },
-      ),
-      /state\.db is authoritative/,
-    );
-  } finally {
-    fs.rmSync(target, { recursive: true, force: true });
-    fs.rmSync(project, { recursive: true, force: true });
-  }
-});
-
-test('OpenCode does not assume a project baseline is ready when no active change manifest exists', async () => {
-  const target = mkTarget();
-  const project = mkTarget();
-  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`);
-    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/);
-  } finally {
-    fs.rmSync(target, { recursive: true, force: true });
-    fs.rmSync(project, { recursive: true, force: true });
-  }
-});
-
-test('install preserves user mcp entries; uninstall removes only owned Ultra assets', () => {
-  const target = mkTarget();
-  const configFile = path.join(target, 'opencode.json');
-  try {
-    fs.writeFileSync(configFile, JSON.stringify({
-      theme: 'dark',
-      mcp: { my_server: { command: 'node', args: ['./mine.js'] } },
-    }, null, 2));
-
-    opencode.install({ configDir: target, repoRoot: REPO_ROOT });
-    const merged = JSON.parse(fs.readFileSync(configFile, 'utf8'));
-    assert.equal(merged.theme, 'dark');
-    assert.ok(merged.mcp.my_server);
-    assert.ok(merged.mcp[opencode.MCP_SERVER_NAME]);
-
-    opencode.uninstall({ configDir: target });
-    const after = JSON.parse(fs.readFileSync(configFile, 'utf8'));
-    assert.equal(after.theme, 'dark');
-    assert.ok(after.mcp.my_server);
-    assert.ok(!after.mcp[opencode.MCP_SERVER_NAME]);
-    assert.ok(!('_ubp_manifest' in after));
-    assert.ok(!fs.existsSync(path.join(target, 'commands')));
-    assert.ok(!fs.existsSync(path.join(target, 'plugins', 'ultra-builder-pro.js')));
-  } finally {
-    fs.rmSync(target, { recursive: true, force: true });
-  }
-});
-
-test('shared OpenCode asset roots keep unrelated user commands, skills, agents, and runtime files', () => {
-  const target = mkTarget();
-  const userFiles = [
-    ['commands', 'user-command.md'],
-    ['skills', 'user-skill', 'SKILL.md'],
-    ['agents', 'user-agent.md'],
-    ['runtime', 'user-runtime.txt'],
-  ];
-  try {
-    for (const parts of userFiles) {
-      const file = path.join(target, ...parts);
-      fs.mkdirSync(path.dirname(file), { recursive: true });
-      fs.writeFileSync(file, 'user-owned');
-    }
-
-    opencode.install({ configDir: target, repoRoot: REPO_ROOT });
-    opencode.uninstall({ configDir: target });
-
-    for (const parts of userFiles) {
-      assert.equal(fs.readFileSync(path.join(target, ...parts), 'utf8'), 'user-owned');
-    }
-    assert.equal(fs.existsSync(path.join(target, 'commands', '.ubp-managed')), false);
-    assert.equal(fs.existsSync(path.join(target, 'skills', '.ubp-managed')), false);
-    assert.equal(fs.existsSync(path.join(target, 'agents', '.ubp-managed')), false);
-  } finally {
-    fs.rmSync(target, { recursive: true, force: true });
-  }
-});
-
-test('install refuses to overwrite an unmanaged OpenCode asset with the same name', () => {
-  const target = mkTarget();
-  const conflict = path.join(target, 'skills', 'ultra-init', 'SKILL.md');
-  try {
-    fs.mkdirSync(path.dirname(conflict), { recursive: true });
-    fs.writeFileSync(conflict, 'user-owned');
-    assert.throws(
-      () => opencode.install({ configDir: target, repoRoot: REPO_ROOT }),
-      /unmanaged OpenCode skill/,
-    );
-    assert.equal(fs.readFileSync(conflict, 'utf8'), 'user-owned');
-  } finally {
-    fs.rmSync(target, { recursive: true, force: true });
-  }
-});

package/mcp-server/lib/archive-journal.test.cjs

@@ -1,35 +0,0 @@
-'use strict';
-
-const test = require('node:test');
-const assert = require('node:assert/strict');
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-
-const journal = require('./archive-journal.cjs');
-
-test('archive journal restores the exact active directory when finalization cannot run', () => {
-  const rootDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ubp-archive-journal-'));
-  const source = path.join(rootDir, '.ultra', 'changes', 'active', 'change-a');
-  fs.mkdirSync(source, { recursive: true });
-  fs.writeFileSync(path.join(source, 'intent.md'), '# Change A\n');
-  try {
-    const prepared = journal.prepareArchiveMove({
-      rootDir,
-      change: { id: 'change-a', title: 'Change A', artifact_root: '.ultra/changes/active/change-a' },
-      summary: 'Archive Change A.', baselineUpdates: [],
-      noBaselineChangeReason: 'No baseline content changed.',
-      now: new Date('2026-07-18T00:00:00.000Z'),
-    });
-    assert.equal(fs.existsSync(prepared.source), false);
-    assert.equal(journal.listArchiveIntents(rootDir).length, 1);
-
-    journal.rollbackArchiveIntent(rootDir, prepared.intent);
-    assert.equal(fs.existsSync(source), true);
-    assert.equal(fs.existsSync(path.join(source, 'intent.md')), true);
-    assert.equal(fs.existsSync(path.join(source, 'archive-summary.md')), false);
-    assert.equal(journal.listArchiveIntents(rootDir).length, 0);
-  } finally {
-    fs.rmSync(rootDir, { recursive: true, force: true });
-  }
-});