ultra-builder-pro-cli 0.8.1 → 0.9.0

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

@@ -0,0 +1,122 @@
+'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 { spawnSync } = require('node:child_process');
+
+const REPO_ROOT = path.resolve(__dirname, '..', '..');
+const ADAPTER = path.join(REPO_ROOT, 'hooks', 'adapters', 'kimi.py');
+
+function run(feature, payload, args = []) {
+  return spawnSync('python3', [ADAPTER, feature, ...args], {
+    cwd: REPO_ROOT,
+    input: JSON.stringify(payload),
+    encoding: 'utf8',
+  });
+}
+
+test('Kimi hook adapter rejects non-workflow policy hooks without blocking the host', () => {
+  const result = run('block_dangerous_commands.py', {
+    session_id: 'session-1',
+    cwd: REPO_ROOT,
+    hook_event_name: 'PreToolUse',
+    tool_name: 'Shell',
+    tool_input: { command: 'git reset --hard' },
+  });
+  assert.equal(result.status, 0, result.stderr);
+  assert.match(JSON.parse(result.stdout).message, /refused unknown feature/);
+});
+
+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',
+    }));
+    const result = run('active_task_context.py', {
+      session_id: 'session-2',
+      cwd: project,
+      hook_event_name: 'PreToolUse',
+      tool_name: 'Edit',
+      tool_input: { file_path: 'src/a.py' },
+    });
+    assert.equal(result.status, 0, result.stderr);
+    const output = JSON.parse(result.stdout);
+    assert.match(output.message, /task-7/);
+    assert.equal(output.hookSpecificOutput, undefined);
+  } finally {
+    fs.rmSync(project, { recursive: true, force: true });
+  }
+});
+
+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,
+      hook_event_name: 'PreToolUse',
+      tool_name: 'Write',
+      tool_input: { file_path: '.ultra/tasks/tasks.json' },
+    });
+    assert.equal(result.status, 0, result.stderr);
+    const output = JSON.parse(result.stdout);
+    assert.equal(output.hookSpecificOutput.permissionDecision, 'deny');
+    assert.match(output.hookSpecificOutput.permissionDecisionReason, /\.ultra\/state\.db/);
+  } finally {
+    fs.rmSync(project, { recursive: true, force: true });
+  }
+});
+
+test('Kimi subagent fields are normalized for the existing lifecycle tracker', () => {
+  const script = [
+    'import importlib.util, json, pathlib',
+    `p = pathlib.Path(${JSON.stringify(ADAPTER)})`,
+    's = importlib.util.spec_from_file_location("kimi_hook_adapter", p)',
+    'm = importlib.util.module_from_spec(s)',
+    's.loader.exec_module(m)',
+    'payload = {"hook_event_name":"SubagentStart","agent_name":"review-code","session_id":"s"}',
+    'print(json.dumps(m.normalize_input(payload)))',
+  ].join('; ');
+  const result = spawnSync('python3', ['-c', script], { cwd: REPO_ROOT, encoding: 'utf8' });
+  assert.equal(result.status, 0, result.stderr);
+  assert.deepEqual(JSON.parse(result.stdout), {
+    hook_event_name: 'SubagentStart',
+    agent_name: 'review-code',
+    session_id: 's',
+    agent_id: 'review-code',
+    agent_type: 'review-code',
+  });
+});
+
+test('Kimi stop blocks and recovery context use the exact structured-output schema', () => {
+  const script = [
+    'import importlib.util, json, pathlib',
+    `p = pathlib.Path(${JSON.stringify(ADAPTER)})`,
+    's = importlib.util.spec_from_file_location("kimi_hook_adapter", p)',
+    'm = importlib.util.module_from_spec(s)',
+    's.loader.exec_module(m)',
+    'values = [m.adapt_output({"decision":"block","reason":"finish gates"}, "Stop"), m.adapt_output({"additionalContext":"restored"}, "PostCompact")]',
+    'print(json.dumps(values))',
+  ].join('; ');
+  const result = spawnSync('python3', ['-c', script], { cwd: REPO_ROOT, encoding: 'utf8' });
+  assert.equal(result.status, 0, result.stderr);
+  assert.deepEqual(JSON.parse(result.stdout), [
+    {
+      hookSpecificOutput: {
+        message: 'finish gates',
+        permissionDecision: 'deny',
+        permissionDecisionReason: 'finish gates',
+      },
+    },
+    { message: 'restored' },
+  ]);
+});

