cue-ai 0.9.0 → 0.9.2

package/src/commands/doctor.test.ts

@@ -0,0 +1,58 @@
+/**
+ * D9 activation check (checkActivation). Injectable opts let us drive it
+ * against a throwaway HOME/PATH without touching the real machine.
+ */
+import { describe, expect, test, beforeEach, afterEach } from "bun:test";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { checkActivation } from "./doctor";
+
+let home: string;
+let binDir: string;
+beforeEach(() => {
+  home = mkdtempSync(join(tmpdir(), "cue-doctor-"));
+  binDir = join(home, ".local", "bin");
+  mkdirSync(binDir, { recursive: true });
+});
+afterEach(() => rmSync(home, { recursive: true, force: true }));
+
+function writeShim() {
+  writeFileSync(join(binDir, "claude"), '#!/usr/bin/env bash\nexec cue launch claude "$@"\n');
+}
+
+describe("checkActivation (D9)", () => {
+  test("no shim → D9 warning (gating)", () => {
+    const issues = checkActivation({ homeDir: home, realBin: "/usr/bin/claude", pathDirs: [binDir, "/usr/bin"] });
+    expect(issues).toHaveLength(1);
+    expect(issues[0]!.code).toBe("D9");
+    expect(issues[0]!.severity).toBe("warning");
+    expect(issues[0]!.message).toContain("shim missing");
+    expect(issues[0]!.fix).toBe("cue shell install");
+  });
+
+  test("shim + real bin + ~/.local/bin first on PATH → healthy", () => {
+    writeShim();
+    const issues = checkActivation({ homeDir: home, realBin: "/usr/bin/claude", pathDirs: [binDir, "/usr/bin"] });
+    expect(issues).toHaveLength(0);
+  });
+
+  test("shim + real bin shadowing the shim on PATH → D9 error", () => {
+    writeShim();
+    const issues = checkActivation({ homeDir: home, realBin: "/usr/bin/claude", pathDirs: ["/usr/bin", binDir] });
+    expect(issues).toHaveLength(1);
+    expect(issues[0]!.code).toBe("D9");
+    expect(issues[0]!.severity).toBe("error");
+    expect(issues[0]!.message).toContain("shadowed");
+  });
+
+  test("shim but no real claude binary → D9 warning", () => {
+    writeShim();
+    const issues = checkActivation({ homeDir: home, realBin: null, pathDirs: [binDir] });
+    expect(issues).toHaveLength(1);
+    expect(issues[0]!.code).toBe("D9");
+    expect(issues[0]!.severity).toBe("warning");
+    expect(issues[0]!.message).toContain("not found");
+  });
+});

package/src/commands/doctor.ts

@@ -16,16 +16,18 @@
  */
 
 import { readFileSync, existsSync, lstatSync, readlinkSync, readdirSync } from "node:fs";
