@kal-elsam/kairo-runtime 0.18.0 → 0.20.0

package/CHANGELOG.md

@@ -5,6 +5,47 @@ Historical entries below may reference the legacy `@kal-elsam/harness` package n
 
 ## Unreleased
 
+## 0.20.0 — 2026-09-18 (Kairo Runtime)
+
+Minor release. Promotes Cursor to a real automatic execution provider.
+
+### Changed
+
+- Cursor's accessMode flips from "manual" to "automatic"
+  (`model-candidate-catalog.js`). Its own execution adapter already
+  builds a real, auditable non-interactive launch (`cursor-agent -p
+  --output-format stream-json`) and parses its structured event stream
+  — the same shape as Codex/Claude, and an officially documented,
+  supported use of the Cursor CLI. Real task routing now judges Cursor
+  by the exact same launchable/eligibility gate as Codex/Claude, for
+  both execution and recommendations — no more special-cased
+  manual-only rejection in `execution-router.js`'s `checkCandidate`.
+- Cursor's own opaque "auto" router model still stays manual (its
+  identity is non-deterministic, unlike a named model). OpenCode Go is
+  unaffected — it remains manual for its own, real, already-confirmed
+  Go/Zen billing-attribution ambiguity.
+
+## 0.19.0 — 2026-09-18 (Kairo Runtime)
+
+Patch-level polish on top of 0.18.0's PROJECT TEAM work: fixes the
+provider column's alignment and adds a way back to the interactive
+analyst picker once a strategy already exists.
+
+### Added
+
+- `r` key inside the `/project` overlay (RESULT/ACTIVE/STALE states)
+  forces a genuinely fresh analysis, landing back on the real
+  interactive analyst picker — previously only reachable on a
+  project's very first `/project` run.
+
+### Fixed
+
+- The PROJECT TEAM view's provider column (`CockpitView.teamRoleLabel()`)
+  now pads every row's model name to a shared width
+  (`teamModelColumnWidth()`), so the " · Provider" separator lines up
+  across rows regardless of how much individual model names vary in
+  length.
+
 ## 0.18.0 — 2026-09-18 (Kairo Runtime)
 
 Minor release. Provider visibility and quota-aware improvements to the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kal-elsam/kairo-runtime",
-  "version": "0.18.0",
+  "version": "0.20.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/cockpit/project-overlay.js

@@ -40,14 +40,15 @@ const overlayFrameTheme = {
   fg: (role, text) => theme.fg(role === "border" ? "info" : role, text)
 };
 
