ultra-builder-pro-cli 0.8.1 → 0.10.0

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

@@ -9,7 +9,8 @@ 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 = '9.0';
+const EXPECTED_VERSION = '10.0';
+const KIMI_SCHEMA_VERSION = '9.1';
 
 const REQUIRED_TABLES = Object.freeze([
   'tasks',
@@ -23,6 +24,7 @@ const REQUIRED_TABLES = Object.freeze([
   'changes',
   'artifacts',
   'context_snapshots',
+  'spec_learning_candidates',
   'trace_links',
   'incidents',
   'projection_jobs',
@@ -71,6 +73,13 @@ function columnNames(db, table) {
   return new Set(db.prepare(`PRAGMA table_info(${table})`).all().map((row) => row.name));
 }
 
+function latestSchemaVersion(db) {
+  if (!tableNames(db).includes('schema_version')) return null;
+  return db.prepare(
+    'SELECT version FROM schema_version ORDER BY applied_at DESC, rowid DESC LIMIT 1',
+  ).get()?.version || null;
+}
+
 function applyCompatibleColumns(db) {
   const tables = new Set(tableNames(db));
   if (!tables.has('tasks')) return;
@@ -87,14 +96,149 @@ function applyCompatibleColumns(db) {
   }
 }
 
-function applyCompatibleUpgrades(db) {
+function applyContextSpineUpgrade(db) {
+  const tables = new Set(tableNames(db));
+  if (!tables.has('context_snapshots')) return false;
+  let changed = !tables.has('spec_learning_candidates');
+  const columns = columnNames(db, 'context_snapshots');
+  const additions = [
+    ['role', "TEXT NOT NULL DEFAULT 'plan' CHECK (role IN ('plan', 'implement', 'check', 'review'))"],
+    ['gate', "TEXT NOT NULL DEFAULT 'alignment' CHECK (gate IN ('alignment', 'planning', 'implementation', 'verification', 'review', 'convergence', 'recovery'))"],
+    ['next_action', "TEXT NOT NULL DEFAULT 'Resolve the next Ultra workflow action.'"],
+    ['readiness', "TEXT NOT NULL DEFAULT 'ready' CHECK (readiness IN ('ready', 'blocked'))"],
+    ['blockers_json', "TEXT NOT NULL DEFAULT '[]'"],
+    ['context_json', "TEXT NOT NULL DEFAULT '{}'"],
+    ['token_estimate', 'INTEGER NOT NULL DEFAULT 0 CHECK (token_estimate >= 0)'],
+    ['token_budget', 'INTEGER NOT NULL DEFAULT 12000 CHECK (token_budget > 0)'],
+  ];
+  for (const [name, definition] of additions) {
+    if (!columns.has(name)) {
+      db.exec(`ALTER TABLE context_snapshots ADD COLUMN ${name} ${definition}`);
+      changed = true;
+    }
+  }
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS spec_learning_candidates (
+      id            TEXT PRIMARY KEY,
+      change_id     TEXT NOT NULL REFERENCES changes(id) ON DELETE CASCADE,
+      task_id       TEXT REFERENCES tasks(id) ON DELETE SET NULL,
+      target_ref    TEXT NOT NULL,
+      summary       TEXT NOT NULL,
+      evidence_json TEXT NOT NULL DEFAULT '[]',
+      status        TEXT NOT NULL DEFAULT 'proposed'
+                      CHECK (status IN ('proposed', 'approved', 'rejected', 'applied')),
+      resolution    TEXT,
+      proposed_at   TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
+      resolved_at   TEXT,
+      applied_at    TEXT
+    );
+    CREATE INDEX IF NOT EXISTS spec_learning_change
+      ON spec_learning_candidates(change_id, status, proposed_at);
+  `);
+  return changed;
+}
+
+function tableSupportsKimi(db, table) {
+  const row = db.prepare(
+    "SELECT sql FROM sqlite_master WHERE type = 'table' AND name = ?",
+  ).get(table);
+  return typeof row?.sql === 'string' && row.sql.includes("'kimi'");
+}
+
+function upgradeRuntimeConstraints(db, fromVersion = latestSchemaVersion(db)) {
+  if (tableSupportsKimi(db, 'events') && tableSupportsKimi(db, 'sessions')) return false;
+  const previousVersion = fromVersion || 'unknown';
+  const foreignKeys = db.pragma('foreign_keys', { simple: true });
+  db.pragma('foreign_keys = OFF');
+  try {
+    db.transaction(() => {
+      db.exec(`
+        DROP TABLE IF EXISTS events_runtime_upgrade;
+        CREATE TABLE events_runtime_upgrade (
+          id            INTEGER PRIMARY KEY AUTOINCREMENT,
+          ts            TEXT    NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
+          type          TEXT    NOT NULL,
+          task_id       TEXT,
+          change_id     TEXT,
+          session_id    TEXT,
+          runtime       TEXT CHECK (runtime IS NULL OR runtime IN ('claude', 'opencode', 'codex', 'kimi')),
+          payload_json  TEXT
+        );
+        INSERT INTO events_runtime_upgrade
+          (id, ts, type, task_id, change_id, session_id, runtime, payload_json)
+        SELECT id, ts, type, task_id, change_id, session_id, runtime, payload_json FROM events;
+        DROP TABLE events;
+        ALTER TABLE events_runtime_upgrade RENAME TO events;
+        CREATE INDEX events_ts_type ON events(ts, type);
+        CREATE INDEX events_task ON events(task_id, id);
+        CREATE INDEX events_session ON events(session_id, id);
+        CREATE INDEX events_change ON events(change_id, id);
+
+        DROP TABLE IF EXISTS sessions_runtime_upgrade;
+        CREATE TABLE sessions_runtime_upgrade (
+          sid               TEXT PRIMARY KEY,
+          task_id           TEXT NOT NULL REFERENCES tasks(id),
+          runtime           TEXT NOT NULL CHECK (runtime IN ('claude', 'opencode', 'codex', 'kimi')),
+          pid               INTEGER,
+          worktree_path     TEXT NOT NULL,
+          artifact_dir      TEXT NOT NULL,
+          status            TEXT NOT NULL DEFAULT 'running'
+                              CHECK (status IN ('running', 'completed', 'crashed', 'orphan')),
+          lease_expires_at  TEXT NOT NULL,
+          heartbeat_at      TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
+          started_at        TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
+        );
+        INSERT INTO sessions_runtime_upgrade
+          (sid, task_id, runtime, pid, worktree_path, artifact_dir, status,
+           lease_expires_at, heartbeat_at, started_at)
+        SELECT sid, task_id, runtime, pid, worktree_path, artifact_dir, status,
+               lease_expires_at, heartbeat_at, started_at FROM sessions;
+        DROP TABLE sessions;
+        ALTER TABLE sessions_runtime_upgrade RENAME TO sessions;
+        CREATE INDEX sessions_active ON sessions(status, task_id);
+        CREATE INDEX sessions_lease ON sessions(lease_expires_at) WHERE status = 'running';
+      `);
+      db.prepare(
+        `INSERT INTO migration_history
+          (from_version, to_version, direction, status, notes)
+         VALUES (?, ?, 'forward', 'success', ?)`,
+      ).run(
+        previousVersion,
+        KIMI_SCHEMA_VERSION,
+        'Add Kimi to durable event and session runtime constraints',
+      );
+      const violations = db.pragma('foreign_key_check');
+      if (violations.length > 0) {
+        throw new Error(`runtime constraint migration produced ${violations.length} foreign key violation(s)`);
+      }
+    })();
+  } finally {
+    db.pragma(`foreign_keys = ${foreignKeys ? 'ON' : 'OFF'}`);
+  }
+  return true;
+}
+
+function applyCompatibleUpgrades(db, fromVersion = latestSchemaVersion(db)) {
+  const runtimeChanged = upgradeRuntimeConstraints(db, fromVersion);
   db.transaction(() => {
     applyCompatibleColumns(db);
+    const contextChanged = applyContextSpineUpgrade(db);
+    if (contextChanged || (fromVersion && fromVersion !== EXPECTED_VERSION)) {
+      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,
+        'Add Context Spine role/gate readiness, execution contracts, breadcrumbs, and specification learning',
+      );
+    }
     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, 'Continuous change units and recoverable runtime state');
+    ).run(EXPECTED_VERSION, 'Role-scoped context snapshots, deterministic breadcrumbs, and approval-gated specification learning');
   })();
 }
 
@@ -116,12 +260,13 @@ function ensureSchemaVersion(db) {
 function initStateDb(dbPath) {
   const db = openStateDb(dbPath);
   const existing = new Set(tableNames(db));
+  const fromVersion = latestSchemaVersion(db);
   applyCompatibleColumns(db);
   const missing = REQUIRED_TABLES.filter((t) => !existing.has(t));
   if (missing.length > 0) {
     applySchema(db);
   }
-  applyCompatibleUpgrades(db);
+  applyCompatibleUpgrades(db, fromVersion);
   const version = ensureSchemaVersion(db);
   return {
     db,

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

@@ -9,11 +9,13 @@ const path = require('node:path');
 const {
   EXPECTED_VERSION,
   REQUIRED_TABLES,
+  SCHEMA_FILE,
   initStateDb,
   closeStateDb,
   openStateDb,
   tableNames,
 } = require('./state-db.cjs');
+const stateOps = require('./state-ops.cjs');
 
 function tmpDbPath(prefix = 'ubp-state') {
   const dir = fs.mkdtempSync(path.join(os.tmpdir(), `${prefix}-`));
@@ -114,3 +116,62 @@ test('Phase 8A.1 schema: tasks.parent_id column + tasks_parent partial index + s
     fs.rmSync(dir, { recursive: true, force: true });
   }
 });
+
+test('initStateDb migrates existing runtime constraints to Kimi without losing references', () => {
+  const { dir, file } = tmpDbPath('ubp-kimi-runtime-upgrade');
+  try {
+    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(
+      "INSERT INTO tasks (id, title, type, priority) VALUES ('task-old', 'Old', 'feature', 'P1')",
+    ).run();
+    legacy.prepare(
+      `INSERT INTO sessions
+       (sid, task_id, runtime, worktree_path, artifact_dir, lease_expires_at)
+       VALUES ('session-old', 'task-old', 'codex', '/tmp/worktree', '/tmp/artifacts', '2099-01-01T00:00:00.000Z')`,
+    ).run();
+    legacy.prepare(
+      "INSERT INTO telemetry (session_id, event_type, tool_name) VALUES ('session-old', 'tool_call', 'task.list')",
+    ).run();
+    legacy.prepare(
+      `INSERT INTO incidents
+       (id, code, severity, message, session_id)
+       VALUES ('incident-old', 'OLD', 'warning', 'preserve me', 'session-old')`,
+    ).run();
+    legacy.prepare(
+      "INSERT INTO events (type, session_id, runtime) VALUES ('session_spawned', 'session-old', 'codex')",
+    ).run();
+    closeStateDb(legacy);
+
+    const upgraded = initStateDb(file);
+    assert.equal(upgraded.schema_version, '10.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",
+    ).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)));
+
+    upgraded.db.prepare(
+      "INSERT INTO tasks (id, title, type, priority) VALUES ('task-kimi', 'Kimi', 'feature', 'P1')",
+    ).run();
+    const session = stateOps.createSession(upgraded.db, {
+      sid: 'session-kimi',
+      task_id: 'task-kimi',
+      runtime: 'kimi',
+      worktree_path: '/tmp/kimi-worktree',
+      artifact_dir: '/tmp/kimi-artifacts',
+    });
+    assert.equal(session.runtime, 'kimi');
+    const event = stateOps.appendEvent(upgraded.db, { type: 'kimi-ready', runtime: 'kimi' });
+    assert.ok(event.event_id > 0);
+    closeStateDb(upgraded.db);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});

package/mcp-server/server.cjs

@@ -73,6 +73,9 @@ const CHANGE_TOOLS = Object.freeze([
   'change.get',
   'change.list',
   'change.context',
+  'change.breadcrumb',
+  'change.learning_propose',
+  'change.learning_resolve',
   'change.converge',
   'change.archive',
 ]);
@@ -95,6 +98,7 @@ const MUTATING_TOOLS = new Set([
   'session.spawn', 'session.close', 'session.heartbeat',
   'plan.export',
   'change.create', 'change.update', 'change.context', 'change.converge', 'change.archive',
+  'change.learning_propose', 'change.learning_resolve',
 ]);
 
 function loadRegisteredTools() {
@@ -368,7 +372,12 @@ async function dispatchTool(name, input, db, ctx = {}) {
         err.code = 'CHANGE_NOT_FOUND';
         throw err;
       }
-      return { change };
+      return {
+        change: {
+          ...change,
+          learning_candidates: changes.listSpecLearning(db, change.id),
+        },
+      };
     }
     case 'change.list': {
       const rows = changes.listChanges(db, input || {});
@@ -382,6 +391,27 @@ async function dispatchTool(name, input, db, ctx = {}) {
         manifest: out.manifest,
       };
     }
+    case 'change.breadcrumb': {
+      return {
+        breadcrumb: changes.readBreadcrumb(
+          db, input || {}, { rootDir: ctx.rootDir || process.cwd() },
+        ),
+      };
+    }
+    case 'change.learning_propose': {
+      return {
+        candidate: changes.proposeSpecLearning(
+          db, input, { rootDir: ctx.rootDir || process.cwd() },
+        ),
+      };
+    }
+    case 'change.learning_resolve': {
+      return {
+        candidate: changes.resolveSpecLearning(
+          db, input, { rootDir: ctx.rootDir || process.cwd() },
+        ),
+      };
+    }
     case 'change.converge': {
       return changes.convergeChange(db, input, { rootDir: ctx.rootDir || process.cwd() });
     }

package/mcp-server/tests/db-ops.test.cjs

@@ -11,7 +11,7 @@ const Database = require('better-sqlite3');
 
 const REPO_ROOT = path.resolve(__dirname, '..', '..');
 const CLI = path.join(REPO_ROOT, 'ultra-tools', 'cli.cjs');
-const { initStateDb, closeStateDb } = require('../lib/state-db.cjs');
+const { EXPECTED_VERSION, initStateDb, closeStateDb } = require('../lib/state-db.cjs');
 const ops = require('../lib/state-ops.cjs');
 
 function tmpDir() {
@@ -97,8 +97,8 @@ test('db backup writes a file that opens independently with the same schema', ()
 
     // Independently open the backup with a fresh connection
     const snap = new Database(backupPath);
-    const v = snap.prepare("SELECT version FROM schema_version").get();
-    assert.equal(v.version, '4.5');
+    const v = snap.prepare('SELECT version FROM schema_version WHERE version = ?').get(EXPECTED_VERSION);
+    assert.equal(v.version, EXPECTED_VERSION);
     const t = snap.prepare("SELECT id FROM tasks WHERE id = 'b-1'").get();
     assert.equal(t.id, 'b-1');
     snap.close();

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

@@ -36,8 +36,8 @@ 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.0'").get();
-      assert.equal(version.version, '9.0');
+      const version = db.prepare("SELECT version FROM schema_version WHERE version = '9.1'").get();
+      assert.equal(version.version, '9.1');
       assert.ok(db.prepare("SELECT name FROM sqlite_master WHERE name = 'changes'").get());
     } finally {
       db.close();

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

@@ -75,10 +75,13 @@ test('listTools returns workflow tools and exposes no Ultra memory API', async (
       const names = list.tools.map((t) => t.name).sort();
       assert.deepEqual(names, [
         'change.archive',
+        'change.breadcrumb',
         'change.context',
         'change.converge',
         'change.create',
         'change.get',
+        'change.learning_propose',
+        'change.learning_resolve',
         'change.list',
         'change.update',
         'plan.export',
@@ -142,9 +145,19 @@ test('change.create + change.context expose a continuous change unit with extern
         name: 'change.context', arguments: { id: 'mcp-change' },
       }));
       assert.equal(context.manifest.change.id, 'mcp-change');
+      assert.equal(context.manifest.schema_version, '2.0');
+      assert.equal(context.manifest.role, 'plan');
+      assert.equal(context.manifest.readiness.status, 'ready');
       assert.equal(context.manifest.providers.memory.provider, 'cloud-mem');
       assert.equal(context.manifest.provider_boundary.includes('content remain external'), true);
 
+      const breadcrumb = readToolPayload(await client.callTool({
+        name: 'change.breadcrumb', arguments: { id: 'mcp-change' },
+      }));
+      assert.equal(breadcrumb.breadcrumb.change_id, 'mcp-change');
+      assert.equal(breadcrumb.breadcrumb.recommended_workflow, 'ultra-change');
+      assert.match(breadcrumb.breadcrumb.context_manifest_hash, /^[0-9a-f]{64}$/);
+
       const listed = readToolPayload(await client.callTool({
         name: 'change.list', arguments: { status: 'active' },
       }));
@@ -156,6 +169,67 @@ 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 {
+    await withClient(proj, async (client) => {
+      await client.callTool({
+        name: 'change.create',
+        arguments: {
+          id: 'learning-change', title: 'Learn stable contract', kind: 'quick',
+          intent: 'Persist only approved specification discoveries.',
+          docs_impact: { status: 'none', files: [], rationale: 'Contract fixture.' },
+        },
+      });
+      await client.callTool({
+        name: 'task.create',
+        arguments: {
+          id: 'learning-task', title: 'Discover contract', type: 'feature', priority: 'P1',
+          change_id: 'learning-change',
+        },
+      });
+      const proposed = readToolPayload(await client.callTool({
+        name: 'change.learning_propose',
+        arguments: {
+          id: 'learning-contract', change_id: 'learning-change', task_id: 'learning-task',
+          target_ref: 'README.md#contract', summary: 'Context compilation fails closed on stale refs.',
+          evidence: ['node --test context-spine.test.cjs'],
+        },
+      }));
+      assert.equal(proposed.candidate.status, 'proposed');
+      const withLearning = readToolPayload(await client.callTool({
+        name: 'change.get', arguments: { id: 'learning-change' },
+      }));
+      assert.deepEqual(
+        withLearning.change.learning_candidates.map((candidate) => candidate.id),
+        ['learning-contract'],
+      );
+
+      const approved = readToolPayload(await client.callTool({
+        name: 'change.learning_resolve',
+        arguments: {
+          change_id: 'learning-change', candidate_id: 'learning-contract', decision: 'approve',
+          resolution: 'Stable behavior contract.',
+        },
+      }));
+      assert.equal(approved.candidate.status, 'approved');
+      const applied = readToolPayload(await client.callTool({
+        name: 'change.learning_resolve',
+        arguments: {
+          change_id: 'learning-change', candidate_id: 'learning-contract', decision: 'apply',
+          resolution: 'Applied to README.md#contract.',
+        },
+      }));
+      assert.equal(applied.candidate.status, 'applied');
+      assert.ok(fs.existsSync(path.join(
+        proj.dir, '.ultra', 'changes', 'active', 'learning-change', 'spec-learning.json',
+      )));
+    });
+  } finally {
+    fs.rmSync(proj.dir, { recursive: true, force: true });
+  }
+});
+
 test('system.doctor returns structured provider ownership and projection health', async () => {
   const proj = tmpProject();
   try {

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

@@ -8,7 +8,7 @@ const path = require('node:path');
 
 const stateDb = require('../lib/state-db.cjs');
 
-test('initStateDb upgrades a pre-9.0 database in place with task/event change linkage', () => {
+test('initStateDb upgrades a pre-10.0 database in place with Context Spine state', () => {
   const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'ubp-db-upgrade-'));
   const file = path.join(dir, 'state.db');
   try {
@@ -59,8 +59,25 @@ test('initStateDb upgrades a pre-9.0 database in place with task/event change li
     assert.ok(columns.includes('change_id'));
     const eventColumns = upgraded.db.prepare('PRAGMA table_info(events)').all().map((row) => row.name);
     assert.ok(eventColumns.includes('change_id'));
-    assert.equal(upgraded.schema_version, '9.0');
-    assert.ok(upgraded.db.prepare("SELECT 1 FROM schema_version WHERE version = '9.0'").get());
+    assert.equal(upgraded.schema_version, '10.0');
+    assert.ok(upgraded.db.prepare("SELECT 1 FROM schema_version WHERE version = '10.0'").get());
+    const contextColumns = upgraded.db.prepare('PRAGMA table_info(context_snapshots)').all()
+      .map((row) => row.name);
+    for (const column of ['role', 'gate', 'next_action', 'readiness', 'context_json', 'token_budget']) {
+      assert.ok(contextColumns.includes(column), column);
+    }
+    assert.ok(upgraded.db.prepare(
+      "SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'spec_learning_candidates'",
+    ).get());
+    const contextMigration = upgraded.db.prepare(
+      "SELECT from_version, to_version, notes FROM migration_history WHERE to_version = '10.0' ORDER BY id DESC LIMIT 1",
+    ).get();
+    assert.equal(contextMigration.from_version, '9.1');
+    assert.equal(contextMigration.to_version, '10.0');
+    assert.match(contextMigration.notes, /Context Spine/);
+    assert.ok(upgraded.db.prepare(
+      "SELECT 1 FROM migration_history WHERE from_version = '8A.1' AND to_version = '9.1' AND notes LIKE '%Kimi%'",
+    ).get());
     stateDb.closeStateDb(upgraded.db);
   } finally {
     fs.rmSync(dir, { recursive: true, force: true });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "ultra-builder-pro-cli",
-  "version": "0.8.1",
-  "description": "Multi-runtime installer for the Ultra Builder Pro agent engineering system — deploys commands, agents, skills, hooks, and MCP server to Claude Code, OpenCode, and Codex CLI.",
+  "version": "0.10.0",
+  "description": "Multi-runtime installer for the Ultra Builder Pro agent engineering system — deploys commands, agents, skills, hooks, and MCP server to Claude Code, OpenCode, Codex CLI, and Kimi Code.",
   "bin": {
     "ultra-builder-pro-cli": "bin/install.js",
     "ubp": "bin/install.js",
@@ -60,6 +60,7 @@
     "claude-code",
     "opencode",
     "codex",
+    "kimi-code",
     "agent",
     "cli",
     "multi-runtime",
@@ -92,6 +93,7 @@
     "verify:release": "npm run test:all && npm run test:hooks && npm audit --omit=dev --audit-level=high",
     "prepublishOnly": "npm run verify:release",
     "install:claude": "node bin/install.js --claude --local",
+    "install:kimi": "node bin/install.js --kimi --local",
     "install:all": "node bin/install.js --all --local"
   },
   "dependencies": {

package/skills/learn/SKILL.md

@@ -1,6 +1,7 @@
 ---
 name: learn
 description: "Extract one reusable pattern from the current session into a valid user skill, with explicit user approval before writing."
+user-invocable: true
 ---
 
 # learn — Phase 3.6