cue-ai 0.5.0 → 0.7.0

package/src/commands/cli.ts

@@ -0,0 +1,303 @@
+/**
+ * `cue cli list [profile]`              — show required CLIs + install status
+ * `cue cli install <tool>`              — install one tool via the right pkg manager
+ * `cue cli install --all [profile]`     — install every missing tool the active
+ *                                          profile needs (skips manual-install ones)
+ *
+ * Flags:
+ *   --dry-run  (default)  print what would run, don't execute
+ *   --yes                 actually execute (still prompts for sudo via the cmd itself)
+ *   --json                machine output
+ *
+ * OS detection: linux + which package manager is present (apt > dnf > pacman);
+ * macOS uses brew; Windows uses winget. Falls back to manual hints when the
+ * recipe doesn't declare the needed mode.
+ */
+
+import { spawnSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { join, dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { homedir, platform } from "node:os";
+
+import { resolveProfileForCwd } from "../lib/cwd-resolver";
+import { requiredClisFor } from "../lib/cli-extractor";
+import { listProfiles } from "../lib/profile-loader";
+
+const REPO_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..", "..");
+const RECIPES_PATH = join(REPO_ROOT, "resources", "cli-recipes.json");
+
+type Recipe = Partial<Record<"apt" | "brew" | "dnf" | "pacman" | "snap" | "winget" | "pip" | "pipx" | "npm" | "script" | "manual" | "needs", string>>;
+
+const bold = (s: string) => `\x1b[1m${s}\x1b[0m`;
+const green = (s: string) => `\x1b[32m${s}\x1b[0m`;
+const red = (s: string) => `\x1b[31m${s}\x1b[0m`;
+const yellow = (s: string) => `\x1b[33m${s}\x1b[0m`;
+const dim = (s: string) => `\x1b[2m${s}\x1b[0m`;
+
+function which(cmd: string): boolean {
+  return spawnSync("which", [cmd], { stdio: "ignore", timeout: 1000 }).status === 0;
+}
+
+function readRecipes(): Record<string, Recipe> {
+  try { return JSON.parse(readFileSync(RECIPES_PATH, "utf8")); }
+  catch { return {}; }
+}
+
+/**
+ * Pick the best install command for the current OS.
+ * Returns the shell command to run, or { manual: hint } when nothing works.
+ */
+interface InstallPlan {
+  cli: string;
+  mode: "apt" | "brew" | "dnf" | "pacman" | "snap" | "winget" | "pip" | "pipx" | "npm" | "script" | "manual" | "unknown";
+  command?: string;
+  hint?: string;
+  needs?: string;
+}
+
+function planInstall(cli: string, recipe: Recipe | undefined): InstallPlan {
+  if (!recipe) return { cli, mode: "unknown", hint: `no recipe for "${cli}" in resources/cli-recipes.json` };
+  const os = platform();
+  const tries: Array<[InstallPlan["mode"], string]> = [];
+  if (os === "linux") {
+    if (recipe.apt && which("apt"))       tries.push(["apt",    `sudo apt install -y ${recipe.apt}`]);
+    if (recipe.dnf && which("dnf"))       tries.push(["dnf",    `sudo dnf install -y ${recipe.dnf}`]);
+    if (recipe.pacman && which("pacman")) tries.push(["pacman", `sudo pacman -S --noconfirm ${recipe.pacman}`]);
+    // snap as a fallback for tools that aren't in distro repos (helm, terraform, etc.)
+    if (recipe.snap && which("snap")) {
+      const classic = recipe.snap.includes("--classic") ? "" : " --classic";
+      const pkg = recipe.snap.replace(/--classic\s*/, "").trim();
+      tries.push(["snap", `sudo snap install ${pkg}${classic}`]);
+    }
+  } else if (os === "darwin") {
+    if (recipe.brew && which("brew"))     tries.push(["brew",   `brew install ${recipe.brew}`]);
+  } else if (os === "win32") {
+    if (recipe.winget && which("winget")) tries.push(["winget", `winget install --id ${recipe.winget} -e`]);
+  }
+  // Cross-platform language pkg managers as fallback.
+  // For Python packages: prefer pipx (isolated, ships its own pip), then pip3
+  // direct binary, then python3 -m pip. Some distros (Nix, some minimal Linux
+  // installs) ship python3 without the pip module, so `python3 -m pip` fails
+  // even when pip3 works fine. Auto-promote `pip` recipes to pipx when pipx is
+  // available — most pip recipes here are CLI tools, which is exactly what
+  // pipx is designed for.
+  if (recipe.pipx && which("pipx")) {
+    tries.push(["pipx", `pipx install ${recipe.pipx}`]);
+  } else if (recipe.pip) {
+    if (which("pipx"))     tries.push(["pipx", `pipx install ${recipe.pip}`]);
+    else if (which("pip3")) tries.push(["pip",  `pip3 install --user ${recipe.pip}`]);
+    else                    tries.push(["pip",  `python3 -m pip install --user ${recipe.pip}`]);
+  }
+  if (recipe.npm && which("npm"))    tries.push(["npm",  `npm install -g ${recipe.npm}`]);
+  if (recipe.script)                 tries.push(["script", recipe.script]);
+
+  if (tries.length === 0) {
+    const manual = recipe.manual ?? `no installer for this OS/recipe`;
+    return { cli, mode: "manual", hint: manual, needs: recipe.needs };
+  }
+  const [mode, command] = tries[0]!;
+  return { cli, mode, command, needs: recipe.needs };
+}
+
+async function resolveProfileArg(args: string[]): Promise<string | undefined> {
+  const arg = args.find((a) => !a.startsWith("-"));
+  if (arg) return arg;
+  try {
+    const r = await resolveProfileForCwd({ cwd: process.cwd(), homeDir: homedir(), configDir: join(homedir(), ".config", "cue") });
+    if (r.source !== "none") return (r as any).profile;
+  } catch {}
+  return undefined;
+}
+
+async function listAllProfilesCmd(args: string[]): Promise<number> {
+  const asJson = args.includes("--json");
+  const missingOnly = args.includes("--missing-only");
+  const recipes = readRecipes();
+
+  // Aggregate: which profiles need each CLI?
+  const byCli = new Map<string, { profiles: Set<string>; skillCount: number }>();
+  const names = await listProfiles();
+  for (const name of names) {
+    try {
+      const reqs = await requiredClisFor(name);
+      for (const r of reqs) {
+        const entry = byCli.get(r.cli) ?? { profiles: new Set(), skillCount: 0 };
+        entry.profiles.add(name);
+        entry.skillCount += r.skills.length;
+        byCli.set(r.cli, entry);
+      }
+    } catch { /* skip broken profile */ }
+  }
+
+  let rows = [...byCli.entries()].map(([cli, info]) => ({
+    cli,
+    installed: which(cli),
+    profileCount: info.profiles.size,
+    profiles: [...info.profiles].sort(),
+    skillCount: info.skillCount,
+    plan: planInstall(cli, recipes[cli]),
+  }));
+  if (missingOnly) rows = rows.filter((r) => !r.installed);
+  // Sort: not-installed first (action items), then by # profiles desc.
+  rows.sort((a, b) => Number(a.installed) - Number(b.installed) || b.profileCount - a.profileCount);
+
+  if (asJson) {
+    process.stdout.write(JSON.stringify({ rows }, null, 2) + "\n");
+    return 0;
+  }
+
+  const totalCli = rows.length;
+  const installed = rows.filter((r) => r.installed).length;
+  const missing = totalCli - installed;
+  process.stdout.write(`\n  ${bold("All profiles")}  ·  ${totalCli} unique CLIs  ·  ${green(`✅ ${installed}`)} · ${red(`❌ ${missing}`)}\n\n`);
+  process.stdout.write(`    ${"cli".padEnd(15)}  ${"profiles".padStart(8)}  ${"plan".padEnd(8)}  used by\n`);
+  process.stdout.write(`    ${"-".repeat(15)}  ${"-".repeat(8)}  ${"-".repeat(8)}  ${"-".repeat(40)}\n`);
+  for (const r of rows) {
+    const mark = r.installed ? green("✓") : red("✗");
+    const mode = r.installed ? dim("installed")
+      : r.plan.mode === "manual" ? yellow("manual")
+      : r.plan.mode === "unknown" ? red("none")
+      : dim(r.plan.mode);
+    const profList = r.profiles.length <= 3
+      ? r.profiles.join(", ")
+      : `${r.profiles.slice(0, 3).join(", ")} +${r.profiles.length - 3} more`;
+    process.stdout.write(`  ${mark} ${r.cli.padEnd(15)}  ${String(r.profileCount).padStart(8)}  ${mode.padEnd(8)}  ${dim(profList)}\n`);
+  }
+  process.stdout.write(`\n  Filter: ${bold("cue cli list --all-profiles --missing-only")}\n\n`);
+  return 0;
+}
+
+async function listCmd(args: string[]): Promise<number> {
+  if (args.includes("--all-profiles")) return listAllProfilesCmd(args);
+
+  const profile = await resolveProfileArg(args);
+  if (!profile) {
+    process.stderr.write("Usage: cue cli list [profile] | --all-profiles [--missing-only]\n");
+    return 1;
+  }
+  const asJson = args.includes("--json");
+  const reqs = await requiredClisFor(profile);
+  const recipes = readRecipes();
+
+  const rows = reqs.map((r) => ({
+    cli: r.cli,
+    installed: which(r.cli),
+    skillCount: r.skills.length,
+    plan: planInstall(r.cli, recipes[r.cli]),
+  }));
+
+  if (asJson) {
+    process.stdout.write(JSON.stringify({ profile, rows }, null, 2) + "\n");
+    return 0;
+  }
+
+  const installed = rows.filter((r) => r.installed).length;
+  const missing = rows.length - installed;
+  process.stdout.write(`\n  ${bold(profile)} — ${rows.length} CLIs · ${green(`✅ ${installed}`)} · ${red(`❌ ${missing}`)}\n\n`);
+  for (const r of rows) {
+    const mark = r.installed ? green("✓") : red("✗");
+    const mode = r.installed ? dim("(installed)")
+      : r.plan.mode === "manual" ? yellow("manual")
+      : r.plan.mode === "unknown" ? red("no recipe")
+      : dim(`→ ${r.plan.mode}`);
+    process.stdout.write(`    ${mark} ${r.cli.padEnd(15)}  ${String(r.skillCount).padStart(3)} skills  ${mode}\n`);
+  }
+  process.stdout.write(`\n  Run ${bold("cue cli install --all")} to install the auto-installable ones.\n\n`);
+  return 0;
+}
+
+async function installCmd(args: string[]): Promise<number> {
+  const all = args.includes("--all");
+  const yes = args.includes("--yes");
+  const dryRun = !yes;
+  const asJson = args.includes("--json");
+  const positional = args.filter((a) => !a.startsWith("-"));
+  const recipes = readRecipes();
+
+  let targets: string[] = [];
+  if (all) {
+    const profile = await resolveProfileArg(positional);
+    if (!profile) {
+      process.stderr.write("Usage: cue cli install --all [profile]\n");
+      return 1;
+    }
+    const reqs = await requiredClisFor(profile);
+    targets = reqs.filter((r) => !which(r.cli)).map((r) => r.cli);
+  } else {
+    if (positional.length === 0) {
+      process.stderr.write("Usage: cue cli install <tool> | --all [profile]\n");
+      return 1;
+    }
+    targets = positional;
+  }
+
+  if (targets.length === 0) {
+    process.stdout.write(`  ${green("All required CLIs are already installed.")}\n`);
+    return 0;
+  }
+
+  const plans = targets.map((cli) => planInstall(cli, recipes[cli]));
+  const installable = plans.filter((p) => p.command);
+  const manual = plans.filter((p) => !p.command);
+
+  if (asJson) {
+    process.stdout.write(JSON.stringify({ dryRun, plans }, null, 2) + "\n");
+    return 0;
+  }
+
+  process.stdout.write(`\n  ${bold(`${installable.length} installable`)}  ·  ${yellow(`${manual.length} manual`)}\n\n`);
+
+  if (installable.length > 0) {
+    process.stdout.write(`  ${bold("Install plan")} ${dryRun ? dim("(dry-run — pass --yes to execute)") : ""}\n`);
+    for (const p of installable) {
+      process.stdout.write(`    ${green("•")} ${p.cli.padEnd(15)}  ${dim(`(${p.mode})`)}  ${p.command}\n`);
+      if (p.needs) process.stdout.write(`      ${dim("note: " + p.needs)}\n`);
+    }
+    process.stdout.write("\n");
+  }
+
+  if (manual.length > 0) {
+    process.stdout.write(`  ${bold("Manual (skipping)")}\n`);
+    for (const p of manual) {
+      process.stdout.write(`    ${yellow("•")} ${p.cli.padEnd(15)}  ${p.hint ?? ""}\n`);
+    }
+    process.stdout.write("\n");
+  }
+
+  if (dryRun) return 0;
+
+  // Execute installable plans sequentially. sudo will prompt as needed.
+  let failed = 0;
+  for (const p of installable) {
+    process.stdout.write(`\n  ${bold(`→ Installing ${p.cli}`)}\n  ${dim("$ " + p.command)}\n`);
+    const res = spawnSync("bash", ["-c", p.command!], { stdio: "inherit" });
+    if (res.status !== 0) {
+      process.stdout.write(`  ${red(`✗ ${p.cli} install failed (exit ${res.status})`)}\n`);
+      failed++;
+    } else {
+      process.stdout.write(`  ${green(`✓ ${p.cli} installed`)}\n`);
+    }
+  }
+  if (failed > 0) {
+    process.stdout.write(`\n  ${red(`${failed} install(s) failed.`)}\n`);
+    return 1;
+  }
+  process.stdout.write(`\n  ${green(`${installable.length} installed.`)}\n`);
+  return 0;
+}
+
+export async function run(args: string[]): Promise<number> {
+  const sub = args[0];
+  const rest = args.slice(1);
+  switch (sub) {
+    case "list":    return listCmd(rest);
+    case "install": return installCmd(rest);
+    default:
+      process.stderr.write("Usage: cue cli <list|install> [args]\n");
+      process.stderr.write("  cue cli list [profile]\n");
+      process.stderr.write("  cue cli install <tool>\n");
+      process.stderr.write("  cue cli install --all [profile] [--yes] [--json]\n");
+      return sub ? 1 : 0;
+  }
+}

package/src/commands/current.ts

@@ -1,5 +1,5 @@
 /**
- * `soul current` — print the active profile and resolved capability list.
+ * `cue current` — print the active profile and resolved capability list.
  *
  * Reads .cue-profile / repo-default / global-default via cwd-resolver.
  * Outputs profile name, source, skill count, MCP count, plugin count, and runtime dir.

package/src/commands/debug.test.ts

@@ -0,0 +1,62 @@
+/**
+ * Tests for `cue debug`. Asserts on stdout content for representative cases.
+ * Uses the real profiles tree — debug is a diagnostic command, not pure.
+ */
+
+import { describe, expect, test, beforeEach } from "bun:test";
+import { run as debugRun } from "./debug";
+
+beforeEach(() => {
+  delete process.env.CUE_PROFILES_DIR;
+  delete process.env.SOUL_PROFILES_DIR;
+});
+
+function strip(s: string): string {
+  return s.replace(/\x1b\[[0-9;]*m/g, "");
+}
+
+async function captureStdout<T>(fn: () => Promise<T>): Promise<{ stdout: string; value: T }> {
+  const orig = process.stdout.write.bind(process.stdout);
+  let buf = "";
+  (process.stdout as any).write = (chunk: string | Uint8Array) => { buf += String(chunk); return true; };
+  try {
+    const value = await fn();
+    return { stdout: buf, value };
+  } finally {
+    (process.stdout as any).write = orig;
+  }
+}
+
+describe("cue debug", () => {
+  test("explicit profile arg wins over cwd auto-detect, reports all sections", async () => {
+    const { stdout, value } = await captureStdout(() => debugRun(["ecc"]));
+    // Exit code can be 0 or 1 — the profile may have skills missing from disk
+    // (managed by other sessions). What matters is that all sections render.
+    expect(value === 0 || value === 1).toBe(true);
+    const clean = strip(stdout);
+    expect(clean).toContain("Profile: ecc (source: cli-arg)");
+    expect(clean).toContain("Inheritance: core → ecc");
+    expect(clean).toContain("Skills");
+    expect(clean).toContain("MCPs");
+    expect(clean).toContain("Rules");
+    expect(clean).toContain("Commands");
+    expect(clean).toContain("Hooks");
+    expect(clean).toContain("Summary:");
+  });
+
+  test("glob skill ids (full profile uses */*) are not reported as missing", async () => {
+    const { stdout, value } = await captureStdout(() => debugRun(["full"]));
+    expect(value === 0 || value === 1).toBe(true);
+    const clean = strip(stdout);
+    // No "not found" / no "✗" for glob entries — they're resolved at materialize time
+    expect(clean).not.toContain("*/* — not found");
+    expect(clean).toContain("Summary:");
+  });
+
+  test("verbose mode lists each skill individually", async () => {
+    const { stdout } = await captureStdout(() => debugRun(["ecc", "--verbose"]));
+    const clean = strip(stdout);
+    // ecc has 8 inherited skills; at least one should show up by name
+    expect(clean).toMatch(/meta\/analyze|caveman\/caveman|nvidia\/skill-evolution/);
+  });
+});

package/src/commands/debug.ts

@@ -0,0 +1,212 @@
+/**
+ * `cue debug [profile]` — trace why skills/MCPs aren't loading.
+ *
+ * Walks the full resolution chain and reports at each step:
+ * - Profile resolution (which .cue-profile, inheritance chain)
+ * - Skill resolution (found/missing, path, size)
+ * - MCP resolution (in registry or not, env vars set)
+ * - Plugin resolution (installed or not)
+ * - Runtime state (hash, stale, symlinks)
+ */
+
+import { resolve, join, dirname } from "node:path";
+import { existsSync, readFileSync, lstatSync, readlinkSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { homedir } from "node:os";
+
+import { loadProfile } from "../lib/profile-loader";
+import { resolveProfileForCwd } from "../lib/cwd-resolver";
+
+const REPO_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..", "..");
+const SKILLS_ROOT = join(REPO_ROOT, "resources", "skills", "skills");
+const MCP_CONFIGS_DIR = join(REPO_ROOT, "resources", "mcps", "configs");
+const RUNTIME_ROOT = join(homedir(), ".config", "cue", "runtime");
+
+export async function run(args: string[]): Promise<number> {
+  const explicitProfile = args.find(a => !a.startsWith("-"));
+  let profileName = explicitProfile;
+  const verbose = args.includes("-v") || args.includes("--verbose");
+
+  const green = (s: string) => `\x1b[32m${s}\x1b[0m`;
+  const red = (s: string) => `\x1b[31m${s}\x1b[0m`;
+  const yellow = (s: string) => `\x1b[33m${s}\x1b[0m`;
+  const dim = (s: string) => `\x1b[2m${s}\x1b[0m`;
+  const bold = (s: string) => `\x1b[1m${s}\x1b[0m`;
+
+  process.stdout.write(`\n  ${bold("cue debug")} — tracing profile resolution\n\n`);
+
+  // 1. Profile resolution — explicit arg wins over cwd auto-detection
+  process.stdout.write(`  ${bold("① Profile Resolution")}\n`);
+  if (explicitProfile) {
+    process.stdout.write(`    ${green("✓")} Profile: ${explicitProfile} (source: cli-arg)\n`);
+  } else {
+    const cwd = process.cwd();
+    try {
+      const resolved = await resolveProfileForCwd({ cwd, homeDir: homedir(), configDir: join(homedir(), ".config", "cue") });
+      if (resolved.source === "none") {
+        process.stdout.write(`    ${red("✗")} No profile found for ${cwd}\n`);
+        process.stdout.write(`    ${dim("Fix: echo <profile> > .cue-profile or pass a profile name")}\n\n`);
+        return 1;
+      }
+      profileName = (resolved as any).profile;
+      process.stdout.write(`    ${green("✓")} Profile: ${profileName} (source: ${resolved.source})\n`);
+    } catch (e) {
+      process.stdout.write(`    ${red("✗")} Resolution failed: ${e}\n`);
+      return 1;
+    }
+  }
+
+  // 2. Load profile
+  process.stdout.write(`\n  ${bold("② Profile Loading")}\n`);
+  let profile;
+  try {
+    profile = await loadProfile(profileName!);
+    process.stdout.write(`    ${green("✓")} Loaded: ${profileName}\n`);
+    process.stdout.write(`    ${dim(`Inheritance: ${profile.inheritanceChain.join(" → ")}`)}\n`);
+  } catch (e) {
+    process.stdout.write(`    ${red("✗")} Failed to load: ${e}\n`);
+    return 1;
+  }
+
+  // 3. Skills — expand glob ids (e.g. "*/*") instead of treating them literally
+  process.stdout.write(`\n  ${bold("③ Skills")} (${profile.skills.local.length} local, ${profile.skills.npx.length} npx)\n`);
+  let skillIssues = 0;
+  let resolvedCount = 0;
+  for (const s of profile.skills.local) {
+    const id = s.id;
+    if (id.includes("*")) {
+      if (verbose) process.stdout.write(`    ${dim(`~ ${id} (glob — resolved at materialize time)`)}\n`);
+      continue;
+    }
+    const path = join(SKILLS_ROOT, id, "SKILL.md");
+    if (existsSync(path)) {
+      resolvedCount++;
+      if (verbose) {
+        const size = readFileSync(path, "utf8").length;
+        process.stdout.write(`    ${green("✓")} ${id} ${dim(`(${Math.ceil(size/4)} tokens)`)}\n`);
+      }
+    } else {
+      process.stdout.write(`    ${red("✗")} ${id} — not found at ${path}\n`);
+      skillIssues++;
+    }
+  }
+  if (skillIssues === 0 && !verbose) {
+    process.stdout.write(`    ${green("✓")} ${resolvedCount} literal skill ids resolved\n`);
+  }
+
+  // 4. MCPs
+  process.stdout.write(`\n  ${bold("④ MCPs")} (${profile.mcps.length})\n`);
+  const mcpIds = new Set<string>();
+  for (const file of ["claude_runtime.sanitized.json", "claude.sanitized.json", "codex.sanitized.json"]) {
+    try {
+      const raw = JSON.parse(readFileSync(join(MCP_CONFIGS_DIR, file), "utf8"));
+      if (raw.servers) for (const id of Object.keys(raw.servers)) mcpIds.add(id);
+    } catch {}
+  }
+
+  let mcpIssues = 0;
+  for (const m of profile.mcps) {
+    const id = m.id;
+    if (mcpIds.has(id)) {
+      if (verbose) process.stdout.write(`    ${green("✓")} ${id} — in registry\n`);
+    } else {
+      process.stdout.write(`    ${red("✗")} ${id} — NOT in any MCP registry config\n`);
+      mcpIssues++;
+    }
+  }
+  if (mcpIssues === 0 && !verbose) {
+    process.stdout.write(`    ${green("✓")} All ${profile.mcps.length} MCPs found in registry\n`);
+  }
+
+  // 4b. Rules / Commands / Hooks
+  const RESOURCES_ROOT = join(REPO_ROOT, "resources");
+  let resourceIssues = 0;
+  for (const [kind, refs, base] of [
+    ["Rules", profile.rules, join(RESOURCES_ROOT, "rules")],
+    ["Commands", profile.commands, join(RESOURCES_ROOT, "commands")],
+    ["Hooks", profile.hooks, join(RESOURCES_ROOT, "hooks")],
+  ] as const) {
+    if (refs.length === 0) continue;
+    process.stdout.write(`\n  ${bold(`④${kind === "Rules" ? "a" : kind === "Commands" ? "b" : "c"} ${kind}`)} (${refs.length})\n`);
+    let missing = 0;
+    for (const ref of refs) {
+      const needsExt = kind !== "Hooks" && !ref.endsWith(".md");
+      const path = needsExt ? join(base, `${ref}.md`) : (ref.startsWith("/") ? ref : join(base, ref));
+      if (existsSync(path)) {
+        if (verbose) process.stdout.write(`    ${green("✓")} ${ref}\n`);
+      } else {
+        process.stdout.write(`    ${red("✗")} ${ref} — not found at ${path}\n`);
+        missing++;
+      }
+    }
+    if (missing === 0 && !verbose) {
+      process.stdout.write(`    ${green("✓")} All ${refs.length} ${kind.toLowerCase()} found\n`);
+    }
+    resourceIssues += missing;
+  }
+
+  // 5. Runtime state
+  process.stdout.write(`\n  ${bold("⑤ Runtime State")}\n`);
+  const runtimeDir = join(RUNTIME_ROOT, profileName!, "claude");
+  if (existsSync(runtimeDir)) {
+    const hashFile = join(runtimeDir, ".cue-hash");
+    if (existsSync(hashFile)) {
+      const hash = readFileSync(hashFile, "utf8").trim();
+      process.stdout.write(`    ${green("✓")} Runtime exists: ${runtimeDir}\n`);
+      process.stdout.write(`    ${dim(`Hash: ${hash.slice(0, 16)}...`)}\n`);
+    } else {
+      process.stdout.write(`    ${yellow("⚠")} Runtime exists but no hash — may be stale\n`);
+    }
+
+    // Check credentials
+    const creds = join(runtimeDir, ".credentials.json");
+    if (existsSync(creds)) {
+      const st = lstatSync(creds);
+      if (st.isSymbolicLink()) {
+        const target = readlinkSync(creds);
+        process.stdout.write(`    ${yellow("⚠")} Credentials: symlink → ${target} ${dim("(should be copy)")}\n`);
+      } else {
+        process.stdout.write(`    ${green("✓")} Credentials: present (${st.size} bytes)\n`);
+      }
+    } else {
+      process.stdout.write(`    ${red("✗")} Credentials: missing — will need /login\n`);
+    }
+
+    // Check skills symlinks
+    const skillsDir = join(runtimeDir, "skills");
+    if (existsSync(skillsDir)) {
+      const { readdirSync } = await import("node:fs");
+      const entries = readdirSync(skillsDir);
+      let broken = 0;
+      for (const e of entries) {
+        const p = join(skillsDir, e);
+        try {
+          const st = lstatSync(p);
+          if (st.isSymbolicLink()) {
+            const target = readlinkSync(p);
+            if (!existsSync(resolve(dirname(p), target))) broken++;
+          }
+        } catch { broken++; }
+      }
+      if (broken > 0) {
+        process.stdout.write(`    ${red("✗")} ${broken} broken skill symlinks in runtime\n`);
+      } else {
+        process.stdout.write(`    ${green("✓")} ${entries.length} skill symlinks OK\n`);
+      }
+    }
+  } else {
+    process.stdout.write(`    ${dim("No runtime materialized yet — will build on next launch")}\n`);
+  }
+
+  // Summary
+  const totalIssues = skillIssues + mcpIssues + resourceIssues;
+  process.stdout.write(`\n  ${bold("Summary:")} `);
+  if (totalIssues === 0) {
+    process.stdout.write(`${green("All clear")} — profile should load correctly.\n`);
+  } else {
+    process.stdout.write(`${red(`${totalIssues} issue(s)`)} found. Fix and run \`cue doctor --fix\`.\n`);
+  }
+  process.stdout.write("\n");
+
+  return totalIssues > 0 ? 1 : 0;
+}