-import { readFile, writeFile, readdir, lstat, rm } from "node:fs/promises";
+import { readFile, writeFile, rm } from "node:fs/promises";
 import { resolve, dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
-import { createHash } from "node:crypto";
 import { spawnSync } from "node:child_process";
 
 import { listProfiles, loadProfile } from "../lib/profile-loader";
 import { listAllSkillIds } from "../lib/resolver-local";
-import { findIncompleteSkills, fetchCompanionFiles, detectSkillPath, readSourceFile } from "../lib/companion-fetch";
+import { findIncompleteSkills, fetchCompanionFiles, readSourceFile } from "../lib/companion-fetch";
 import { detectMissingDependencies } from "../lib/skill-dependencies";
+import { shimInstalled, runInstall } from "./shell";
+import { findRealClaudeBin } from "../lib/claude-binary";
+import { homedir } from "node:os";
 
 const REPO_ROOT = process.env.CUE_REPO_ROOT ?? process.env.SOUL_REPO_ROOT ?? resolve(dirname(fileURLToPath(import.meta.url)), "..", "..");
 const PROFILES_DIR = process.env.CUE_PROFILES_DIR ?? join(REPO_ROOT, "profiles");
@@ -202,6 +204,67 @@ async function checkProfile(profileName: string, allSkillIds: Set<string>, allMc
   return issues;
 }
 
+/**
+ * D9 — Activation health (environment-scoped, runs once, not per profile).
+ * Verifies the claude shim is installed, the real binary resolves, and
+ * ~/.local/bin precedes it on PATH. Injectable for testing.
+ */
+export function checkActivation(
+  opts: { homeDir?: string; pathDirs?: string[]; realBin?: string | null } = {},
+): Issue[] {
+  const issues: Issue[] = [];
+  const PROF = "(activation)";
+
+  // 1. The claude shim must be installed (and be a cue shim). Gating check —
+  //    the rest is moot without it.
+  if (!shimInstalled(opts.homeDir)) {
+    // Warning, not error: a user may legitimately not have run `cue shell
+    // install` yet (or use `cue launch` directly). Surfacing it shouldn't flip
+    // `cue doctor`'s exit code, which should track actual profile breakage.
+    issues.push({
+      code: "D9",
+      severity: "warning",
+      profile: PROF,
+      message: "~/.local/bin/claude shim missing or not a cue shim — `claude` won't load profiles (run `cue shell install`)",
+      fix: "cue shell install",
+    });
+    return issues;
+  }
+
+  // 2. The real claude binary must resolve.
+  const realBin = opts.realBin !== undefined ? opts.realBin : findRealClaudeBin();
+  if (!realBin) {
+    issues.push({
+      code: "D9",
+      severity: "warning",
+      profile: PROF,
+      message: "Real claude binary not found on PATH (only the cue shim resolves)",
+      fix: "Install Claude Code, or set CUE_REAL_CLAUDE",
+    });
+    return issues;
+  }
+
+  // 3. ~/.local/bin must precede the real binary's dir on PATH (else the real
+  //    binary shadows the shim). Only meaningful when both dirs are on PATH.
+  const home = opts.homeDir ?? homedir();
+  const shimDir = join(home, ".local", "bin");
+  const pathDirs = opts.pathDirs ?? (process.env.PATH ?? "").split(":");
+  const shimIdx = pathDirs.indexOf(shimDir);
+  const realDir = resolve(realBin, "..");
+  const realIdx = pathDirs.indexOf(realDir);
+  if (shimIdx >= 0 && realIdx >= 0 && shimIdx > realIdx) {
+    issues.push({
+      code: "D9",
+      severity: "error",
+      profile: PROF,
+      message: `Real binary dir ${realDir} precedes ${shimDir} on PATH — the shim is shadowed`,
+      fix: "Reorder PATH so ~/.local/bin comes before the real claude/codex",
+    });
+  }
+
+  return issues;
+}
+
 async function applyFix(issue: Issue): Promise<boolean> {
   const yamlPath = join(PROFILES_DIR, issue.profile, "profile.yaml");
 
@@ -287,6 +350,14 @@ async function applyFix(issue: Issue): Promise<boolean> {
       });
       return fetched.length > 0;
     }
+    case "D9": {
+      // Install/repair the shim. runInstall returns 1 (no throw) when PATH
+      // ordering is wrong — that case can't be auto-fixed (user must reorder
+      // their shell PATH), so success is keyed on rc === 0.
+      const realBin = findRealClaudeBin();
+      const rc = await runInstall({ realClaude: realBin ?? undefined });
+      return rc === 0;
+    }
     default:
       return false;
   }
@@ -311,6 +382,7 @@ Checks:
   D6  Broken symlink in runtime
   D7  Incomplete skill (companions declared but missing)
   D8  Quality gate declared but the .sh under resources/quality-gates/ is missing
+  D9  Activation: claude shim installed, real claude resolves, ~/.local/bin precedes it
 
 Flags:
   --fix             Auto-repair issues
@@ -363,6 +435,10 @@ Examples:
     } catch { /* skip */ }
   }
 
