@kal-elsam/kairo-runtime 0.22.0 → 0.23.0

package/CHANGELOG.md

@@ -5,6 +5,43 @@ Historical entries below may reference the legacy `@kal-elsam/harness` package n
 
 ## Unreleased
 
+## 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.
+
+### Fixed
+
+- Execution links no longer hardcode `provider: "claude"` on every
+  write regardless of which real adapter (Codex, Cursor, OpenCode Go,
+  Claude) actually executed the task. `provider` now mirrors the
+  link's own real `agentId`, matching what `service.js`'s
+  `executionFor` already treated as ground truth at read time. The
+  cockpit reads this field directly for its provider display, so every
+  task's shown execution provider had always silently said "claude"
+  regardless of what actually ran it.
+
 ## 0.22.0 — 2026-09-18 (Kairo Runtime)
 
 Minor release. Promotes OpenCode Go to a real automatic execution

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kal-elsam/kairo-runtime",
-  "version": "0.22.0",
+  "version": "0.23.0",
   "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/architect/architect-store.js

@@ -307,23 +307,41 @@ export async function readExecutionLink(projectRoot, taskId) {
   const stat = await statOrNull(paths.executionPath);
   if (!stat) return null;
   const link = JSON.parse(await readFile(paths.executionPath, "utf8"));
+  // `provider` is real, structural validation only (a non-empty real
+  // string) — never a single hardcoded value. PROJECT TEAM can route a
+  // real task to any real adapter (Codex, Claude, Cursor, OpenCode Go),
+  // and a legacy artifact from before that existed still carries "claude"
+  // for real, so this must accept every real one honestly, never lie
+  // by forcing them all to read back as "claude".
   if (link?.schema !== EXECUTION_SCHEMA || link?.taskId !== taskId
-    || !/^run_[a-z0-9_]+$/.test(link?.runId ?? "") || link?.provider !== "claude") {
+    || !/^run_[a-z0-9_]+$/.test(link?.runId ?? "") || typeof link?.provider !== "string" || link.provider.length === 0) {
     throw new Error(`Invalid execution artifact: ${taskId}`);
   }
   return link;
 }
 
+/**
+ * `provider` always mirrors the link's own real `agentId` — the field a
+ * real caller (executePlan) actually sets, and the one PROJECT TEAM's own
+ * routing decision already named. Never a fabricated or hardcoded value;
+ * a legacy caller that never set agentId falls back to "claude" only
+ * because that's genuinely what every execution WAS before PROJECT TEAM's
+ * multi-provider routing existed — never a guess for real, current data.
+ */
+function resolveExecutionProvider(link) {
+  return link?.agentId ?? link?.provider ?? "claude";
+}
+
 export async function writeExecutionLink(projectRoot, taskId, link) {
   const paths = await prepareTaskDirectory(projectRoot, taskId);
-  const value = { ...link, schema: EXECUTION_SCHEMA, taskId, provider: "claude" };
+  const value = { ...link, schema: EXECUTION_SCHEMA, taskId, provider: resolveExecutionProvider(link) };
   await writeAtomicJson(paths.executionPath, value, { createExclusive: true });
   return value;
 }
 
 export async function updateExecutionLink(projectRoot, taskId, link) {
   const paths = await prepareTaskDirectory(projectRoot, taskId);
-  const value = { ...link, schema: EXECUTION_SCHEMA, taskId, provider: "claude" };
+  const value = { ...link, schema: EXECUTION_SCHEMA, taskId, provider: resolveExecutionProvider(link) };
   await writeAtomicJson(paths.executionPath, value);
   return value;
 }

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 —

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/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.0" },
+      clientInfo: { name: "kairo", title: "Kairo", version: "0.23.0" },
       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.0" },
+      clientInfo: { name: "kairo", title: "Kairo", version: "0.23.0" },
       capabilities: {}
     });
   });