-function teamLines(label, team, aiTeamLabel, tone = "bold") {
+function teamLines(label, team, view, tone = "bold") {
   const lines = [tone === "bold" ? theme.bold(label) : theme.fg("muted", label)];
   if (!team?.length) {
     lines.push(theme.fg("muted", "  (no active roles)"));
     return lines;
   }
+  const modelColumnWidth = view.teamModelColumnWidth(team.map((entry) => entry.model));
   for (const entry of team) {
-    const modelText = entry.model ? aiTeamLabel(entry.model) : theme.fg("warning", "no eligible option");
+    const modelText = entry.model ? view.teamRoleLabel(entry.model, modelColumnWidth) : theme.fg("warning", "no eligible option");
     lines.push(theme.fg("muted", `  ${entry.role.padEnd(10)} ${modelText}`));
   }
   return lines;
@@ -174,6 +175,23 @@ export class ProjectOverlay {
     this.requestRender();
   }
 
+  /**
+   * Forces a genuinely fresh analysis — the ONLY way back to the real
+   * interactive analyst-picker (SELECT_ANALYST) once a SUGGESTED/ACTIVE/
+   * STALE strategy already exists (the constructor's own existing-strategy
+   * shortcut otherwise always wins). Discards the held suggested/active
+   * strategy in memory only — nothing persisted is touched until a new
+   * choice is confirmed and a new /project approve happens; the previous
+   * real strategy stays exactly as persisted if the human backs out
+   * (Esc from SELECT_ANALYST) before confirming anything.
+   */
+  reanalyze() {
+    this.suggestedStrategy = null;
+    this.activeStrategy = null;
+    this.resultSelectList = null;
+    void this.loadPreflight();
+  }
+
   /** A short, honest label for a catalog entry's own real recommendationTags/evidenceStatus — never a fabricated "Quality"/"Efficient" claim for a model that doesn't actually carry that tag. */
   static tagLabel(model) {
     if (model.evidenceStatus === "unscored") return "Unscored";
@@ -269,8 +287,9 @@ export class ProjectOverlay {
    */
   buildResultRoleList() {
     const team = this.suggestedStrategy?.projectTeam ?? [];
+    const modelColumnWidth = this.view.teamModelColumnWidth(team.map((entry) => entry.model));
     const items = team.map((entry) => {
-      const modelText = entry.model ? this.view.teamRoleLabel(entry.model) : "no eligible option";
+      const modelText = entry.model ? this.view.teamRoleLabel(entry.model, modelColumnWidth) : "no eligible option";
       const overrideNote = entry.assignmentSource === "override" ? theme.fg("accent", " (override)") : "";
       // Role + model are the real primary information here — explicit
       // `text` color, never left to default/muted.
@@ -458,11 +477,19 @@ export class ProjectOverlay {
       // edits the highlighted role instead. Enter must never silently
       // approve just because a role row happens to be focused.
       if (data === "a" || data === "A") return void this.approve();
+      // "r" forces a genuinely fresh analysis (re-picks the analyst from
+      // scratch) — distinct from editing one role's model (Enter) or
+      // approving the current suggestion (a) — see reanalyze()'s own doc.
+      if (data === "r" || data === "R") return void this.reanalyze();
       this.resultSelectList.handleInput(data);
       this.requestRender();
       return;
     }
 
+    if ((this.state === S.ACTIVE || this.state === S.STALE) && (data === "r" || data === "R")) {
+      return void this.reanalyze();
+    }
+
     if (this.state === S.EDIT_MODEL_SEARCH) {
       if (matchesKey(data, Key.escape) || matchesKey(data, Key.esc)) {
         this.state = S.RESULT;
@@ -533,7 +560,6 @@ export class ProjectOverlay {
     // isn't a modal boundary a human eye reliably notices.
     const box = new Box(2, 1);
     this.box = box;
-    const aiTeamLabel = (model) => this.view.teamRoleLabel(model);
     // Text defaults to one blank row above and below every child; inside
     // a framed modal that inflated the height until pi-tui clipped the
     // bottom border. Keep spacing explicit and compact instead.
@@ -594,9 +620,9 @@ export class ProjectOverlay {
         // Quality/Efficient stay real, comparative REFERENCE — muted, and
         // rendered strictly below the real operational PROJECT TEAM list
         // above, never replacing it visually.
-        for (const line of teamLines("Quality (reference)", strategy.qualityTeam, aiTeamLabel, "muted")) push(line);
-        for (const line of teamLines("Efficient (reference)", strategy.efficientTeam, aiTeamLabel, "muted")) push(line);
-        push(theme.fg("muted", "Enter edit role · a approve & activate · Esc close without approving"));
+        for (const line of teamLines("Quality (reference)", strategy.qualityTeam, this.view, "muted")) push(line);
+        for (const line of teamLines("Efficient (reference)", strategy.efficientTeam, this.view, "muted")) push(line);
+        push(theme.fg("muted", "Enter edit role · a approve & activate · r re-analyze from scratch · Esc close without approving"));
         break;
       }
       case S.EDIT_LOADING:
@@ -645,16 +671,16 @@ export class ProjectOverlay {
         const strategy = this.activeStrategy;
         push(theme.fg("success", "ACTIVE"));
         push(theme.fg("muted", `Approved ${strategy.approvedAt ?? "?"}`));
-        for (const line of teamLines("PROJECT TEAM", strategy.projectTeam ?? strategy.qualityTeam, aiTeamLabel)) push(line);
-        push(theme.fg("muted", "Esc close"));
+        for (const line of teamLines("PROJECT TEAM", strategy.projectTeam ?? strategy.qualityTeam, this.view)) push(line);
+        push(theme.fg("muted", "r re-analyze from scratch · Esc close"));
         break;
       }
       case S.STALE: {
         const strategy = this.activeStrategy;
         push(theme.fg("warning", "STALE"));
         push(theme.fg("muted", "The real project evidence has changed since this team was approved — previous assignments are kept until refreshed."));
-        for (const line of teamLines("PROJECT TEAM (previous)", strategy.projectTeam ?? strategy.qualityTeam, aiTeamLabel)) push(line);
-        push(theme.fg("muted", "Enter refresh · Esc close"));
+        for (const line of teamLines("PROJECT TEAM (previous)", strategy.projectTeam ?? strategy.qualityTeam, this.view)) push(line);
+        push(theme.fg("muted", "Enter refresh · r re-analyze from scratch · Esc close"));
         break;
       }
       case S.ERROR:

package/src/global/cockpit/view.js

@@ -576,8 +576,12 @@ export class CockpitView {
       };
     }
     const lines = [];
-    if (strategy.bootstrapAnalyst) lines.push(`${"Project Analyst".padEnd(18)} ${this.teamRoleLabel(strategy.bootstrapAnalyst)}`);
-    if (strategy.orchestrator) lines.push(`${"Orchestrator".padEnd(18)} ${this.teamRoleLabel(strategy.orchestrator)}`);
+    const projectTeam = strategy.projectTeam ?? strategy.qualityTeam ?? [];
+    const modelColumnWidth = this.teamModelColumnWidth([
+      strategy.bootstrapAnalyst, strategy.orchestrator, ...projectTeam.map((entry) => entry.model)
+    ]);
+    if (strategy.bootstrapAnalyst) lines.push(`${"Project Analyst".padEnd(18)} ${this.teamRoleLabel(strategy.bootstrapAnalyst, modelColumnWidth)}`);
+    if (strategy.orchestrator) lines.push(`${"Orchestrator".padEnd(18)} ${this.teamRoleLabel(strategy.orchestrator, modelColumnWidth)}`);
     // The real OPERATIONAL team (see buildProjectStrategy's own doc) —
     // never qualityTeam, which is comparative reference only. The overlay
     // (project-overlay.js) already shows projectTeam under this exact
@@ -585,8 +589,8 @@ export class CockpitView {
     // same label was the real, reported mismatch. qualityTeam only
     // remains as a fallback for a strategy persisted before projectTeam
     // existed (see applyProjectTeamOverride's own legacy-entry comment).
-    for (const entry of strategy.projectTeam ?? strategy.qualityTeam ?? []) {
-      lines.push(`${entry.role.padEnd(18)} ${entry.model ? this.teamRoleLabel(entry.model) : theme.fg("warning", "no eligible option")}`);
+    for (const entry of projectTeam) {
+      lines.push(`${entry.role.padEnd(18)} ${entry.model ? this.teamRoleLabel(entry.model, modelColumnWidth) : theme.fg("warning", "no eligible option")}`);
     }
     if (strategy.status === "suggested") lines.push(theme.fg("muted", "Suggested from real project analysis. Use /project approve to activate."));
     if (strategy.status === "stale") lines.push(theme.fg("warning", "Real evidence changed since approval — use /project refresh."));
@@ -764,10 +768,29 @@ export class CockpitView {
    * actually run against — two roles can land on visually similar model
    * names from different providers, and knowing which subscription a role
    * draws from is exactly what a real, provider-aware team review needs.
+   *
+   * `modelColumnWidth` left-pads the model name so every row's " · Provider"
+   * lines up in its own column instead of drifting with each model name's
+   * own length — see `CockpitView.teamModelColumnWidth()`, which a caller
+   * computes once across the real rows it's about to render and passes
+   * here for every row in that same list.
+   * @param {object} model
+   * @param {number} [modelColumnWidth]
    */
-  teamRoleLabel(model) {
+  teamRoleLabel(model, modelColumnWidth = 0) {
     const provider = model.adapterId.charAt(0).toUpperCase() + model.adapterId.slice(1);
-    return `${this.aiTeamLabel(model)}  ·  ${provider}`;
+    return `${this.aiTeamLabel(model).padEnd(modelColumnWidth)}  ·  ${provider}`;
+  }
+
+  /**
+   * The real model-name column width for a set of rows about to be
+   * rendered with `teamRoleLabel()` — the longest real, cleaned model
+   * name among them, never a fixed guess (model names vary wildly in
+   * length, e.g. "GPT-5.6-Terra" vs "Muse Spark 1.3 1M Extra High").
+   * @param {Array<object|null|undefined>} models
+   */
+  teamModelColumnWidth(models) {
+    return models.reduce((max, model) => (model ? Math.max(max, this.aiTeamLabel(model).length) : max), 0);
   }
 
   /**
@@ -1235,7 +1258,7 @@ export class CockpitView {
       `Claude   ${claudeText}`,
       `Go       ${goText}`,
       `Zen      ${zenText}`,
-      `Cursor   ${entry("Cursor", "MANUAL · usage unknown")}`
+      `Cursor   ${entry("Cursor", "READY · usage unknown")}`
     ];
   }
 

package/src/global/conversation/service.js

@@ -496,8 +496,8 @@ export function createConversationService(deps = {}) {
         // scoredAllRaw directly, so an old generation Cursor still
         // re-exposes (e.g. Claude Sonnet 4) naturally stops competing
         // without buildAiTeam/buildEfficientTeam's own ranking logic
-        // needing to know why. Manual-only real candidates (Cursor,
-        // OpenCode Go) stay in it — this is "what Kairo can honestly
+        // needing to know why. Manual-only real candidates (OpenCode Go,
+        // and Cursor's own opaque "auto" router model) stay in it — this is "what Kairo can honestly
         // recommend", not "what Kairo can launch by itself".
         const scoredAll = buildRecommendationPool(scoredAllRaw, completeCandidateCatalog);
         // The Automatic Execution Pool: the real subset of scoredAll

package/src/global/intelligence/execution-router.js

@@ -156,40 +156,32 @@ export const LOW_QUOTA_WARN_PERCENT = 20;
  *   have the model via the Go subscription — without claiming Kairo can
  *   safely auto-execute through it yet (see opencode.js's checkAvailability
  *   for why: no per-event way to prove a run didn't silently bill Zen).
- *   It also lets Cursor be named as a real recommendation (e.g. Builder ->
- *   Cursor Composer 2.5) even though Kairo never auto-executes through it —
- *   the user continues that work manually inside the Cursor IDE; this is
- *   permanent for Cursor, not a temporary safety gap like opencode-go's.
- *   Real task routing (selectExecutionProvider/selectAskProvider) always
- *   uses the default `true` — it must never pick something guaranteed to
- *   fail at launch (run-manager.js's own launchable gate would reject it).
+ *   Cursor no longer needs this exemption: its own execution adapter
+ *   (execution-adapters/cursor.js) builds a real, auditable non-interactive
+ *   launch and Cursor's own docs support headless/CI use, so real task
+ *   routing now judges it exactly like Codex/Claude — same launchable gate,
+ *   no special case. Real task routing (selectExecutionProvider/
+ *   selectAskProvider) always uses the default `true` — it must never pick
+ *   something guaranteed to fail at launch (run-manager.js's own
+ *   launchable gate would reject it).
  */
 export function checkCandidate(adapterId, { adapters, codexUsage, claudeUsage, opencodeGoUsage, cursorManualQuota }, { requireLaunchable = true } = {}) {
   // Zen carries real PAYG/billing risk (see conversation/service.js's
   // capabilities.openCodeExecution) — never an automatic pick, regardless
   // of what its real catalog/benchmarks might otherwise say.
   if (adapterId === "opencode-zen") return { ok: false, reason: "OpenCode Zen is excluded from automatic routing (PAYG risk)" };
-  // Cursor is a deliberate manual-only destination for real task
-  // execution — recommendation and execution are different capabilities
-  // (see model-intelligence.js's role assignments): Kairo can genuinely
-  // recommend a real Cursor model for a role (Builder -> Cursor Composer
-  // 2.5, say), the same requireLaunchable:false exception opencode-go
-  // already gets below, but real task routing (requireLaunchable: true,
-  // the default) always refuses it — the user continues that work
-  // manually inside the Cursor IDE, never an automatic Kairo-launched run.
-  if (adapterId === "cursor" && requireLaunchable) {
-    return { ok: false, reason: "Cursor is manual-only — continue the work in the Cursor IDE, never auto-executed by Kairo" };
-  }
 
   const adapter = findAdapter(adapterId, adapters);
   if (!adapter) return { ok: false, reason: `${adapterId}: no adapter found` };
   if (!adapter.available) return { ok: false, reason: adapter.reason ?? `${adapterId}: not available` };
   // "launchable" means safe for Kairo to invoke programmatically — not the
-  // bar a manual recommendation needs. Cursor gets the same exemption
-  // opencode-go already has: real availability is enough to recommend it,
-  // even though (unlike opencode-go) it's exempt from launchable for a
-  // structurally different reason — it will NEVER be launchable, by design.
-  const launchableRequired = requireLaunchable || (adapterId !== "opencode-go" && adapterId !== "cursor");
+  // bar a manual recommendation needs. OpenCode Go alone keeps the
+  // exemption: real availability is enough to recommend it, even though
+  // Kairo can't safely auto-execute through it yet (unresolved Go/Zen
+  // billing-attribution gap — see opencode.js). Cursor no longer needs
+  // this exemption — its real launchability is judged the same way for
+  // both recommendation and execution now.
+  const launchableRequired = requireLaunchable || adapterId !== "opencode-go";
   if (launchableRequired && !adapter.launchable) return { ok: false, reason: adapter.reason ?? `${adapterId}: not launchable yet` };
 
   if (adapterId === "codex") {
@@ -209,11 +201,10 @@ export function checkCandidate(adapterId, { adapters, codexUsage, claudeUsage, o
     if (limited) return { ok: false, reason: `OpenCode Go ${limited.name} window is rate-limited` };
   }
   // Cursor: only ever the human's own last word (see this function's own
-  // doc) — never fabricated from a guess. Checked here, after the
-  // requireLaunchable-gated manual-only return above, so it only ever
-  // takes effect on the recommendation path (requireLaunchable: false) —
-  // real task routing already refuses Cursor unconditionally regardless
-  // of quota.
+  // doc) — never fabricated from a guess. Applies to BOTH the
+  // recommendation path AND real task routing now that Cursor is a real
+  // automatic candidate — a human-reported "out of credits" must block
+  // an actual launch, not just a suggestion.
   if (adapterId === "cursor" && cursorManualQuota?.manualExhausted) {
     return { ok: false, reason: cursorManualQuota.reason ?? "Cursor marked out of credits (manual, via /project cursor exhausted)" };
   }

package/src/global/intelligence/model-candidate-catalog.js

@@ -39,7 +39,7 @@ import { matchArtificialAnalysisScore } from "./model-intelligence.js";
  * @property {string} modelName - human-readable clean name, with real effort/context/privacy variant tokens stripped (see stripDisplayVariant). Never invented — always derived from the provider's own real displayName.
  * @property {string} rawDisplayName - the provider's own displayName, completely unmodified — the real evidence modelName was derived from. Whatever stripDisplayVariant peeled off (effort/context/privacy tokens) to produce modelName is still visible here, never a separate field: /models --evidence's own "technical detail" is just this string.
  * @property {string} adapterId - "codex" | "claude" | "cursor" | "opencode-go".
- * @property {"automatic"|"manual"} accessMode - whether Kairo can actually launch this candidate itself right now, or whether it's a real, recommendable option the human runs manually (Cursor always; OpenCode Go until its own empirical automatic-execution proof lands — see this module's own doc).
+ * @property {"automatic"|"manual"} accessMode - whether Kairo can actually launch this candidate itself right now, or whether it's a real, recommendable option the human runs manually (Cursor's own "auto" router model always; OpenCode Go until its own empirical automatic-execution proof lands — see this module's own doc). Named Cursor models are automatic.
  * @property {"scored"|"partial"|"unscored"} evidenceStatus - "scored": AA matched this exact model AND reports at least one of intelligenceIndex/codingIndex. "partial": AA matched it but both composite indices are null (real match, thin evidence). "unscored": no confident AA match at all. Never role-specific — see this module's own doc for why.
  * @property {string|null} lineageKey - real, recognized model family/lineage (see LINEAGE_PARSERS) — null when the modelId doesn't match any recognized, conservative pattern. Never guessed.
  * @property {number|null} generation - a real, comparable version number within that lineage — null whenever lineageKey is null.
@@ -285,12 +285,22 @@ function applyLifecycle(catalog) {
 // automatic-execution proof this session's plan calls for
 // (`opencode run -m opencode-go/<model>`, verifying real provider
 // attribution and Go-only consumption) actually runs and passes — see
-// this module's own doc. Cursor is permanently "manual" by design (see
-// execution-router.js's own checkCandidate: real task execution always
-// refuses it, recommendation never does).
-const ACCESS_MODE_BY_ADAPTER = { codex: "automatic", claude: "automatic", cursor: "manual", "opencode-go": "manual" };
+// this module's own doc. Cursor is "automatic": its own execution
+// adapter (execution-adapters/cursor.js) already builds a real,
+// auditable non-interactive launch (`cursor-agent -p --output-format
+// stream-json`) and parses its structured event stream, the exact same
+// shape as Codex/Claude — Cursor's own docs explicitly support this
+// (headless/CI use is an intended, documented capability, not a hack).
+// The earlier "permanent manual" policy predated this adapter being
+// finished and had no technical or billing reason behind it (unlike
+// OpenCode Go's real, confirmed Go/Zen billing-attribution gap above).
+const ACCESS_MODE_BY_ADAPTER = { codex: "automatic", claude: "automatic", cursor: "automatic", "opencode-go": "manual" };
 
 function resolveAccessMode(adapterId, modelId) {
+  // Cursor's own "auto" router picks whichever underlying model it wants
+  // per request — an opaque, non-deterministic identity Kairo can't
+  // attribute to a real scored model, so THIS one candidate stays manual
+  // even though named Cursor models are now real automatic candidates.
   if (adapterId === "cursor" && modelId === "auto") return "manual";
   return ACCESS_MODE_BY_ADAPTER[adapterId] ?? "manual";
 }
@@ -437,8 +447,9 @@ export function buildRecommendationPool(scoredAll, completeCatalog) {
  * The Automatic Execution Pool: the subset of the Recommendation Pool
  * Kairo can actually launch itself, right now — real routing's own
  * candidate source, never QUALITY/EFFICIENT TEAM's. Requires BOTH a real
- * accessMode of "automatic" (Cursor/OpenCode Go are permanently or
- * currently manual — see ModelCandidateIdentity's own doc) AND real,
+ * accessMode of "automatic" (OpenCode Go is currently manual, and
+ * Cursor's own "auto" router model stays manual — see
+ * ModelCandidateIdentity's own doc) AND real,
  * current eligibility (adapter availability, quota, launchability — the
  * exact same `eligibility` object checkCandidate/execution-router.js
  * already compute, reused here rather than reimplemented). Never

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