+  // D9: activation health (shim + real binary + PATH order). Environment-
+  // scoped, so run once regardless of --profile.
+  issues.push(...checkActivation());
+
   // D3 only when checking all profiles, and only if no profile globs everything.
   if (!targetProfile && !hasGlobAll) {
     for (const id of allSkillIds) {

package/src/commands/eval-behavior.ts

@@ -13,7 +13,7 @@
  * Output: per-scenario pass/fail + a single summary score per profile.
  */
 
-import { readFileSync, existsSync } from "node:fs";
+import { readFileSync, } from "node:fs";
 import { join, resolve, dirname, isAbsolute } from "node:path";
 import { fileURLToPath } from "node:url";
 import { homedir } from "node:os";

package/src/commands/eval.ts

@@ -15,8 +15,8 @@
  * cost-per-message and the score now use perMessage so they reflect reality.
  */
 
-import { resolve, join, dirname, basename, isAbsolute } from "node:path";
-import { readFileSync, existsSync } from "node:fs";
+import { resolve, join, dirname, isAbsolute } from "node:path";
+import { readFileSync, } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { homedir } from "node:os";
 

package/src/commands/evolve.ts

@@ -19,8 +19,9 @@ import {
 } from "node:fs";
 import { join, resolve, dirname } from "node:path";
 import { homedir } from "node:os";
+import { configDir } from "../lib/config-paths";
 
-import { loadProfile, listProfiles } from "../lib/profile-loader";
+import { loadProfile, } from "../lib/profile-loader";
 import { resolveProfileForCwd } from "../lib/cwd-resolver";
 
 const CONFIG_DIR = join(process.env.XDG_CONFIG_HOME ?? join(homedir(), ".config"), "cue");
@@ -249,11 +250,11 @@ export async function run(args: string[]): Promise<number> {
   if (args.includes("--history")) { showHistory(); return 0; }
 
   // Resolve profile
-  const configDir = join(process.env.XDG_CONFIG_HOME ?? join(homedir(), ".config"), "cue");
+  const cfgDir = configDir();
   const explicit = args.find(a => !a.startsWith("-"));
   let profileName = explicit;
   if (!profileName) {
-    const resolved = await resolveProfileForCwd({ cwd: process.cwd(), homeDir: homedir(), configDir });
+    const resolved = await resolveProfileForCwd({ cwd: process.cwd(), homeDir: homedir(), configDir: cfgDir });
     profileName = "profile" in resolved ? resolved.profile : "core";
   }
 

package/src/commands/failures.test.ts

@@ -5,7 +5,7 @@
 
 import { describe, expect, test, beforeEach, afterEach } from "bun:test";
 import { mkdirSync, writeFileSync, rmSync } from "node:fs";
-import { tmpdir, homedir } from "node:os";
+import { tmpdir, } from "node:os";
 import { join } from "node:path";
 
 import { run as failuresRun } from "./failures";

package/src/commands/features-batch1.test.ts

@@ -3,7 +3,7 @@
  */
 
 import { describe, expect, test, beforeEach, afterEach } from "bun:test";
-import { mkdirSync, writeFileSync, rmSync, readFileSync, existsSync } from "node:fs";
+import { mkdirSync, rmSync, readFileSync, existsSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 
@@ -16,9 +16,14 @@ let tmp: string;
 beforeEach(() => {
   tmp = `${tmpdir()}/cue-features-test-${Date.now()}-${Math.random().toString(36).slice(2)}`;
   mkdirSync(tmp, { recursive: true });
+  // Point `cue suggest`'s session scan at the empty tmp dir so the suggest
+  // tests stay hermetic + fast — otherwise they scan the real ~/.claude
+  // history (minutes on a heavy machine), which hung the whole suite.
+  process.env.CUE_SUGGEST_SESSIONS_DIR = tmp;
 });
 
 afterEach(() => {
+  delete process.env.CUE_SUGGEST_SESSIONS_DIR;
   try { rmSync(tmp, { recursive: true, force: true }); } catch {}
 });
 

package/src/commands/icon.ts

@@ -10,6 +10,7 @@ import * as p from "@clack/prompts";
 import { resolveProfileForCwd } from "../lib/cwd-resolver";
 import { loadProfile } from "../lib/profile-loader";
 import { homedir } from "node:os";
+import { configDir } from "../lib/config-paths";
 
 const REPO_ROOT = process.env.CUE_REPO_ROOT ?? process.env.SOUL_REPO_ROOT ?? resolve(dirname(fileURLToPath(import.meta.url)), "..", "..");
 
@@ -19,11 +20,6 @@ const ICONS = [
   "🦈", "🐊", "🦅", "🐎", "🦁", "🐘",
 ];
 
-function configDir(): string {
-  return process.env.XDG_CONFIG_HOME
-    ? join(process.env.XDG_CONFIG_HOME, "cue")
-    : join(homedir(), ".config", "cue");
-}
 
 export async function run(args: string[]): Promise<number> {
   const profileName = args[0] ?? await resolveCurrentProfile();

package/src/commands/import-profile.ts

@@ -4,7 +4,7 @@
  */
 
 import { readFileSync, writeFileSync, mkdirSync, existsSync } from "node:fs";
-import { resolve, dirname, join, basename } from "node:path";
+import { resolve, dirname, join, } from "node:path";
 import { fileURLToPath } from "node:url";
 
 import { loadProfile } from "../lib/profile-loader";

package/src/commands/init.ts

@@ -18,6 +18,8 @@ import { detectProfile } from "../lib/auto-detect";
 import { scanProject } from "../lib/project-scanner";
 import { listProfiles } from "../lib/profile-loader";
 import { getCachedGemsForProfile, autoInstallClis } from "./discover";
+import { shimInstalled, runInstall } from "./shell";
+import { gateFreshSkill } from "./security";
 import {
   configDir,
   enable as enableTelemetry,
@@ -67,11 +69,6 @@ export async function runGlobalOnboarding(): Promise<boolean> {
         hint: "recommended — minimal base plus skill management",
       },
       { value: "core", label: "core only", hint: "smallest — just the base" },
-      {
-        value: "core+skill-writer+ecc",
-        label: "core + skill-writer + ecc",
-        hint: "+ workspace conventions (CLAUDE.md / AGENTS.md)",
-      },
       { value: "__custom", label: "Custom…", hint: "type a +-separated composite" },
       { value: "__skip", label: "Skip for now", hint: "falls back to plain `core`" },
     ],
@@ -82,7 +79,7 @@ export async function runGlobalOnboarding(): Promise<boolean> {
   let defaultComposite: string | null = null;
   if (defaultPick === "__custom") {
     const custom = await p.text({
-      message: "Composite (e.g., core+skill-writer+ecc):",
+      message: "Composite (e.g., core+skill-writer+backend):",
       placeholder: "core+skill-writer",
       validate: (v) => {
         const parts = (v ?? "").split("+").map((s) => s.trim()).filter((s) => s.length > 0);
@@ -160,14 +157,58 @@ async function offerDiscoverGems(profile: string): Promise<void> {
   const install = await p.confirm({ message: "Install these gems?" });
   if (p.isCancel(install) || !install) return;
 
+  let flagged = 0;
   for (const g of gems) {
     p.log.step(`Installing ${g.full_name}...`);
     spawnSync("npx", ["skills", "add", g.full_name, "-a", "claude-code", "-y"], {
       encoding: "utf8", timeout: 60000, stdio: ["ignore", "pipe", "pipe"],
     });
+    // Security gate: flag a just-fetched skill with critical findings and skip
+    // its CLI auto-install (the gem is installed to ~/.claude/skills, but the
+    // wizard does not auto-register it to a profile).
+    const gate = gateFreshSkill(g.name);
+    if (!gate.ok) {
+      flagged++;
+      p.log.error(`${g.full_name}: ${gate.critical.length} critical security finding(s) — review before use.`);
+      for (const c of gate.critical) p.log.message(`  [${c.code}] ${c.message}`);
+      continue;
+    }
+    if (!gate.scanned) {
+      p.log.warn(`${g.full_name}: no SKILL.md found to scan — review manually.`);
+    }
     autoInstallClis(g.name);
   }
-  p.log.success(`Installed ${gems.length} gem(s).`);
+  p.log.success(`Installed ${gems.length} gem(s) to ~/.claude/skills${flagged > 0 ? ` (${flagged} flagged by the security scan — review before use)` : ""}.`);
+}
+
+/**
+ * Offer to install the shell shims if they're missing. Without the
+ * `~/.local/bin/claude` shim, typing `claude` runs vanilla Claude Code and
+ * the pinned profile is never loaded — the #1 "I followed the docs and
+ * nothing happened" failure. Detect it here and offer the one-time fix.
+ */
+async function ensureShim(): Promise<void> {
+  if (shimInstalled()) return;
+  p.log.warn(
+    "The `claude`/`codex` shim isn't installed yet — without it, launching `claude` runs vanilla Claude Code and won't load this profile.",
+  );
+  const install = await p.confirm({
+    message: "Install the shell shim now? (writes ~/.local/bin/claude)",
+  });
+  if (p.isCancel(install) || !install) {
+    p.log.message("Skipped — run `cue shell install` later to activate profile loading.");
+    return;
+  }
+  try {
+    const code = await runInstall();
+    if (code === 0) {
+      p.log.success("Shim installed to ~/.local/bin. Make sure it's earlier on your PATH than the real claude/codex.");
+    } else {
+      p.log.warn("Shim install reported an issue — run `cue shell install` manually for details.");
+    }
+  } catch {
+    p.log.warn("Couldn't install the shim automatically — run `cue shell install` manually.");
+  }
 }
 
 export async function run(args: string[]): Promise<number> {
@@ -264,6 +305,7 @@ export async function run(args: string[]): Promise<number> {
 
     writeFileSync(join(cwd, ".cue-profile"), (name as string) + "\n");
     await offerDiscoverGems(name as string);
+    await ensureShim();
     p.outro(`✅ Created profile "${name}" and pinned to this directory.`);
     return 0;
   }
@@ -271,6 +313,7 @@ export async function run(args: string[]): Promise<number> {
   // Pin the chosen profile
   writeFileSync(join(cwd, ".cue-profile"), (choice as string) + "\n");
   await offerDiscoverGems(choice as string);
+  await ensureShim();
   p.outro(`✅ Pinned "${choice}" to this directory. Next \`claude\` launch will use it.`);
   return 0;
 }

package/src/commands/install-sh.e2e.test.ts

@@ -0,0 +1,65 @@
+/**
+ * Smoke test for install.sh — proves the shell install path that every new
+ * user depends on: it symlinks `cue` onto PATH, writes a working `claude`
+ * shim, and `cue --version` runs through the shim dir.
+ *
+ * Hermetic: installs into a throwaway SHIM_DIR with a stub `authmux` on PATH so
+ * install.sh's Step 5 never runs `npm install -g authmux` (no network).
+ */
+import { describe, expect, test, beforeEach, afterEach } from "bun:test";
+import { spawnSync } from "node:child_process";
+import { mkdtempSync, writeFileSync, chmodSync, existsSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+const REPO_ROOT = join(import.meta.dir, "..", "..");
+// CI-only: install.sh does `cd CUE_DIR && bun install`, which would mutate the
+// developer's real node_modules and may hit the network on a cold cache. CI
+// runs on a fresh checkout where that's fine and is the canonical place to
+// prove the shell install path; locally we skip to keep the working tree clean.
+const CAN_RUN =
+  !!process.env.CI &&
+  process.platform !== "win32" &&
+  spawnSync("bash", ["--version"], { encoding: "utf8" }).status === 0;
+
+describe.skipIf(!CAN_RUN)("install.sh smoke", () => {
+  let shimDir: string;
+  beforeEach(() => {
+    shimDir = mkdtempSync(join(tmpdir(), "cue-installsh-"));
+    // Stub authmux so `command -v authmux` short-circuits Step 5 (no npm -g).
+    const stub = join(shimDir, "authmux");
+    writeFileSync(stub, "#!/usr/bin/env bash\necho 0.0.0\n");
+    chmodSync(stub, 0o755);
+  });
+  afterEach(() => rmSync(shimDir, { recursive: true, force: true }));
+
+  test("symlinks cue, writes a working claude shim, and cue --version runs through it", () => {
+    const env = {
+      ...process.env,
+      SHIM_DIR: shimDir,
+      CUE_DIR: REPO_ROOT,
+      PATH: `${shimDir}:${process.env.PATH ?? ""}`,
+    };
+    const res = spawnSync("bash", [join(REPO_ROOT, "install.sh"), "--yes"], {
+      encoding: "utf8",
+      timeout: 120000,
+      env,
+    });
+    expect(res.status).toBe(0);
+
+    // cue is exposed on PATH (symlink to bin/cue).
+    expect(existsSync(join(shimDir, "cue"))).toBe(true);
+
+    // claude shim routes through cue.
+    const claudeShim = join(shimDir, "claude");
+    expect(existsSync(claudeShim)).toBe(true);
+    expect(readFileSync(claudeShim, "utf8")).toContain("exec cue launch claude");
+
+    // `cue --version` works through the installed symlink and matches package.json.
+    const pkgVersion = JSON.parse(readFileSync(join(REPO_ROOT, "package.json"), "utf8")).version;
+    const ver = spawnSync(join(shimDir, "cue"), ["--version"], { encoding: "utf8", env, timeout: 20000 });
+    expect(ver.status).toBe(0);
+    expect(ver.stdout.trim()).toBe(pkgVersion);
+    expect(ver.stdout.trim()).toMatch(/^\d+\.\d+\.\d+/);
+  });
+});

package/src/commands/launch-handoff.e2e.test.ts

@@ -0,0 +1,88 @@
+/**
+ * E2e coverage for the launch EXEC HANDOFF — the lines that decide whether
+ * `claude`/`codex` actually starts with the right env. Uses `--dry-run` (which
+ * builds childEnv + the exec plan and prints it as JSON without exec'ing) and a
+ * direct recursion-guard probe.
+ *
+ * Kept in its own file (not launch.e2e.test.ts) to stay additive while that
+ * file is being edited concurrently.
+ */
+import { describe, expect, test, beforeEach, afterEach } from "bun:test";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { spawnSync } from "node:child_process";
+
+const CUE_BIN = join(import.meta.dir, "../index.ts");
+const BUN_SPAWNABLE = spawnSync("bun", ["--version"], { encoding: "utf8" }).status === 0;
+
+function cue(args: string[], env: Record<string, string> = {}): { status: number; stdout: string; stderr: string } {
+  const cleanEnv = { ...process.env, ...env };
+  delete cleanEnv.CUE_LAUNCHING;
+  delete cleanEnv.CLAUDE_CONFIG_DIR;
+  const res = spawnSync("bun", ["run", CUE_BIN, ...args], { encoding: "utf8", timeout: 20000, env: cleanEnv });
+  return { status: res.status ?? 1, stdout: res.stdout ?? "", stderr: res.stderr ?? "" };
+}
+
+function plan(stdout: string): any {
+  return JSON.parse(stdout.match(/\{[\s\S]*\}/)![0]);
+}
+
+describe.skipIf(!BUN_SPAWNABLE)("cue launch --dry-run exec handoff", () => {
+  let xdg: string;
+  beforeEach(async () => {
+    xdg = await mkdtemp(join(tmpdir(), "cue-handoff-"));
+  });
+  afterEach(async () => {
+    await rm(xdg, { recursive: true, force: true });
+  });
+
+  test("claude → CLAUDE_CONFIG_DIR points at the materialized runtime", () => {
+    const r = cue(["launch", "claude", "--cue-profile", "core", "--dry-run"], { XDG_CONFIG_HOME: xdg });
+    expect(r.status).toBe(0);
+    const p = plan(r.stdout);
+    const expected = join(xdg, "cue", "runtime", "core", "claude");
+    expect(p.agent).toBe("claude-code");
+    expect(p.env.CLAUDE_CONFIG_DIR).toBe(expected);
+    expect(p.runtimeDir).toBe(expected);
+    expect(p.command).toEqual(["claude"]);
+    expect(p.env.CODEX_HOME).toBeUndefined();
+    // NOTE: CUE_LAUNCHING is intentionally absent from the dry-run JSON (only
+    // env[envKey] is serialized); it's covered by the recursion-guard test.
+  });
+
+  test("codex → CODEX_HOME points at the codex runtime", () => {
+    const r = cue(["launch", "codex", "--cue-profile", "core", "--dry-run"], { XDG_CONFIG_HOME: xdg });
+    expect(r.status).toBe(0);
+    const p = plan(r.stdout);
+    const expected = join(xdg, "cue", "runtime", "core", "codex");
+    expect(p.agent).toBe("codex");
+    expect(p.env.CODEX_HOME).toBe(expected);
+    expect(p.command).toEqual(["codex"]);
+    expect(p.env.CLAUDE_CONFIG_DIR).toBeUndefined();
+  });
+
+  test("passthrough args flow into the exec command", () => {
+    const r = cue(["launch", "claude", "--cue-profile", "core", "--dry-run", "--resume", "foo"], { XDG_CONFIG_HOME: xdg });
+    expect(r.status).toBe(0);
+    const p = plan(r.stdout);
+    expect(p.command).toEqual(["claude", "--resume", "foo"]);
+  });
+});
+
+describe.skipIf(!BUN_SPAWNABLE)("cue launch recursion guard", () => {
+  test("CUE_LAUNCHING=1 aborts with exit 2 (shim recursion)", () => {
+    // Must NOT use the cue() helper — it strips CUE_LAUNCHING. Spawn directly
+    // with CUE_LAUNCHING=1 set (and CLAUDE_CONFIG_DIR cleared to avoid the
+    // unrelated account-alias → picker path).
+    const env = { ...process.env, CUE_LAUNCHING: "1" };
+    delete env.CLAUDE_CONFIG_DIR;
+    const res = spawnSync("bun", ["run", CUE_BIN, "launch", "claude", "--cue-profile", "core", "--dry-run"], {
+      encoding: "utf8",
+      timeout: 15000,
+      env,
+    });
+    expect(res.status).toBe(2);
+    expect(res.stderr).toContain("shim recursion detected");
+  });
+});

package/src/commands/launch.e2e.test.ts

@@ -11,6 +11,13 @@ import { spawnSync } from "node:child_process";
 
 const CUE_BIN = join(import.meta.dir, "../index.ts");
 
+// These e2e tests shell out to `bun run`. In some sandboxes (and odd PATH
+// setups) a spawned child can't find `bun`, which would hard-fail the suite
+// with "Executable not found in $PATH: bun" — unrelated to what's under test.
+// Skip the whole describe when a child `bun` can't be spawned. CI installs bun
+// via setup-bun, so this only skips in constrained local/sandbox runs.
+const BUN_SPAWNABLE = spawnSync("bun", ["--version"], { encoding: "utf8" }).status === 0;
+
 function cue(args: string[], opts: { cwd?: string; env?: Record<string, string> } = {}): { status: number; stdout: string; stderr: string } {
   // Strip env vars set when the test runner itself is running inside a cue
   // session — they propagate to the child cue invocation and break it in
@@ -29,7 +36,7 @@ function cue(args: string[], opts: { cwd?: string; env?: Record<string, string>
   return { status: res.status ?? 1, stdout: res.stdout ?? "", stderr: res.stderr ?? "" };
 }
 
-describe("cue launch e2e", () => {
+describe.skipIf(!BUN_SPAWNABLE)("cue launch e2e", () => {
   let tmpDir: string;
 
   beforeEach(async () => {

package/src/commands/launch.test.ts

@@ -219,6 +219,22 @@ describe("buildPickerSections", () => {
     expect(composite?.label).toBe("backend + designer");
   });
 
+  test("recent composite reuses each part's icon label, not bare names", () => {
+    // Combined recent rows should carry every part's icon (emoji or kitty image
+    // placeholder), pulled from each part's own option label.
+    const all = [
+      { value: "improver", label: "📈 improver", hint: "" },
+      { value: "secops", label: "🔒 secops", hint: "" },
+      { value: "builder", label: "🐻 builder", hint: "" },
+    ];
+    const recent = [
+      { name: "improver+secops+builder", sessions: 4, lastUsed: "2026-05-26T09:00:00Z" },
+    ];
+    const out = buildPickerSections(opt("__default"), all, recent, 3, now);
+    const composite = out.find((o) => o.value === "improver+secops+builder");
+    expect(composite?.label).toBe("📈 improver + 🔒 secops + 🐻 builder");
+  });
+
   test("featured: composites synthesized, single profiles reuse their option and leave All", () => {
     const all = [opt("backend"), opt("designer"), opt("webshop")];
     const out = buildPickerSections(
@@ -510,6 +526,19 @@ describe("formatProfileSummary", () => {
     expect(out[0]).toBe("skills    6  ← 🧬 writer:2 + 🐢 core:2");
   });
 
+  test("caps a fat composite breakdown at 6 parts with a '+N more' suffix", () => {
+    const names = ["a", "b", "c", "d", "e", "f", "g"]; // 7 parts → cap kicks in
+    const main = makeProfile({
+      name: names.join("+"),
+      skills: { local: names.map((n) => ({ id: `${n}/1` })), npx: [] },
+    });
+    const parts = names.map((n) =>
+      makeProfile({ name: n, skills: { local: [{ id: `${n}/1` }], npx: [] } }),
+    );
+    const out = formatProfileSummary(main, parts);
+    expect(out[0]).toBe("skills    7  ← a:1 + b:1 + c:1 + d:1 + e:1 + f:1 +1 more");
+  });
+
   test("adds category line below skills when localCount >= 5", () => {
     const profile = makeProfile({
       skills: {