ultra-builder-pro-cli 0.21.1 → 0.23.0

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

@@ -657,8 +657,9 @@ function inspectRunHealth(run, steps, rootDir) {
     const firstOpen = steps.find(
       (item) => item.required && !['completed', 'skipped'].includes(item.status),
     );
-    if (!firstOpen) blockers.push('WORKFLOW_ACTIVE_WITHOUT_OPEN_STEP');
-    else if (run.current_step !== firstOpen.step_id) {
+    if (!firstOpen) {
+      if (runMetadata.draft_dirty !== true) blockers.push('WORKFLOW_ACTIVE_WITHOUT_OPEN_STEP');
+    } else if (run.current_step !== firstOpen.step_id) {
       blockers.push(`WORKFLOW_CURRENT_STEP_INVALID:${run.current_step || 'missing'}`);
     }
   }
@@ -1196,6 +1197,166 @@ function startWorkflow(db, input = {}, { rootDir = process.cwd() } = {}) {
   return readWorkflow(db, id, { rootDir });
 }
 
+function abandonWorkflow(db, input = {}, { rootDir = process.cwd() } = {}) {
+  const id = nonEmpty(input.id, 'id');
+  const reason = nonEmpty(input.reason, 'reason');
+  return ops.tx(db, () => {
+    const run = readWorkflow(db, id, { rootDir });
+    if (!run) throw new WorkflowStateError('WORKFLOW_NOT_FOUND', `workflow ${id} not found`);
+    if (run.status === 'cancelled') return run;
+    if (run.status === 'completed') {
+      throw new WorkflowStateError(
+        'WORKFLOW_NOT_MUTABLE',
+        `accepted workflow ${id} is immutable; create a new draft revision instead`,
+      );
+    }
+    const metadata = {
+      ...run.metadata,
+      abandoned: {
+        reason,
+        abandoned_at: nowIso(),
+      },
+    };
+    delete metadata.authority_invalidation;
+    const ts = nowIso();
+    db.prepare(
+      `UPDATE workflow_runs
+       SET status = 'cancelled', current_step = NULL, blockers_json = '[]',
+           metadata_json = ?, completed_at = ?, updated_at = ?
+       WHERE id = ?`,
+    ).run(JSON.stringify(metadata), ts, ts, id);
+    ops.appendEventInTx(db, {
+      type: 'workflow_abandoned',
+      task_id: run.task_id,
+      change_id: run.change_id,
+      payload: { workflow_id: id, kind: run.kind, reason },
+    });
+    return readWorkflow(db, id, { rootDir });
+  });
+}
+
+function prepareWorkflowCheckpoint(db, input = {}, { rootDir = process.cwd() } = {}) {
+  const id = nonEmpty(input.id, 'id');
+  const suppliedSteps = new Map(
+    (Array.isArray(input.steps) ? input.steps : []).map((item) => [
+      nonEmpty(item.step_id, 'steps.step_id'),
+      item,
+    ]),
+  );
+  const defaultEvidence = Array.isArray(input.evidence) && input.evidence.length > 0
+    ? normalizeEvidence(input.evidence)
+    : [{
+      kind: 'checkpoint',
+      ref: `workflow:${id}`,
+      summary: 'The model recorded this semantic stage in one checkpoint.',
+    }];
+  return ops.tx(db, () => {
+    const run = readWorkflow(db, id, { rootDir });
+    if (!run) throw new WorkflowStateError('WORKFLOW_NOT_FOUND', `workflow ${id} not found`);
+    if (run.status === 'completed') return { workflow: run, blockers: [], ready: true };
+    if (run.status === 'cancelled') {
+      throw new WorkflowStateError('WORKFLOW_NOT_MUTABLE', `workflow ${id} is cancelled`);
+    }
+    const blockers = [];
+    const ts = nowIso();
+    for (const workflowStep of run.steps) {
+      if (!workflowStep.required) continue;
+      const supplied = suppliedSteps.get(workflowStep.step_id) || {};
+      const definition = WORKFLOW_DEFINITIONS[run.kind]
+        .find((item) => item.id === workflowStep.step_id);
+      const outputs = supplied.outputs === undefined
+        ? workflowStep.outputs
+        : normalizeOutputs(supplied.outputs, rootDir);
+      const evidence = supplied.evidence === undefined
+        ? (workflowStep.evidence.length > 0 ? workflowStep.evidence : defaultEvidence)
+        : normalizeEvidence(supplied.evidence);
+      const semanticRecords = supplied.semantic_records === undefined
+        ? workflowStep.semantic_records
+        : (run.kind === 'research'
+          ? normalizeSemanticRecords(supplied.semantic_records, workflowStep.step_id, rootDir)
+          : normalizeObjects(supplied.semantic_records, 'semantic_records'));
+      if (definition.output_required && outputs.length === 0) {
+        blockers.push(`WORKFLOW_OUTPUT_REQUIRED:${workflowStep.step_id}`);
+        continue;
+      }
+      if (definition.evidence_required && evidence.length === 0) {
+        blockers.push(`WORKFLOW_EVIDENCE_REQUIRED:${workflowStep.step_id}`);
+        continue;
+      }
+      if (run.kind === 'research' && semanticRecords.length === 0) {
+        blockers.push(`WORKFLOW_SEMANTIC_RECORDS_REQUIRED:${workflowStep.step_id}`);
+        continue;
+      }
+      db.prepare(
+        `UPDATE workflow_steps
+         SET status = 'completed', evidence_json = ?, outputs_json = ?,
+             decisions_json = ?, semantic_records_json = ?, blockers_json = '[]',
+             started_at = COALESCE(started_at, ?), completed_at = ?, updated_at = ?
+         WHERE run_id = ? AND step_id = ?`,
+      ).run(
+        JSON.stringify(evidence),
+        JSON.stringify(outputs),
+        JSON.stringify(supplied.decisions === undefined
+          ? workflowStep.decisions
+          : normalizeObjects(supplied.decisions, 'decisions')),
+        JSON.stringify(semanticRecords),
+        ts,
+        ts,
+        ts,
+        id,
+        workflowStep.step_id,
+      );
+    }
+    const metadata = { ...run.metadata };
+    delete metadata.authority_invalidation;
+    metadata.draft_dirty = blockers.length > 0;
+    db.prepare(
+      `UPDATE workflow_runs
+       SET status = ?, current_step = NULL, blockers_json = ?, metadata_json = ?, updated_at = ?
+       WHERE id = ?`,
+    ).run(
+      blockers.length > 0 ? 'active' : 'ready',
+      JSON.stringify(blockers),
+      JSON.stringify(metadata),
+      ts,
+      id,
+    );
+    ops.appendEventInTx(db, {
+      type: blockers.length > 0 ? 'workflow_checkpoint_rejected' : 'workflow_checkpoint_prepared',
+      task_id: run.task_id,
+      change_id: run.change_id,
+      payload: { workflow_id: id, kind: run.kind, blockers },
+    });
+    return {
+      workflow: readWorkflow(db, id, { rootDir }),
+      blockers,
+      ready: blockers.length === 0,
+    };
+  });
+}
+
+function reopenWorkflowDraft(db, input = {}, { rootDir = process.cwd() } = {}) {
+  const id = nonEmpty(input.id, 'id');
+  const blocker = typeof input.blocker === 'string' && input.blocker.trim()
+    ? input.blocker.trim()
+    : 'CHECKPOINT_REJECTED';
+  return ops.tx(db, () => {
+    const run = readWorkflow(db, id, { rootDir });
+    if (!run) throw new WorkflowStateError('WORKFLOW_NOT_FOUND', `workflow ${id} not found`);
+    if (run.status === 'completed' || run.status === 'cancelled') return run;
+    const metadata = { ...run.metadata, draft_dirty: true };
+    delete metadata.authority_invalidation;
+    const blockers = [...new Set([...(run.blockers || []), blocker])];
+    db.prepare(
+      `UPDATE workflow_runs
+       SET status = 'active', blockers_json = ?, metadata_json = ?,
+           updated_at = ?
+       WHERE id = ?`,
+    ).run(JSON.stringify(blockers), JSON.stringify(metadata), nowIso(), id);
+    return readWorkflow(db, id, { rootDir });
+  });
+}
+
 function reviseWorkflow(db, input = {}, { rootDir = process.cwd() } = {}) {
   const id = nonEmpty(input.id, 'id');
   const replacementId = nonEmpty(input.replacement_id, 'replacement_id');
@@ -2948,6 +3109,9 @@ module.exports = {
   WorkflowStateError,
   insertWorkflowInTx,
   startWorkflow,
+  abandonWorkflow,
+  prepareWorkflowCheckpoint,
+  reopenWorkflowDraft,
   readWorkflow,
   listWorkflows,
   recordWorkflowStep,

package/mcp-server/server.cjs

@@ -22,6 +22,7 @@ const {
 const { assertStateAuthority } = require('./lib/state-authority.cjs');
 const ops = require('./lib/state-ops.cjs');
 const projector = require('./lib/projector.cjs');
+const taskLedger = require('./lib/task-ledger.cjs');
 const telemetry = require('./lib/telemetry.cjs');
 const topo = require('./lib/topo.cjs');
 const parser = require('./lib/prd-parser.cjs');
@@ -38,6 +39,7 @@ const workflows = require('./lib/workflow-state.cjs');
 const decisions = require('./lib/decision-dialogue.cjs');
 const doctor = require('./lib/doctor.cjs');
 const artifactRegistry = require('./lib/artifact-registry.cjs');
+const ultraFacade = require('./lib/ultra-facade.cjs');
 const {
   readProjectBreadcrumb,
   renderProjectBreadcrumb,
@@ -62,6 +64,9 @@ const TASK_TOOLS = Object.freeze([
   'task.dependency_topo',
   'task.parse_prd',
   'task.expand',
+  'task.ledger_get',
+  'task.ledger_publish',
+  'task.ledger_import',
 ]);
 
 const SESSION_TOOLS = Object.freeze([
@@ -133,21 +138,32 @@ const ARTIFACT_TOOLS = Object.freeze([
   'artifact.get',
 ]);
 
-const REGISTERED_TOOLS = Object.freeze([
+const LEGACY_TOOLS = Object.freeze([
   ...TASK_TOOLS, ...SESSION_TOOLS, ...PLAN_TOOLS, ...BASELINE_TOOLS, ...CHANGE_TOOLS,
   ...DECISION_TOOLS,
   ...WORKFLOW_TOOLS,
   ...ARTIFACT_TOOLS,
   ...SYSTEM_TOOLS,
 ]);
+const PUBLIC_TOOLS = ultraFacade.PUBLIC_TOOLS;
+const REGISTERED_TOOLS = Object.freeze([...PUBLIC_TOOLS, ...LEGACY_TOOLS]);
 
 const STATELESS_TOOLS = new Set(['task.init_project']);
 
+function isStatelessPublicCall(name, input = {}) {
+  return name === 'ultra.record'
+    && Array.isArray(input.entries)
+    && input.entries.length === 1
+    && input.entries[0]?.operation === 'task.init_project';
+}
+
 // init_project owns its target project's schema, baseline seed, and first
 // projection internally. Do not enqueue a second projection on the caller DB.
 const MUTATING_TOOLS = new Set([
+  'ultra.record', 'ultra.checkpoint', 'ultra.sync', 'ultra.session', 'ultra.archive',
   'task.create', 'task.update', 'task.delete', 'task.append_event', 'task.switch_tag',
   'task.parse_prd', 'task.expand',
+  'task.ledger_import',
   'session.spawn', 'session.close', 'session.heartbeat',
   'plan.export',
   'baseline.start', 'baseline.record', 'baseline.converge',
@@ -161,6 +177,15 @@ const MUTATING_TOOLS = new Set([
   'artifact.record',
 ]);
 
+const TEAM_LEDGER_SYNC_TOOLS = new Set([
+  'ultra.record', 'ultra.checkpoint', 'ultra.archive',
+  'task.create', 'task.update', 'task.delete', 'task.parse_prd', 'task.expand',
+  'plan.export',
+  'baseline.start', 'baseline.record', 'baseline.converge',
+  'change.create', 'change.update', 'change.delta', 'change.documentation_reconcile',
+  'change.converge', 'change.archive',
+]);
+
 function loadRegisteredTools() {
   const manifest = yaml.load(fs.readFileSync(TOOLS_FILE, 'utf8'));
   return manifest.tools.filter((t) => REGISTERED_TOOLS.includes(t.name));
@@ -184,7 +209,18 @@ async function dispatchTool(name, input, db, ctx = {}) {
       return { id: task.id, status: task.status, created_at: task.created_at };
     }
     case 'task.update': {
+      const before = ops.readTask(db, input.id);
       const task = ops.patchTask(db, input.id, input.patch || {});
+      const durableChanged = before
+        && taskLedger.durableTask(before).digest !== taskLedger.durableTask(task).digest;
+      if (durableChanged) {
+        taskLedger.publishTaskLedger(db, {
+          rootDir: ctx.rootDir || process.cwd(),
+          reason: before.status !== task.status
+            ? `task_${task.status}`
+            : 'task_contract_updated',
+        });
+      }
       return { ok: true, task };
     }
     case 'task.list': {
@@ -201,7 +237,12 @@ async function dispatchTool(name, input, db, ctx = {}) {
       return { task };
     }
     case 'task.delete': {
-      return ops.deleteTask(db, input.id, { force: !!input.force });
+      const result = ops.deleteTask(db, input.id, { force: !!input.force });
+      taskLedger.publishTaskLedger(db, {
+        rootDir: ctx.rootDir || process.cwd(),
+        reason: 'task_deleted',
+      });
+      return result;
     }
     case 'task.init_project': {
       return initProject(input);
@@ -411,8 +452,58 @@ async function dispatchTool(name, input, db, ctx = {}) {
         children: input.children,
         rootDir,
       });
+      taskLedger.publishTaskLedger(db, {
+        rootDir,
+        reason: 'task_expanded',
+      });
       return { parent_id: result.parent_id, children: result.children };
     }
+    case 'task.ledger_get': {
+      const rootDir = ctx.rootDir || process.cwd();
+      return {
+        ledger: taskLedger.readTaskLedger(rootDir),
+        health: taskLedger.inspectTaskLedger(db, { rootDir }),
+      };
+    }
+    case 'task.ledger_publish': {
+      const result = taskLedger.publishTaskLedger(db, {
+        rootDir: ctx.rootDir || process.cwd(),
+        reason: input.reason || 'manual_checkpoint',
+      });
+      const output = {
+        changed: result.changed,
+        path: path.relative(ctx.rootDir || process.cwd(), result.path),
+        generation: result.ledger.generation,
+        state_digest: result.ledger.state_digest,
+      };
+      if (result.migrated_legacy_projection) {
+        output.migrated_legacy_projection = true;
+        output.legacy_backup_path = path.relative(
+          ctx.rootDir || process.cwd(),
+          result.legacy_backup_path,
+        );
+      }
+      return output;
+    }
+    case 'task.ledger_import': {
+      const result = taskLedger.importTaskLedger(db, {
+        rootDir: ctx.rootDir || process.cwd(),
+      });
+      return {
+        imported: result.imported,
+        preserved: result.preserved,
+        deleted: result.deleted,
+        imported_changes: result.imported_changes,
+        preserved_changes: result.preserved_changes,
+        imported_baseline: result.imported_baseline,
+        preserved_baseline: result.preserved_baseline,
+        generation: result.generation,
+        state_digest: result.state_digest,
+        requires_plan_revalidation: result.requires_plan_revalidation,
+        requires_baseline_revalidation: result.requires_baseline_revalidation,
+        already_current: result.already_current,
+      };
+    }
     case 'plan.export': {
       const rootDir = ctx.rootDir || process.cwd();
       const change = changes.readChange(db, input.change_id);
@@ -626,21 +717,42 @@ async function dispatchTool(name, input, db, ctx = {}) {
       };
     }
     case 'baseline.converge': {
-      return baselines.convergeBaseline(
+      const result = baselines.convergeBaseline(
         db, input, { rootDir: ctx.rootDir || process.cwd() },
       );
+      if (result.ready) {
+        taskLedger.publishTaskLedger(db, {
+          rootDir: ctx.rootDir || process.cwd(),
+          reason: 'baseline_converged',
+        });
+      }
+      return result;
     }
     case 'change.create': {
       const { randomUUID } = require('node:crypto');
       const id = input.id || `chg-${randomUUID().slice(0, 12)}`;
-      return changes.createChange(db, { ...input, id }, { rootDir: ctx.rootDir || process.cwd() });
+      const result = changes.createChange(
+        db,
+        { ...input, id },
+        { rootDir: ctx.rootDir || process.cwd() },
+      );
+      taskLedger.publishTaskLedger(db, {
+        rootDir: ctx.rootDir || process.cwd(),
+        reason: 'change_created',
+      });
+      return result;
     }
     case 'change.update': {
+      const change = changes.updateChange(
+        db, input.id, input.patch || {}, { rootDir: ctx.rootDir || process.cwd() },
+      );
+      taskLedger.publishTaskLedger(db, {
+        rootDir: ctx.rootDir || process.cwd(),
+        reason: 'change_updated',
+      });
       return {
         ok: true,
-        change: changes.updateChange(
-          db, input.id, input.patch || {}, { rootDir: ctx.rootDir || process.cwd() },
-        ),
+        change,
       };
     }
     case 'change.get': {
@@ -691,10 +803,24 @@ async function dispatchTool(name, input, db, ctx = {}) {
       };
     }
     case 'change.converge': {
-      return changes.convergeChange(db, input, { rootDir: ctx.rootDir || process.cwd() });
+      const result = changes.convergeChange(
+        db, input, { rootDir: ctx.rootDir || process.cwd() },
+      );
+      taskLedger.publishTaskLedger(db, {
+        rootDir: ctx.rootDir || process.cwd(),
+        reason: 'change_converged',
+      });
+      return result;
     }
     case 'change.archive': {
-      return changes.archiveChange(db, input, { rootDir: ctx.rootDir || process.cwd() });
+      const result = changes.archiveChange(
+        db, input, { rootDir: ctx.rootDir || process.cwd() },
+      );
+      taskLedger.publishTaskLedger(db, {
+        rootDir: ctx.rootDir || process.cwd(),
+        reason: 'change_archived',
+      });
+      return result;
     }
     case 'change.delta': {
       return changes.recordDelta(db, input, { rootDir: ctx.rootDir || process.cwd() });
@@ -851,6 +977,19 @@ function startServer({
   };
   const getDb = (toolName = null) => {
     if (!db) {
+      if (toolName === 'ultra.context') {
+        if (!fs.existsSync(authorityDbPath)) {
+          const error = new Error(
+            'Ultra authority is not initialized; invoke ultra-init before reading project context',
+          );
+          error.code = 'STATE_DB_MISSING';
+          throw error;
+        }
+        db = openStateDb(authorityDbPath);
+        ensureSchemaVersion(db);
+        assertStateAuthority(db, rootDir, { importTeamLedger: false });
+        return db;
+      }
       const projectPaths = runtimePaths.pathsFor(rootDir);
       if ([projectPaths.legacyStateDbPath, projectPaths.stateDbPath].includes(authorityDbPath)) {
         // The packaged launcher has no explicit DB override. Its default path
@@ -874,9 +1013,20 @@ function startServer({
         });
       }
       db = initStateDb(authorityDbPath).db;
+      const teamSync = assertStateAuthority(db, rootDir, { importTeamLedger: true });
+      if (teamSync?.status === 'imported') {
+        runtimeState.enqueueProjection(db, {
+          tool_name: 'task.ledger_import',
+        });
+        runtimeState.processProjectionJobs(db, {
+          rootDir,
+          project,
+          limit: 500,
+        });
+      }
       planRecovery = planStore.recoverPlanPublications(db, { rootDir });
     }
-    if (toolName !== 'system.doctor'
+      if (!['system.doctor', 'ultra.doctor'].includes(toolName)
       && (planRecovery?.pending > 0 || planRecovery?.issues?.length > 0)) {
       planRecovery = planStore.recoverPlanPublications(db, { rootDir });
       if (planRecovery.pending > 0 || planRecovery.issues.length > 0) {
@@ -892,6 +1042,7 @@ function startServer({
   };
 
   const tools = loadRegisteredTools();
+  const publicTools = tools.filter((tool) => PUBLIC_TOOLS.includes(tool.name));
   const ajv = buildAjv();
   const inputValidators = new Map();
   const outputValidators = new Map();
@@ -906,7 +1057,7 @@ function startServer({
   );
 
   server.setRequestHandler('tools/list', async () => ({
-    tools: tools.map((t) => ({
+    tools: publicTools.map((t) => ({
       name: t.name,
       description: t.description,
       inputSchema: t.input_schema,
@@ -952,20 +1103,51 @@ function startServer({
     let result;
     let toolDb = null;
     try {
-      toolDb = STATELESS_TOOLS.has(name) ? null : getDb(name);
+      toolDb = (STATELESS_TOOLS.has(name) || isStatelessPublicCall(name, args))
+        ? null
+        : getDb(name);
       if (toolDb) assertStateAuthority(toolDb, rootDir);
-      result = await dispatchTool(
-        name,
-        args,
-        toolDb,
-        {
-          rootDir,
-          sessionId,
-          projector: project,
-          markPlanRecoveryRequired,
-        },
-      );
-      if (name === 'system.doctor' && args.repair === true) {
+      if (toolDb && TEAM_LEDGER_SYNC_TOOLS.has(name)) {
+        taskLedger.syncTaskLedger(toolDb, { rootDir });
+      }
+      const callContext = {
+        rootDir,
+        sessionId,
+        projector: project,
+        markPlanRecoveryRequired,
+      };
+      const callLegacy = async (legacyName, legacyArgs = {}) => {
+        if (!LEGACY_TOOLS.includes(legacyName)) {
+          const error = new Error(`legacy operation ${legacyName} is not supported`);
+          error.code = 'ULTRA_RECORD_OPERATION_UNSUPPORTED';
+          throw error;
+        }
+        const validateLegacyInput = inputValidators.get(legacyName);
+        if (!validateLegacyInput(legacyArgs)) {
+          const error = new Error(ajv.errorsText(validateLegacyInput.errors));
+          error.code = 'VALIDATION_ERROR';
+          error.details = validateLegacyInput.errors;
+          throw error;
+        }
+        const legacyResult = await dispatchTool(
+          legacyName,
+          legacyArgs,
+          toolDb,
+          callContext,
+        );
+        const validateLegacyOutput = outputValidators.get(legacyName);
+        if (!validateLegacyOutput(legacyResult)) {
+          const error = new Error(ajv.errorsText(validateLegacyOutput.errors));
+          error.code = 'OUTPUT_SCHEMA_DRIFT';
+          error.details = validateLegacyOutput.errors;
+          throw error;
+        }
+        return legacyResult;
+      };
+      result = PUBLIC_TOOLS.includes(name)
+        ? await ultraFacade.dispatch(name, args, toolDb, { ...callContext, callLegacy })
+        : await dispatchTool(name, args, toolDb, callContext);
+      if (['system.doctor', 'ultra.doctor'].includes(name) && args.repair === true) {
         planRecovery = result.repair?.plan_publications || null;
       }
     } catch (err) {
@@ -976,7 +1158,11 @@ function startServer({
     }
 
     let runtimeMeta = null;
-    if (toolDb && projectOnWrite && MUTATING_TOOLS.has(name)) {
+    const shouldProject = toolDb
+      && projectOnWrite
+      && MUTATING_TOOLS.has(name)
+      && !(name === 'task.ledger_import' && result.already_current === true);
+    if (shouldProject) {
       const job = runtimeState.enqueueProjection(toolDb, { tool_name: name });
       const processed = runtimeState.processProjectionJobs(toolDb, { rootDir, project, limit: 500 });
       const own = processed.jobs.find((item) => item.id === job.id);
@@ -986,7 +1172,7 @@ function startServer({
         projection_job_id: job.id,
       };
       if (own && own.incident_id) runtimeMeta.incident_id = own.incident_id;
-    } else if (toolDb && name === 'system.doctor' && args.repair === true) {
+    } else if (toolDb && ['system.doctor', 'ultra.doctor'].includes(name) && args.repair === true) {
       runtimeMeta = {
         state_commit: 'committed',
         projection_status: result.checks.projections.status === 'pass' ? 'completed' : 'failed',
@@ -1124,6 +1310,8 @@ module.exports = {
   ARTIFACT_TOOLS,
   SYSTEM_TOOLS,
   REGISTERED_TOOLS,
+  LEGACY_TOOLS,
+  PUBLIC_TOOLS,
   STATELESS_TOOLS,
   MUTATING_TOOLS,
   appendHookLifecycleEvent,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ultra-builder-pro-cli",
-  "version": "0.21.1",
+  "version": "0.23.0",
   "description": "Explicitly invoked Ultra Builder Pro workflows for Claude Code, OpenCode, Codex CLI, and Kimi Code, with project-local MCP authority and lifecycle recovery.",
   "bin": {
     "ultra-builder-pro-cli": "bin/install.js",