cue-ai 0.9.0 → 0.9.2

package/src/index.ts

@@ -66,6 +66,7 @@ function printHelp(): void {
       ["stats", "Profile usage analytics"],
       ["scan", "Tree of installed skills/plugins by domain"],
       ["why", "Trace why a skill/MCP is loaded"],
+      ["mem", "Inspect/manage per-profile claude-mem stores"],
     ],
     "Launch & Shell": [
       ["launch", "Resolve + materialize + exec claude/codex"],
@@ -154,10 +155,10 @@ function similarity(a: string, b: string): number {
 async function checkForUpdate(currentVersion: string): Promise<void> {
   const { existsSync, readFileSync: rf, writeFileSync: wf, mkdirSync } = await import("node:fs");
   const { join } = await import("node:path");
-  const { homedir } = await import("node:os");
+  const { configDir } = await import("./lib/config-paths");
 
-  const configDir = join(process.env.XDG_CONFIG_HOME ?? join(homedir(), ".config"), "cue");
-  const checkFile = join(configDir, ".last-update-check");
+  const cfgDir = configDir();
+  const checkFile = join(cfgDir, ".last-update-check");
 
   // Only check once per 24 hours
   if (existsSync(checkFile)) {
@@ -173,7 +174,7 @@ async function checkForUpdate(currentVersion: string): Promise<void> {
   if (!latest) return;
 
   // Save check timestamp
-  mkdirSync(configDir, { recursive: true });
+  mkdirSync(cfgDir, { recursive: true });
   wf(checkFile, String(Date.now()));
 
   // Compare versions
@@ -191,11 +192,12 @@ async function checkForUpdate(currentVersion: string): Promise<void> {
     const readline = await import("node:readline");
     const rl = readline.createInterface({ input: process.stdin, output: process.stderr });
     const answer = await new Promise<string>((resolve) => {
-      rl.question("     Install now? [Y/n] ", (a) => { rl.close(); resolve(a); });
-      // Auto-accept after 5 seconds
-      setTimeout(() => { rl.close(); resolve("y"); }, 5000);
+      rl.question("     Install now? [y/N] ", (a) => { rl.close(); resolve(a); });
+      // Auto-decline after 5 seconds — never install a new global without an
+      // affirmative y/yes. Walking away from the terminal must be a no-op.
+      setTimeout(() => { rl.close(); resolve("n"); }, 5000);
     });
-    if (!answer || answer.toLowerCase() === "y" || answer.toLowerCase() === "yes") {
+    if (answer.toLowerCase() === "y" || answer.toLowerCase() === "yes") {
       process.stderr.write("     📦 Updating...\n");
       const { spawnSync } = await import("node:child_process");
       const result = spawnSync("npm", ["install", "-g", "cue-ai"], { encoding: "utf8", timeout: 60000, stdio: ["ignore", "pipe", "pipe"] });
@@ -213,8 +215,22 @@ async function checkForUpdate(currentVersion: string): Promise<void> {
 async function main(argv: string[]): Promise<number> {
   const args = argv.slice(2);
 
-  // Non-blocking update check (runs in background, shows prompt if outdated)
-  checkForUpdate(readVersion()).catch(() => {});
+  // Update check — never during a live agent launch. The `claude`/`codex`
+  // shim is `exec cue launch ...`, so running it here would open a readline on
+  // the agent's stdin (stealing keystrokes) and could fire a blocking
+  // `npm install -g` mid-session. Skip for any command that spawns an agent
+  // (`launch`, plus `quick`/`playground`), for trivial or non-interactive
+  // invocations, when launching (CUE_LAUNCHING), or in CI.
+  const AGENT_LAUNCH_COMMANDS = new Set(["launch", "quick", "playground"]);
+  const TRIVIAL_ARGS = new Set(["--version", "-v", "version", "--help", "-h", "help"]);
+  const skipUpdateCheck =
+    AGENT_LAUNCH_COMMANDS.has(args[0] ?? "") ||
+    TRIVIAL_ARGS.has(args[0] ?? "") ||
+    process.env.CUE_LAUNCHING === "1" ||
+    !!process.env.CI ||
+    !process.stdin.isTTY ||
+    !process.stdout.isTTY;
+  if (!skipUpdateCheck) checkForUpdate(readVersion()).catch(() => {});
 
   if (args.length === 0) {
     // Show status dashboard by default (like `git status`)

package/src/lib/active-sessions.ts

@@ -22,7 +22,7 @@
  * expected; we skip them and keep going.
  */
 
-import { existsSync, readdirSync, readFileSync, readlinkSync, statSync } from "node:fs";
+import { existsSync, readdirSync, readFileSync, readlinkSync, } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 

package/src/lib/agent-adapters.test.ts

@@ -0,0 +1,100 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { mkdtempSync, rmSync, readFileSync, writeFileSync } from "node:fs";
+import { tmpdir, homedir } from "node:os";
+import { join } from "node:path";
+
+import { ADAPTERS, AGENT_IDS, getAdapter, claudeCode, codex } from "./agent-adapters";
+
+describe("agent-adapters registry contract", () => {
+  test("every adapter conforms to the AgentAdapter shape", () => {
+    for (const [key, a] of Object.entries(ADAPTERS)) {
+      expect(typeof a.id, key).toBe("string");
+      expect(a.id.length, key).toBeGreaterThan(0);
+      expect(typeof a.name, key).toBe("string");
+      expect(typeof a.configDir, key).toBe("function");
+      expect(typeof a.writeSkills, key).toBe("function");
+      expect(typeof a.writeMcps, key).toBe("function");
+      expect(typeof a.detectBinary, key).toBe("function");
+    }
+  });
+
+  test("each adapter's id matches its registry key (no copy-paste drift)", () => {
+    for (const [key, a] of Object.entries(ADAPTERS)) {
+      expect(a.id).toBe(key);
+    }
+  });
+
+  test("AGENT_IDS mirrors the registry keys", () => {
+    expect([...AGENT_IDS].sort()).toEqual(Object.keys(ADAPTERS).sort());
+  });
+
+  test("configDir() returns a non-empty absolute path for every adapter", () => {
+    for (const [key, a] of Object.entries(ADAPTERS)) {
+      const dir = a.configDir();
+      expect(dir.length, key).toBeGreaterThan(0);
+      expect(dir.startsWith("/"), key).toBe(true);
+    }
+  });
+});
+
+describe("getAdapter", () => {
+  test("resolves known agent ids to the right adapter", () => {
+    expect(getAdapter("claude-code")).toBe(claudeCode);
+    expect(getAdapter("codex")).toBe(codex);
+  });
+
+  test("returns null for an unknown id", () => {
+    expect(getAdapter("does-not-exist")).toBeNull();
+    expect(getAdapter("")).toBeNull();
+  });
+});
+
+describe("configDir env overrides", () => {
+  const saved = { claude: process.env.CLAUDE_CONFIG_DIR, codex: process.env.CODEX_HOME };
+  afterEach(() => {
+    if (saved.claude === undefined) delete process.env.CLAUDE_CONFIG_DIR;
+    else process.env.CLAUDE_CONFIG_DIR = saved.claude;
+    if (saved.codex === undefined) delete process.env.CODEX_HOME;
+    else process.env.CODEX_HOME = saved.codex;
+  });
+
+  test("claude-code honors CLAUDE_CONFIG_DIR, else ~/.claude", () => {
+    process.env.CLAUDE_CONFIG_DIR = "/tmp/custom-claude";
+    expect(claudeCode.configDir()).toBe("/tmp/custom-claude");
+    delete process.env.CLAUDE_CONFIG_DIR;
+    expect(claudeCode.configDir()).toBe(join(homedir(), ".claude"));
+  });
+
+  test("codex honors CODEX_HOME, else ~/.codex", () => {
+    process.env.CODEX_HOME = "/tmp/custom-codex";
+    expect(codex.configDir()).toBe("/tmp/custom-codex");
+    delete process.env.CODEX_HOME;
+    expect(codex.configDir()).toBe(join(homedir(), ".codex"));
+  });
+});
+
+describe("writeMcps behavior", () => {
+  let dir: string;
+  beforeEach(() => {
+    dir = mkdtempSync(join(tmpdir(), "cue-adapters-"));
+  });
+  afterEach(() => {
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  test("claude-code writes mcpServers into settings.json and preserves existing keys", () => {
+    // Pre-existing settings with an unrelated key that must survive the merge.
+    writeFileSync(join(dir, "settings.json"), JSON.stringify({ theme: "dark" }));
+    claudeCode.writeMcps({ ctx7: { command: "npx", args: ["ctx7"] } }, dir);
+    const out = JSON.parse(readFileSync(join(dir, "settings.json"), "utf8"));
+    expect(out.theme).toBe("dark");
+    expect(out.mcpServers.ctx7).toEqual({ command: "npx", args: ["ctx7"] });
+  });
+
+  test("codex writes a config.toml with an [mcp_servers.<id>] section", () => {
+    codex.writeMcps({ ctx7: { command: "npx" } }, dir);
+    const toml = readFileSync(join(dir, "config.toml"), "utf8");
+    expect(toml).toContain("[mcp_servers.ctx7]");
+    expect(toml).toContain('command = "npx"');
+  });
+});

package/src/lib/agent-adapters.ts

@@ -5,8 +5,8 @@
  * that a specific agent expects.
  */
 
-import { writeFileSync, mkdirSync, existsSync, readFileSync, symlinkSync } from "node:fs";
-import { join, resolve } from "node:path";
+import { writeFileSync, mkdirSync, existsSync, readFileSync, } from "node:fs";
+import { join, } from "node:path";
 import { homedir } from "node:os";
 import { spawnSync } from "node:child_process";
 

package/src/lib/analytics.test.ts

@@ -0,0 +1,88 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { computeDailyActivity } from "./analytics";
+
+// A fixed "now" so the day-bucket math is deterministic regardless of when the
+// suite runs. 10:00 UTC means the boundary cases below straddle a UTC midnight.
+const NOW = Date.parse("2026-06-03T10:00:00.000Z");
+
+let prevXdg: string | undefined;
+let scratch: string;
+
+function writeAnalytics(lines: object[]): void {
+  writeFileSync(join(scratch, "cue", "analytics.jsonl"), lines.map((l) => JSON.stringify(l)).join("\n") + "\n");
+}
+function writeSessionLog(lines: object[]): void {
+  writeFileSync(join(scratch, "cue", "session-log.jsonl"), lines.map((l) => JSON.stringify(l)).join("\n") + "\n");
+}
+function bucket(rows: { date: string; sessions: number }[], date: string): number {
+  return rows.find((r) => r.date === date)?.sessions ?? -1;
+}
+
+beforeEach(() => {
+  prevXdg = process.env.XDG_CONFIG_HOME;
+  scratch = mkdtempSync(join(tmpdir(), "cue-analytics-test-"));
+  mkdirSync(join(scratch, "cue"), { recursive: true });
+  process.env.XDG_CONFIG_HOME = scratch;
+});
+
+afterEach(() => {
+  if (prevXdg === undefined) delete process.env.XDG_CONFIG_HOME;
+  else process.env.XDG_CONFIG_HOME = prevXdg;
+  try { rmSync(scratch, { recursive: true, force: true }); } catch { /* ignore */ }
+});
+
+describe("computeDailyActivity", () => {
+  test("returns exactly `days` contiguous UTC buckets ending today", () => {
+    writeAnalytics([]);
+    writeSessionLog([]);
+    const out = computeDailyActivity(30, NOW);
+    expect(out).toHaveLength(30);
+    expect(out[0]!.date).toBe("2026-05-05"); // now - 29 days
+    expect(out[29]!.date).toBe("2026-06-03"); // today
+    // every bucket present, zero-filled, strictly ascending
+    for (let i = 1; i < out.length; i++) {
+      expect(out[i]!.date > out[i - 1]!.date).toBe(true);
+    }
+  });
+
+  test("counts a session on its own day", () => {
+    writeAnalytics([]);
+    writeSessionLog([
+      { ts: "2026-05-20T12:00:00.000Z", cwd: "/x", profile: "core", session_id: "S2" },
+    ]);
+    expect(bucket(computeDailyActivity(30, NOW), "2026-05-20")).toBe(1);
+  });
+
+  // Regression for the off-by-one: reading a full `days` span back pulled in the
+  // day BEFORE the oldest bucket. A session whose `start` lands there poisoned the
+  // dedup set, so its Stop-hook log on the oldest shown day was dropped. With the
+  // fix `since` is the oldest bucket's midnight, so the start is simply out of
+  // window and the log counts. This bucket is 2 after the fix, 1 before it.
+  test("does not drop a session that starts pre-window but logs on the oldest shown day", () => {
+    writeAnalytics([
+      // out of window after the fix (prior day, 23:00) — must NOT poison dedup
+      { ts: "2026-05-04T23:00:00.000Z", event: "start", profile: "core", cwd: "/x", session_id: "S1" },
+      // in window, early on the oldest shown day — proves full-day capture
+      { ts: "2026-05-05T00:30:00.000Z", event: "start", profile: "core", cwd: "/x", session_id: "S3" },
+    ]);
+    writeSessionLog([
+      { ts: "2026-05-05T01:00:00.000Z", cwd: "/x", profile: "core", session_id: "S1" },
+    ]);
+    const out = computeDailyActivity(30, NOW);
+    expect(bucket(out, "2026-05-05")).toBe(2); // S1 (via log) + S3 (via start)
+  });
+
+  test("excludes events before the window entirely", () => {
+    writeAnalytics([]);
+    writeSessionLog([
+      { ts: "2026-05-04T09:00:00.000Z", cwd: "/x", profile: "core", session_id: "OLD" },
+    ]);
+    const out = computeDailyActivity(30, NOW);
+    const total = out.reduce((a, r) => a + r.sessions, 0);
+    expect(total).toBe(0);
+  });
+});

package/src/lib/analytics.ts

@@ -69,10 +69,15 @@ function readSessionLog(since?: Date): SessionLogEntry[] {
  *   - `skill_invoked` (structured `Skill` tool_use): skill, session_id, tool_use_id
  *   - `skill_miss` (trigger matched but skill wasn't fired): session_id,
  *     prompt_redacted (first 80 chars, secret-masked), matched_skills
+ *   - `skill_gap` (self-learner — profile-self-improve.sh Stop hook): where the
+ *     active profile's skills fell short. `source:"hook"` carries cheap friction
+ *     `signals`; `source:"critic"` carries a critic-agent verdict (`skill`,
+ *     `gap_type`, `suggestion`, `confidence`). Consumed by `cue profile
+ *     self-improve`; inert to existing readers.
  */
 export interface SessionEvent {
   ts: string;
-  event: "start" | "end" | "skill_hit" | "skill_invoked" | "skill_miss";
+  event: "start" | "end" | "skill_hit" | "skill_invoked" | "skill_miss" | "skill_gap";
   profile?: string;
   agent?: "claude-code" | "codex";
   cwd?: string;
@@ -82,6 +87,13 @@ export interface SessionEvent {
   tool_use_id?: string;
   prompt_redacted?: string;
   matched_skills?: string[];
+  // skill_gap variant
+  source?: "hook" | "critic";
+  signals?: string[];
+  gap_type?: "missing-skill" | "weak-description" | "weak-body" | "profile-composition";
+  suggestion?: string;
+  confidence?: number;
+  first_prompt?: string;
 }
 
 /**
@@ -238,6 +250,75 @@ export function computeStats(optsOrSince: Date | ComputeStatsOptions = {}): Prof
     .sort((a, b) => b.sessions - a.sessions);
 }
 
+export interface DailyActivity {
+  /** Calendar day, `YYYY-MM-DD` (UTC). */
+  date: string;
+  sessions: number;
+}
+
+/**
+ * Sessions per calendar day over the window, gap-filled so a sparkline/area
+ * chart is continuous (days with no activity render as 0, not a missing point).
+ * Dedupes a session that appears in both the `start` events and the Stop-hook
+ * session log by `session_id`, mirroring computeStats' intent.
+ */
+export function computeDailyActivity(sinceDays: number, now: number = Date.now()): DailyActivity[] {
+  const days = Math.max(1, Math.floor(sinceDays));
+  // Read from the START of the oldest day we actually render a bucket for. Reading
+  // a full `days` span back (now - days*day) reaches into the day BEFORE the oldest
+  // bucket: those events have no bucket, and worse, their session ids poison the
+  // dedup `seen` set, so a session that starts late on that prior day but whose
+  // Stop-hook log lands on the oldest shown day is dropped from the chart entirely.
+  // Anchoring `since` to the oldest bucket's UTC midnight keeps read and display
+  // windows identical.
+  const oldestDay = new Date(now - (days - 1) * 86_400_000).toISOString().slice(0, 10);
+  const since = new Date(`${oldestDay}T00:00:00.000Z`);
+  const counts = new Map<string, number>();
+  const seen = new Set<string>();
+  const bump = (ts: string, id: string): void => {
+    if (seen.has(id)) return;
+    seen.add(id);
+    const day = ts.slice(0, 10);
+    counts.set(day, (counts.get(day) ?? 0) + 1);
+  };
+  for (const e of readEvents(since)) {
+    if (e.event !== "start" || !e.profile) continue;
+    bump(e.ts, e.session_id || `start|${e.ts}|${e.cwd ?? ""}`);
+  }
+  for (const e of readSessionLog(since)) {
+    bump(e.ts, e.session_id || `log|${e.ts}|${e.cwd}`);
+  }
+  const out: DailyActivity[] = [];
+  for (let i = days - 1; i >= 0; i--) {
+    const key = new Date(now - i * 86_400_000).toISOString().slice(0, 10);
+    out.push({ date: key, sessions: counts.get(key) ?? 0 });
+  }
+  return out;
+}
+
+export interface DurationSummary {
+  /** Average length of *ended* sessions, in seconds. */
+  avgS: number;
+  /** Total tracked session time, in seconds. */
+  totalS: number;
+  /** How many sessions had a recorded end (the basis for avgS). */
+  ended: number;
+}
+
+/**
+ * Aggregate session-duration stats from `end` events (the only ones carrying
+ * `duration_s`). Reported separately from session *counts* because many
+ * sessions start but never log a clean end — averaging over starts would
+ * understate real session length.
+ */
+export function sessionDurationSummary(since?: Date): DurationSummary {
+  const ends = readEvents(since).filter(
+    (e) => e.event === "end" && typeof e.duration_s === "number",
+  );
+  const totalS = ends.reduce((a, e) => a + (e.duration_s ?? 0), 0);
+  return { avgS: ends.length ? Math.round(totalS / ends.length) : 0, totalS, ended: ends.length };
+}
+
 export interface SkillUsageStats {
   skill: string;
   hits: number;

package/src/lib/auto-detect.test.ts

@@ -24,14 +24,20 @@ describe("detectProfileV2", () => {
     expect(rust!.reasons).toContain("Cargo.toml");
   });
 
-  test("Cargo.toml + src/main.rs → rust-cli at 0.7", () => {
+  test("Cargo.toml + src/main.rs → rust, corroborated above the lone-signal base", () => {
     writeFileSync(join(tmp, "Cargo.toml"), "[package]");
     mkdirSync(join(tmp, "src"));
     writeFileSync(join(tmp, "src/main.rs"), "fn main() {}");
     const results = detectProfileV2(tmp);
-    const cli = results.find(r => r.profile === "rust-cli");
-    expect(cli).toBeDefined();
-    expect(cli!.confidence).toBe(0.7);
+    const rust = results.find(r => r.profile === "rust");
+    expect(rust).toBeDefined();
+    expect(rust!.reasons).toContain("src/main.rs");
+    // Two corroborating signals (Cargo.toml + src/main.rs) lift confidence
+    // above the 0.9 lone-signal base, capped at 0.97.
+    expect(rust!.confidence).toBeGreaterThan(0.9);
+    expect(rust!.confidence).toBeLessThanOrEqual(0.97);
+    // `rust-cli` was a phantom profile (no profiles/rust-cli on disk) — gone now.
+    expect(results.find(r => r.profile === "rust-cli")).toBeUndefined();
   });
 
   test("package.json with next → nextjs 0.9", () => {

package/src/lib/auto-detect.ts

@@ -12,7 +12,7 @@ interface Signal {
   profile: string;
 }
 
-const SIGNALS: Signal[] = [
+export const SIGNALS: Signal[] = [
   // Frontend / Next.js
   { file: "next.config.js", weight: 5, profile: "nextjs" },
   { file: "next.config.ts", weight: 5, profile: "nextjs" },
@@ -41,15 +41,15 @@ const SIGNALS: Signal[] = [
   { file: ".github/workflows/", weight: 1, profile: "backend" },
 
   // Python API
-  { file: "pyproject.toml", weight: 4, profile: "python-api" },
-  { file: "setup.py", weight: 3, profile: "python-api" },
-  { file: "requirements.txt", weight: 3, profile: "python-api" },
-  { file: "app/main.py", weight: 5, profile: "python-api" },
-  { file: "main.py", weight: 3, profile: "python-api" },
-  { file: "manage.py", weight: 5, profile: "python-api" },
-  { file: "uvicorn.ini", weight: 4, profile: "python-api" },
-  { file: "alembic.ini", weight: 4, profile: "python-api" },
-  { file: ".python-version", weight: 2, profile: "python-api" },
+  { file: "pyproject.toml", weight: 4, profile: "python" },
+  { file: "setup.py", weight: 3, profile: "python" },
+  { file: "requirements.txt", weight: 3, profile: "python" },
+  { file: "app/main.py", weight: 5, profile: "python" },
+  { file: "main.py", weight: 3, profile: "python" },
+  { file: "manage.py", weight: 5, profile: "python" },
+  { file: "uvicorn.ini", weight: 4, profile: "python" },
+  { file: "alembic.ini", weight: 4, profile: "python" },
+  { file: ".python-version", weight: 2, profile: "python" },
 
   // Rust
   { file: "Cargo.toml", weight: 5, profile: "rust" },
@@ -58,10 +58,6 @@ const SIGNALS: Signal[] = [
   { file: "src/lib.rs", weight: 3, profile: "rust" },
   { file: ".cargo/config.toml", weight: 2, profile: "rust" },
 
-  // Rust CLI sub-profile
-  { file: "src/main.rs", weight: 3, profile: "rust-cli" },
-  { file: "Cargo.toml", weight: 3, profile: "rust-cli" },
-
   // Go API
   { file: "go.mod", weight: 5, profile: "go-api" },
   { file: "go.sum", weight: 3, profile: "go-api" },
@@ -97,9 +93,9 @@ const SIGNALS: Signal[] = [
   // Three.js
   { file: "three.js", weight: 4, profile: "threejs" },
 
-  // ECC
-  { file: "CLAUDE.md", weight: 2, profile: "ecc" },
-  { file: ".claude/", weight: 2, profile: "ecc" },
+  // Generic Claude-managed repo → baseline profile
+  { file: "CLAUDE.md", weight: 2, profile: "core" },
+  { file: ".claude/", weight: 2, profile: "core" },
 
   // Full (meta)
   { file: "profiles/", weight: 2, profile: "full" },
@@ -183,7 +179,7 @@ export function detectProfileV2(cwd: string): DetectionResultV2[] {
   // ── Rust ──
   if (ex(cwd, "Cargo.toml")) {
     add("rust", 0.9, "Cargo.toml");
-    if (ex(cwd, "src/main.rs")) add("rust-cli", 0.7, "src/main.rs");
+    if (ex(cwd, "src/main.rs")) add("rust", 0.7, "src/main.rs");
     if (ex(cwd, "src/lib.rs")) add("rust", 0.6, "src/lib.rs");
   }
 
@@ -193,10 +189,10 @@ export function detectProfileV2(cwd: string): DetectionResultV2[] {
   if (exAny(cwd, ["cmd", "internal"])) add("go-api", 0.4, "cmd/ or internal/");
 
   // ── Python ──
-  if (ex(cwd, "pyproject.toml")) add("python-api", 0.7, "pyproject.toml");
-  if (ex(cwd, "requirements.txt")) add("python-api", 0.7, "requirements.txt");
-  if (ex(cwd, "manage.py")) add("python-api", 0.8, "manage.py");
-  if (exAny(cwd, ["alembic.ini", "app/main.py"])) add("python-api", 0.6, "alembic.ini or app/main.py");
+  if (ex(cwd, "pyproject.toml")) add("python", 0.7, "pyproject.toml");
+  if (ex(cwd, "requirements.txt")) add("python", 0.7, "requirements.txt");
+  if (ex(cwd, "manage.py")) add("python", 0.8, "manage.py");
+  if (exAny(cwd, ["alembic.ini", "app/main.py"])) add("python", 0.6, "alembic.ini or app/main.py");
 
   // ── Backend (containers / CI / DB) ──
   if (exAny(cwd, ["docker-compose.yml", "docker-compose.yaml", "Dockerfile"])) {
@@ -223,7 +219,7 @@ export function detectProfileV2(cwd: string): DetectionResultV2[] {
 
   // ── Fleet / meta ──
   if (exAny(cwd, [".colony", ".omx", "scripts/codex-fleet"])) add("fleet-control", 0.6, "fleet markers");
-  if (exAny(cwd, ["CLAUDE.md", ".claude"])) add("ecc", 0.4, "CLAUDE.md or .claude/");
+  if (exAny(cwd, ["CLAUDE.md", ".claude"])) add("core", 0.4, "CLAUDE.md or .claude/");
   if (ex(cwd, "profiles")) add("full", 0.3, "profiles/ dir");
 
   // ── package.json deps ──

package/src/lib/brand-icons.ts

@@ -14,7 +14,6 @@ import { fileURLToPath } from "node:url";
 
 const REPO_ROOT = process.env.CUE_REPO_ROOT ?? process.env.SOUL_REPO_ROOT ?? resolve(dirname(fileURLToPath(import.meta.url)), "..", "..");
 const SKILLS_ROOT = join(REPO_ROOT, "resources", "skills", "skills");
-const PROFILES_DIR = join(REPO_ROOT, "profiles");
 const ICONS_DIR = join(REPO_ROOT, "resources", "icons");
 
 // Known brand → asset file mappings (skill slug or MCP id → relative icon path)

package/src/lib/cache.ts

@@ -17,8 +17,8 @@
  */
 
 import { existsSync, mkdirSync, readdirSync, renameSync, rmSync, statSync, utimesSync } from "node:fs";
-import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
+import { cacheDir } from "./config-paths";
 
 export interface CacheLayout {
   /**
@@ -41,8 +41,7 @@ const NPX_SUBDIR = "npx";
 function npxRoot(layout: CacheLayout): string {
   if (layout.cacheRoot) return resolve(layout.cacheRoot, NPX_SUBDIR);
   if (layout.repoRoot) return resolve(layout.repoRoot, "profiles", "_cache", NPX_SUBDIR);
-  const xdg = process.env.XDG_CACHE_HOME ?? join(homedir(), ".cache");
-  return join(xdg, "cue", NPX_SUBDIR);
+  return join(cacheDir(), NPX_SUBDIR);
 }
 
 /** Maximum number of cache entries before LRU eviction kicks in. */