@kal-elsam/kairo-runtime 0.3.1 → 0.4.0

package/README.md

@@ -35,19 +35,22 @@ kairo
 **First run** (no `~/.harness/state.json`): interactive onboarding → safe diagnosis →
 setup with confirmation → full-screen operations cockpit.
 
-**Later runs** (state present): full-screen cockpit with mission control (recommended
-action), navigation, and a system strip. Layout adapts to terminal size:
+**Later runs** (state present): full-screen cockpit Home that explains what Kairo
+does, shows real readiness, and recommends a useful next action. Layout adapts to
+terminal size:
 
 | Mode | Size | Layout |
 |------|------|--------|
-| Wide | ≥100 cols × ≥28 rows | Nav + content + system |
-| Compact | ≥72×20 | Nav + content |
-| Minimal | 60–71 cols or short height | Single panel + nav header |
+| Wide | ≥100 cols × ≥28 rows | Nav + Home/content + system |
+| Compact | ≥72×20 | Nav + Home/content (readiness embedded) |
+| Minimal | 60–71 cols or short height | Selected section + essential readiness/next/recent |
 | Below gate | <60 cols | Explicit TTY fallback (Ink disabled) |
 
-Keys: `↑↓` navigate · `Enter` open · `Esc` back (exit only from Overview) ·
-`R` refresh · `C` cancel run · `?` help. `Tab` switches region only when content
-is interactive (run lists / launch).
+Keys: `↑↓` navigate (selection explanation updates) · `Enter` open ·
+`Esc` back (exit only from Home) · `R` refresh/retry · `C` cancel run · `?` help.
+`Tab` switches region only when content is interactive (run lists / New run).
+
+Navigation labels: Home · Running now · History · Agents · New run · System health.
 
 Respects `NO_COLOR`, `HARNESS_ASCII=1`, and `HARNESS_INK=0`. Status is always labeled
 in text, never color alone.

package/package.json

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

package/scripts/cockpit-smoke.mjs

