@kal-elsam/kairo-runtime 0.22.1 → 0.23.1

package/CHANGELOG.md

@@ -5,6 +5,44 @@ Historical entries below may reference the legacy `@kal-elsam/harness` package n
 
 ## Unreleased
 
+## 0.23.1 — 2026-09-18 (Kairo Runtime)
+
+Patch release.
+
+### Fixed
+
+- A plain chat question's action label and any failure message said
+  generic "Asking Kairo" throughout the wait, even though one specific
+  real adapter (Codex or Claude) is what's actually being asked and
+  can actually fail — Kairo is the system, never the one answering.
+  Adds `service.planAsk`, a read-only preview of ASK mode's routing
+  decision (reusing the same cached probes `submitTask` already uses),
+  so the cockpit now names the real provider/model from the start of
+  the wait instead of only leaking it incidentally through a raw error
+  message on failure.
+
+## 0.23.0 — 2026-09-18 (Kairo Runtime)
+
+Minor release. First slice of PROJECT TEAM's automatic model-fallback
+cascade.
+
+### Changed
+
+- When a role's assigned model is unavailable but a real, currently-
+  eligible fallback exists, the cockpit no longer stops for an extra
+  y/n confirm on the substitution. The human already asked for this
+  task to execute now (picked the role, pressed execute) — Kairo runs
+  the real fallback automatically and narrates the substitution into
+  the transcript, so it stays visible without a confirmation prompt.
+  ROUTED, MANUAL_HANDOFF, and WAIT_FOR_PROJECT_TEAM with no real
+  alternative are all unchanged — still explicit confirm steps.
+
+Not yet in this release: showing which model is currently running for
+a role directly in the PROJECT TEAM view, auto-reverting to the
+originally-assigned model once it becomes eligible again, and
+retrying a run that starts on the assigned model and then fails or
+hangs mid-execution.
+
 ## 0.22.1 — 2026-09-18 (Kairo Runtime)
 
 Patch release.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kal-elsam/kairo-runtime",
-  "version": "0.22.1",
+  "version": "0.23.1",
   "description": "Kairo Runtime — local agent operating system for Codex, Cursor, Claude, Pi, Engram, and Graphify.",
   "type": "module",
   "homepage": "https://github.com/Kal-elSam/harness#readme",

package/src/global/cockpit/app.js

