@kal-elsam/kairo-runtime 0.4.3 → 0.5.0

package/src/global/global-installer.js

@@ -19,6 +19,11 @@ import {
   normalizeGlobalState
 } from "./state-migration.js";
 import { formatCliCommand } from "./brand/cli.js";
+import {
+  aggregateSessionRefreshRequired,
+  applySddLifecycle,
+  nextSddState
+} from "./integrations/sdd-lifecycle.js";
 
 export async function installGlobalHarness({
   packageRoot,
@@ -32,6 +37,7 @@ export async function installGlobalHarness({
   dryRun = false
 }) {
   const paths = harnessHomePaths(homeDir);
+  const priorState = await readGlobalState(paths.statePath);
   const timestamp = backupTimestamp();
   const targetComponents = resolveTargetComponents({ components, noDefaultComponents, workspaceRoot });
   const context = buildAdapterContext({
@@ -58,7 +64,9 @@ export async function installGlobalHarness({
     configsRepaired: [],
     configsUnchanged: [],
     backups: [],
-    driftDetected: false
+    driftDetected: false,
+    integrations: {},
+    sessionRefreshRequired: false
   };
 
   const componentFiles = await installComponentAssets({
@@ -72,6 +80,9 @@ export async function installGlobalHarness({
   result.assetsRepaired.push(...Object.keys(componentFiles));
 
   await applyAdapterPlans({ context, targetAdapters, result });
+  await attachSddLifecycle({
+    result, homeDir, packageRoot, targetAdapters, targetComponents, dryRun, priorState
+  });
 
   if (!dryRun) {
     await persistGlobalState({
@@ -82,7 +93,8 @@ export async function installGlobalHarness({
       targetComponents,
       homeDir,
       componentFiles,
-      backups: result.backups
+      backups: result.backups,
+      sdd: nextSddState(priorState?.sdd, result.integrations.sdd)
     });
   }
 
@@ -144,7 +156,9 @@ export async function syncGlobalHarness({
     configsUnchanged: [],
     backups: [],
     driftDetected: hasRepairableDrift(driftChecks),
-    repairs: driftChecks.filter((check) => check.status === "missing" || check.status === "stale")
+    repairs: driftChecks.filter((check) => check.status === "missing" || check.status === "stale"),
+    integrations: {},
+    sessionRefreshRequired: false
   };
 
   const { coreFiles, repaired, unchanged } = await repairComponentAssets({
@@ -184,6 +198,10 @@ export async function syncGlobalHarness({
     if (applied.action !== "unchanged") result.configsRepaired.push(applied.configFile);
   }
 
+  await attachSddLifecycle({
+    result, homeDir, packageRoot, targetAdapters, targetComponents, dryRun, priorState: state
+  });
+
   if (!dryRun) {
     await persistGlobalState({
       paths,
@@ -194,7 +212,8 @@ export async function syncGlobalHarness({
       homeDir,
       componentFiles: coreFiles,
       backups: [...(state.backups ?? []), ...result.backups],
-      installedAt: state.installedAt
+      installedAt: state.installedAt,
+      sdd: nextSddState(state?.sdd, result.integrations.sdd)
     });
   }
 
@@ -244,6 +263,22 @@ export async function uninstallGlobalHarness({ homeDir, dryRun = false }) {
   return result;
 }
 
+async function attachSddLifecycle({
+  result, homeDir, packageRoot, targetAdapters, targetComponents, dryRun, priorState
+}) {
+  const sdd = await applySddLifecycle({
+    homeDir,
+    packageRoot,
+    agentIds: targetAdapters.map((adapter) => adapter.id),
+    componentIds: targetComponents.map((component) => component.id),
+    dryRun,
+    priorSdd: priorState?.sdd ?? null,
+    yes: true
+  });
+  result.integrations.sdd = sdd;
+  result.sessionRefreshRequired = aggregateSessionRefreshRequired(result, sdd);
+}
+
 async function applyAdapterPlans({ context, targetAdapters, result }) {
   for (const adapter of targetAdapters) {
     const plan = adapter.plan(context);
@@ -266,7 +301,8 @@ async function persistGlobalState({
   homeDir,
   componentFiles,
   backups,
-  installedAt
+  installedAt,
+  sdd
 }) {
   const existingState = installedAt ? { installedAt } : await readGlobalState(paths.statePath);
   const adapterEntries = targetAdapters.map((adapter) => buildAdapterStateEntry(adapter, homeDir));
@@ -279,6 +315,7 @@ async function persistGlobalState({
     components: componentEntries,
     coreFiles: componentFiles,
     backups,
-    installedAt: existingState?.installedAt
+    installedAt: existingState?.installedAt,
+    sdd
   }));
 }

package/src/global/governance-actions.js

@@ -0,0 +1,212 @@
+import { createHash } from "node:crypto";
+import { buildChangesFromPlan } from "./diff.js";
+import { buildCheckSnapshot, recordRollbackHistory, recordSyncHistory } from "./history.js";
+import { harnessHomePaths } from "./paths.js";
+import { applyRollback, previewRollback } from "./rollback.js";
+import { buildStatusReport } from "./status.js";
+import { runHarnessSync } from "./sync.js";
+import { needsManagedRepair } from "./governance-repair.js";
+
+function stableJson(value) {
+  if (value == null || typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map(stableJson).join(",")}]`;
+  const keys = Object.keys(value).sort();
+  return `{${keys.map((key) => `${JSON.stringify(key)}:${stableJson(value[key])}`).join(",")}}`;
+}
+
+export function fingerprintGovernancePreview(payload) {
+  return createHash("sha256").update(stableJson(payload)).digest("hex");
+}
+
+function summarizeIntegrations(result) {
+  const sdd = result?.integrations?.sdd ?? null;
+  if (!sdd) return null;
+  return {
+    status: sdd.status ?? null,
+    partial: Boolean(sdd.partial),
+    conflicts: sdd.conflicts ?? [],
+    receiptId: sdd.receipt?.id ?? null,
+    sessionRefreshRequired: Boolean(result?.sessionRefreshRequired ?? sdd.sessionRefreshRequired)
+  };
+}
+
+function buildSyncPreviewBody({ action, report, result }) {
+  const changes = result ? buildChangesFromPlan(result) : [];
+  const integrations = summarizeIntegrations(result);
+  const hasIntegrationWork = Boolean(
+    integrations
+    && integrations.status
+    && integrations.status !== "skipped"
+    && integrations.status !== "noop"
+  );
+  return {
+    kind: "sync",
+    action,
+    setupRequired: action === "setup-required",
+    hasChanges: changes.length > 0 || hasIntegrationWork || needsManagedRepair(report),
+    changes,
+    integrations,
+    checksBefore: buildCheckSnapshot(report?.counts),
+    overall: report?.overall ?? null
+  };
+}
+
+async function captureSyncPreview(options) {
+  const outcome = await runHarnessSync({
+    ...options,
+    dryRun: true,
+    yes: false,
+    confirm: false,
+    json: true,
+    interactive: false,
+    preflight: false
+  });
+  const body = buildSyncPreviewBody({
+    action: outcome.action,
+    report: outcome.report,
+    result: outcome.result
+  });
+  const fingerprint = fingerprintGovernancePreview(body);
+  return { ...body, fingerprint, wrote: false };
+}
+
+export async function previewGovernanceSync(options) {
+  return captureSyncPreview(options);
+}
+
+export async function applyGovernanceSync({
+  preview,
+  packageRoot,
+  packageName,
+  cliVersion,
+  homeDir,
+  workspaceRoot = null
+}) {
+  if (!preview?.fingerprint) {
+    return { ok: false, reason: "missing-preview", wrote: false, receipt: null };
+  }
+
+  const paths = harnessHomePaths(homeDir);
+  const checksBefore = preview.checksBefore
+    ?? buildCheckSnapshot((await buildStatusReport(homeDir, { packageRoot, workspaceRoot }))?.counts);
+
+  const fresh = await captureSyncPreview({
+    packageRoot, packageName, cliVersion, homeDir, workspaceRoot
+  });
+
+  if (fresh.setupRequired) {
+    return { ok: false, reason: "setup-required", wrote: false, receipt: null, preview: fresh };
+  }
+
+  if (fresh.fingerprint !== preview.fingerprint) {
+    return { ok: false, reason: "stale-preview", wrote: false, receipt: null, preview: fresh };
+  }
+
+  if (!fresh.hasChanges) {
+    return {
+      ok: true,
+      reason: "noop",
+      wrote: false,
+      receipt: {
+        action: "noop",
+        backups: [],
+        checksBefore,
+        checksAfter: fresh.checksBefore,
+        integrations: fresh.integrations
+      }
+    };
+  }
+
+  const outcome = await runHarnessSync({
+    packageRoot,
+    packageName,
+    cliVersion,
+    homeDir,
+    workspaceRoot,
+    dryRun: false,
+    yes: true,
+    confirm: false,
+    json: true,
+    interactive: false,
+    preflight: false
+  });
+
+  await recordSyncHistory(homeDir, {
+    cliVersion,
+    options: { dryRun: false, yes: true, json: true, interactive: false, preflight: false },
+    outcome,
+    checksBefore,
+    packageRoot,
+    workspaceRoot
+  });
+
+  const afterReport = outcome.report
+    ?? await buildStatusReport(homeDir, { packageRoot, workspaceRoot });
+  const receipt = {
+    action: outcome.action,
+    backups: outcome.result?.backups ?? [],
+    checksBefore,
+    checksAfter: buildCheckSnapshot(afterReport?.counts),
+    integrations: summarizeIntegrations(outcome.result),
+    sessionRefreshRequired: Boolean(outcome.result?.sessionRefreshRequired),
+    historyPath: paths.historyPath
+  };
+
+  return {
+    ok: outcome.action === "repaired" || outcome.action === "noop",
+    reason: outcome.action,
+    wrote: Boolean(outcome.wrote),
+    receipt,
+    partial: Boolean(outcome.result?.integrations?.sdd?.partial)
+  };
+}
+
+function buildRollbackPreviewBody(preview) {
+  return {
+    kind: "rollback",
+    snapshot: preview.snapshot,
+    noop: Boolean(preview.noop),
+    files: (preview.plans ?? []).map((plan) => ({
+      backupName: plan.backupName,
+      displayPath: plan.displayPath
+    }))
+  };
+}
+
+export async function previewGovernanceRollback({ homeDir, snapshot }) {
+  const raw = await previewRollback({ homeDir, snapshot });
+  const body = buildRollbackPreviewBody(raw);
+  return { ...body, fingerprint: fingerprintGovernancePreview(body), wrote: false };
+}
+
+export async function applyGovernanceRollback({
+  preview,
+  homeDir,
+  cliVersion
+}) {
+  if (!preview?.fingerprint || !preview?.snapshot) {
+    return { ok: false, reason: "missing-preview", wrote: false, receipt: null };
+  }
+
+  const fresh = await previewGovernanceRollback({ homeDir, snapshot: preview.snapshot });
+  if (fresh.fingerprint !== preview.fingerprint) {
+    return { ok: false, reason: "stale-preview", wrote: false, receipt: null, preview: fresh };
+  }
+
+  const result = await applyRollback({ homeDir, snapshot: preview.snapshot });
+  await recordRollbackHistory(homeDir, { cliVersion, snapshot: preview.snapshot, result });
+
+  const afterReport = await buildStatusReport(homeDir, {});
+  return {
+    ok: true,
+    reason: result.noop ? "noop" : "applied",
+    wrote: !result.noop,
+    receipt: {
+      action: result.noop ? "noop" : "rollback",
+      snapshot: preview.snapshot,
+      restored: result.restored ?? [],
+      safetyBackup: result.safetyBackup ?? null,
+      checksAfter: buildCheckSnapshot(afterReport?.counts)
+    }
+  };
+}

package/src/global/governance-repair.js

@@ -0,0 +1,13 @@
+/** Shared “repair needed” rule for sync, diff/snapshot, and cockpit actions. */
+export function needsManagedRepair(statusReport) {
+  if (!statusReport) return false;
+  const needsSddRepair = (statusReport.checks ?? []).some((check) =>
+    check.componentId === "sdd-core"
+    && check.category === "integration"
+    && check.status === "warning"
+  );
+  return statusReport.overall === "drift"
+    || (statusReport.counts?.missing ?? 0) > 0
+    || (statusReport.counts?.stale ?? 0) > 0
+    || needsSddRepair;
+}

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

@@ -0,0 +1,124 @@
+import { formatProposalLines, proposalLimitForLayout } from "./cockpit-proposals.js";
+
+export const CHANGES_PHASE = Object.freeze({
+  IDLE: "idle",
+  PREVIEWING: "previewing",
+  CONFIRMING: "confirming",
+  APPLYING: "applying",
+  COMPLETED: "completed",
+  FAILED: "failed"
+});
+
+export function createChangesActionState() {
+  return { phase: CHANGES_PHASE.IDLE, preview: null, receipt: null, error: null, message: null };
+}
+
+export function reduceChangesAction(state, action) {
+  switch (action.type) {
+    case "reset":
+      return createChangesActionState();
+    case "preview-start":
+      return { ...createChangesActionState(), phase: CHANGES_PHASE.PREVIEWING, message: "Building exact preview…" };
+    case "preview-ready":
+      if (action.preview?.setupRequired) {
+        return {
+          ...createChangesActionState(),
+          phase: CHANGES_PHASE.FAILED,
+          error: "setup-required",
+          message: "Not configured — open Control center and run setup. Changes never installs silently."
+        };
+      }
+      if (!action.preview?.hasChanges) {
+        return {
+          ...createChangesActionState(),
+          phase: CHANGES_PHASE.IDLE,
+          preview: action.preview,
+          message: "No pending governance changes."
+        };
+      }
+      return {
+        phase: CHANGES_PHASE.CONFIRMING,
+        preview: action.preview,
+        receipt: null,
+        error: null,
+        message: "Confirm apply? Y apply · N/Esc cancel"
+      };
+    case "preview-failed":
+      return { ...state, phase: CHANGES_PHASE.FAILED, error: action.error ?? "preview-failed", message: action.message ?? "Preview failed." };
+    case "apply-start":
+      return { ...state, phase: CHANGES_PHASE.APPLYING, message: "Applying confirmed repairs…" };
+    case "apply-done":
+      return {
+        phase: action.ok ? CHANGES_PHASE.COMPLETED : CHANGES_PHASE.FAILED,
+        preview: action.preview ?? state.preview,
+        receipt: action.receipt ?? null,
+        error: action.ok ? null : (action.reason ?? "apply-failed"),
+        message: action.message ?? (action.ok ? "Apply complete." : "Apply failed.")
+      };
+    case "cancel":
+      return { ...createChangesActionState(), message: "Cancelled — no files written." };
+    default:
+      return state;
+  }
+}
+
+export function formatChangesActionLines({ snapshot, changesAction, layoutMode = "compact" }) {
+  const diff = snapshot?.diff;
+  const phase = changesAction?.phase ?? CHANGES_PHASE.IDLE;
+  const lines = [`Changes · ${phase}`];
+
+  const proposalLines = formatProposalLines(snapshot?.proposals ?? [], {
+    limit: proposalLimitForLayout(layoutMode),
+    destinationFilter: "changes",
+    budgets: snapshot?.budgets ?? null
+  });
+  if (proposalLines[0] !== "No proposals targeting this view.") {
+    lines.push(...proposalLines, "");
+  }
+
+  if (changesAction?.message) lines.push(changesAction.message);
+  if (changesAction?.error && changesAction.error !== "setup-required") lines.push(`Error: ${changesAction.error}`);
+
+  const preview = changesAction?.preview;
+  if (preview?.hasChanges) {
+    lines.push(`${preview.changes?.length ?? 0} planned change(s)`);
+    for (const change of preview.changes ?? []) {
+      lines.push(`${change.action ?? change.kind} · ${change.target} · ${change.status ?? "planned"}`);
+    }
+    if (preview.integrations?.status && preview.integrations.status !== "skipped") {
+      lines.push(`SDD lifecycle · ${preview.integrations.status}${preview.integrations.partial ? " (partial)" : ""}`);
+    }
+    if (preview.fingerprint) lines.push(`Fingerprint · ${preview.fingerprint.slice(0, 12)}…`);
+  } else if (diff && !preview) {
+    if (!diff.installed) lines.push(diff.summary ?? "Setup required before changes can be previewed.");
+    else if (!diff.hasChanges) lines.push(diff.summary ?? "No pending governance changes.");
+    else {
+      lines.push(diff.summary ?? "Pending changes");
+      for (const change of diff.changes ?? []) lines.push(`${change.action ?? change.kind} · ${change.target} · ${change.status}`);
+    }
+  } else if (!diff) {
+    lines.push("Scan did not include diff yet. Press R to re-scan.");
+  }
+
+  const receipt = changesAction?.receipt;
+  if (receipt) {
+    lines.push("", `Receipt · ${receipt.action}`);
+    if (receipt.backups?.length) lines.push(`Backups · ${receipt.backups.length}`);
+    if (receipt.checksBefore && receipt.checksAfter) {
+      lines.push(`Checks · before ok=${receipt.checksBefore.ok} → after ok=${receipt.checksAfter.ok}`);
+    }
+    if (receipt.integrations) lines.push(`Integrations · ${receipt.integrations.status ?? "n/a"}`);
+    if (receipt.partial) lines.push("Partial evidence retained — success not claimed.");
+  }
+
+  if (phase === CHANGES_PHASE.IDLE || phase === CHANGES_PHASE.COMPLETED || phase === CHANGES_PHASE.FAILED) {
+    lines.push("", "A preview · Y confirm apply · N/Esc cancel · R re-scan");
+  }
+  return lines;
+}
+
+export function buildChangesFooterParts(phase) {
+  if (phase === CHANGES_PHASE.PREVIEWING || phase === CHANGES_PHASE.APPLYING) return ["Working…", "Esc Back"];
+  if (phase === CHANGES_PHASE.CONFIRMING) return ["Y Apply", "N/Esc Cancel"];
+  return ["A Preview", "R Re-scan", "Esc Back"];
+}

package/src/global/ink/cockpit-control-center.js

@@ -0,0 +1,106 @@
+import { CONTROL_PLANE_HEALTH } from "../control-plane-snapshot.js";
+import { formatProposalLines, proposalLimitForLayout } from "./cockpit-proposals.js";
+
+export function buildControlCenterModel({
+  projectName = "project",
+  snapshot = null,
+  layoutMode = "compact"
+} = {}) {
+  if (!snapshot) {
+    return {
+      title: `CONTROL CENTER — ${projectName}`,
+      purpose: "Kairo aligns installed IDEs and agents with this project's architecture, rules, tools, and workflows.",
+      health: {
+        kind: CONTROL_PLANE_HEALTH.CHECK_FAILED,
+        label: "CHECK FAILED",
+        summaryLine: "Control-plane scan not available yet."
+      },
+      coverageLines: [],
+      cta: {
+        title: "NEXT",
+        actionTitle: "Retry scan",
+        actionDetail: "Press R to reload the read-only governance scan.",
+        enterHint: "R Retry",
+        kind: "verify",
+        destination: null
+      },
+      notes: [],
+      proposalLines: ["No evidence-backed proposals."],
+      includeEmbeddedStatus: layoutMode !== "wide"
+    };
+  }
+
+  const healthLabel = formatHealthLabel(snapshot.health);
+  const coverage = snapshot.coverage ?? {};
+  const policy = snapshot.policy;
+  const warnings = snapshot.status?.counts?.warning ?? 0;
+
+  return {
+    title: `CONTROL CENTER — ${projectName}`,
+    purpose: "Kairo aligns installed IDEs and agents with this project's architecture, rules, tools, and workflows.",
+    health: {
+      kind: snapshot.health,
+      label: healthLabel,
+      summaryLine: [
+        `${coverage.governedAgents ?? 0}/${coverage.detectedAgents ?? 0} agents governed`,
+        `${coverage.components ?? 0} modules`,
+        `${snapshot.backups?.count ?? 0} backups`
+      ].join(" · ")
+    },
+    coverageLines: [
+      `Active modules: ${(coverage.activeModules ?? []).join(", ") || "none"}`,
+      `Policy: ${policy?.profile ?? "none"} · applyMode ${policy?.applyMode ?? "n/a"}`,
+      warnings > 0
+        ? `Notes: ${warnings} non-blocking check warning(s)`
+        : "Notes: none",
+      snapshot.diff?.hasChanges
+        ? `Drift: ${snapshot.diff.changeCount ?? snapshot.diff.changes?.length ?? 0} change(s) pending review`
+        : "Drift: clean"
+    ],
+    cta: {
+      title: "NEXT",
+      actionTitle: snapshot.cta?.title ?? "Review control plane",
+      actionDetail: snapshot.cta?.detail ?? "",
+      enterHint: "Enter again →",
+      kind: snapshot.cta?.kind ?? null,
+      destination: snapshot.cta?.destination ?? null
+    },
+    notes: buildNotes(snapshot),
+    proposalLines: formatProposalLines(snapshot.proposals ?? [], {
+      limit: proposalLimitForLayout(layoutMode),
+      budgets: snapshot.budgets ?? null
+    }),
+    includeEmbeddedStatus: layoutMode !== "wide",
+    runsSecondaryHint: "Runs remain available as a secondary capability after setup and repairs."
+  };
+}
+
+function formatHealthLabel(kind) {
+  switch (kind) {
+    case CONTROL_PLANE_HEALTH.NOT_CONFIGURED:
+      return "NOT CONFIGURED";
+    case CONTROL_PLANE_HEALTH.ACTION_REQUIRED:
+      return "ACTION REQUIRED";
+    case CONTROL_PLANE_HEALTH.HEALTHY_WITH_NOTES:
+      return "HEALTHY WITH NOTES";
+    case CONTROL_PLANE_HEALTH.HEALTHY:
+      return "HEALTHY";
+    case CONTROL_PLANE_HEALTH.CHECK_FAILED:
+      return "CHECK FAILED";
+    default:
+      return String(kind ?? "UNKNOWN");
+  }
+}
+
+function buildNotes(snapshot) {
+  const notes = [];
+  for (const check of snapshot.status?.checks ?? []) {
+    if (check.status === "warning") {
+      notes.push(`${check.name}: ${check.detail ?? check.status}`);
+    }
+  }
+  if (notes.length === 0 && snapshot.health === CONTROL_PLANE_HEALTH.HEALTHY_WITH_NOTES) {
+    notes.push("Non-blocking notes are present. Open IDEs & models or Harness modules for detail.");
+  }
+  return notes.slice(0, 6);
+}

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

@@ -12,6 +12,8 @@ import {
   regionsForLayout,
   routeCockpitKey
 } from "./cockpit-focus.js";
+import { isRunsChildView } from "./cockpit-runs.js";
+import { navIndexForView } from "./cockpit-models.js";
 
 export {
   canTabBetweenRegions,
@@ -142,6 +144,9 @@ export function reduceCockpitUi(state, action) {
           returnView: null
         };
       }
+      if (isRunsChildView(state.view)) {
+        return goRunsHub(state);
+      }
       if (state.view !== ORCHESTRATOR_VIEWS.HOME) {
         return goOverview(state);
       }
@@ -169,3 +174,15 @@ function goOverview(state) {
     returnView: null
   };
 }
+
+function goRunsHub(state) {
+  return {
+    ...state,
+    helpOpen: false,
+    view: ORCHESTRATOR_VIEWS.RUNS,
+    navIndex: navIndexForView(ORCHESTRATOR_VIEWS.RUNS),
+    listIndex: 0,
+    region: defaultRegionForView(ORCHESTRATOR_VIEWS.RUNS, state.layoutMode),
+    returnView: null
+  };
+}

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

@@ -0,0 +1,27 @@
+import { ORCHESTRATOR_VIEWS } from "./orchestrator-state.js";
+
+/**
+ * Separate nav open from Control center CTA activation.
+ * Enter opens Control center first; Enter again while there activates the CTA.
+ */
+export function resolveEnterNavIntent({
+  currentView,
+  navItem,
+  ctaDestination = null
+} = {}) {
+  if (!navItem) return { kind: "noop" };
+
+  const isOverview = navItem.id === "overview" || navItem.view === ORCHESTRATOR_VIEWS.HOME;
+  if (isOverview) {
+    if (currentView === ORCHESTRATOR_VIEWS.HOME && ctaDestination) {
+      return { kind: "activate-cta", destination: ctaDestination };
+    }
+    return { kind: "open-nav", view: ORCHESTRATOR_VIEWS.HOME };
+  }
+
+  if (navItem.action === "launch") {
+    return { kind: "launch" };
+  }
+
+  return { kind: "open-nav", view: navItem.view };
+}

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

@@ -4,16 +4,22 @@ import { LAYOUT_MODES } from "./layout.js";
 
 const NAV_FOCUSED_VIEWS = new Set([
   ORCHESTRATOR_VIEWS.HOME,
+  ORCHESTRATOR_VIEWS.IDES,
+  ORCHESTRATOR_VIEWS.MODULES,
+  ORCHESTRATOR_VIEWS.CHANGES,
+  ORCHESTRATOR_VIEWS.PROFILE,
   ORCHESTRATOR_VIEWS.PROVIDERS,
   ORCHESTRATOR_VIEWS.DIAGNOSTICS,
   ORCHESTRATOR_VIEWS.HELP
 ]);
 
 const CONTENT_INTERACTIVE_VIEWS = new Set([
+  ORCHESTRATOR_VIEWS.RUNS,
   ORCHESTRATOR_VIEWS.ACTIVE_RUNS,
   ORCHESTRATOR_VIEWS.RECENT_RUNS,
   ORCHESTRATOR_VIEWS.RUN_DETAIL,
-  ORCHESTRATOR_VIEWS.LAUNCH
+  ORCHESTRATOR_VIEWS.LAUNCH,
+  ORCHESTRATOR_VIEWS.ACTIVITY
 ]);
 
 export function isNavFocusedView(view) {