package/adapters/tests/kimi.test.cjs

@@ -0,0 +1,255 @@
+'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) assert.match(hookText, new RegExp(hook.replace('.', '\\.')));
+    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\/learned-<pattern-slug>-unverified\/SKILL\.md/);
+    assert.match(review, /Kimi `AgentSwarm`/);
+    assert.match(review, /5 specialized reviewers/);
+    assert.doesNotMatch(review, /6 specialized|ALL 6/);
+    assert.match(review, /\$KIMI_PLUGIN_ROOT\/agents\/review-code\.md/);
+    assert.match(review, /`prompt_template` containing\s+`\{\{item\}\}`/);
+    assert.match(review, /selected reviewer names as the `items` array/);
+    assert.match(review, /Launch the coordinator with one foreground Kimi `Agent` call/);
+    assert.doesNotMatch(review, /background mode|Set Kimi `AgentSwarm` parallel execution|Launch review-coordinator with Kimi `AgentSwarm`/);
+    assert.match(init, /\| Kimi \| `\/ultra-builder-pro:ultra-init/);
+    assert.doesNotMatch(init, /codex exec "run \/ultra-init/);
+    assert.match(bootstrap, /\.ultra\/state\.db/);
+    assert.match(bootstrap, /external providers/);
+
+    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);
+    }
+  } 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/bin/handbook.js

@@ -14,8 +14,8 @@ const {
 function usage() {
   return [
     'Usage:',
-    '  ubp-handbook preview --runtime <claude|codex|opencode> [--file <path>]',
-    '  ubp-handbook apply   --runtime <claude|codex|opencode> [--file <path>]',
+    '  ubp-handbook preview --runtime <claude|codex|opencode|kimi> [--file <path>]',
+    '  ubp-handbook apply   --runtime <claude|codex|opencode|kimi> [--file <path>]',
     '',
     'The apply command creates a timestamped backup before changing an existing file.',
   ].join('\n');

package/bin/install.js

@@ -4,14 +4,14 @@
  * ultra-builder-pro-cli — multi-runtime installer.
  *
  * Distributes Ultra Builder Pro assets — commands, agents, skills, hooks,
- * MCP server — to Claude Code, OpenCode, and Codex CLI via
+ * MCP server — to Claude Code, OpenCode, Codex CLI, and Kimi Code via
  * runtime-specific adapters under adapters/. Install is idempotent and
  * uses atomic writes; uninstall reverses via sentinel/manifest blocks.
  *
  * Usage:
  *   npx ultra-builder-pro-cli [options]
  *
- *   --claude / --opencode / --codex              select runtime(s)
+ *   --claude / --opencode / --codex / --kimi     select runtime(s)
  *   --all                                         install to all supported runtimes
  *   -g, --global                                  install to runtime's global config dir
  *   -l, --local                                   install into current working directory
@@ -58,7 +58,7 @@ function printBanner() {
     paint('cyan', '   ╚═════╝ ╚═════╝ ╚═╝         ╚═════╝╚══════╝╚═╝'),
     '',
     `  ${paint('bold', 'Ultra Builder Pro CLI')} ${paint('dim', 'v' + pkg.version)}`,
-    `  ${paint('dim', 'Multi-runtime installer for Claude Code, OpenCode, and Codex')}`,
+    `  ${paint('dim', 'Multi-runtime installer for Claude Code, OpenCode, Codex, and Kimi Code')}`,
     '',
   ];
   console.log(banner.join('\n'));
@@ -71,6 +71,7 @@ function printHelp() {
     ${paint('cyan', '--claude')}           Claude Code
     ${paint('cyan', '--opencode')}         OpenCode
     ${paint('cyan', '--codex')}            Codex CLI (OpenAI)
+    ${paint('cyan', '--kimi')}             Kimi Code (Moonshot AI)
     ${paint('cyan', '--all')}              all supported runtimes
 
   ${paint('yellow', 'Scope:')}
@@ -95,6 +96,9 @@ function printHelp() {
     ${paint('dim', '# Uninstall from OpenCode')}
     npx ultra-builder-pro-cli --opencode --global --uninstall
 
+    ${paint('dim', '# Install to Kimi Code globally')}
+    npx ultra-builder-pro-cli --kimi --global
+
     ${paint('dim', '# Verify all host installations without changing them')}
     npx ultra-builder-pro-cli --all --global --doctor
 `);