@@ -9,6 +9,7 @@ import { createFullscreenSession } from "../src/global/ink/fullscreen-session.js
 import {
   buildFooterModel,
   buildHomeMissionModel,
+  buildNavModel,
   buildTopBarModel,
   COCKPIT_NAV,
   COCKPIT_REGIONS
@@ -24,7 +25,7 @@ const root = join(dirname(fileURLToPath(import.meta.url)), "..");
 const require = createRequire(import.meta.url);
 const pkg = require(join(root, "package.json"));
 
-assert.equal(pkg.version, "0.3.1");
+assert.equal(pkg.version, "0.4.0");
 assert.ok(pkg.dependencies["ansi-escapes"]);
 
 assert.equal(resolveLayoutMode({ columns: 120, rows: 40 }), LAYOUT_MODES.WIDE);
@@ -51,14 +52,39 @@ assert.equal(session.enter(), true);
 assert.equal(session.leave(), true);
 assert.equal(session.leave(), false);
 
-const top = buildTopBarModel({ projectName: "smoke" });
+const top = buildTopBarModel({ projectName: "smoke", unicode: false });
 assert.match(top.status, /ONLINE|Offline/);
 const mission = buildHomeMissionModel({
-  hasGlobalState: false,
-  diagnostics: { diagnostics: { detected: 0 } },
-  dashboard: { providers: [], recentRuns: [] }
+  projectName: "smoke",
+  hasGlobalState: true,
+  diagnostics: {
+    diagnostics: { detected: 2, errors: 0 },
+    intelligence: { summary: { localAvailable: false, cloudAuthenticated: false } },
+    recommendations: []
+  },
+  dashboard: {
+    providers: [{ launchable: true }],
+    recentRuns: [{ runId: "r1", agentId: "codex", state: "failed" }]
+  },
+  layoutMode: LAYOUT_MODES.MINIMAL
 });
-assert.match(mission.title, /MISSION CONTROL/);
+assert.match(mission.title, /HOME — smoke/);
+assert.match(mission.readiness.headline, /LIMITED|READY|NEEDS/i);
+assert.equal(mission.next.targetAction, "launch");
+assert.match(mission.recent.headline, /Codex · Failed/);
+
+const asciiNav = buildNavModel({
+  navIndex: 1,
+  currentView: ORCHESTRATOR_VIEWS.HOME,
+  focused: true,
+  unicode: false,
+  dashboard: { activeRuns: [], recentRuns: [], providers: [{ launchable: true }] },
+  diagnostics: { diagnostics: { detected: 1, errors: 0 } }
+});
+assert.equal(asciiNav.items[1].marker, ">");
+assert.equal(asciiNav.items[0].current, true);
+assert.equal(asciiNav.items[1].selected, true);
+assert.match(asciiNav.explanation, /Supervised runs|Running/i);
 
 function applyKey(state, keyAction) {
   const routed = routeCockpitKey(state, keyAction);

package/src/global/dashboard-guidance.js

@@ -1,7 +1,15 @@
 import { formatCliCommand } from "./brand/cli.js";
 
+/** Public cockpit destinations for recommended actions (match ORCHESTRATOR_VIEWS). */
+export const RECOMMENDATION_TARGETS = {
+  DIAGNOSTICS: "diagnostics",
+  LAUNCH: "launch",
+  RECENT_RUNS: "recent-runs",
+  PROVIDERS: "providers"
+};
+
 export const DASHBOARD_PURPOSE =
-  "Detects, configures, and coordinates local AI agents — no changes without confirmation.";
+  "Kairo coordinates installed AI agents for this project, with controlled execution and auditable results.";
 
 export const NEXT_STEP_KINDS = {
   CONFIGURE: "configure",
@@ -10,13 +18,117 @@ export const NEXT_STEP_KINDS = {
   REVIEW: "review"
 };
 
+export const READINESS_KINDS = {
+  NEEDS_SETUP: "needs_setup",
+  NEEDS_ATTENTION: "needs_attention",
+  LIMITED: "limited",
+  READY: "ready"
+};
+
+export const READINESS_LABELS = {
+  [READINESS_KINDS.NEEDS_SETUP]: "Needs setup",
+  [READINESS_KINDS.NEEDS_ATTENTION]: "Needs attention",
+  [READINESS_KINDS.LIMITED]: "Limited",
+  [READINESS_KINDS.READY]: "Ready to work"
+};
+
 export function formatDashboardPurpose() {
   return DASHBOARD_PURPOSE;
 }
 
+export function countLaunchableAgents(dashboard = null) {
+  return (dashboard?.providers ?? []).filter((entry) => entry.launchable).length;
+}
+
+export function hasIntelligenceConfigured(diagnostics = null) {
+  const summary = diagnostics?.intelligence?.summary;
+  return Boolean(summary?.localAvailable || summary?.cloudAuthenticated);
+}
+
+function hasBlockingDiagnostics(diagnostics = null) {
+  const summary = diagnostics?.diagnostics ?? { errors: 0 };
+  const hasErrors = (summary.errors ?? 0) > 0;
+  const hasProblemRecommendation = (diagnostics?.recommendations ?? []).some((line) =>
+    /error|fix|drift|not detected|failed|problem/i.test(line)
+  );
+  return hasErrors || hasProblemRecommendation;
+}
+
+/**
+ * Derive project readiness from diagnostics + dashboard.
+ * Intelligence absence is Limited (optional), never Needs attention by itself.
+ */
+export function resolveProjectReadiness({
+  hasGlobalState = false,
+  diagnostics = null,
+  dashboard = null
+} = {}) {
+  const summary = diagnostics?.diagnostics ?? { detected: 0, errors: 0 };
+  const launchableCount = countLaunchableAgents(dashboard);
+  const detected = summary.detected ?? 0;
+  const agentsReady = launchableCount;
+  const activeRuns = dashboard?.activeRuns?.length ?? 0;
+  const intelConfigured = hasIntelligenceConfigured(diagnostics);
+  const summaryLine = `${agentsReady} agents ready · ${detected} detected · ${activeRuns} active runs`;
+
+  if (!hasGlobalState || detected === 0) {
+    return {
+      kind: READINESS_KINDS.NEEDS_SETUP,
+      label: READINESS_LABELS[READINESS_KINDS.NEEDS_SETUP],
+      headline: "NEEDS SETUP",
+      summaryLine,
+      capabilityLines: [
+        "Intelligence: Optional capability not configured"
+      ],
+      healthKind: "warn"
+    };
+  }
+
+  if (hasBlockingDiagnostics(diagnostics) || launchableCount === 0) {
+    return {
+      kind: READINESS_KINDS.NEEDS_ATTENTION,
+      label: READINESS_LABELS[READINESS_KINDS.NEEDS_ATTENTION],
+      headline: "NEEDS ATTENTION",
+      summaryLine,
+      capabilityLines: [
+        intelConfigured
+          ? "Intelligence: Configured"
+          : "Intelligence: Optional capability not configured"
+      ],
+      healthKind: "error"
+    };
+  }
+
+  if (!intelConfigured) {
+    return {
+      kind: READINESS_KINDS.LIMITED,
+      label: READINESS_LABELS[READINESS_KINDS.LIMITED],
+      headline: "LIMITED",
+      summaryLine,
+      capabilityLines: [
+        "Intelligence: Optional capability not configured"
+      ],
+      healthKind: "warn"
+    };
+  }
+
+  return {
+    kind: READINESS_KINDS.READY,
+    label: READINESS_LABELS[READINESS_KINDS.READY],
+    headline: "READY TO WORK",
+    summaryLine,
+    capabilityLines: [
+      "Intelligence: Configured"
+    ],
+    healthKind: "ready"
+  };
+}
+
 /**
  * Contextual next step from existing diagnostics + dashboard snapshot.
- * Priority: configure → review problems → enable intelligence → launch.
+ * Priority: configure → review when blocked → launch when launchable →
+ * enable intelligence → review.
+ * Launchable agents win over missing optional intelligence.
  */
 export function resolveDashboardRecommendation({
   hasGlobalState = false,
@@ -25,42 +137,59 @@ export function resolveDashboardRecommendation({
 } = {}) {
   const summary = diagnostics?.diagnostics ?? { detected: 0, errors: 0 };
   const intelligence = diagnostics?.intelligence?.summary;
-  const launchableCount = (dashboard?.providers ?? []).filter((entry) => entry.launchable).length;
-  const hasErrors = (summary.errors ?? 0) > 0;
-  const hasProblemRecommendation = (diagnostics?.recommendations ?? []).some((line) =>
-    /error|fix|drift|not detected|failed|problem/i.test(line)
-  );
+  const launchableCount = countLaunchableAgents(dashboard);
+  const blocked = hasBlockingDiagnostics(diagnostics);
 
   if (!hasGlobalState || (summary.detected ?? 0) === 0) {
     return {
       kind: NEXT_STEP_KINDS.CONFIGURE,
-      message: `Configure the local environment with ${formatCliCommand("setup")}.`
+      title: "Finish local setup",
+      message: `Configure the local environment with ${formatCliCommand("setup")}.`,
+      detail: "Open System health to review what Kairo detected.",
+      targetView: RECOMMENDATION_TARGETS.DIAGNOSTICS,
+      targetAction: null
     };
   }
 
-  if (hasErrors || hasProblemRecommendation) {
+  if (blocked && launchableCount === 0) {
     return {
       kind: NEXT_STEP_KINDS.REVIEW,
-      message: "Review diagnostics for problems before launching a run."
+      title: "Review system health",
+      message: "Review System health for problems before launching a run.",
+      detail: "Fix agent or configuration issues, then try again.",
+      targetView: RECOMMENDATION_TARGETS.DIAGNOSTICS,
+      targetAction: null
     };
   }
 
-  if (!intelligence?.localAvailable && !intelligence?.cloudAuthenticated) {
+  if (launchableCount > 0) {
     return {
-      kind: NEXT_STEP_KINDS.ENABLE_INTELLIGENCE,
-      message: "Enable intelligence: start Ollama or set OPENROUTER_API_KEY, then retry."
+      kind: NEXT_STEP_KINDS.LAUNCH,
+      title: "Create a new run",
+      message: "Create a new run",
+      detail: "Delegate a task to Cursor, Codex or Claude.",
+      targetView: RECOMMENDATION_TARGETS.LAUNCH,
+      targetAction: "launch"
     };
   }
 
-  if (launchableCount > 0) {
+  if (!intelligence?.localAvailable && !intelligence?.cloudAuthenticated) {
     return {
-      kind: NEXT_STEP_KINDS.LAUNCH,
-      message: "Launch a supervised run from the menu or with kairo run."
+      kind: NEXT_STEP_KINDS.ENABLE_INTELLIGENCE,
+      title: "Enable optional intelligence",
+      message: "Enable intelligence: start Ollama or set OPENROUTER_API_KEY, then retry.",
+      detail: "Agents can still run without this optional capability.",
+      targetView: RECOMMENDATION_TARGETS.DIAGNOSTICS,
+      targetAction: null
     };
   }
 
   return {
     kind: NEXT_STEP_KINDS.REVIEW,
-    message: "Review diagnostics for problems before launching a run."
+    title: "Review system health",
+    message: "Review System health for problems before launching a run.",
+    detail: "Open System health to inspect agents and configuration.",
+    targetView: RECOMMENDATION_TARGETS.DIAGNOSTICS,
+    targetAction: null
   };
 }

package/src/global/ink/cockpit/primitives.js

@@ -47,17 +47,24 @@ export function CockpitTopBar({ model, colorEnabled = true }) {
 
 export function CockpitNav({ model, colorEnabled = true }) {
   return React.createElement(Box, { flexDirection: "column" },
-    model.items.map((item) =>
-      React.createElement(Text, {
+    model.items.map((item) => {
+      const suffix = item.current && !item.selected ? " (open)" : "";
+      const color = item.focused
+        ? (colorEnabled ? COCKPIT_COLORS.primary : undefined)
+        : item.selected
+          ? (colorEnabled ? COCKPIT_COLORS.secondary : undefined)
+          : item.current
+            ? (colorEnabled ? COCKPIT_COLORS.muted : undefined)
+            : undefined;
+      return React.createElement(Text, {
         key: item.id,
         bold: item.focused || item.selected,
-        color: item.focused
-          ? (colorEnabled ? COCKPIT_COLORS.primary : undefined)
-          : item.selected
-            ? (colorEnabled ? COCKPIT_COLORS.secondary : undefined)
-            : undefined
-      }, `${item.marker} ${item.label}`)
-    )
+        color
+      }, `${item.marker} ${item.label}${suffix}`);
+    }),
+    model.explanation && React.createElement(Text, {
+      color: COCKPIT_COLORS.muted
+    }, model.explanation)
   );
 }
 

package/src/global/ink/cockpit-controller.js

@@ -108,6 +108,9 @@ export function reduceCockpitUi(state, action) {
         ...state,
         view: nextView,
         listIndex: 0,
+        navIndex: action.navIndex == null
+          ? state.navIndex
+          : clamp(action.navIndex, 0, COCKPIT_NAV.length - 1),
         region: action.region ?? defaultRegionForView(nextView, state.layoutMode),
         returnView: action.returnView ?? state.returnView,
         helpOpen: nextView === ORCHESTRATOR_VIEWS.HELP

package/src/global/ink/cockpit-home.js

@@ -0,0 +1,115 @@
+import { ORCHESTRATOR_VIEWS } from "./orchestrator-state.js";
+import {
+  DASHBOARD_PURPOSE,
+  resolveDashboardRecommendation,
+  resolveProjectReadiness
+} from "../dashboard-guidance.js";
+import { LAYOUT_MODES } from "./layout.js";
+
+export function formatHomeRecentRun(run) {
+  if (!run) return null;
+  const agent = humanizeId(run.agentId);
+  const result = humanizeRunState(run.state);
+  return {
+    headline: `Last run · ${agent} · ${result}`,
+    hint: "Open History to inspect the result."
+  };
+}
+
+export function buildHomeMissionModel({
+  projectName = "project",
+  hasGlobalState = false,
+  diagnostics = null,
+  dashboard = null,
+  layoutMode = LAYOUT_MODES.COMPACT,
+  recentRuns = null
+} = {}) {
+  const readiness = resolveProjectReadiness({ hasGlobalState, diagnostics, dashboard });
+  const recommendation = resolveDashboardRecommendation({
+    hasGlobalState,
+    diagnostics,
+    dashboard
+  });
+  const runs = recentRuns ?? dashboard?.recentRuns ?? [];
+  const lastRun = formatHomeRecentRun(runs[0] ?? null);
+  const includeEmbeddedStatus = layoutMode !== LAYOUT_MODES.WIDE;
+
+  return {
+    title: `HOME — ${projectName}`,
+    purpose: DASHBOARD_PURPOSE,
+    readiness,
+    includeEmbeddedStatus,
+    next: {
+      title: "NEXT",
+      actionTitle: recommendation.title,
+      actionDetail: recommendation.detail ?? recommendation.message,
+      enterHint: "Enter →",
+      kind: recommendation.kind,
+      targetView: recommendation.targetView,
+      targetAction: recommendation.targetAction,
+      message: recommendation.message
+    },
+    recent: lastRun
+      ? {
+        title: "RECENT",
+        headline: lastRun.headline,
+        hint: lastRun.hint,
+        emptyHint: null
+      }
+      : {
+        title: "RECENT",
+        headline: null,
+        hint: null,
+        emptyHint: "No runs yet. Create a new run when an agent is ready."
+      },
+    explore: {
+      title: "EXPLORE",
+      lines: [
+        "Agents — See which installed tools Kairo can launch and audit.",
+        "System health — Inspect intelligence, authentication, and configuration."
+      ]
+    },
+    recommendedTitle: recommendation.title,
+    recommendedAction: recommendation.message,
+    recommendedKind: recommendation.kind,
+    recommendedTargetView: recommendation.targetView,
+    recommendedTargetAction: recommendation.targetAction,
+    emptyHint: lastRun ? null : "No runs yet. Create a new run when an agent is ready."
+  };
+}
+
+export function openRecommendedDestination(recommendation, { navItems } = {}) {
+  if (!recommendation?.targetView) return null;
+  const index = (navItems ?? []).findIndex((item) => item.view === recommendation.targetView
+    || (recommendation.targetAction && item.action === recommendation.targetAction));
+  return {
+    view: recommendation.targetView,
+    action: recommendation.targetAction ?? null,
+    navIndex: index >= 0 ? index : null
+  };
+}
+
+function humanizeId(value) {
+  const raw = String(value ?? "agent");
+  return raw.charAt(0).toUpperCase() + raw.slice(1);
+}
+
+function humanizeRunState(state) {
+  switch (state) {
+    case "succeeded":
+    case "completed":
+      return "Succeeded";
+    case "failed":
+      return "Failed";
+    case "cancelled":
+    case "canceled":
+      return "Cancelled";
+    case "running":
+    case "starting":
+      return "Running";
+    default:
+      return humanizeId(state);
+  }
+}
+
+export { ORCHESTRATOR_VIEWS };

package/src/global/ink/cockpit-models.js

@@ -1,9 +1,9 @@
-import { LAYOUT_MODES } from "./layout.js";
+import { LAYOUT_MODES, resolveListLimit } from "./layout.js";
 import { ORCHESTRATOR_VIEWS } from "./orchestrator-state.js";
-import { resolveDashboardRecommendation } from "../dashboard-guidance.js";
+import { resolveProjectReadiness } from "../dashboard-guidance.js";
 import { STATUS_LABELS, resolveGlyphs } from "./theme.js";
 import { windowList } from "./list-window.js";
-import { resolveListLimit } from "./layout.js";
+import { buildHomeMissionModel, formatHomeRecentRun } from "./cockpit-home.js";
 
 export const COCKPIT_REGIONS = {
   NAV: "nav",
@@ -12,12 +12,43 @@ export const COCKPIT_REGIONS = {
 };
 
 export const COCKPIT_NAV = [
-  { id: "overview", label: "Overview", view: ORCHESTRATOR_VIEWS.HOME },
-  { id: "active", label: "Active runs", view: ORCHESTRATOR_VIEWS.ACTIVE_RUNS },
-  { id: "recent", label: "Recent runs", view: ORCHESTRATOR_VIEWS.RECENT_RUNS },
-  { id: "providers", label: "Providers", view: ORCHESTRATOR_VIEWS.PROVIDERS },
-  { id: "launch", label: "Launch run", view: ORCHESTRATOR_VIEWS.LAUNCH, action: "launch" },
-  { id: "diagnostics", label: "Diagnostics", view: ORCHESTRATOR_VIEWS.DIAGNOSTICS }
+  {
+    id: "overview",
+    label: "Home",
+    view: ORCHESTRATOR_VIEWS.HOME,
+    description: "What Kairo does here, readiness, and the next useful action."
+  },
+  {
+    id: "active",
+    label: "Running now",
+    view: ORCHESTRATOR_VIEWS.ACTIVE_RUNS,
+    description: "Supervised runs executing right now."
+  },
+  {
+    id: "recent",
+    label: "History",
+    view: ORCHESTRATOR_VIEWS.RECENT_RUNS,
+    description: "Past runs with agent, state, and readable result."
+  },
+  {
+    id: "providers",
+    label: "Agents",
+    view: ORCHESTRATOR_VIEWS.PROVIDERS,
+    description: "Installed tools Kairo can launch and audit."
+  },
+  {
+    id: "launch",
+    label: "New run",
+    view: ORCHESTRATOR_VIEWS.LAUNCH,
+    action: "launch",
+    description: "Delegate a task to an executable agent."
+  },
+  {
+    id: "diagnostics",
+    label: "System health",
+    view: ORCHESTRATOR_VIEWS.DIAGNOSTICS,
+    description: "Agents, intelligence, authentication, and configuration."
+  }
 ];
 
 export function regionsForLayout(layoutMode) {
@@ -30,6 +61,11 @@ export function regionsForLayout(layoutMode) {
   return [COCKPIT_REGIONS.CONTENT];
 }
 
+export function navIndexForView(view, items = COCKPIT_NAV) {
+  const index = items.findIndex((item) => item.view === view);
+  return index >= 0 ? index : 0;
+}
+
 export function buildTopBarModel({
   projectName = "project",
   systemOnline = true,
@@ -46,28 +82,73 @@ export function buildTopBarModel({
   };
 }
 
+export function resolveNavStatusSummary(item, { dashboard = null, diagnostics = null } = {}) {
+  const active = dashboard?.activeRuns?.length ?? 0;
+  const recent = dashboard?.recentRuns?.length ?? 0;
+  const providers = dashboard?.providers ?? [];
+  const launchable = providers.filter((entry) => entry.launchable).length;
+  const detected = diagnostics?.diagnostics?.detected ?? providers.filter((p) => p.available).length;
+  const errors = diagnostics?.diagnostics?.errors ?? 0;
+
+  switch (item.id) {
+    case "overview":
+      return resolveProjectReadiness({
+        hasGlobalState: true,
+        diagnostics,
+        dashboard
+      }).label;
+    case "active":
+      return active === 0 ? "Idle" : `${active} active`;
+    case "recent":
+      return recent === 0 ? "No history" : `${recent} recent`;
+    case "providers":
+      return `${launchable}/${providers.length || detected} ready`;
+    case "launch":
+      return launchable > 0 ? "Ready" : "Unavailable";
+    case "diagnostics":
+      return errors > 0 ? `${errors} issues` : "Checked";
+    default:
+      return "";
+  }
+}
+
 export function buildNavModel({
   navIndex = 0,
+  currentView = ORCHESTRATOR_VIEWS.HOME,
   focused = false,
   unicode = true,
-  items = COCKPIT_NAV
+  items = COCKPIT_NAV,
+  dashboard = null,
+  diagnostics = null
 } = {}) {
   const glyphs = resolveGlyphs(unicode);
+  const selected = items[navIndex] ?? items[0];
+  const mapped = items.map((item, index) => {
+    const isSelected = index === navIndex;
+    const isCurrent = item.view === currentView;
+    return {
+      ...item,
+      marker: isSelected ? glyphs.focus : (isCurrent ? glyphs.bullet : " "),
+      selected: isSelected,
+      current: isCurrent,
+      focused: focused && isSelected,
+      statusSummary: resolveNavStatusSummary(item, { dashboard, diagnostics })
+    };
+  });
+
   return {
     title: "NAVIGATION",
-    items: items.map((item, index) => ({
-      ...item,
-      marker: index === navIndex ? glyphs.focus : " ",
-      selected: index === navIndex,
-      focused: focused && index === navIndex
-    }))
+    explanation: selected
+      ? `${selected.description} (${resolveNavStatusSummary(selected, { dashboard, diagnostics })})`
+      : "",
+    items: mapped
   };
 }
 
 export function buildSystemStripModel({
   dashboard = null,
   diagnostics = null,
-  healthKind = "ready"
+  readiness = null
 } = {}) {
   const agentsDetected = diagnostics?.diagnostics?.detected
     ?? (dashboard?.providers ?? []).filter((p) => p.available).length;
@@ -81,6 +162,11 @@ export function buildSystemStripModel({
     : intelligence?.cloudAuthenticated
       ? "Cloud"
       : "None";
+  const resolved = readiness ?? resolveProjectReadiness({
+    hasGlobalState: agentsDetected > 0,
+    diagnostics,
+    dashboard
+  });
 
   return {
     title: "SYSTEM",
@@ -88,50 +174,32 @@ export function buildSystemStripModel({
       { key: "Agents", value: `${agentsDetected}/${agentsTotal}`, kind: agentsDetected > 0 ? "ready" : "warn" },
       { key: "Runs", value: String(activeRuns), kind: activeRuns > 0 ? "ready" : "muted" },
       { key: "Intel", value: intelLabel, kind: intelLabel === "None" ? "warn" : "ready" },
-      { key: "Health", value: STATUS_LABELS[healthKind] ?? healthKind, kind: healthKind }
+      {
+        key: "Health",
+        value: STATUS_LABELS[resolved.kind] ?? resolved.label ?? resolved.kind,
+        kind: resolved.healthKind ?? "warn"
+      }
     ]
   };
 }
 
-export function buildHomeMissionModel({
-  hasGlobalState = false,
-  diagnostics = null,
-  dashboard = null,
-  layoutMode = LAYOUT_MODES.COMPACT,
-  activityLines = []
-} = {}) {
-  const recommendation = resolveDashboardRecommendation({
-    hasGlobalState,
-    diagnostics,
-    dashboard
-  });
-  const limit = resolveListLimit(layoutMode, { contentRows: 10 });
-  const windowed = windowList(activityLines, limit);
-
-  return {
-    title: "MISSION CONTROL",
-    recommendedTitle: "Recommended action",
-    recommendedAction: recommendation.message,
-    recommendedKind: recommendation.kind,
-    activityTitle: activityLines.length ? "Activity" : "Activity / empty state",
-    activityLines: windowed.items,
-    moreLine: windowed.moreLine,
-    emptyHint: activityLines.length === 0
-      ? "No recent activity. Launch a run when agents are ready."
-      : null
-  };
-}
-
 export function buildFooterModel({
   view = ORCHESTRATOR_VIEWS.HOME,
   region = COCKPIT_REGIONS.NAV,
   helpOpen = false,
   canCancel = false,
-  unicode = true
+  unicode = true,
+  hasError = false
 } = {}) {
   const glyphs = resolveGlyphs(unicode);
   const parts = [];
 
+  if (hasError) {
+    parts.push("R Retry");
+    parts.push("Esc Exit");
+    return { text: parts.join(` ${glyphs.bullet} `) };
+  }
+
   if (helpOpen || view === ORCHESTRATOR_VIEWS.HELP) {
     parts.push("Esc close help");
     parts.push("? Help");
@@ -173,8 +241,15 @@ export function buildFooterModel({
   return { text: parts.join(` ${glyphs.bullet} `) };
 }
 
+export function windowLinesForLayout(lines = [], layoutMode = LAYOUT_MODES.COMPACT, contentRows = 12) {
+  const limit = resolveListLimit(layoutMode, { contentRows });
+  return windowList(lines, limit);
+}
+
 export function resolveProjectName(workspaceRoot = "") {
   if (!workspaceRoot) return "project";
   const parts = String(workspaceRoot).split(/[/\\]/).filter(Boolean);
   return parts[parts.length - 1] || "project";
 }
+
+export { buildHomeMissionModel, formatHomeRecentRun };

package/src/global/ink/cockpit-views.js

@@ -3,38 +3,60 @@ import { Box, Text } from "ink";
 import { COCKPIT_COLORS } from "./theme.js";
 import { CockpitEmptyState } from "./cockpit/primitives.js";
 import {
-  formatDiagnosticsLines,
-  formatLaunchWizardLines,
   formatProviderLines,
   formatRunDetailLines,
   formatRunLines,
+  formatSystemHealthLines,
+  formatLaunchWizardLines,
   ORCHESTRATOR_VIEWS,
   LAUNCH_WIZARD_STEPS
 } from "./orchestrator-state.js";
+import { windowLinesForLayout } from "./cockpit-models.js";
+import { LAYOUT_MODES } from "./layout.js";
 
 export function HomeMissionPanel({ model, colorEnabled = true }) {
+  const readiness = model.readiness;
   return React.createElement(Box, { flexDirection: "column" },
     React.createElement(Text, {
       bold: true,
       color: colorEnabled ? COCKPIT_COLORS.secondary : undefined
     }, model.title),
-    React.createElement(Text, { bold: true }, model.recommendedTitle),
+    React.createElement(Text, null, model.purpose),
+    React.createElement(Text, null, ""),
+    React.createElement(Box, { flexDirection: "column" },
+      React.createElement(Text, {
+        bold: true,
+        color: colorEnabled ? COCKPIT_COLORS.primary : undefined
+      }, readiness.headline),
+      React.createElement(Text, null, readiness.summaryLine),
+      ...(readiness.capabilityLines ?? []).map((line) =>
+        React.createElement(Text, { key: line, color: COCKPIT_COLORS.muted }, line)
+      ),
+      React.createElement(Text, null, "")
+    ),
+    React.createElement(Text, { bold: true }, model.next.title),
     React.createElement(Text, {
+      bold: true,
       color: colorEnabled ? COCKPIT_COLORS.primary : undefined
-    }, model.recommendedAction),
+    }, model.next.actionTitle),
+    React.createElement(Text, null, model.next.actionDetail),
+    React.createElement(Text, { color: COCKPIT_COLORS.muted }, model.next.enterHint),
     React.createElement(Text, null, ""),
-    React.createElement(Text, { bold: true }, model.activityTitle),
-    model.emptyHint
+    React.createElement(Text, { bold: true }, model.recent.title),
+    model.recent.emptyHint
       ? React.createElement(CockpitEmptyState, {
-        message: model.emptyHint,
-        hint: "Enter on Launch run when ready."
+        message: model.recent.emptyHint,
+        hint: "Enter opens the recommended next step."
       })
-      : model.activityLines.map((line) =>
-        React.createElement(Text, { key: line }, line)
+      : React.createElement(Box, { flexDirection: "column" },
+        React.createElement(Text, null, model.recent.headline),
+        React.createElement(Text, { color: COCKPIT_COLORS.muted }, model.recent.hint)
       ),
-    model.moreLine && React.createElement(Text, {
-      color: COCKPIT_COLORS.muted
-    }, model.moreLine)
+    React.createElement(Text, null, ""),
+    React.createElement(Text, { bold: true }, model.explore.title),
+    model.explore.lines.map((line) =>
+      React.createElement(Text, { key: line, color: COCKPIT_COLORS.muted }, line)
+    )
   );
 }
 
@@ -51,6 +73,7 @@ export function renderCockpitView({
   selectedRun,
   selectedEvents,
   homeMission,
+  layoutMode = LAYOUT_MODES.COMPACT,
   colorEnabled = true
 }) {
   switch (view) {
@@ -58,34 +81,52 @@ export function renderCockpitView({
       return React.createElement(HomeMissionPanel, { model: homeMission, colorEnabled });
     case ORCHESTRATOR_VIEWS.ACTIVE_RUNS:
       return listBlock(
-        "Active runs",
-        formatRunLines(dashboard?.activeRuns ?? [], { emptyMessage: "No active runs." }),
+        "Running now",
+        formatRunLines(dashboard?.activeRuns ?? [], {
+          emptyMessage: "No runs are executing. Open New run to start one.",
+          readable: true
+        }),
         listIndex,
-        colorEnabled
+        colorEnabled,
+        "Nothing is running yet — that means Kairo is idle, not broken."
       );
     case ORCHESTRATOR_VIEWS.RECENT_RUNS:
       return listBlock(
-        "Recent runs",
-        formatRunLines(dashboard?.recentRuns ?? [], { emptyMessage: "No completed runs yet." }),
+        "History",
+        formatRunLines(dashboard?.recentRuns ?? [], {
+          emptyMessage: "No completed runs yet. Create a new run to build history.",
+          readable: true
+        }),
         listIndex,
-        colorEnabled
+        colorEnabled,
+        "History fills after supervised runs finish."
       );
-    case ORCHESTRATOR_VIEWS.PROVIDERS:
+    case ORCHESTRATOR_VIEWS.PROVIDERS: {
+      const lines = formatProviderLines(dashboard?.providers ?? []);
+      const windowed = windowLinesForLayout(lines, layoutMode);
       return React.createElement(Box, { flexDirection: "column" },
-        React.createElement(Text, { bold: true }, "Providers"),
-        formatProviderLines(dashboard?.providers ?? [])
-          .map((line) => React.createElement(Text, { key: line }, line))
+        React.createElement(Text, { bold: true }, "Agents"),
+        lines.length === 0
+          ? React.createElement(CockpitEmptyState, {
+            message: "No agents detected yet.",
+            hint: "Open System health or finish setup, then return here."
+          })
+          : windowed.items.map((line) => React.createElement(Text, { key: line }, line)),
+        windowed.moreLine && React.createElement(Text, {
+          color: COCKPIT_COLORS.muted
+        }, windowed.moreLine)
       );
+    }
     case ORCHESTRATOR_VIEWS.LAUNCH:
       if (launchableAgents.length === 0) {
         return React.createElement(CockpitEmptyState, {
-          title: "Launch run",
-          message: "No launchable agents detected.",
-          hint: "Esc to return · check Diagnostics"
+          title: "New run",
+          message: "No executable agents are ready. Kairo cannot start a run yet.",
+          hint: "Esc to return · open System health or Agents"
         });
       }
       return React.createElement(Box, { flexDirection: "column" },
-        React.createElement(Text, { bold: true }, "Launch run"),
+        React.createElement(Text, { bold: true }, "New run"),
         formatLaunchWizardLines({
           step: launchStep,
           draft: launchDraft,
@@ -105,18 +146,23 @@ export function renderCockpitView({
         formatRunDetailLines(selectedRun, selectedEvents)
           .map((line) => React.createElement(Text, { key: line }, line))
       );
-    case ORCHESTRATOR_VIEWS.DIAGNOSTICS:
+    case ORCHESTRATOR_VIEWS.DIAGNOSTICS: {
+      const lines = formatSystemHealthLines(diagnostics);
+      const windowed = windowLinesForLayout(lines, layoutMode);
       return React.createElement(Box, { flexDirection: "column" },
-        React.createElement(Text, { bold: true }, "Diagnostics"),
-        formatDiagnosticsLines(diagnostics)
-          .map((line) => React.createElement(Text, { key: line }, line))
+        React.createElement(Text, { bold: true }, "System health"),
+        windowed.items.map((line) => React.createElement(Text, { key: line }, line)),
+        windowed.moreLine && React.createElement(Text, {
+          color: COCKPIT_COLORS.muted
+        }, windowed.moreLine)
       );
+    }
     case ORCHESTRATOR_VIEWS.HELP:
       return React.createElement(Box, { flexDirection: "column" },
         React.createElement(Text, { bold: true }, "Help"),
-        React.createElement(Text, null, "Kairo runtime launches and audits agent CLIs you manage."),
-        React.createElement(Text, null, "↑↓ navigate · Tab region · Enter open · Esc back/exit"),
-        React.createElement(Text, null, "R refresh · C cancel active run · ? toggle help"),
+        React.createElement(Text, null, "Kairo coordinates installed AI agents with controlled, auditable runs."),
+        React.createElement(Text, null, "↑↓ navigate · Enter open recommended or selected section · Esc back/exit"),
+        React.createElement(Text, null, "Tab region (lists / New run) · R refresh/retry · C cancel · ? help"),
         React.createElement(Text, null, "CLI: kairo run --agent <id> --task \"...\""),
         React.createElement(Text, null, "Audit trail: ~/.harness/runs/<runId>/")
       );
@@ -127,14 +173,20 @@ export function renderCockpitView({
   }
 }
 
-function listBlock(title, lines, listIndex, colorEnabled) {
+function listBlock(title, lines, listIndex, colorEnabled, emptyHint) {
+  const isEmpty = lines.length === 1 && /no |nothing |empty/i.test(lines[0]);
   return React.createElement(Box, { flexDirection: "column" },
     React.createElement(Text, { bold: true }, title),
-    lines.map((line, index) => React.createElement(Text, {
-      key: `${index}-${line}`,
-      bold: index === listIndex,
-      color: index === listIndex && colorEnabled ? COCKPIT_COLORS.primary : undefined
-    }, `${index === listIndex ? "› " : "  "}${line}`))
+    isEmpty
+      ? React.createElement(CockpitEmptyState, {
+        message: lines[0],
+        hint: emptyHint
+      })
+      : lines.map((line, index) => React.createElement(Text, {
+        key: `${index}-${line}`,
+        bold: index === listIndex,
+        color: index === listIndex && colorEnabled ? COCKPIT_COLORS.primary : undefined
+      }, `${index === listIndex ? "› " : "  "}${line}`))
   );
 }
 

package/src/global/ink/orchestrator-app.js

@@ -13,6 +13,7 @@ import {
   isContentInteractiveView
 } from "./cockpit-controller.js";
 import {
+  COCKPIT_NAV,
   COCKPIT_REGIONS,
   buildFooterModel,
   buildHomeMissionModel,
@@ -21,6 +22,8 @@ import {
   buildTopBarModel,
   resolveProjectName
 } from "./cockpit-models.js";
+import { openRecommendedDestination } from "./cockpit-home.js";
+import { resolveProjectReadiness } from "../dashboard-guidance.js";
 import { CockpitShell } from "./cockpit/primitives.js";
 import { renderCockpitView } from "./cockpit-views.js";
 import { handleLaunchInput } from "./launch-input.js";
@@ -66,11 +69,40 @@ export function OrchestratorApp({
     exit();
   };
 
+  const openDestination = (recommendation) => {
+    const destination = openRecommendedDestination(recommendation, { navItems: COCKPIT_NAV });
+    if (!destination) return false;
+    if (destination.action === "launch") {
+      data.resetLaunchWizard();
+    }
+    dispatch({
+      type: "set-view",
+      view: destination.view,
+      navIndex: destination.navIndex ?? undefined
+    });
+    return true;
+  };
+
   useInput((inputKey, key) => {
-    if (data.loading || data.error || data.busy) return;
+    if (data.loading) return;
+
+    if (data.error) {
+      if (key.escape) {
+        finish({ cancelled: true });
+        return;
+      }
+      if (inputKey.toLowerCase() === "r") {
+        data.setError(null);
+        data.reload().catch((reloadError) => {
+          data.setError(reloadError instanceof Error ? reloadError.message : String(reloadError));
+        });
+      }
+      return;
+    }
+
+    if (data.busy) return;
 
     if (key.escape) {
-      // Launch wizard may retreat a step before leaving the view.
       if (ui.view === ORCHESTRATOR_VIEWS.LAUNCH && data.launchableAgents.length > 0) {
         const retreated = handleLaunchInput({
           key,
@@ -130,9 +162,23 @@ export function OrchestratorApp({
     if (routed) {
       if (routed.type === "enter-nav") {
         const item = resolveNavAction(ui.navIndex);
+        if (item?.id === "overview" || item?.view === ORCHESTRATOR_VIEWS.HOME) {
+          const mission = buildHomeMissionModel({
+            projectName: resolveProjectName(workspaceRoot),
+            hasGlobalState,
+            diagnostics: data.diagnostics,
+            dashboard: data.dashboard,
+            layoutMode: ui.layoutMode ?? LAYOUT_MODES.COMPACT
+          });
+          if (openDestination(mission.next)) return;
+        }
         if (item?.action === "launch") {
           data.resetLaunchWizard();
-          dispatch({ type: "set-view", view: ORCHESTRATOR_VIEWS.LAUNCH });
+          dispatch({
+            type: "set-view",
+            view: ORCHESTRATOR_VIEWS.LAUNCH,
+            navIndex: ui.navIndex
+          });
           return;
         }
       }
@@ -140,7 +186,6 @@ export function OrchestratorApp({
       return;
     }
 
-    // View-specific handlers after centralized region routing.
     if (ui.view === ORCHESTRATOR_VIEWS.LAUNCH && data.launchableAgents.length > 0) {
       if (handleLaunchInput({
         key,
@@ -201,13 +246,26 @@ export function OrchestratorApp({
     return React.createElement(Box, { flexDirection: "column" },
       React.createElement(Text, { bold: true, color: COCKPIT_COLORS.danger }, "Runtime error"),
       React.createElement(Text, null, data.error),
-      React.createElement(Text, { dimColor: true }, "Esc to exit")
+      React.createElement(Text, { dimColor: true }, "R Retry · Esc to exit")
     );
   }
 
   const mode = ui.layoutMode ?? LAYOUT_MODES.COMPACT;
   const colorEnabled = caps.color;
   const unicode = caps.unicode;
+  const projectName = resolveProjectName(workspaceRoot);
+  const readiness = resolveProjectReadiness({
+    hasGlobalState,
+    diagnostics: data.diagnostics,
+    dashboard: data.dashboard
+  });
+  const homeMission = buildHomeMissionModel({
+    projectName,
+    hasGlobalState,
+    diagnostics: data.diagnostics,
+    dashboard: data.dashboard,
+    layoutMode: mode
+  });
 
   return React.createElement(Box, { flexDirection: "column" },
     data.statusMessage && React.createElement(Text, {
@@ -215,8 +273,8 @@ export function OrchestratorApp({
     }, data.statusMessage),
     React.createElement(CockpitShell, {
       topBar: buildTopBarModel({
-        projectName: resolveProjectName(workspaceRoot),
-        systemOnline: true,
+        projectName,
+        systemOnline: readiness.kind !== "needs_setup",
         unicode
       }),
       footer: buildFooterModel({
@@ -229,13 +287,16 @@ export function OrchestratorApp({
       layoutMode: mode,
       nav: buildNavModel({
         navIndex: ui.navIndex,
+        currentView: ui.view,
         focused: ui.region === COCKPIT_REGIONS.NAV || !isContentInteractiveView(ui.view),
-        unicode
+        unicode,
+        dashboard: data.dashboard,
+        diagnostics: data.diagnostics
       }),
       system: buildSystemStripModel({
         dashboard: data.dashboard,
         diagnostics: data.diagnostics,
-        healthKind: "ready"
+        readiness
       }),
       navFocused: ui.region === COCKPIT_REGIONS.NAV,
       contentFocused: ui.region === COCKPIT_REGIONS.CONTENT,
@@ -254,15 +315,8 @@ export function OrchestratorApp({
         launchableAgents: data.launchableAgents,
         selectedRun: data.selectedRun,
         selectedEvents: data.selectedEvents,
-        homeMission: buildHomeMissionModel({
-          hasGlobalState,
-          diagnostics: data.diagnostics,
-          dashboard: data.dashboard,
-          layoutMode: mode,
-          activityLines: (data.dashboard?.recentRuns ?? []).map((run) =>
-            `${run.runId} ${run.state} ${run.agentId}`
-          )
-        }),
+        homeMission,
+        layoutMode: mode,
         colorEnabled
       })
     )

package/src/global/ink/orchestrator-state.js

@@ -23,11 +23,11 @@ export const ORCHESTRATOR_VIEWS = {
 };
 
 export const ORCHESTRATOR_MENU = [
-  { id: "active", label: "Active runs", view: ORCHESTRATOR_VIEWS.ACTIVE_RUNS },
-  { id: "recent", label: "Recent runs", view: ORCHESTRATOR_VIEWS.RECENT_RUNS },
-  { id: "providers", label: "Providers", view: ORCHESTRATOR_VIEWS.PROVIDERS },
-  { id: "launch", label: "Launch run", view: ORCHESTRATOR_VIEWS.LAUNCH, action: "launch" },
-  { id: "diagnostics", label: "Diagnostics", view: ORCHESTRATOR_VIEWS.DIAGNOSTICS },
+  { id: "active", label: "Running now", view: ORCHESTRATOR_VIEWS.ACTIVE_RUNS },
+  { id: "recent", label: "History", view: ORCHESTRATOR_VIEWS.RECENT_RUNS },
+  { id: "providers", label: "Agents", view: ORCHESTRATOR_VIEWS.PROVIDERS },
+  { id: "launch", label: "New run", view: ORCHESTRATOR_VIEWS.LAUNCH, action: "launch" },
+  { id: "diagnostics", label: "System health", view: ORCHESTRATOR_VIEWS.DIAGNOSTICS },
   { id: "help", label: "Help", view: ORCHESTRATOR_VIEWS.HELP }
 ];
 
@@ -157,13 +157,22 @@ export function shiftMenuIndex(currentIndex, direction, menuLength = ORCHESTRATO
   return Math.min(menuLength - 1, Math.max(0, currentIndex + delta));
 }
 
-export function formatRunLines(runs, { emptyMessage = "No runs." } = {}) {
+export function formatRunLines(runs, {
+  emptyMessage = "No runs.",
+  readable = false
+} = {}) {
   if (!runs || runs.length === 0) return [emptyMessage];
 
   return runs.map((run) => {
-    const state = run.state.padEnd(12);
-    const agent = run.agentId.padEnd(10);
-    return `${run.runId}  ${state}  ${agent}  ${formatTaskLabel(run)}`;
+    const agent = humanizeToken(run.agentId);
+    const state = humanizeRunState(run.state);
+    const task = formatTaskLabel(run);
+    if (readable) {
+      return `${agent} · ${state} · ${task}`;
+    }
+    const statePad = run.state.padEnd(12);
+    const agentPad = run.agentId.padEnd(10);
+    return `${run.runId}  ${statePad}  ${agentPad}  ${task}`;
   });
 }
 
@@ -181,17 +190,42 @@ export function formatProviderLines(providers) {
 }
 
 export function formatDiagnosticsLines(diagnostics) {
+  return formatSystemHealthLines(diagnostics);
+}
+
+export function formatSystemHealthLines(diagnostics) {
   const summary = diagnostics?.diagnostics;
+  const intelligence = diagnostics?.intelligence?.summary;
+  const profile = diagnostics?.profile;
+  const capabilities = diagnostics?.capabilities ?? [];
+  const authKnown = capabilities.filter((entry) => entry.authenticated != null);
+  const authReady = authKnown.filter((entry) => entry.authenticated).length;
+
   const lines = [
-    "Summary",
-    `CLI version: ${diagnostics?.cliVersion ?? "unknown"}`,
-    `Agents detected: ${summary?.detected ?? 0}/${diagnostics?.capabilities?.length ?? 0}`,
+    "Agents",
+    `Detected: ${summary?.detected ?? 0}/${capabilities.length}`,
     `Available: ${summary?.available ?? 0}`,
     `Unknown: ${summary?.unknown ?? 0}`,
     `Errors: ${summary?.errors ?? 0}`,
+    ...formatAgentStatusLines(capabilities),
+    "",
+    "Intelligence",
+    intelligence?.localAvailable
+      ? "Local backend available"
+      : "Local backend unavailable",
+    intelligence?.cloudAuthenticated
+      ? "Cloud backend authenticated"
+      : "Cloud backend not configured",
+    `Routing: ${diagnostics?.intelligence?.routingPreview?.reason ?? "n/a"}`,
+    "",
+    "Authentication",
+    authKnown.length === 0
+      ? "No agent authentication signals yet"
+      : `${authReady}/${authKnown.length} agents report ready auth`,
     "",
-    "Agent capabilities",
-    ...formatAgentStatusLines(diagnostics?.capabilities ?? [])
+    "Configuration",
+    `CLI version: ${diagnostics?.cliVersion ?? "unknown"}`,
+    `Profile sources: ${(profile?.sources ?? []).join(", ") || "none"}`
   ];
 
   const recommendations = diagnostics?.recommendations ?? [];
@@ -265,6 +299,29 @@ export function isRunCancellable(run) {
   return run && isActiveRunState(run.state);
 }
 
+function humanizeToken(value) {
+  const raw = String(value ?? "agent");
+  return raw.charAt(0).toUpperCase() + raw.slice(1);
+}
+
+function humanizeRunState(state) {
+  switch (state) {
+    case "succeeded":
+    case "completed":
+      return "Succeeded";
+    case "failed":
+      return "Failed";
+    case "cancelled":
+    case "canceled":
+      return "Cancelled";
+    case "running":
+    case "starting":
+      return "Running";
+    default:
+      return humanizeToken(state);
+  }
+}
+
 function summarizeEvent(event) {
   if (event.type === "agent.tool_call") {
     return event.data?.tool_name ?? event.data?.name ?? "tool";

package/src/global/ink/theme.js

@@ -19,7 +19,10 @@ export const STATUS_LABELS = {
   offline: "Offline",
   local: "Local",
   online: "ONLINE",
-  loading: "Loading"
+  loading: "Loading",
+  needs_setup: "Needs setup",
+  needs_attention: "Needs attention",
+  limited: "Limited"
 };
 
 export const COCKPIT_GLYPHS = {
@@ -55,9 +58,12 @@ export function statusColor(kind, { colorEnabled = true } = {}) {
       return COCKPIT_COLORS.success;
     case "warn":
     case "warning":
+    case "needs_setup":
+    case "limited":
       return COCKPIT_COLORS.warning;
     case "error":
     case "danger":
+    case "needs_attention":
       return COCKPIT_COLORS.danger;
     case "offline":
     case "muted":