cue-ai 0.3.0 → 0.4.1

package/src/commands/share.ts

@@ -0,0 +1,230 @@
+/**
+ * `cue share <profile>` — publish a profile to the cue marketplace.
+ * `cue browse` — browse shared profiles from the community.
+ *
+ * Profiles are published as GitHub Gists (no backend needed).
+ * The marketplace index is a JSON file in the cue repo's GitHub Pages.
+ */
+
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+import { resolve, dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { homedir } from "node:os";
+
+import { loadProfile } from "../lib/profile-loader";
+
+const REPO_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..", "..");
+const PROFILES_DIR = process.env.CUE_PROFILES_DIR ?? join(REPO_ROOT, "profiles");
+const MARKETPLACE_URL = "https://raw.githubusercontent.com/recodeee/cue-marketplace/main/index.json";
+const SKILLS_ROOT = join(REPO_ROOT, "resources", "skills", "skills");
+
+export async function run(args: string[]): Promise<number> {
+  const sub = args[0];
+
+  if (args.includes("-h") || args.includes("--help") || !sub) {
+    process.stdout.write(`cue share — publish & browse community profiles
+
+Usage:
+  cue share <profile>        Publish a profile to the marketplace
+  cue share browse [query]   Browse shared profiles
+  cue share install <id>     Install a shared profile
+
+Examples:
+  cue share backend          # publish your backend profile
+  cue share browse           # see what others shared
+  cue share browse "medusa"  # search shared profiles
+  cue share install user/backend  # install someone's profile
+`);
+    return 0;
+  }
+
+  switch (sub) {
+    case "browse": return cmdBrowse(args.slice(1));
+    case "install": return cmdInstall(args[1] ?? "");
+    default: return cmdShare(sub);
+  }
+}
+
+async function cmdShare(profileName: string): Promise<number> {
+  // Check gh CLI
+  const ghCheck = spawnSync("gh", ["auth", "status"], { encoding: "utf8" });
+  if (ghCheck.status !== 0) {
+    process.stderr.write("Not authenticated with GitHub. Run `gh auth login` first.\n");
+    return 1;
+  }
+
+  // Get username
+  const whoami = spawnSync("gh", ["api", "user", "--jq", ".login"], { encoding: "utf8" });
+  const username = whoami.stdout.trim();
+
+  // Load profile
+  let profile;
+  try { profile = await loadProfile(profileName); } catch {
+    process.stderr.write(`Profile "${profileName}" not found.\n`);
+    return 1;
+  }
+
+  // Build shareable YAML
+  const yaml = require("yaml");
+  const shareData = {
+    name: profile.name,
+    description: profile.description,
+    icon: profile.icon,
+    author: username,
+    shared_at: new Date().toISOString(),
+    skills: { local: profile.skills.local.map(s => s.id) },
+    mcps: profile.mcps.map(m => m.id),
+    plugins: profile.plugins.map(p => p.id),
+    stats: {
+      skill_count: profile.skills.local.length,
+      mcp_count: profile.mcps.length,
+    },
+  };
+
+  const content = yaml.stringify(shareData);
+
+  // Create a GitHub Gist
+  process.stdout.write(`📤 Sharing profile "${profileName}" as ${username}/${profileName}...\n`);
+
+  const gistRes = spawnSync("gh", [
+    "gist", "create",
+    "--public",
+    "--desc", `cue profile: ${profileName} — ${profile.description}`,
+    "--filename", `${profileName}.cue-profile.yaml`,
+    "-"
+  ], {
+    input: content,
+    encoding: "utf8",
+    timeout: 15000,
+  });
+
+  if (gistRes.status !== 0) {
+    process.stderr.write(`Failed to create gist: ${gistRes.stderr}\n`);
+    return 1;
+  }
+
+  const gistUrl = gistRes.stdout.trim();
+
+  process.stdout.write(`\n✅ Profile shared!\n\n`);
+  process.stdout.write(`  🔗 ${gistUrl}\n`);
+  process.stdout.write(`  📋 Others install with: cue share install ${username}/${profileName}\n\n`);
+  process.stdout.write(`  Profile: ${profile.icon} ${profileName}\n`);
+  process.stdout.write(`  Skills:  ${profile.skills.local.length}\n`);
+  process.stdout.write(`  MCPs:    ${profile.mcps.length}\n`);
+  process.stdout.write(`  Author:  ${username}\n\n`);
+
+  // Save the share record locally
+  const sharesFile = join(homedir(), ".config", "cue", "shares.json");
+  mkdirSync(dirname(sharesFile), { recursive: true });
+  let shares: Record<string, unknown>[] = [];
+  try { shares = JSON.parse(readFileSync(sharesFile, "utf8")); } catch {}
+  shares.push({ id: `${username}/${profileName}`, url: gistUrl, ts: new Date().toISOString() });
+  writeFileSync(sharesFile, JSON.stringify(shares, null, 2));
+
+  return 0;
+}
+
+async function cmdBrowse(args: string[]): Promise<number> {
+  const query = args.filter(a => !a.startsWith("-")).join(" ");
+
+  // Search GitHub Gists with cue-profile tag
+  process.stdout.write(`🔍 Searching shared cue profiles${query ? ` for "${query}"` : ""}...\n\n`);
+
+  const searchQuery = `cue profile ${query}`.trim();
+  const res = spawnSync("gh", [
+    "search", "code",
+    "--json", "repository,path,textMatch",
+    "--limit", "10",
+    "filename:cue-profile.yaml", searchQuery,
+  ], { encoding: "utf8", timeout: 15000 });
+
+  if (res.status !== 0) {
+    // Fallback: search gists
+    const gistRes = spawnSync("gh", [
+      "gist", "list", "--public", "--limit", "10"
+    ], { encoding: "utf8", timeout: 10000 });
+
+    if (gistRes.stdout.trim()) {
+      process.stdout.write("  Recent public gists (filter by 'cue-profile'):\n\n");
+      process.stdout.write(gistRes.stdout);
+    } else {
+      process.stdout.write("  No shared profiles found yet.\n");
+      process.stdout.write("  Be the first! Run: cue share <profile>\n");
+    }
+    return 0;
+  }
+
+  try {
+    const results = JSON.parse(res.stdout);
+    if (!results.length) {
+      process.stdout.write("  No shared profiles found.\n");
+      process.stdout.write("  Be the first! Run: cue share <profile>\n");
+      return 0;
+    }
+    for (const r of results) {
+      const repo = r.repository?.fullName ?? "unknown";
+      process.stdout.write(`  📦 ${repo}\n`);
+      process.stdout.write(`     ${r.path}\n\n`);
+    }
+  } catch {
+    process.stdout.write("  Could not parse results. Try: cue share browse\n");
+  }
+
+  return 0;
+}
+
+async function cmdInstall(id: string): Promise<number> {
+  if (!id) {
+    process.stderr.write("Usage: cue share install <user/profile>\n");
+    return 1;
+  }
+
+  const [user, name] = id.includes("/") ? id.split("/") : [null, id];
+
+  if (!user) {
+    process.stderr.write("Specify user: cue share install <user>/<profile>\n");
+    return 1;
+  }
+
+  process.stdout.write(`📥 Installing profile "${id}"...\n`);
+
+  // Try to find the gist
+  const res = spawnSync("gh", [
+    "gist", "list", "--public", "--limit", "50"
+  ], { encoding: "utf8", timeout: 10000 });
+
+  // Alternative: try fetching from a known URL pattern
+  const gistUrl = `https://gist.githubusercontent.com/${user}/raw/${name}.cue-profile.yaml`;
+
+  try {
+    const fetchRes = await fetch(gistUrl, { signal: AbortSignal.timeout(10000) });
+    if (fetchRes.ok) {
+      const content = await fetchRes.text();
+      const yaml = require("yaml");
+      const parsed = yaml.parse(content);
+      const profileName = parsed.name ?? name;
+
+      const profileDir = join(PROFILES_DIR, profileName!);
+      mkdirSync(profileDir, { recursive: true });
+
+      // Convert shared format back to profile.yaml
+      const profileYaml: Record<string, unknown> = {
+        name: profileName,
+        description: parsed.description ?? `Shared by ${user}`,
+        icon: parsed.icon ?? "📦",
+      };
+      if (parsed.skills?.local?.length) profileYaml.skills = { local: parsed.skills.local };
+      if (parsed.mcps?.length) profileYaml.mcps = parsed.mcps;
+
+      writeFileSync(join(profileDir, "profile.yaml"), yaml.stringify(profileYaml));
+      process.stdout.write(`✅ Installed "${profileName}" from ${user}\n`);
+      process.stdout.write(`   Activate: echo ${profileName} > .cue-profile\n`);
+      return 0;
+    }
+  } catch { /* gist not found at that URL */ }
+
+  // Fallback: use cue import
+  process.stdout.write(`  Could not find gist. Try: cue import https://gist.github.com/${user}/<gist-id>/raw\n`);
+  return 1;
+}

package/src/commands/status.ts

@@ -35,20 +35,18 @@ function quickDiagnose(profileName: string, profile: any): Warning[] {
   // Check skills exist on disk
   for (const s of profile.skills.local) {
     const id = s.id ?? s;
-    // Try to find the skill in any category
+    if (typeof id === "string" && id.includes("*")) continue; // skip wildcards
+    // Try direct path first (category/slug format)
+    if (existsSync(join(SKILLS_ROOT, id, "SKILL.md"))) continue;
+    // Try to find the skill in any category (bare slug)
     let found = false;
     try {
       const cats = readdirSync(SKILLS_ROOT, { withFileTypes: true });
       for (const cat of cats) {
         if (!cat.isDirectory()) continue;
-        const skillDir = join(SKILLS_ROOT, cat.name, id);
-        if (existsSync(join(skillDir, "SKILL.md"))) { found = true; break; }
+        if (existsSync(join(SKILLS_ROOT, cat.name, id, "SKILL.md"))) { found = true; break; }
       }
     } catch { /* skip */ }
-    if (!found && typeof id === "string" && !id.includes("/")) {
-      // Could be a category/slug ref — check directly
-      if (existsSync(join(SKILLS_ROOT, id, "SKILL.md"))) found = true;
-    }
     if (!found) {
       warnings.push({ code: "D1", message: `skill "${id}" not found on disk` });
     }

package/src/commands/tree.ts

@@ -2,8 +2,10 @@
  * `cue tree [profile]` — visualize profile inheritance tree.
  */
 
+import { resolve } from "node:path";
 import { loadProfile } from "../lib/profile-loader";
 import { resolveProfileForCwd } from "../lib/cwd-resolver";
+import { detectKittyTerminal, transmitKittyImage, kittyPlaceholderLabel } from "../lib/kitty-image";
 
 export async function run(args: string[]): Promise<number> {
   const json = args.includes("--json");
@@ -18,6 +20,19 @@ export async function run(args: string[]): Promise<number> {
 
   const profile = await loadProfile(profileName!);
   const chain = profile.inheritanceChain;
+  const kitty = await detectKittyTerminal();
+  const profilesRoot = resolve(new URL(import.meta.url).pathname, "..", "..", "..", "profiles");
+  let nextImageId = 1;
+
+  function getIcon(p: any, name: string): string {
+    if (kitty && p.iconImage && nextImageId <= 255) {
+      const imgPath = resolve(profilesRoot, name, p.iconImage);
+      const id = nextImageId++;
+      transmitKittyImage(imgPath, id, 2, 1);
+      return kittyPlaceholderLabel(id, 2, 1);
+    }
+    return p.icon ?? "";
+  }
 
   if (json) {
     const tree = {
@@ -33,7 +48,7 @@ export async function run(args: string[]): Promise<number> {
   }
 
   // Build visual tree
-  const icon = profile.icon ?? "";
+  const icon = getIcon(profile, profileName!);
   process.stdout.write(`${icon} ${profileName}\n`);
 
   // Show inheritance chain (ancestors)
@@ -42,7 +57,7 @@ export async function run(args: string[]): Promise<number> {
       const ancestor = chain[i]!;
       try {
         const ancestorProfile = await loadProfile(ancestor);
-        const aIcon = ancestorProfile.icon ?? "";
+        const aIcon = getIcon(ancestorProfile, ancestor);
         const indent = "│   ".repeat(chain.length - 1 - i);
         process.stdout.write(`${indent}└── ${aIcon} ${ancestor}\n`);
 

package/src/lib/agent-adapters.ts

@@ -0,0 +1,302 @@
+/**
+ * Agent adapters — materialize skills + MCPs for any AI coding agent.
+ *
+ * Each adapter knows how to write skills and MCP configs in the format
+ * that a specific agent expects.
+ */
+
+import { writeFileSync, mkdirSync, existsSync, readFileSync, symlinkSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { homedir } from "node:os";
+import { spawnSync } from "node:child_process";
+
+// ---------------------------------------------------------------------------
+// Interface
+// ---------------------------------------------------------------------------
+
+export interface AgentAdapter {
+  /** Agent identifier (used in profile.yaml agents field) */
+  id: string;
+  /** Human-readable name */
+  name: string;
+  /** Where this agent reads its config from */
+  configDir(): string;
+  /** Write skills as the agent's rules/instructions file */
+  writeSkills(skills: { id: string; content: string }[], targetDir: string): void;
+  /** Write MCP server configs in the agent's format */
+  writeMcps(mcps: Record<string, unknown>, targetDir: string): void;
+  /** Try to find the agent binary on PATH */
+  detectBinary(): string | null;
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function findBinary(name: string): string | null {
+  const res = spawnSync("which", [name], { encoding: "utf8" });
+  return res.status === 0 ? res.stdout.trim() : null;
+}
+
+function concatSkills(skills: { id: string; content: string }[]): string {
+  return skills.map(s => `<!-- skill: ${s.id} -->\n${s.content}`).join("\n\n---\n\n");
+}
+
+// ---------------------------------------------------------------------------
+// Claude Code adapter (existing behavior)
+// ---------------------------------------------------------------------------
+
+export const claudeCode: AgentAdapter = {
+  id: "claude-code",
+  name: "Claude Code",
+  configDir: () => process.env.CLAUDE_CONFIG_DIR ?? join(homedir(), ".claude"),
+  writeSkills(skills, targetDir) {
+    const skillsDir = join(targetDir, "skills");
+    mkdirSync(skillsDir, { recursive: true });
+    // Skills are symlinked individually (handled by materializer)
+  },
+  writeMcps(mcps, targetDir) {
+    const settingsPath = join(targetDir, "settings.json");
+    let settings: Record<string, unknown> = {};
+    if (existsSync(settingsPath)) {
+      try { settings = JSON.parse(readFileSync(settingsPath, "utf8")); } catch {}
+    }
+    settings.mcpServers = { ...(settings.mcpServers as Record<string, unknown> ?? {}), ...mcps };
+    writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+  },
+  detectBinary: () => findBinary("claude"),
+};
+
+// ---------------------------------------------------------------------------
+// Codex adapter (existing behavior)
+// ---------------------------------------------------------------------------
+
+export const codex: AgentAdapter = {
+  id: "codex",
+  name: "Codex",
+  configDir: () => process.env.CODEX_HOME ?? join(homedir(), ".codex"),
+  writeSkills(skills, targetDir) {
+    const skillsDir = join(targetDir, "skills");
+    mkdirSync(skillsDir, { recursive: true });
+  },
+  writeMcps(mcps, targetDir) {
+    // Codex uses config.toml
+    const lines: string[] = [];
+    for (const [id, val] of Object.entries(mcps)) {
+      lines.push(`[mcp_servers.${id}]`);
+      for (const [k, v] of Object.entries(val as Record<string, unknown>)) {
+        lines.push(`${k} = ${JSON.stringify(v)}`);
+      }
+      lines.push("");
+    }
+    writeFileSync(join(targetDir, "config.toml"), lines.join("\n"));
+  },
+  detectBinary: () => findBinary("codex"),
+};
+
+// ---------------------------------------------------------------------------
+// Cursor adapter
+// ---------------------------------------------------------------------------
+
+export const cursor: AgentAdapter = {
+  id: "cursor",
+  name: "Cursor",
+  configDir: () => process.cwd(), // project-local
+  writeSkills(skills, targetDir) {
+    // Cursor reads .cursorrules in project root
+    const content = concatSkills(skills);
+    writeFileSync(join(targetDir, ".cursorrules"), content);
+  },
+  writeMcps(mcps, targetDir) {
+    // Cursor reads .cursor/mcp.json
+    const cursorDir = join(targetDir, ".cursor");
+    mkdirSync(cursorDir, { recursive: true });
+    writeFileSync(join(cursorDir, "mcp.json"), JSON.stringify({ mcpServers: mcps }, null, 2));
+  },
+  detectBinary: () => findBinary("cursor"),
+};
+
+// ---------------------------------------------------------------------------
+// Cline adapter
+// ---------------------------------------------------------------------------
+
+export const cline: AgentAdapter = {
+  id: "cline",
+  name: "Cline",
+  configDir: () => process.cwd(),
+  writeSkills(skills, targetDir) {
+    // Cline reads .clinerules in project root
+    const content = concatSkills(skills);
+    writeFileSync(join(targetDir, ".clinerules"), content);
+  },
+  writeMcps(mcps, targetDir) {
+    // Cline reads cline_mcp_settings.json in project root
+    writeFileSync(join(targetDir, "cline_mcp_settings.json"), JSON.stringify({ mcpServers: mcps }, null, 2));
+  },
+  detectBinary: () => null, // VS Code extension, no binary
+};
+
+// ---------------------------------------------------------------------------
+// Windsurf adapter
+// ---------------------------------------------------------------------------
+
+export const windsurf: AgentAdapter = {
+  id: "windsurf",
+  name: "Windsurf",
+  configDir: () => process.cwd(),
+  writeSkills(skills, targetDir) {
+    const content = concatSkills(skills);
+    writeFileSync(join(targetDir, ".windsurfrules"), content);
+  },
+  writeMcps(mcps, targetDir) {
+    // Windsurf uses same format as Cursor
+    const dir = join(targetDir, ".windsurf");
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(join(dir, "mcp.json"), JSON.stringify({ mcpServers: mcps }, null, 2));
+  },
+  detectBinary: () => findBinary("windsurf"),
+};
+
+// ---------------------------------------------------------------------------
+// Gemini CLI adapter
+// ---------------------------------------------------------------------------
+
+export const gemini: AgentAdapter = {
+  id: "gemini",
+  name: "Gemini CLI",
+  configDir: () => join(homedir(), ".gemini"),
+  writeSkills(skills, targetDir) {
+    // Gemini reads skills from ~/.gemini/skills/ as individual files
+    const skillsDir = join(targetDir, "skills");
+    mkdirSync(skillsDir, { recursive: true });
+    for (const s of skills) {
+      const slug = s.id.split("/").pop() ?? s.id;
+      writeFileSync(join(skillsDir, `${slug}.md`), s.content);
+    }
+  },
+  writeMcps(mcps, targetDir) {
+    // Gemini uses settings.json with mcpServers
+    const settingsPath = join(targetDir, "settings.json");
+    let settings: Record<string, unknown> = {};
+    if (existsSync(settingsPath)) {
+      try { settings = JSON.parse(readFileSync(settingsPath, "utf8")); } catch {}
+    }
+    settings.mcpServers = mcps;
+    writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+  },
+  detectBinary: () => findBinary("gemini"),
+};
+
+// ---------------------------------------------------------------------------
+// GitHub Copilot adapter
+// ---------------------------------------------------------------------------
+
+export const copilot: AgentAdapter = {
+  id: "copilot",
+  name: "GitHub Copilot",
+  configDir: () => process.cwd(),
+  writeSkills(skills, targetDir) {
+    // Copilot reads .github/copilot-instructions.md
+    const ghDir = join(targetDir, ".github");
+    mkdirSync(ghDir, { recursive: true });
+    const content = concatSkills(skills);
+    writeFileSync(join(ghDir, "copilot-instructions.md"), content);
+  },
+  writeMcps(mcps, targetDir) {
+    // Copilot uses .vscode/mcp.json or .github/mcp.json
+    const ghDir = join(targetDir, ".github");
+    mkdirSync(ghDir, { recursive: true });
+    writeFileSync(join(ghDir, "mcp.json"), JSON.stringify({ servers: mcps }, null, 2));
+  },
+  detectBinary: () => null, // VS Code extension
+};
+
+// ---------------------------------------------------------------------------
+// Roo Code adapter
+// ---------------------------------------------------------------------------
+
+export const roo: AgentAdapter = {
+  id: "roo",
+  name: "Roo Code",
+  configDir: () => process.cwd(),
+  writeSkills(skills, targetDir) {
+    // Roo reads .roo/rules/
+    const rulesDir = join(targetDir, ".roo", "rules");
+    mkdirSync(rulesDir, { recursive: true });
+    for (const s of skills) {
+      const slug = s.id.split("/").pop() ?? s.id;
+      writeFileSync(join(rulesDir, `${slug}.md`), s.content);
+    }
+  },
+  writeMcps(mcps, targetDir) {
+    // Roo uses .roo/mcp.json
+    const rooDir = join(targetDir, ".roo");
+    mkdirSync(rooDir, { recursive: true });
+    writeFileSync(join(rooDir, "mcp.json"), JSON.stringify({ mcpServers: mcps }, null, 2));
+  },
+  detectBinary: () => null, // VS Code extension
+};
+
+// ---------------------------------------------------------------------------
+// Amp adapter
+// ---------------------------------------------------------------------------
+
+export const amp: AgentAdapter = {
+  id: "amp",
+  name: "Amp",
+  configDir: () => process.cwd(),
+  writeSkills(skills, targetDir) {
+    // Amp reads AGENTS.md in project root
+    const content = concatSkills(skills);
+    writeFileSync(join(targetDir, "AGENTS.md"), content);
+  },
+  writeMcps(mcps, targetDir) {
+    // Amp uses .amp/mcp.json
+    const ampDir = join(targetDir, ".amp");
+    mkdirSync(ampDir, { recursive: true });
+    writeFileSync(join(ampDir, "mcp.json"), JSON.stringify({ mcpServers: mcps }, null, 2));
+  },
+  detectBinary: () => findBinary("amp"),
+};
+
+// ---------------------------------------------------------------------------
+// Aider adapter
+// ---------------------------------------------------------------------------
+
+export const aider: AgentAdapter = {
+  id: "aider",
+  name: "Aider",
+  configDir: () => process.cwd(),
+  writeSkills(skills, targetDir) {
+    // Aider reads .aider.conf.yml conventions
+    const content = concatSkills(skills);
+    writeFileSync(join(targetDir, ".aider.conventions.md"), content);
+  },
+  writeMcps(_mcps, _targetDir) {
+    // Aider doesn't support MCP
+  },
+  detectBinary: () => findBinary("aider"),
+};
+
+// ---------------------------------------------------------------------------
+// Registry
+// ---------------------------------------------------------------------------
+
+export const ADAPTERS: Record<string, AgentAdapter> = {
+  "claude-code": claudeCode,
+  "codex": codex,
+  "cursor": cursor,
+  "cline": cline,
+  "windsurf": windsurf,
+  "gemini": gemini,
+  "copilot": copilot,
+  "roo": roo,
+  "amp": amp,
+  "aider": aider,
+};
+
+export const AGENT_IDS = Object.keys(ADAPTERS);
+
+export function getAdapter(id: string): AgentAdapter | null {
+  return ADAPTERS[id] ?? null;
+}

package/src/lib/kitty-image.ts

@@ -339,22 +339,25 @@ export function probeKittyTerminal(timeoutMs = 100): Promise<boolean> {
  * Use this from the launch hot path; `isKittyTerminal()` is the env-only
  * sync version kept around for callers that can't await.
  *
- * The probe is the only reliable signal — env vars like KITTY_WINDOW_ID can
- * leak into non-Kitty terminals (e.g. GNOME Terminal launched from a Kitty
- * session). When the probe is available (TTY), we always use it.
+ * Trust strong env signals (KITTY_WINDOW_ID, TERM=xterm-kitty) directly —
+ * these are set by Kitty itself and reliable. Only probe when signals are
+ * ambiguous (e.g. inside tmux with no Kitty env vars).
  */
 export async function detectKittyTerminal(timeoutMs = 100): Promise<boolean> {
   if (process.env.CUE_DISABLE_KITTY_IMAGES === "1") return false;
+  if (process.env.CUE_KITTY === "1") return true;
+
+  // Strong signals — trust directly (Kitty sets these for child processes)
+  if (process.env.TERM === "xterm-kitty") return true;
+  if (process.env.KITTY_WINDOW_ID) return true;
+  if (process.env.KITTY_PID) return true;
 
-  // If we can probe (TTY), always probe — it's the only reliable signal.
-  // Env vars like KITTY_WINDOW_ID leak through tmux/child terminals.
+  // Weak/ambiguous — probe the terminal
   if (process.stdout.isTTY && process.stdin.isTTY) {
     return probeKittyTerminal(timeoutMs);
   }
 
-  // Non-TTY fallback: trust env hints
-  if (process.env.CUE_KITTY === "1") return true;
-  if (process.env.TERM === "xterm-kitty") return true;
-  if (process.env.KITTY_WINDOW_ID) return true;
+  // Non-TTY fallback
+  if (process.env.TERM_PROGRAM === "kitty") return true;
   return false;
 }

package/src/lib/runtime-materializer.ts

@@ -195,6 +195,19 @@ export async function materializeRuntime(input: MaterializeInput): Promise<Mater
   }
 
   // 6. Atomic swap: rm -rf old, rename tmp.
+  // Preserve .claude.json and backups/ — Claude Code writes session state here
+  // and resume depends on it surviving across rematerializations.
+  const preserveFiles = [".claude.json", "backups"];
+  for (const name of preserveFiles) {
+    const oldPath = join(runtimeDir, name);
+    const newPath = join(tmpDir, name);
+    try {
+      const st = await lstat(oldPath);
+      if (st.isFile() || st.isDirectory()) {
+        await rename(oldPath, newPath);
+      }
+    } catch { /* doesn't exist — skip */ }
+  }
   await rm(runtimeDir, { recursive: true, force: true });
   await rename(tmpDir, runtimeDir);
 
@@ -255,9 +268,20 @@ async function overlaySourceState(targetDir: string, sourceDir: string): Promise
         await rm(targetPath, { force: true });
       } catch { continue; }
     }
-    try {
-      await symlink(sourcePath, targetPath);
-    } catch { /* race or permission — skip silently */ }
+
+    // .credentials.json must be COPIED (not symlinked) because Claude Code
+    // refreshes tokens via atomic write (write tmp → rename), which replaces
+    // symlinks with regular files, leaving the source stale.
+    if (name === ".credentials.json") {
+      const { copyFile } = await import("node:fs/promises");
+      try {
+        await copyFile(sourcePath, targetPath);
+      } catch { /* skip */ }
+    } else {
+      try {
+        await symlink(sourcePath, targetPath);
+      } catch { /* race or permission — skip silently */ }
+    }
   }
 }