@@ -120,6 +124,7 @@ function parseArgs(argv) {
       case '--claude': runtimes.add('claude'); break;
       case '--opencode': runtimes.add('opencode'); break;
       case '--codex': runtimes.add('codex'); break;
+      case '--kimi': runtimes.add('kimi'); break;
       case '--all':
         SUPPORTED_RUNTIMES.forEach(r => runtimes.add(r));
         break;
@@ -199,7 +204,7 @@ async function main() {
   if (flags.json && !flags.doctor) bail('--json is available only with --doctor');
 
   if (runtimes.length === 0) {
-    bail('no runtime selected; use --claude / --opencode / --codex / --all');
+    bail('no runtime selected; use --claude / --opencode / --codex / --kimi / --all');
   }
 
   const scope = resolveScope(flags);

package/bin/orchestrator.js

@@ -47,7 +47,7 @@ function optInAllowed(settings) {
 }
 
 function parseRuntimes() {
-  const raw = process.env.UBP_ORCH_RUNTIMES || 'claude,opencode,codex';
+  const raw = process.env.UBP_ORCH_RUNTIMES || 'claude,opencode,codex,kimi';
   const runtimes = [...new Set(raw.split(',').map((s) => s.trim()).filter(Boolean))];
   const invalid = runtimes.filter((runtime) => !isSupportedRuntime(runtime));
   if (invalid.length > 0) {

package/docs/AGENT-CONTEXT.md

@@ -1,7 +1,7 @@
 # Ultra Builder Pro — Agent Context
 
-Current shared runtime contract for the native Claude Code, OpenCode, and Codex
-plugins.
+Current shared runtime contract for the native Claude Code, OpenCode, Codex,
+and Kimi Code plugins.
 
 ## 1. Ownership boundary
 
@@ -12,7 +12,8 @@ Ultra Builder Pro owns only:
   `ultra-think`, plus the daily `ultra-change` and diagnostic `ultra-doctor`;
 - four internal agent-only rule skills: `code-review-expert`, `security-rules`,
   `integration-rules`, and `testing-rules`;
-- the host-specific collaboration companions and `ultra-verify`;
+- the host-specific collaboration companions, `ultra-verify`, and the minimal
+  Kimi session bootstrap required to establish the shared runtime boundary;
 - bounded review/debug agents, workflow-only hooks, MCP task state, and the
   portable CLI/orchestrator.
 
@@ -68,6 +69,7 @@ fixtures. Do not add an ad-hoc server handler first.
 | Claude Code | `.claude-plugin/plugin.json`, native commands/skills/agents, `.mcp.json` | `/ultra-*`, `/learn` | native `hooks/hooks.json` | `codex-collab`, `ultra-verify` |
 | Codex | personal plugin with `.codex-plugin/plugin.json`, namespaced skills, TOML agents, `.mcp.json` | `$ultra-builder-pro:ultra-*`, `$ultra-builder-pro:learn` | native `hooks/hooks.json` through the Codex wire adapter | `cc-collab`, `ultra-verify` |
 | OpenCode | config bundle plus native JavaScript plugin | `/ultra-*`, `/learn` | `event`, system transform, compaction, and tool lifecycle handlers | `cc-collab`, `codex-collab`, `ultra-verify` |
+| Kimi Code 0.26+ | managed `kimi.plugin.json` plugin with commands, skills, hooks, and MCP | `/ultra-builder-pro:ultra-*`, `/ultra-builder-pro:learn` | native hooks through the Kimi wire adapter | `cc-collab`, `codex-collab`, `ultra-verify` |
 
 The current host remains primary. Collaboration skills call another runtime
 only when explicitly requested, use it as a read-only advisor, and return the

package/docs/ARCHITECTURE.md

@@ -10,7 +10,7 @@
 
 `ultra-builder-pro-cli` is a multi-runtime plugin suite that **distributes** the
 Ultra Builder Pro engineering loop (skills + commands + workflow hooks) as
-native Claude Code, OpenCode, and Codex plugins, and
+native Claude Code, OpenCode, Codex, and Kimi Code plugins, and
 **runs** that loop with isolated sessions sharing one authoritative state
 store (`.ultra/state.db`).
 
@@ -23,7 +23,7 @@ the supported hosts share.
                        ┌──────────────────────────┐
                        │       runtime CLI        │
                        │  (claude / opencode /    │
-                       │   codex)                 │
+                       │   codex / kimi)          │
                        └────────────┬─────────────┘
                                     │
                 ┌───────────────────┼────────────────────┐
@@ -156,7 +156,7 @@ backup-first mechanical recovery when explicitly requested.
 
 ## 5. Sessions — the execution unit
 
-A **session** is the standard unit of execution across all three runtimes
+A **session** is the standard unit of execution across all four runtimes
 (D20). One session =
 
 - a fresh OS process for the runtime,
@@ -189,7 +189,7 @@ durable authority alongside `.ultra/state.db`.
 
 ## 7. Installation provenance — read-only cross-host diagnosis
 
-Every Claude Code, OpenCode, and Codex adapter writes a normalized
+Every Claude Code, OpenCode, Codex, and Kimi Code adapter writes a normalized
 `provenance.json` for the assets it owns. The manifest records adapter/package
 identity, source metadata, per-file SHA-256 hashes, an aggregate digest, and the
 host-specific plugin, MCP, hook, launcher, and runtime contracts expected at

package/docs/PLAN.zh-CN.md

@@ -6,12 +6,12 @@
 > 插件只保留 12 个 Ultra 公共 workflow（新增 daily `ultra-change` 与诊断
 > `ultra-doctor`）、4 个 agent-only 规则 skill、宿主专属 collab companion、
 > workflow/change hook 与 `.ultra/state.db` 权威。Memory 和代码图谱内容全部由外部
-> provider 所有，Ultra 只保存 provider 元数据引用。Claude Code、Codex、OpenCode
-> 采用各自 native plugin 呈现，其他旧 runtime adapter 已退役。下文所有与此冲突的
+> provider 所有，Ultra 只保存 provider 元数据引用。Claude Code、Codex、OpenCode、
+> Kimi Code 采用各自 native plugin 呈现，其他旧 runtime adapter 已退役。下文所有与此冲突的
 > memory/hindsight 章节仅作为历史实施记录，不再是当前需求或运行时契约。
 
-**当前状态**：v0.8.1；三宿主 native plugin、29 个 live MCP tool、
-schema 9.0（15 表）、持续 change/context/convergence/doctor、incident debug lane、
+**当前状态**：v0.9.0；四宿主 native plugin、29 个 live MCP tool、
+schema 9.1（15 表）、持续 change/context/convergence/doctor、incident debug lane、
 checkpoint 恢复消费与跨宿主安装 provenance/doctor 已落地；npm 发布由
 `v*.*.*` tag 触发。以下 Phase 0-9 正文保留为 2026-04 的实施历史，不再作为
 当前 runtime 或发布状态的事实来源。

package/docs/ROADMAP.md

@@ -6,14 +6,14 @@
 > when historical plan text differs.
 
 **Goal**: distribute the Ultra Builder Pro engineering loop as native Claude
-Code, OpenCode, and Codex plugins, and run it with isolated sessions sharing one
-authoritative workflow store.
+Code, OpenCode, Codex, and Kimi Code plugins, and run it with isolated sessions
+sharing one authoritative workflow store.
 
-**First-class runtimes**: Claude Code · OpenCode · Codex.
+**First-class runtimes**: Claude Code · OpenCode · Codex · Kimi Code.
 
 **Distribution channels (v1.0)**: npm · Homebrew · pip.
 
-**Release line**: `0.7.x`; every release is gated by `npm run verify:release`.
+**Release line**: `0.9.x`; every release is gated by `npm run verify:release`.
 
 ---