@@ -189,6 +189,24 @@ export async function runCockpitApp({
         // handleListInput — 'x' never calls this without one).
         return runAction("Asking PROJECT TEAM who should execute this", async () => {
           const decision = await service.planExecution({ cwd, taskId, role });
+          // WAIT_FOR_PROJECT_TEAM with a real suggested alternative: the
+          // human already explicitly asked for this task to execute now
+          // (picked the role, pressed execute) — the assigned model just
+          // isn't the one that got them there. Kairo runs the real,
+          // currently-eligible fallback automatically, with zero extra
+          // y/n gate, and narrates the substitution into the transcript
+          // so it stays visible even without a confirm prompt. Every
+          // other decision (ROUTED, MANUAL_HANDOFF, or WAIT_FOR_PROJECT_TEAM
+          // with no real alternative) is unchanged — still an explicit
+          // confirm step.
+          if (decision.decision === "WAIT_FOR_PROJECT_TEAM" && decision.confirmationTarget?.selection === "suggested-alternative") {
+            const blockedLabel = decision.blockedAssignment?.model?.displayName ?? decision.blockedAssignment?.model?.modelId ?? decision.blockedAssignment?.provider ?? "the assigned model";
+            const alt = decision.suggestedAlternative;
+            const altLabel = alt?.model?.displayName ?? alt?.model?.modelId ?? "unknown model";
+            pushTranscript("kairo", `${blockedLabel} is unavailable for ${decision.role} — automatically falling back to ${alt?.provider} · ${altLabel}.`);
+            await service.executePlan({ cwd, taskId, confirmationTarget: decision.confirmationTarget });
+            return;
+          }
           view.showExecuteConfirm(taskId, decision);
           // MANUAL_HANDOFF: Kairo can't launch this itself, so the real
           // task text (the exact same one an automatic run would get —
@@ -230,7 +248,7 @@ export async function runCockpitApp({
     });
   }
 
-  editor.onSubmit = (text) => {
+  editor.onSubmit = async (text) => {
     const task = text.trim();
     if (!task) return;
     if (task.startsWith("/")) {
@@ -417,7 +435,38 @@ export async function runCockpitApp({
     // PLAN/AGENT always create a plan (see service.submitTask) — replacing
     // the old isLikelyQuestion guess with what the user explicitly told
     // Kairo they're doing (Shift+Tab / /plan).
-    return runAction("Asking Kairo", async () => {
+    //
+    // Kairo is the system, never the thing actually answering — a real
+    // adapter (Codex, Claude, …) always is, and that real name should be
+    // visible from the moment the wait starts, not just in a successful
+    // result or leaked incidentally through an error message. PLAN/AGENT
+    // is deterministically Codex (see submitArchitecture/createPlan), so
+    // that label needs no extra call; ASK's real provider depends on
+    // current quota/eligibility, so a cheap planAsk preview (the same
+    // routing submitTask itself will use, its probes cached — see
+    // service.js's planAsk doc) resolves it first. A caller that predates
+    // planAsk (or a preview that itself fails) falls back to the old
+    // generic label rather than ever blocking the real submit on it.
+    const mode = view.workMode;
+    let askLabel = "Asking Kairo";
+    if (mode === "plan" || mode === "agent") {
+      askLabel = "Asking Codex to plan";
+    } else {
+      try {
+        const preview = await service.planAsk?.({ cwd, task });
+        if (preview?.decision?.decision === "ROUTED") {
+          const provider = preview.decision.provider;
+          const providerLabel = provider ? provider.charAt(0).toUpperCase() + provider.slice(1) : null;
+          if (providerLabel) {
+            askLabel = `Asking ${providerLabel}${preview.decision.model ? ` · ${preview.decision.model}` : ""}`;
+          }
+        }
+      } catch {
+        // Best-effort label only — a real routing failure still surfaces
+        // through submitTask itself below, never swallowed here.
+      }
+    }
+    return runAction(askLabel, async () => {
       const result = await service.submitTask({ cwd, task, mode: view.workMode });
       if (result.kind === "answer") {
         pushTranscript("kairo", `${result.provider}${result.model ? ` · ${result.model}` : ""}: ${result.answer}`);

package/src/global/conversation/project-router.js

@@ -86,9 +86,13 @@ function blocked(role, strategyFingerprint, why, { blockedAssignment = null, sug
  *    `suggestedAlternative` set to the strategy's own PERSISTED fallback
  *    for this role (see project-strategy.js) when that fallback is
  *    itself currently real-eligible and automatically executable —
- *    otherwise honestly null. Never a silent automatic substitution: the
- *    caller must still explicitly confirm before anything runs on the
- *    suggested alternative.
+ *    otherwise honestly null. This module never launches anything itself
+ *    — it only ever decides what WOULD run — but by explicit, deliberate
+ *    product decision the cockpit caller (app.js's onRequestExecute) does
+ *    treat a real suggestedAlternative as automatically executable once
+ *    the human has already asked for this task to run, narrating the
+ *    substitution into the transcript instead of gating it behind an
+ *    extra y/n prompt.
  * 5. Otherwise -> ROUTED, with the real provider/model/assignmentSource
  *    this role delegates to.
  * @param {object} args

package/src/global/conversation/service.js

@@ -651,12 +651,16 @@ export function createConversationService(deps = {}) {
       return { ...publicPlan(result.status), reused: result.reused === true, projectRoot };
     },
     /**
-     * Real read-only question -> real answer, via whichever provider is
-     * actually available/quota-healthy — no task, no plan, no approval
-     * gate. Throws (never returns a fabricated answer) if no provider can
-     * answer or the call itself fails.
+     * Read-only preview of who ASK mode would actually ask right now —
+     * never calls a provider. Lets a caller (the cockpit's action label)
+     * show the real provider/model BEFORE the potentially slow real call
+     * starts, instead of a generic "Asking Kairo" that stays true no
+     * matter which real provider ends up answering (or timing out).
+     * Cheap to call again right after: the same underlying usage/catalog
+     * probes askQuestion itself uses are cached (see readCodexUsageCached
+     * etc.), so there's no real duplicate provider I/O.
      */
-    async askQuestion({ cwd, task }) {
+    async planAsk({ cwd, task }) {
       const projectRoot = await root(cwd);
       const adapters = inspectAdapters({ cwd: projectRoot });
       let codexUsage = null;
@@ -672,6 +676,16 @@ export function createConversationService(deps = {}) {
         claudeCatalog = readClaudeModelsImpl();
       }
       const decision = routeAsk({ adapters, codexUsage, claudeUsage, catalogs: { codex: codexCatalog, claude: claudeCatalog }, taskText: task });
+      return { decision, projectRoot };
+    },
+    /**
+     * Real read-only question -> real answer, via whichever provider is
+     * actually available/quota-healthy — no task, no plan, no approval
+     * gate. Throws (never returns a fabricated answer) if no provider can
+     * answer or the call itself fails.
+     */
+    async askQuestion({ cwd, task }) {
+      const { decision, projectRoot } = await this.planAsk({ cwd, task });
       if (decision.decision !== "ROUTED") throw new Error(`Cannot answer: ${decision.why}`);
       const result = await askProviderImpl({ provider: decision.provider, question: task, model: decision.model, cwd: projectRoot });
       if (result.status !== "answered") throw new Error(result.error ?? `${decision.provider} gave no answer.`);

package/src/global/observability/codex-models.js

@@ -89,7 +89,7 @@ export async function readCodexModels({
     child.once?.("close", () => { if (!finished) finish(unknown("codex app-server closed before model list")); });
 
     writeRequest(child, 1, "initialize", {
-      clientInfo: { name: "kairo", title: "Kairo", version: "0.22.1" },
+      clientInfo: { name: "kairo", title: "Kairo", version: "0.23.1" },
       capabilities: {}
     });
   });

package/src/global/observability/codex-usage.js

@@ -151,7 +151,7 @@ export async function readCodexUsage({
     child.once?.("close", () => { if (!finished) finish(unknown("codex app-server closed before rate limits")); });
 
     writeRequest(child, 1, "initialize", {
-      clientInfo: { name: "kairo", title: "Kairo", version: "0.22.1" },
+      clientInfo: { name: "kairo", title: "Kairo", version: "0.23.1" },
       capabilities: {}
     });
   });