ctx-switch 2.0.0

package/dist/index.mjs

@@ -0,0 +1,2021 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import path9 from "node:path";
+
+// src/cli.ts
+import fs6 from "node:fs";
+import path8 from "node:path";
+import readline from "node:readline";
+
+// src/args.ts
+import path from "node:path";
+
+// src/types.ts
+var SUPPORTED_COMMANDS = ["continue", "doctor", "sessions"];
+var SUPPORTED_PROVIDERS = ["openrouter"];
+var SUPPORTED_TARGETS = ["generic", "codex", "cursor", "chatgpt"];
+var SUPPORTED_SOURCES = ["claude", "codex", "opencode"];
+
+// src/args.ts
+function requireValue(flag, args) {
+  const value = args.shift();
+  if (!value || value.startsWith("-")) {
+    throw new Error(`Missing value for ${flag}`);
+  }
+  return value;
+}
+function parseArgs(argv) {
+  const args = [...argv];
+  const options = {
+    command: "continue",
+    refine: false,
+    help: false,
+    version: false,
+    session: null,
+    model: null,
+    provider: "openrouter",
+    output: null,
+    apiKey: null,
+    target: "generic",
+    source: null,
+    limit: 10
+  };
+  if (args[0] === "doctor" || args[0] === "sessions") {
+    options.command = args[0];
+    args.shift();
+  }
+  while (args.length > 0) {
+    const arg = args.shift();
+    switch (arg) {
+      case "--help":
+      case "-h":
+        options.help = true;
+        break;
+      case "--version":
+      case "-v":
+        options.version = true;
+        break;
+      case "--refine":
+        options.refine = true;
+        break;
+      case "--session":
+        options.session = requireValue(arg, args);
+        break;
+      case "--model":
+        options.model = requireValue(arg, args);
+        break;
+      case "--provider":
+        options.provider = requireValue(arg, args);
+        break;
+      case "--output":
+      case "-o":
+        options.output = path.resolve(requireValue(arg, args));
+        break;
+      case "--api-key":
+        options.apiKey = requireValue(arg, args);
+        break;
+      case "--target":
+        options.target = requireValue(arg, args);
+        break;
+      case "--source":
+        options.source = requireValue(arg, args);
+        break;
+      case "--limit":
+      case "-n":
+        options.limit = Number(requireValue(arg, args));
+        break;
+      default:
+        if (!arg) {
+          break;
+        }
+        if (arg.startsWith("-")) {
+          throw new Error(`Unknown flag: ${arg}`);
+        }
+        if (!options.session) {
+          options.session = arg;
+          break;
+        }
+        throw new Error(`Unexpected argument: ${arg}`);
+    }
+  }
+  if (!SUPPORTED_PROVIDERS.includes(options.provider)) {
+    throw new Error(
+      `Unsupported provider "${options.provider}". Supported providers: ${SUPPORTED_PROVIDERS.join(", ")}`
+    );
+  }
+  if (!SUPPORTED_TARGETS.includes(options.target)) {
+    throw new Error(
+      `Unsupported target "${options.target}". Supported targets: ${SUPPORTED_TARGETS.join(", ")}`
+    );
+  }
+  if (options.source && !SUPPORTED_SOURCES.includes(options.source)) {
+    throw new Error(
+      `Unsupported source "${options.source}". Supported sources: ${SUPPORTED_SOURCES.join(", ")}`
+    );
+  }
+  if (!SUPPORTED_COMMANDS.includes(options.command)) {
+    throw new Error(
+      `Unsupported command "${options.command}". Supported commands: ${SUPPORTED_COMMANDS.join(", ")}`
+    );
+  }
+  if (!Number.isInteger(options.limit) || options.limit <= 0) {
+    throw new Error(`Invalid limit "${options.limit}". Expected a positive integer.`);
+  }
+  return options;
+}
+function getHelpText({ name, version }) {
+  return [
+    `${name} ${version}`,
+    "",
+    "Turn AI coding agent sessions into high-quality continuation prompts for Codex, Cursor, ChatGPT, or any other agent.",
+    "Supports Claude Code, Codex, and OpenCode as session sources.",
+    "",
+    "Usage",
+    `  ${name} [options]`,
+    `  ${name} doctor [options]`,
+    `  ${name} sessions [options]`,
+    "",
+    "Core Options",
+    "  -h, --help              Show help",
+    "  -v, --version           Show version",
+    "  -o, --output <file>     Write the final prompt to a file",
+    "      --source <name>     Session source: claude, codex, opencode (interactive if omitted)",
+    "      --session <id|path> Use a specific session file or session id",
+    "      --target <name>     Prompt target: generic, codex, cursor, chatgpt",
+    "  -n, --limit <count>     Limit rows for the sessions command (default: 10)",
+    "",
+    "Refinement (optional)",
+    "      --refine             Refine the prompt via an LLM provider (default: raw mode)",
+    "      --provider <name>   Refinement provider (default: openrouter)",
+    "      --model <name>      Provider model override (default: openrouter/free)",
+    "      --api-key <key>     Provider API key override",
+    "",
+    "Doctor",
+    "  Verifies session discovery, git context, clipboard support, and API key availability.",
+    "",
+    "Sessions",
+    "  Lists recent session files for the current project from the selected source.",
+    "",
+    "Examples",
+    `  ${name}                              # interactive source picker`,
+    `  ${name} --source claude               # use Claude Code sessions`,
+    `  ${name} --source codex --target codex`,
+    `  ${name} --source opencode`,
+    `  ${name} --refine --model openrouter/free`,
+    `  ${name} --output ./handoff.md`,
+    `  ${name} doctor`,
+    `  ${name} sessions --source claude --limit 5`
+  ].join("\n");
+}
+
+// src/clipboard.ts
+import { spawnSync } from "node:child_process";
+function hasCommand(command) {
+  const probe = spawnSync("which", [command], { stdio: "ignore" });
+  return probe.status === 0;
+}
+function getClipboardStrategy() {
+  if (process.platform === "darwin") {
+    return { command: "pbcopy", args: [] };
+  }
+  if (process.platform === "win32") {
+    return { command: "cmd", args: ["/c", "clip"] };
+  }
+  if (hasCommand("wl-copy")) {
+    return { command: "wl-copy", args: [] };
+  }
+  if (hasCommand("xclip")) {
+    return { command: "xclip", args: ["-selection", "clipboard"] };
+  }
+  if (hasCommand("xsel")) {
+    return { command: "xsel", args: ["--clipboard", "--input"] };
+  }
+  return null;
+}
+function copyToClipboard(text) {
+  const strategy = getClipboardStrategy();
+  if (!strategy) {
+    return { ok: false, error: "No supported clipboard utility found" };
+  }
+  const result = spawnSync(strategy.command, strategy.args, {
+    input: text,
+    encoding: "utf8"
+  });
+  if (result.status !== 0) {
+    return {
+      ok: false,
+      error: (result.stderr || "Clipboard command failed").trim()
+    };
+  }
+  return { ok: true, command: strategy.command };
+}
+
+// src/config.ts
+import fs from "node:fs";
+import os from "node:os";
+import path2 from "node:path";
+var CONFIG_PATH = path2.join(os.homedir(), ".ctx-switch.json");
+var LEGACY_CONFIG_PATH = path2.join(os.homedir(), ".cc-continue.json");
+function loadConfig(configPath = CONFIG_PATH) {
+  for (const candidate of [configPath, LEGACY_CONFIG_PATH]) {
+    try {
+      return JSON.parse(fs.readFileSync(candidate, "utf8"));
+    } catch {
+    }
+  }
+  return {};
+}
+function saveConfig(config, configPath = CONFIG_PATH) {
+  fs.writeFileSync(configPath, `${JSON.stringify(config, null, 2)}
+`, { mode: 384 });
+  try {
+    fs.chmodSync(configPath, 384);
+  } catch {
+  }
+}
+function getProviderConfig(config, provider) {
+  return config.providers?.[provider] || {};
+}
+function getApiKey({
+  provider,
+  cliValue,
+  env = process.env,
+  config = loadConfig()
+}) {
+  if (cliValue) return cliValue;
+  if (provider === "openrouter" && env.OPENROUTER_API_KEY) {
+    return env.OPENROUTER_API_KEY;
+  }
+  const providerConfig = getProviderConfig(config, provider);
+  return providerConfig.apiKey || config.openrouter_api_key || null;
+}
+function getDefaultModel({
+  provider,
+  cliValue,
+  config = loadConfig()
+}) {
+  if (cliValue) return cliValue;
+  const providerConfig = getProviderConfig(config, provider);
+  return providerConfig.model || "openrouter/free";
+}
+function storeApiKey({
+  provider,
+  apiKey,
+  configPath = CONFIG_PATH
+}) {
+  const config = loadConfig(configPath);
+  config.providers = config.providers || {};
+  config.providers[provider] = config.providers[provider] || {};
+  config.providers[provider].apiKey = apiKey;
+  if (provider === "openrouter") {
+    delete config.openrouter_api_key;
+  }
+  saveConfig(config, configPath);
+}
+function promptForApiKey({
+  provider,
+  input = process.stdin,
+  output = process.stderr
+}) {
+  if (!input.isTTY || !output.isTTY) {
+    return Promise.resolve(null);
+  }
+  const label = provider === "openrouter" ? "OpenRouter" : provider;
+  const prompt = `Enter your ${label} API key: `;
+  return new Promise((resolve, reject) => {
+    let buffer = "";
+    const previousRawMode = input.isRaw;
+    function cleanup() {
+      input.removeListener("data", onData);
+      if (input.isTTY) {
+        input.setRawMode(Boolean(previousRawMode));
+      }
+      input.pause();
+    }
+    function finish(value) {
+      cleanup();
+      output.write("\n");
+      resolve(value.trim() || null);
+    }
+    function onData(chunk) {
+      const text = chunk.toString("utf8");
+      if (text === "") {
+        cleanup();
+        output.write("\n");
+        const error = new Error("Prompt cancelled");
+        error.exitCode = 130;
+        reject(error);
+        return;
+      }
+      if (text === "\r" || text === "\n") {
+        finish(buffer);
+        return;
+      }
+      if (text === "\x7F") {
+        buffer = buffer.slice(0, -1);
+        return;
+      }
+      if (text.startsWith("\x1B")) {
+        return;
+      }
+      buffer += text;
+    }
+    output.write(prompt);
+    input.setRawMode(true);
+    input.resume();
+    input.on("data", onData);
+  });
+}
+
+// src/doctor.ts
+import fs5 from "node:fs";
+import { execFileSync as execFileSync3 } from "node:child_process";
+
+// src/git.ts
+import { execFileSync } from "node:child_process";
+import fs2 from "node:fs";
+import path3 from "node:path";
+function runGit(args, cwd, timeout = 5e3) {
+  try {
+    const stdout = execFileSync("git", args, {
+      cwd,
+      encoding: "utf8",
+      timeout,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    return { ok: true, stdout: stdout.trim() };
+  } catch (error) {
+    const gitError = error;
+    return {
+      ok: false,
+      stdout: "",
+      stderr: gitError.stderr ? String(gitError.stderr).trim() : "",
+      code: typeof gitError.status === "number" ? gitError.status : 1
+    };
+  }
+}
+function truncate(text, maxChars) {
+  if (!text) return "";
+  if (text.length <= maxChars) return text;
+  return `${text.slice(0, maxChars)}
+... [truncated ${text.length - maxChars} chars]`;
+}
+function readUntrackedPreview(cwd, relativePath, maxChars) {
+  try {
+    const fullPath = path3.join(cwd, relativePath);
+    const buffer = fs2.readFileSync(fullPath);
+    if (buffer.includes(0)) {
+      return null;
+    }
+    return truncate(buffer.toString("utf8"), maxChars);
+  } catch {
+    return null;
+  }
+}
+function getGitContext(cwd, options = {}) {
+  const maxDiffChars = options.maxDiffChars || 12e3;
+  const maxUntrackedPreviewChars = options.maxUntrackedPreviewChars || 1500;
+  const repoCheck = runGit(["rev-parse", "--is-inside-work-tree"], cwd, 3e3);
+  if (!repoCheck.ok || repoCheck.stdout !== "true") {
+    return {
+      isGitRepo: false,
+      branch: null,
+      status: "",
+      staged: { stat: "", diff: "" },
+      unstaged: { stat: "", diff: "" },
+      untracked: [],
+      hasChanges: false,
+      recentCommits: "",
+      committedDiff: ""
+    };
+  }
+  const branchResult = runGit(["branch", "--show-current"], cwd, 3e3);
+  const detachedResult = runGit(["rev-parse", "--short", "HEAD"], cwd, 3e3);
+  const branch = branchResult.ok && branchResult.stdout ? branchResult.stdout : detachedResult.ok && detachedResult.stdout ? `detached@${detachedResult.stdout}` : null;
+  const statusResult = runGit(["status", "--short", "--untracked-files=all"], cwd, 5e3);
+  const stagedStatResult = runGit(["diff", "--cached", "--stat"], cwd, 5e3);
+  const stagedDiffResult = runGit(["diff", "--cached"], cwd, 5e3);
+  const unstagedStatResult = runGit(["diff", "--stat"], cwd, 5e3);
+  const unstagedDiffResult = runGit(["diff"], cwd, 5e3);
+  const untrackedResult = runGit(["ls-files", "--others", "--exclude-standard"], cwd, 5e3);
+  const untracked = (untrackedResult.ok ? untrackedResult.stdout.split("\n") : []).map((item) => item.trim()).filter(Boolean).map((relativePath) => ({
+    path: relativePath,
+    preview: readUntrackedPreview(cwd, relativePath, maxUntrackedPreviewChars)
+  }));
+  const stagedDiff = truncate(stagedDiffResult.ok ? stagedDiffResult.stdout : "", maxDiffChars / 2);
+  const unstagedDiff = truncate(unstagedDiffResult.ok ? unstagedDiffResult.stdout : "", maxDiffChars / 2);
+  const recentCommitsResult = runGit(["log", "--oneline", "-15"], cwd, 5e3);
+  const recentCommits = recentCommitsResult.ok ? recentCommitsResult.stdout : "";
+  let committedDiff = "";
+  if (recentCommits) {
+    const commitCount = recentCommits.split("\n").filter(Boolean).length;
+    const diffDepth = Math.min(commitCount, 8);
+    const committedDiffResult = runGit(["diff", `HEAD~${diffDepth}..HEAD`, "--stat"], cwd, 5e3);
+    committedDiff = committedDiffResult.ok ? truncate(committedDiffResult.stdout, maxDiffChars / 2) : "";
+  }
+  return {
+    isGitRepo: true,
+    branch,
+    status: statusResult.ok ? statusResult.stdout : "",
+    staged: {
+      stat: stagedStatResult.ok ? stagedStatResult.stdout : "",
+      diff: stagedDiff
+    },
+    unstaged: {
+      stat: unstagedStatResult.ok ? unstagedStatResult.stdout : "",
+      diff: unstagedDiff
+    },
+    untracked,
+    hasChanges: Boolean(statusResult.ok ? statusResult.stdout : "") || Boolean(stagedDiff) || Boolean(unstagedDiff) || untracked.length > 0,
+    recentCommits,
+    committedDiff
+  };
+}
+
+// src/session-claude.ts
+import fs3 from "node:fs";
+import os2 from "node:os";
+import path4 from "node:path";
+var CLAUDE_DIR = path4.join(os2.homedir(), ".claude");
+var PROJECTS_DIR = path4.join(CLAUDE_DIR, "projects");
+function cwdToProjectDir(cwd) {
+  const resolved = path4.resolve(cwd);
+  const projectKey = resolved.replace(/[:\\/]+/g, "-");
+  return projectKey.startsWith("-") ? projectKey : `-${projectKey}`;
+}
+function listSessionsForProject(cwd, projectsDir = PROJECTS_DIR) {
+  const projectPath = path4.join(projectsDir, cwdToProjectDir(cwd));
+  if (!fs3.existsSync(projectPath)) {
+    return [];
+  }
+  return fs3.readdirSync(projectPath, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".jsonl")).map((entry) => {
+    const sessionPath = path4.join(projectPath, entry.name);
+    return {
+      id: entry.name.replace(/\.jsonl$/, ""),
+      name: entry.name,
+      path: sessionPath,
+      mtimeMs: fs3.statSync(sessionPath).mtimeMs
+    };
+  }).sort((left, right) => right.mtimeMs - left.mtimeMs);
+}
+function findLatestSession(cwd, projectsDir = PROJECTS_DIR) {
+  const sessions = listSessionsForProject(cwd, projectsDir);
+  return sessions[0] || null;
+}
+function resolveSessionPath(selection, cwd, projectsDir = PROJECTS_DIR) {
+  if (!selection) {
+    const latest = findLatestSession(cwd, projectsDir);
+    if (!latest) {
+      return null;
+    }
+    return latest.path;
+  }
+  const looksLikePath = path4.isAbsolute(selection) || selection.includes(path4.sep) || selection.endsWith(".jsonl");
+  if (looksLikePath) {
+    const resolved = path4.resolve(selection);
+    return fs3.existsSync(resolved) ? resolved : null;
+  }
+  const projectPath = path4.join(projectsDir, cwdToProjectDir(cwd));
+  const candidates = [selection, `${selection}.jsonl`];
+  for (const candidate of candidates) {
+    const candidatePath = path4.join(projectPath, candidate);
+    if (fs3.existsSync(candidatePath)) {
+      return candidatePath;
+    }
+  }
+  return null;
+}
+function extractTextFromContent(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content.filter((item) => item && (item.type === "text" || item.type === "input_text")).map((item) => item.text || "").join("\n").trim();
+}
+function extractToolCalls(content) {
+  if (!Array.isArray(content)) return [];
+  return content.filter((item) => item && item.type === "tool_use").map((item) => ({
+    id: item.id || null,
+    tool: item.name || "unknown",
+    input: item.input || {}
+  }));
+}
+function extractToolResults(content) {
+  const results = /* @__PURE__ */ new Map();
+  if (!Array.isArray(content)) return results;
+  for (const item of content) {
+    if (item && item.type === "tool_result" && item.tool_use_id) {
+      const text = typeof item.content === "string" ? item.content : Array.isArray(item.content) ? item.content.filter((c) => c.type === "text").map((c) => c.text || "").join("\n") : "";
+      results.set(item.tool_use_id, {
+        result: text.slice(0, 1500),
+        isError: Boolean(item.is_error)
+      });
+    }
+  }
+  return results;
+}
+function collectMessageCandidates(record) {
+  const candidates = [];
+  if ((record.type === "user" || record.type === "assistant") && record.message) {
+    candidates.push({
+      role: record.type,
+      message: record.message,
+      timestamp: record.timestamp
+    });
+  }
+  const nestedMessage = record.data?.message?.message;
+  const nestedRole = nestedMessage?.role || record.data?.message?.type;
+  const nestedTimestamp = record.data?.message?.timestamp || record.timestamp;
+  if ((nestedRole === "user" || nestedRole === "assistant") && nestedMessage) {
+    candidates.push({
+      role: nestedRole,
+      message: nestedMessage,
+      timestamp: nestedTimestamp
+    });
+  }
+  return candidates;
+}
+function parseSession(sessionPath) {
+  const raw = fs3.readFileSync(sessionPath, "utf8");
+  const lines = raw.split(/\r?\n/).filter(Boolean);
+  const messages = [];
+  const meta = {
+    cwd: null,
+    gitBranch: null,
+    sessionId: path4.basename(sessionPath, ".jsonl")
+  };
+  for (const line of lines) {
+    let record;
+    try {
+      record = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (record.cwd) meta.cwd = record.cwd;
+    if (record.gitBranch) meta.gitBranch = record.gitBranch;
+    if (record.sessionId) meta.sessionId = record.sessionId;
+    const candidates = collectMessageCandidates(record);
+    for (const candidate of candidates) {
+      const content = candidate.message?.content;
+      const text = extractTextFromContent(content);
+      const toolCalls = extractToolCalls(content);
+      if (candidate.role === "user") {
+        const toolResults = extractToolResults(content);
+        if (toolResults.size > 0 && messages.length > 0) {
+          for (let i = messages.length - 1; i >= 0; i--) {
+            if (messages[i].role === "assistant") {
+              for (const tc of messages[i].toolCalls) {
+                if (tc.id && toolResults.has(tc.id)) {
+                  const res = toolResults.get(tc.id);
+                  tc.result = res.result;
+                  tc.isError = res.isError;
+                }
+              }
+              break;
+            }
+          }
+        }
+        const hasToolResultOnly = Array.isArray(content) && content.some((item) => item.type === "tool_result") && !content.some((item) => item.type === "text" || item.type === "input_text");
+        if (hasToolResultOnly) {
+          continue;
+        }
+      }
+      if (!text && toolCalls.length === 0) {
+        continue;
+      }
+      messages.push({
+        role: candidate.role,
+        content: text,
+        toolCalls,
+        timestamp: candidate.timestamp || null
+      });
+    }
+  }
+  return { messages, meta };
+}
+
+// src/session-codex.ts
+import fs4 from "node:fs";
+import os3 from "node:os";
+import path5 from "node:path";
+var CODEX_DIR = path5.join(os3.homedir(), ".codex");
+var CODEX_SESSIONS_DIR = path5.join(CODEX_DIR, "sessions");
+var CODEX_INDEX_PATH = path5.join(CODEX_DIR, "session_index.jsonl");
+function listSessionsForProject2(cwd) {
+  if (!fs4.existsSync(CODEX_SESSIONS_DIR)) {
+    return [];
+  }
+  const resolvedCwd = path5.resolve(cwd);
+  const allSessions = [];
+  function walkDir(dir) {
+    if (!fs4.existsSync(dir)) return;
+    const entries = fs4.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path5.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        walkDir(fullPath);
+      } else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
+        allSessions.push({
+          id: entry.name.replace(/\.jsonl$/, ""),
+          name: entry.name,
+          path: fullPath,
+          mtimeMs: fs4.statSync(fullPath).mtimeMs
+        });
+      }
+    }
+  }
+  walkDir(CODEX_SESSIONS_DIR);
+  const filtered = allSessions.filter((session) => {
+    try {
+      const firstLine = fs4.readFileSync(session.path, "utf8").split("\n")[0];
+      const record = JSON.parse(firstLine);
+      if (record.type === "session_meta" && record.payload?.cwd) {
+        return path5.resolve(record.payload.cwd) === resolvedCwd;
+      }
+    } catch {
+    }
+    return false;
+  });
+  return filtered.sort((a, b) => b.mtimeMs - a.mtimeMs);
+}
+function findLatestSession2(cwd) {
+  const sessions = listSessionsForProject2(cwd);
+  return sessions[0] || null;
+}
+function resolveSessionPath2(selection, cwd) {
+  if (!selection) {
+    const latest = findLatestSession2(cwd);
+    return latest ? latest.path : null;
+  }
+  const looksLikePath = path5.isAbsolute(selection) || selection.includes(path5.sep) || selection.endsWith(".jsonl");
+  if (looksLikePath) {
+    const resolved = path5.resolve(selection);
+    return fs4.existsSync(resolved) ? resolved : null;
+  }
+  const sessions = listSessionsForProject2(cwd);
+  const match = sessions.find((s) => s.id === selection || s.id.includes(selection));
+  return match ? match.path : null;
+}
+function parseSession2(sessionPath) {
+  const raw = fs4.readFileSync(sessionPath, "utf8");
+  const lines = raw.split(/\r?\n/).filter(Boolean);
+  const messages = [];
+  const meta = {
+    cwd: null,
+    gitBranch: null,
+    sessionId: path5.basename(sessionPath, ".jsonl")
+  };
+  const pendingCalls = /* @__PURE__ */ new Map();
+  let currentAssistantText = "";
+  let currentToolCalls = [];
+  function flushAssistant() {
+    if (currentAssistantText || currentToolCalls.length > 0) {
+      messages.push({
+        role: "assistant",
+        content: currentAssistantText.trim(),
+        toolCalls: [...currentToolCalls],
+        timestamp: null
+      });
+      currentAssistantText = "";
+      currentToolCalls = [];
+    }
+  }
+  for (const line of lines) {
+    let record;
+    try {
+      record = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (record.type === "session_meta") {
+      const payload2 = record.payload;
+      if (payload2.cwd) meta.cwd = payload2.cwd;
+      if (payload2.git?.branch) meta.gitBranch = payload2.git.branch;
+      if (payload2.id) meta.sessionId = payload2.id;
+      continue;
+    }
+    if (record.type !== "response_item") continue;
+    const payload = record.payload;
+    const payloadType = payload.type;
+    if (payload.role === "user" && payloadType === "message") {
+      flushAssistant();
+      const text = (payload.content || []).filter((c) => c.type === "input_text").map((c) => c.text || "").join("\n").trim();
+      if (text) {
+        messages.push({
+          role: "user",
+          content: text,
+          toolCalls: [],
+          timestamp: null
+        });
+      }
+      continue;
+    }
+    if (payload.role === "assistant" && payloadType === "message") {
+      const text = (payload.content || []).filter((c) => c.type === "output_text").map((c) => c.text || "").join("\n").trim();
+      if (text) {
+        flushAssistant();
+        currentAssistantText = text;
+      }
+      continue;
+    }
+    if (payloadType === "function_call" && payload.name) {
+      let input = {};
+      try {
+        input = JSON.parse(payload.arguments || "{}");
+      } catch {
+      }
+      const tc = {
+        id: payload.call_id || null,
+        tool: payload.name,
+        input
+      };
+      currentToolCalls.push(tc);
+      if (payload.call_id) {
+        pendingCalls.set(payload.call_id, tc);
+      }
+      continue;
+    }
+    if (payloadType === "function_call_output" && payload.call_id) {
+      const tc = pendingCalls.get(payload.call_id);
+      if (tc) {
+        const output = payload.output || "";
+        tc.result = output.slice(0, 1500);
+        tc.isError = /Process exited with code [^0]/.test(output) || /error|Error|ERROR/.test(output.slice(0, 200));
+      }
+      continue;
+    }
+  }
+  flushAssistant();
+  return { messages, meta };
+}
+
+// src/session-opencode.ts
+import { execFileSync as execFileSync2 } from "node:child_process";
+import os4 from "node:os";
+import path6 from "node:path";
+var OPENCODE_DB_PATH = path6.join(os4.homedir(), ".local", "share", "opencode", "opencode.db");
+function runSqlite(query, dbPath = OPENCODE_DB_PATH) {
+  try {
+    const stdout = execFileSync2("sqlite3", ["-json", dbPath, query], {
+      encoding: "utf8",
+      timeout: 1e4,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    return { ok: true, stdout: stdout.trim() };
+  } catch {
+    return { ok: false, stdout: "" };
+  }
+}
+function parseSqliteJson(result) {
+  if (!result.ok || !result.stdout) return [];
+  try {
+    return JSON.parse(result.stdout);
+  } catch {
+    return [];
+  }
+}
+function listSessionsForProject3(cwd) {
+  const resolvedCwd = path6.resolve(cwd);
+  const projectResult = runSqlite(
+    `SELECT id FROM project WHERE worktree = '${resolvedCwd.replace(/'/g, "''")}';`
+  );
+  const projects = parseSqliteJson(projectResult);
+  if (projects.length === 0) return [];
+  const projectId = projects[0].id;
+  const sessionsResult = runSqlite(
+    `SELECT id, title, directory, time_created, time_updated FROM session WHERE project_id = '${projectId}' ORDER BY time_updated DESC;`
+  );
+  const sessions = parseSqliteJson(sessionsResult);
+  return sessions.map((s) => ({
+    id: s.id,
+    name: s.title || s.id,
+    path: s.id,
+    // OpenCode uses DB IDs, not file paths
+    mtimeMs: s.time_updated
+  }));
+}
+function findLatestSession3(cwd) {
+  const sessions = listSessionsForProject3(cwd);
+  return sessions[0] || null;
+}
+function resolveSessionPath3(selection, cwd) {
+  if (!selection) {
+    const latest = findLatestSession3(cwd);
+    return latest ? latest.id : null;
+  }
+  const sessions = listSessionsForProject3(cwd);
+  const match = sessions.find((s) => s.id === selection || s.id.includes(selection));
+  return match ? match.id : null;
+}
+function parseSession3(sessionId) {
+  const messages = [];
+  const meta = {
+    cwd: null,
+    gitBranch: null,
+    sessionId
+  };
+  const sessionResult = runSqlite(
+    `SELECT title, directory FROM session WHERE id = '${sessionId.replace(/'/g, "''")}';`
+  );
+  const sessionRows = parseSqliteJson(sessionResult);
+  if (sessionRows.length > 0) {
+    meta.cwd = sessionRows[0].directory;
+  }
+  const msgResult = runSqlite(
+    `SELECT id, data FROM message WHERE session_id = '${sessionId.replace(/'/g, "''")}' ORDER BY time_created;`
+  );
+  const msgRows = parseSqliteJson(msgResult);
+  for (const row of msgRows) {
+    let msgData;
+    try {
+      msgData = JSON.parse(row.data);
+    } catch {
+      continue;
+    }
+    if (msgData.path?.cwd && !meta.cwd) {
+      meta.cwd = msgData.path.cwd;
+    }
+    const partsResult = runSqlite(
+      `SELECT data FROM part WHERE message_id = '${row.id.replace(/'/g, "''")}' ORDER BY time_created;`
+    );
+    const partRows = parseSqliteJson(partsResult);
+    const role = msgData.role;
+    if (!role || role !== "user" && role !== "assistant") continue;
+    const textParts = [];
+    const toolCalls = [];
+    for (const partRow of partRows) {
+      let part;
+      try {
+        part = JSON.parse(partRow.data);
+      } catch {
+        continue;
+      }
+      if (part.type === "text" && part.text) {
+        textParts.push(part.text);
+      } else if (part.type === "tool" && part.tool) {
+        const input = part.state?.input || {};
+        const output = part.state?.output || "";
+        const isError = part.state?.status === "error" || /error|Error|ERROR/.test(output.slice(0, 200));
+        const toolName = normalizeToolName(part.tool);
+        const normalizedInput = normalizeInput(part.tool, input);
+        toolCalls.push({
+          id: part.callID || null,
+          tool: toolName,
+          input: normalizedInput,
+          result: output.slice(0, 1500) || void 0,
+          isError: isError || void 0
+        });
+      }
+    }
+    const content = textParts.join("\n").trim();
+    if (!content && toolCalls.length === 0) continue;
+    messages.push({
+      role,
+      content,
+      toolCalls,
+      timestamp: null
+    });
+  }
+  return { messages, meta };
+}
+function normalizeToolName(tool) {
+  const mapping = {
+    read: "read",
+    edit: "edit",
+    write: "write",
+    grep: "grep",
+    glob: "glob",
+    bash: "bash",
+    search: "search",
+    task: "task",
+    skill: "skill",
+    todowrite: "todowrite",
+    question: "question"
+  };
+  return mapping[tool.toLowerCase()] || tool;
+}
+function normalizeInput(tool, input) {
+  if (input.filePath && !input.file_path) {
+    return { ...input, file_path: input.filePath };
+  }
+  return input;
+}
+
+// src/session.ts
+import path7 from "node:path";
+function listSessionsForProject4(cwd, source) {
+  switch (source) {
+    case "claude":
+      return listSessionsForProject(cwd);
+    case "codex":
+      return listSessionsForProject2(cwd);
+    case "opencode":
+      return listSessionsForProject3(cwd);
+  }
+}
+function findLatestSession4(cwd, source) {
+  switch (source) {
+    case "claude":
+      return findLatestSession(cwd);
+    case "codex":
+      return findLatestSession2(cwd);
+    case "opencode":
+      return findLatestSession3(cwd);
+  }
+}
+function resolveSessionPath4(selection, cwd, source) {
+  switch (source) {
+    case "claude":
+      return resolveSessionPath(selection, cwd);
+    case "codex":
+      return resolveSessionPath2(selection, cwd);
+    case "opencode":
+      return resolveSessionPath3(selection, cwd);
+  }
+}
+function parseSession4(sessionPathOrId, source) {
+  switch (source) {
+    case "claude":
+      return parseSession(sessionPathOrId);
+    case "codex":
+      return parseSession2(sessionPathOrId);
+    case "opencode":
+      return parseSession3(sessionPathOrId);
+  }
+}
+function extractFilePath(input) {
+  const value = input.file_path || input.path || input.target_file || input.filePath;
+  return typeof value === "string" ? value : null;
+}
+function extractCommand(input) {
+  const value = input.command || input.cmd;
+  return typeof value === "string" ? value : null;
+}
+function buildSessionContext({
+  messages,
+  meta,
+  cwd,
+  sessionPath,
+  gitContext
+}) {
+  const filesModified = /* @__PURE__ */ new Set();
+  const filesRead = /* @__PURE__ */ new Set();
+  const commands = [];
+  const transcript = [];
+  for (const message of messages) {
+    if (message.role === "assistant" && message.toolCalls.length > 0) {
+      for (const toolCall of message.toolCalls) {
+        const toolName = String(toolCall.tool || "").toLowerCase();
+        const filePath = extractFilePath(toolCall.input);
+        const command = extractCommand(toolCall.input);
+        if (filePath && /(edit|write|create|multi_edit)/.test(toolName)) {
+          filesModified.add(filePath);
+        } else if (filePath && /(read|grep|glob|search)/.test(toolName)) {
+          filesRead.add(filePath);
+        }
+        if (command && /(bash|command|run|exec_command)/.test(toolName)) {
+          commands.push(command);
+        }
+      }
+    }
+    const summaryParts = [];
+    if (message.content) {
+      summaryParts.push(message.content);
+    }
+    if (message.role === "assistant" && message.toolCalls.length > 0) {
+      const toolSummary = message.toolCalls.map((toolCall) => {
+        const filePath = extractFilePath(toolCall.input);
+        const command = extractCommand(toolCall.input);
+        let summary = "";
+        if (filePath) summary = `${toolCall.tool} ${filePath}`;
+        else if (command) summary = `${toolCall.tool}: ${command}`;
+        else summary = toolCall.tool;
+        if (toolCall.isError && toolCall.result) {
+          summary += ` [ERROR: ${toolCall.result.slice(0, 200)}]`;
+        }
+        return summary;
+      }).join(", ");
+      if (toolSummary) {
+        summaryParts.push(`[tools] ${toolSummary}`);
+      }
+    }
+    if (summaryParts.length > 0) {
+      transcript.push({
+        role: message.role,
+        text: summaryParts.join(" | "),
+        timestamp: message.timestamp || null
+      });
+    }
+  }
+  return {
+    cwd,
+    sessionCwd: meta.cwd || cwd,
+    sessionPath,
+    sessionId: meta.sessionId || path7.basename(sessionPath, ".jsonl"),
+    branch: gitContext.branch || meta.gitBranch || null,
+    transcript,
+    filesModified: [...filesModified],
+    filesRead: [...filesRead],
+    commands,
+    messages,
+    gitContext
+  };
+}
+
+// src/doctor.ts
+function checkSqliteAvailable() {
+  try {
+    execFileSync3("sqlite3", ["--version"], { encoding: "utf8", timeout: 3e3, stdio: ["ignore", "pipe", "pipe"] });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function runDoctor({
+  cwd,
+  source,
+  provider,
+  cliApiKey,
+  env,
+  config
+}) {
+  const checks = [];
+  const notes = [];
+  const nextSteps = [];
+  if (source === "claude") {
+    const claudeDirExists = fs5.existsSync(CLAUDE_DIR);
+    checks.push({
+      status: claudeDirExists ? "OK" : "WARN",
+      label: "Claude dir",
+      detail: claudeDirExists ? CLAUDE_DIR : `Missing: ${CLAUDE_DIR}`
+    });
+    if (!claudeDirExists) {
+      nextSteps.push("Install or run Claude Code so ~/.claude/projects is created.");
+    }
+  } else if (source === "codex") {
+    const codexDirExists = fs5.existsSync(CODEX_DIR);
+    checks.push({
+      status: codexDirExists ? "OK" : "WARN",
+      label: "Codex dir",
+      detail: codexDirExists ? CODEX_DIR : `Missing: ${CODEX_DIR}`
+    });
+    if (!codexDirExists) {
+      nextSteps.push("Install or run Codex so ~/.codex/sessions is created.");
+    }
+  } else if (source === "opencode") {
+    const dbExists = fs5.existsSync(OPENCODE_DB_PATH);
+    checks.push({
+      status: dbExists ? "OK" : "WARN",
+      label: "OpenCode DB",
+      detail: dbExists ? OPENCODE_DB_PATH : `Missing: ${OPENCODE_DB_PATH}`
+    });
+    const sqliteOk = checkSqliteAvailable();
+    checks.push({
+      status: sqliteOk ? "OK" : "WARN",
+      label: "sqlite3",
+      detail: sqliteOk ? "Available" : "sqlite3 command not found (required for OpenCode)"
+    });
+    if (!dbExists) {
+      nextSteps.push("Install or run OpenCode so the database is created.");
+    }
+    if (!sqliteOk) {
+      nextSteps.push("Install sqlite3 (required for reading OpenCode sessions).");
+    }
+  }
+  const sessions = listSessionsForProject4(cwd, source);
+  const sourceLabel = source === "claude" ? "Claude" : source === "codex" ? "Codex" : "OpenCode";
+  if (sessions.length > 0) {
+    checks.push({
+      status: "OK",
+      label: "Project sessions",
+      detail: `${sessions.length} ${sourceLabel} session(s) found, latest: ${sessions[0].name}`
+    });
+  } else {
+    checks.push({
+      status: "WARN",
+      label: "Project sessions",
+      detail: `No ${sourceLabel} session files found for the current directory`
+    });
+    nextSteps.push(`Run ${sourceLabel} in this project once so a session file exists.`);
+  }
+  const latest = findLatestSession4(cwd, source);
+  if (latest) {
+    checks.push({
+      status: "OK",
+      label: "Latest session",
+      detail: latest.path
+    });
+  }
+  const gitContext = getGitContext(cwd);
+  if (gitContext.isGitRepo) {
+    checks.push({
+      status: "OK",
+      label: "Git",
+      detail: gitContext.branch ? `Repo detected on ${gitContext.branch}` : "Repo detected"
+    });
+  } else {
+    checks.push({
+      status: "WARN",
+      label: "Git",
+      detail: "Current directory is not a git repository"
+    });
+  }
+  const apiKey = getApiKey({
+    provider,
+    cliValue: cliApiKey,
+    env,
+    config
+  });
+  checks.push({
+    status: apiKey ? "OK" : "WARN",
+    label: "API key",
+    detail: apiKey ? `Available for provider ${provider}` : `Missing for provider ${provider}`
+  });
+  const clipboard = getClipboardStrategy();
+  checks.push({
+    status: clipboard ? "OK" : "WARN",
+    label: "Clipboard",
+    detail: clipboard ? `Using ${clipboard.command}` : "No supported clipboard utility found"
+  });
+  if (!apiKey) {
+    notes.push("Refined mode will prompt for an API key when running interactively.");
+    nextSteps.push("Set OPENROUTER_API_KEY or run ctx-switch once interactively to save it.");
+  }
+  if (!gitContext.isGitRepo) {
+    notes.push("Raw continuation prompts still work outside git, but code-state fidelity is lower.");
+    nextSteps.push("Initialize git in this project if you want better code-state summaries.");
+  }
+  return { checks, notes, nextSteps };
+}
+
+// src/prompt.ts
+function compactText(text, maxChars = 800) {
+  let compacted = String(text || "").replace(/[ \t]+/g, " ").replace(/\n{3,}/g, "\n\n").trim();
+  if (compacted.length <= maxChars) return compacted;
+  return `${compacted.slice(0, maxChars)}...`;
+}
+function unique(list) {
+  return [...new Set(list.filter(Boolean))];
+}
+function buildTargetGuidance(target) {
+  switch (target) {
+    case "codex":
+      return "The next agent is Codex. It should inspect the current files first, avoid redoing completed work, and finish any remaining implementation or verification.";
+    case "cursor":
+      return "The next agent is Cursor. It should continue the implementation directly from the current workspace state and verify behavior in-editor.";
+    case "chatgpt":
+      return "The next agent is ChatGPT. It should reason from the current workspace state, explain what remains, and provide explicit next actions.";
+    default:
+      return "The next agent should continue the interrupted work from the current workspace state without redoing completed steps.";
+  }
+}
+function isNoiseMessage(text) {
+  const trimmed = text.trim().toLowerCase();
+  if (trimmed.length < 5) return true;
+  const noise = [
+    "yes",
+    "no",
+    "ok",
+    "okay",
+    "try",
+    "try?",
+    "sure",
+    "do it",
+    "go ahead",
+    "works",
+    "nice",
+    "cool",
+    "thanks",
+    "thank you",
+    "lgtm",
+    "ship it",
+    "push it",
+    "works push it",
+    "try low effort",
+    "try turn off thinking",
+    "try without timeout"
+  ];
+  if (noise.includes(trimmed)) return true;
+  if (/^(try|yes|ok|sure|test|run)\s/i.test(trimmed) && trimmed.length < 40) return true;
+  if (trimmed.startsWith("[request interrupted")) return true;
+  return false;
+}
+function filterUserMessages(messages) {
+  const all = messages.filter((m) => m.role === "user" && m.content).map((m) => m.content.trim());
+  if (all.length <= 2) return all;
+  const first = all[0];
+  const last = all[all.length - 1];
+  const middle = all.slice(1, -1).filter((msg) => !isNoiseMessage(msg));
+  return [first, ...middle, last];
+}
+function extractUnresolvedErrors(messages) {
+  const errorEntries = [];
+  const successes = /* @__PURE__ */ new Set();
+  for (let i = 0; i < messages.length; i++) {
+    for (const tc of messages[i].toolCalls) {
+      const target = String(tc.input.file_path || tc.input.path || tc.input.command || "").slice(0, 100);
+      const key = `${tc.tool}:${target}`;
+      if (tc.isError && tc.result) {
+        errorEntries.push({ tool: tc.tool, target, error: tc.result.slice(0, 300), index: i });
+      } else if (!tc.isError) {
+        successes.add(key);
+      }
+    }
+  }
+  return errorEntries.filter((e) => !successes.has(`${e.tool}:${e.target}`)).map((e) => `${e.tool}(${e.target}): ${e.error}`);
+}
+function extractKeyDecisions(messages) {
+  const decisions = [];
+  for (const msg of messages) {
+    if (msg.role !== "assistant" || !msg.content) continue;
+    const lower = msg.content.toLowerCase();
+    if (lower.includes("instead") || lower.includes("let me try") || lower.includes("switching to") || lower.includes("the issue is") || lower.includes("the problem is") || lower.includes("root cause")) {
+      decisions.push(compactText(msg.content, 300));
+    }
+  }
+  return decisions.slice(-5);
+}
+function buildRawPrompt(ctx, options = {}) {
+  const userMessages = filterUserMessages(ctx.messages);
+  const errors = extractUnresolvedErrors(ctx.messages);
+  const decisions = extractKeyDecisions(ctx.messages);
+  let prompt = "";
+  prompt += "# Task\n\n";
+  prompt += `Project: \`${ctx.sessionCwd}\`
+`;
+  if (ctx.branch) prompt += `Branch: \`${ctx.branch}\`
+`;
+  prompt += "\nThis is a continuation of an interrupted AI coding session. ";
+  prompt += "The previous agent was working on the task below. Pick up where it left off.\n\n";
+  prompt += "## What The User Asked (chronological)\n\n";
+  for (const msg of userMessages) {
+    prompt += `- ${compactText(msg, 500)}
+`;
+  }
+  prompt += "\n";
+  if (errors.length > 0) {
+    prompt += "## DO NOT REPEAT \u2014 Unresolved Errors\n\n";
+    prompt += "These errors occurred and were NOT fixed. Avoid the same approaches.\n\n";
+    for (const error of errors.slice(-6)) {
+      prompt += `- ${error}
+`;
+    }
+    prompt += "\n";
+  }
+  if (decisions.length > 0) {
+    prompt += "## Key Discoveries From Previous Agent\n\n";
+    for (const decision of decisions) {
+      prompt += `- ${decision}
+`;
+    }
+    prompt += "\n";
+  }
+  prompt += "## Work Already Completed\n\n";
+  if (unique(ctx.filesModified).length > 0) {
+    prompt += "**Files modified:**\n";
+    for (const filePath of unique(ctx.filesModified)) {
+      prompt += `- \`${filePath}\`
+`;
+    }
+    prompt += "\n";
+  }
+  if (ctx.gitContext.recentCommits) {
+    prompt += "**Recent commits:**\n```\n";
+    prompt += `${ctx.gitContext.recentCommits}
+`;
+    prompt += "```\n\n";
+  }
+  if (ctx.gitContext.committedDiff) {
+    prompt += "**Files changed in recent commits:**\n```\n";
+    prompt += `${ctx.gitContext.committedDiff}
+`;
+    prompt += "```\n\n";
+  }
+  const git = ctx.gitContext;
+  if (git.isGitRepo && git.hasChanges) {
+    prompt += "## Uncommitted Changes\n\n";
+    if (git.status) {
+      prompt += "```\n" + git.status + "\n```\n\n";
+    }
+    if (git.staged.diff) {
+      prompt += "**Staged diff:**\n```diff\n" + git.staged.diff + "\n```\n\n";
+    }
+    if (git.unstaged.diff) {
+      prompt += "**Unstaged diff:**\n```diff\n" + git.unstaged.diff + "\n```\n\n";
+    }
+    if (git.untracked.length > 0) {
+      const shown = git.untracked.slice(0, 6);
+      prompt += "**Untracked files:**\n";
+      for (const file of shown) {
+        prompt += `- \`${file.path}\`
+`;
+      }
+      if (git.untracked.length > shown.length) {
+        prompt += `- ... and ${git.untracked.length - shown.length} more
+`;
+      }
+      prompt += "\n";
+    }
+  }
+  prompt += "## Your Instructions\n\n";
+  prompt += `${buildTargetGuidance(options.target)}
+
+`;
+  prompt += "1. **Read modified files first** \u2014 verify their current state before changing anything.\n";
+  if (errors.length > 0) {
+    prompt += "2. **Check the errors above** \u2014 do NOT repeat failed approaches. Try a different strategy.\n";
+  }
+  prompt += `${errors.length > 0 ? "3" : "2"}. **Identify what's done vs what remains** \u2014 the commits and modified files above show completed work.
+`;
+  prompt += `${errors.length > 0 ? "4" : "3"}. **Do the remaining work** \u2014 pick up exactly where the previous agent stopped.
+`;
+  prompt += `${errors.length > 0 ? "5" : "4"}. **Verify** \u2014 run tests/builds to confirm everything works.
+`;
+  return prompt;
+}
+function buildRefinementDump(ctx, options = {}) {
+  return buildRawPrompt(ctx, options);
+}
+function buildRefinementSystemPrompt(target) {
+  return `You are an expert at creating continuation prompts for AI coding agents. You receive a structured dump of an interrupted AI coding session and must produce a handoff prompt that lets the next agent pick up exactly where the previous one left off.
+
+Your output must be a single, actionable prompt with these sections:
+
+## Goal
+State what the user wants in 1-2 sentences. Use the user's own words where possible.
+
+## Completed Work
+List what was already done \u2014 files created/modified, features implemented, tests passing. Be specific with file paths.
+
+## Errors & Failed Approaches
+If any errors or failures occurred, list them clearly so the next agent does NOT waste time repeating them. Include what was tried and why it failed.
+
+## Remaining Work
+List exactly what still needs to be done. Be specific \u2014 "implement the validation logic in src/validator.ts" not "finish the feature".
+
+## Current Code State
+Summarize the git state: branch, what's committed, what's staged, what's modified but uncommitted. Mention specific files.
+
+## Key Files
+List the most important files the next agent should read first to understand the current state.
+
+## Action Plan
+Give the next agent a concrete numbered list of steps to follow, starting with "Read [specific files] to verify current state" and ending with verification steps.
+
+Rules:
+- Output ONLY the handoff prompt. No preamble, no meta-commentary.
+- Be specific and concrete. File paths, function names, error messages \u2014 not vague descriptions.
+- If the data is incomplete or ambiguous, say so explicitly rather than guessing.
+- Prioritize information density. Every sentence should help the next agent.
+- If errors/failures were found in the session, make them prominent \u2014 avoiding repeated mistakes is critical.
+- Target agent: ${target}. ${buildTargetGuidance(target)}`;
+}
+
+// src/openrouter.ts
+import https from "node:https";
+function buildOpenRouterPayload({
+  model,
+  systemPrompt,
+  userPrompt
+}) {
+  return {
+    model,
+    messages: [
+      { role: "system", content: systemPrompt },
+      { role: "user", content: userPrompt }
+    ]
+  };
+}
+function parseJsonSafely(value) {
+  try {
+    return JSON.parse(value);
+  } catch {
+    return null;
+  }
+}
+function classifyOpenRouterError({
+  statusCode,
+  body = "",
+  requestError
+}) {
+  if (requestError) {
+    return {
+      category: "network",
+      message: requestError,
+      suggestions: [
+        "Check your network connection and try again.",
+        "Run `ctx-switch --raw` if you want to skip refinement."
+      ]
+    };
+  }
+  const parsed = parseJsonSafely(body);
+  const providerMessage = parsed?.error?.message || parsed?.message || (body ? String(body).slice(0, 500) : "Unknown provider error");
+  const lower = providerMessage.toLowerCase();
+  if (statusCode === 404 && lower.includes("guardrail restrictions") && lower.includes("data policy")) {
+    return {
+      category: "privacy-policy",
+      message: "OpenRouter blocked this model because your privacy settings do not allow any available endpoint for it.",
+      suggestions: [
+        "Open https://openrouter.ai/settings/privacy and relax the privacy restriction for this model.",
+        "Retry with `ctx-switch --raw` if you want to skip provider refinement.",
+        "Retry with `ctx-switch --model <another-openrouter-model>` if you have another allowed model."
+      ],
+      raw: providerMessage
+    };
+  }
+  if (statusCode === 401 || statusCode === 403) {
+    return {
+      category: "auth",
+      message: "OpenRouter rejected the request. Check that your API key is valid and allowed to use this model.",
+      suggestions: [
+        "Verify `OPENROUTER_API_KEY` or rerun interactively to save a fresh key.",
+        "Retry with `ctx-switch --raw` if you want to skip refinement."
+      ],
+      raw: providerMessage
+    };
+  }
+  if (statusCode === 404) {
+    return {
+      category: "not-found",
+      message: "OpenRouter could not find a compatible endpoint for this request.",
+      suggestions: [
+        "Retry with `ctx-switch --model <another-openrouter-model>`.",
+        "Run `ctx-switch --raw` if you want to skip provider refinement."
+      ],
+      raw: providerMessage
+    };
+  }
+  if (statusCode === 429) {
+    return {
+      category: "rate-limit",
+      message: "OpenRouter rate limited this request.",
+      suggestions: [
+        "Wait a bit and retry.",
+        "Run `ctx-switch --raw` if you want to skip refinement."
+      ],
+      raw: providerMessage
+    };
+  }
+  return {
+    category: "provider",
+    message: statusCode ? `OpenRouter error ${statusCode}: ${providerMessage}` : providerMessage,
+    suggestions: ["Retry with `ctx-switch --raw` if you want to skip refinement."],
+    raw: providerMessage
+  };
+}
+function parseSSEChunk(line) {
+  if (!line.startsWith("data: ")) return null;
+  const data = line.slice(6).trim();
+  if (data === "[DONE]") return null;
+  try {
+    const parsed = JSON.parse(data);
+    if (parsed.error) return null;
+    return parsed.choices?.[0]?.delta?.content || null;
+  } catch {
+    return null;
+  }
+}
+function doStreamRequest({
+  apiKey,
+  body,
+  timeoutMs,
+  onStatus,
+  onToken
+}) {
+  return new Promise((resolve) => {
+    let receivedFirstToken = false;
+    let fullText = "";
+    let sseBuffer = "";
+    const req = https.request(
+      {
+        hostname: "openrouter.ai",
+        path: "/api/v1/chat/completions",
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Content-Length": Buffer.byteLength(body),
+          Authorization: `Bearer ${apiKey}`
+        }
+      },
+      (res) => {
+        onStatus?.(`provider responded (${res.statusCode || "unknown"})`);
+        if (res.statusCode && res.statusCode >= 400) {
+          let errorData = "";
+          res.on("data", (chunk) => {
+            errorData += chunk;
+          });
+          res.on("end", () => {
+            const classified = classifyOpenRouterError({ statusCode: res.statusCode, body: errorData });
+            resolve({
+              ok: false,
+              error: classified.message,
+              category: classified.category,
+              suggestions: classified.suggestions,
+              rawError: classified.raw || errorData.slice(0, 500)
+            });
+          });
+          return;
+        }
+        res.on("data", (chunk) => {
+          sseBuffer += chunk;
+          const lines = sseBuffer.split("\n");
+          sseBuffer = lines.pop() || "";
+          for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed) continue;
+            const token = parseSSEChunk(trimmed);
+            if (token) {
+              if (!receivedFirstToken) {
+                receivedFirstToken = true;
+                onStatus?.("streaming");
+              }
+              fullText += token;
+              onToken?.(token);
+            }
+          }
+        });
+        res.on("end", () => {
+          if (sseBuffer.trim()) {
+            const token = parseSSEChunk(sseBuffer.trim());
+            if (token) {
+              fullText += token;
+              onToken?.(token);
+            }
+          }
+          if (fullText) {
+            resolve({ ok: true, text: fullText });
+          } else {
+            resolve({ ok: false, error: "Empty response from provider" });
+          }
+        });
+      }
+    );
+    onStatus?.("sending request");
+    req.on("socket", () => {
+      onStatus?.("waiting for provider");
+    });
+    if (timeoutMs > 0) {
+      req.setTimeout(timeoutMs, () => {
+        onStatus?.("request timed out");
+        req.destroy(new Error("Provider request timed out"));
+      });
+    }
+    req.on("error", (error) => {
+      const classified = classifyOpenRouterError({ requestError: error.message });
+      resolve({
+        ok: false,
+        error: classified.message,
+        category: classified.category,
+        suggestions: classified.suggestions,
+        rawError: error.message
+      });
+    });
+    req.write(body);
+    req.end();
+  });
+}
+async function refineWithOpenRouter({
+  apiKey,
+  model,
+  systemPrompt,
+  userPrompt,
+  timeoutMs = 0,
+  onStatus,
+  onToken
+}) {
+  const payload = buildOpenRouterPayload({ model, systemPrompt, userPrompt });
+  const fastBody = JSON.stringify({ ...payload, stream: true, reasoning: { effort: "low" } });
+  const firstResult = await doStreamRequest({ apiKey, body: fastBody, timeoutMs, onStatus, onToken });
+  if (!firstResult.ok && firstResult.rawError && /reasoning/i.test(firstResult.rawError)) {
+    onStatus?.("retrying without reasoning flag");
+    const fallbackBody = JSON.stringify({ ...payload, stream: true });
+    return doStreamRequest({ apiKey, body: fallbackBody, timeoutMs, onStatus, onToken });
+  }
+  return firstResult;
+}
+
+// src/ui.ts
+function createColors(enabled) {
+  const wrap = (code) => (text) => enabled ? `\x1B[${code}m${text}\x1B[0m` : text;
+  return {
+    bold: wrap("1"),
+    dim: wrap("2"),
+    cyan: wrap("36"),
+    green: wrap("32"),
+    yellow: wrap("33"),
+    red: wrap("31")
+  };
+}
+function createTheme(stream = process.stderr) {
+  const enabled = Boolean(stream.isTTY) && !process.env.NO_COLOR;
+  const colors = createColors(enabled);
+  function write(line = "") {
+    stream.write(`${line}
+`);
+  }
+  return {
+    step(message) {
+      write(`${colors.cyan("[..]")} ${message}`);
+    },
+    success(message) {
+      write(`${colors.green("[ok]")} ${message}`);
+    },
+    warn(message) {
+      write(`${colors.yellow("[!!]")} ${message}`);
+    },
+    note(message) {
+      write(`${colors.dim(" -> ")} ${message}`);
+    },
+    section(title) {
+      write(colors.bold(title));
+    },
+    plain(message = "") {
+      write(message);
+    }
+  };
+}
+function pad(value, width) {
+  return String(value).padEnd(width, " ");
+}
+function formatRelativeTime(timestamp) {
+  if (!timestamp) return "unknown";
+  const deltaSeconds = Math.max(1, Math.round((Date.now() - timestamp) / 1e3));
+  if (deltaSeconds < 60) return `${deltaSeconds}s ago`;
+  const minutes = Math.round(deltaSeconds / 60);
+  if (minutes < 60) return `${minutes}m ago`;
+  const hours = Math.round(minutes / 60);
+  if (hours < 48) return `${hours}h ago`;
+  const days = Math.round(hours / 24);
+  return `${days}d ago`;
+}
+function summarizeGitContext(gitContext) {
+  if (!gitContext.isGitRepo) {
+    return "not a git repo";
+  }
+  const changed = gitContext.status ? gitContext.status.split("\n").filter(Boolean).length : 0;
+  const untracked = gitContext.untracked.length;
+  if (!changed && !untracked) {
+    return gitContext.branch ? `${gitContext.branch}, clean` : "clean";
+  }
+  const parts = [];
+  if (gitContext.branch) parts.push(gitContext.branch);
+  if (changed) parts.push(`${changed} changed`);
+  if (untracked) parts.push(`${untracked} untracked`);
+  return parts.join(", ");
+}
+function formatRunSummary({
+  ctx,
+  options,
+  mode,
+  model
+}) {
+  const lines = [];
+  lines.push("Run Summary");
+  lines.push(`  Session: ${ctx.sessionId}`);
+  lines.push(`  Source: ${ctx.sessionPath}`);
+  lines.push(`  Messages: ${ctx.messages.length}`);
+  lines.push(`  Files: ${ctx.filesModified.length} modified, ${ctx.filesRead.length} read`);
+  lines.push(`  Git: ${summarizeGitContext(ctx.gitContext)}`);
+  lines.push(`  Target: ${options.target}`);
+  lines.push(`  Mode: ${mode === "raw" ? "raw" : `refined via ${options.provider}${model ? ` (${model})` : ""}`}`);
+  return lines.join("\n");
+}
+function formatDoctorReport(report) {
+  const lines = ["ctx-switch doctor", ""];
+  for (const check of report.checks) {
+    lines.push(`${pad(check.status, 4)} ${pad(check.label, 16)} ${check.detail}`);
+  }
+  if (report.notes.length > 0) {
+    lines.push("");
+    lines.push("Notes");
+    for (const note of report.notes) {
+      lines.push(`- ${note}`);
+    }
+  }
+  if (report.nextSteps.length > 0) {
+    lines.push("");
+    lines.push("Next Steps");
+    for (const step of report.nextSteps) {
+      lines.push(`- ${step}`);
+    }
+  }
+  return lines.join("\n");
+}
+function formatSessionsReport({
+  cwd,
+  sessions,
+  limit,
+  source
+}) {
+  const sourceLabel = source === "codex" ? "Codex" : source === "opencode" ? "OpenCode" : "Claude";
+  const lines = ["ctx-switch sessions", "", `Project: ${cwd}`, `Source: ${sourceLabel}`, ""];
+  if (sessions.length === 0) {
+    lines.push(`No ${sourceLabel} session files were found for this project.`);
+    lines.push("");
+    lines.push("Next Steps");
+    lines.push(`- Run ${sourceLabel} in this project at least once.`);
+    lines.push("- Run `ctx-switch doctor` to verify the expected session directory.");
+    return lines.join("\n");
+  }
+  const visible = sessions.slice(0, limit);
+  const idWidth = Math.max(7, ...visible.map((session) => session.id.length));
+  const ageWidth = 10;
+  lines.push(`${pad("Session", idWidth)}  ${pad("Updated", ageWidth)}  File`);
+  lines.push(`${"-".repeat(idWidth)}  ${"-".repeat(ageWidth)}  ${"-".repeat(40)}`);
+  for (const session of visible) {
+    lines.push(`${pad(session.id, idWidth)}  ${pad(formatRelativeTime(session.mtimeMs), ageWidth)}  ${session.path}`);
+  }
+  if (sessions.length > visible.length) {
+    lines.push("");
+    lines.push(`Showing ${visible.length} of ${sessions.length} session(s). Use --limit to see more.`);
+  }
+  return lines.join("\n");
+}
+
+// src/cli.ts
+var SOURCE_LABELS = {
+  claude: "Claude Code",
+  codex: "Codex",
+  opencode: "OpenCode"
+};
+function fail(message, { exitCode = 1, suggestions = [] } = {}) {
+  const error = new Error(message);
+  error.exitCode = exitCode;
+  error.suggestions = suggestions;
+  throw error;
+}
+function createActivityReporter(label) {
+  const stream = process.stderr;
+  const start = Date.now();
+  let status = "starting";
+  let timer = null;
+  let lastRendered = "";
+  const frames = ["|", "/", "-", "\\"];
+  let frameIndex = 0;
+  function elapsedSeconds() {
+    return Math.max(1, Math.round((Date.now() - start) / 1e3));
+  }
+  function render() {
+    const line = `${frames[frameIndex]} ${label}: ${status} (${elapsedSeconds()}s)`;
+    frameIndex = (frameIndex + 1) % frames.length;
+    if (stream.isTTY) {
+      const padded = line.padEnd(Math.max(lastRendered.length, line.length), " ");
+      stream.write(`\r${padded}`);
+      lastRendered = padded;
+      return;
+    }
+    if (elapsedSeconds() === 1 || elapsedSeconds() % 5 === 0) {
+      stream.write(`${line}
+`);
+    }
+  }
+  function startTimer() {
+    render();
+    timer = setInterval(render, 1e3);
+    timer.unref();
+  }
+  function update(nextStatus) {
+    status = nextStatus;
+    if (stream.isTTY) {
+      render();
+    }
+  }
+  function stop(finalStatus) {
+    if (timer) {
+      clearInterval(timer);
+    }
+    const message = `${label}: ${finalStatus} (${elapsedSeconds()}s)`;
+    if (stream.isTTY) {
+      const padded = message.padEnd(Math.max(lastRendered.length, message.length), " ");
+      stream.write(`\r${padded}
+`);
+    } else {
+      stream.write(`${message}
+`);
+    }
+  }
+  startTimer();
+  return { update, stop };
+}
+function writeOutputFile(outputPath, text) {
+  fs6.mkdirSync(path8.dirname(outputPath), { recursive: true });
+  fs6.writeFileSync(outputPath, `${text}
+`);
+}
+async function promptForSource() {
+  const sources = ["claude", "codex", "opencode"];
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stderr
+  });
+  process.stderr.write("\nSelect the AI agent to extract context from:\n\n");
+  for (let i = 0; i < sources.length; i++) {
+    process.stderr.write(`  ${i + 1}) ${SOURCE_LABELS[sources[i]]}
+`);
+  }
+  process.stderr.write("\n");
+  return new Promise((resolve) => {
+    rl.question("Enter choice (1-3): ", (answer) => {
+      rl.close();
+      const idx = Number.parseInt(answer.trim(), 10) - 1;
+      if (idx >= 0 && idx < sources.length) {
+        resolve(sources[idx]);
+      } else {
+        process.stderr.write("Invalid choice, defaulting to Claude Code.\n");
+        resolve("claude");
+      }
+    });
+  });
+}
+async function main(argv = process.argv.slice(2)) {
+  const options = parseArgs(argv);
+  const pkgInfo = { name: "ctx-switch", version: "2.0.0" };
+  const ui = createTheme(process.stderr);
+  if (options.help) {
+    process.stdout.write(`${getHelpText(pkgInfo)}
+`);
+    return;
+  }
+  if (options.version) {
+    process.stdout.write(`${pkgInfo.version}
+`);
+    return;
+  }
+  const cwd = process.cwd();
+  const config = loadConfig();
+  let source;
+  if (options.source) {
+    source = options.source;
+  } else if (process.stdin.isTTY) {
+    source = await promptForSource();
+  } else {
+    source = "claude";
+  }
+  const sourceLabel = SOURCE_LABELS[source];
+  if (options.command === "doctor") {
+    const report = runDoctor({
+      cwd,
+      source,
+      provider: options.provider,
+      cliApiKey: options.apiKey,
+      env: process.env,
+      config
+    });
+    process.stdout.write(`${formatDoctorReport(report)}
+`);
+    return;
+  }
+  if (options.command === "sessions") {
+    const sessions = listSessionsForProject4(cwd, source);
+    process.stdout.write(`${formatSessionsReport({ cwd, sessions, limit: options.limit, source })}
+`);
+    return;
+  }
+  ui.step(`Finding ${sourceLabel} session`);
+  const sessionPath = resolveSessionPath4(options.session, cwd, source);
+  if (!sessionPath) {
+    fail(
+      options.session ? `Unable to find session "${options.session}" for ${cwd} (source: ${sourceLabel})` : `No ${sourceLabel} session files found for ${cwd}.`,
+      {
+        suggestions: [
+          `Run \`ctx-switch sessions --source ${source}\` to inspect project sessions.`,
+          "Run `ctx-switch doctor` for diagnostics.",
+          `Run ${sourceLabel} in this project at least once if no sessions exist yet.`
+        ]
+      }
+    );
+  }
+  const sessionDisplay = source === "opencode" ? sessionPath : path8.basename(sessionPath);
+  ui.success(`Using session ${sessionDisplay}`);
+  ui.step("Parsing session");
+  const { messages, meta } = parseSession4(sessionPath, source);
+  if (messages.length === 0) {
+    fail(`Parsed zero usable messages from ${sessionPath}`);
+  }
+  ui.step("Capturing git context");
+  const gitContext = getGitContext(cwd);
+  const ctx = buildSessionContext({
+    messages,
+    meta,
+    cwd,
+    sessionPath,
+    gitContext
+  });
+  let finalPrompt = "";
+  let mode = "raw";
+  let activeModel = null;
+  if (!options.refine) {
+    ui.step("Building continuation prompt");
+    finalPrompt = buildRawPrompt(ctx, { target: options.target });
+  } else {
+    const provider = options.provider;
+    let apiKey = getApiKey({
+      provider,
+      cliValue: options.apiKey,
+      env: process.env,
+      config
+    });
+    const model = getDefaultModel({
+      provider,
+      cliValue: options.model,
+      config
+    });
+    activeModel = model;
+    if (!apiKey) {
+      ui.warn(`No ${provider} API key found. A key can be saved to ${CONFIG_PATH}.`);
+      apiKey = await promptForApiKey({ provider });
+      if (apiKey) {
+        storeApiKey({ provider, apiKey });
+        ui.success(`Saved ${provider} API key to ${CONFIG_PATH}`);
+      }
+    }
+    if (!apiKey) {
+      ui.warn("No API key available. Falling back to raw continuation prompt.");
+      finalPrompt = buildRawPrompt(ctx, { target: options.target });
+    } else {
+      mode = "refined";
+      ui.section(formatRunSummary({ ctx, options, mode, model }));
+      ui.plain();
+      ui.step(`Refining prompt with ${provider} (${model})`);
+      ui.note("Streaming response below:");
+      const reporter = createActivityReporter("Refining prompt");
+      let streamStarted = false;
+      const refined = await refineWithOpenRouter({
+        apiKey,
+        model,
+        systemPrompt: buildRefinementSystemPrompt(options.target),
+        userPrompt: buildRefinementDump(ctx, { target: options.target }),
+        timeoutMs: 0,
+        onStatus: (status) => {
+          if (!streamStarted) reporter.update(status);
+        },
+        onToken: (token) => {
+          if (!streamStarted) {
+            streamStarted = true;
+            reporter.stop("streaming");
+            process.stderr.write("\n");
+          }
+          process.stderr.write(token);
+        }
+      });
+      if (streamStarted) {
+        process.stderr.write("\n\n");
+      } else {
+        reporter.stop(refined.ok ? "done" : "failed");
+      }
+      if (refined.ok) {
+        finalPrompt = refined.text;
+      } else {
+        mode = "raw";
+        ui.warn(`Provider refinement failed: ${refined.error}`);
+        if (Array.isArray(refined.suggestions)) {
+          for (const suggestion of refined.suggestions) {
+            ui.note(suggestion);
+          }
+        }
+        if (refined.rawError && refined.rawError !== refined.error) {
+          ui.note(`Provider detail: ${refined.rawError}`);
+        }
+        ui.note("Falling back to the raw structured prompt.");
+        finalPrompt = buildRawPrompt(ctx, { target: options.target });
+      }
+    }
+  }
+  if (mode === "raw") {
+    ui.section(formatRunSummary({ ctx, options, mode, model: activeModel }));
+    ui.plain();
+  }
+  if (options.output) {
+    writeOutputFile(options.output, finalPrompt);
+    ui.success(`Wrote prompt to ${options.output}`);
+  }
+  const clipboard = copyToClipboard(finalPrompt);
+  if (clipboard.ok) {
+    ui.success(`Copied to clipboard (${finalPrompt.length} chars)`);
+  } else {
+    ui.warn(`Clipboard copy failed: ${clipboard.error}`);
+    ui.success(`Prompt ready (${finalPrompt.length} chars)`);
+  }
+  process.stdout.write(`${finalPrompt}
+`);
+}
+
+// src/index.ts
+var binName = path9.basename(process.argv[1] || "");
+if (binName === "cc-continue" || binName === "cc-continue.mjs") {
+  process.stderr.write(
+    "\x1B[33mNote:\x1B[0m cc-continue has been renamed to \x1B[1mctx-switch\x1B[0m. Please use \x1B[36mctx-switch\x1B[0m going forward.\n\n"
+  );
+}
+void main().catch((error) => {
+  const appError = error;
+  const message = appError?.message ? appError.message : String(error);
+  console.error(`Error: ${message}`);
+  if (Array.isArray(appError?.suggestions) && appError.suggestions.length > 0) {
+    console.error("");
+    console.error("Next Steps");
+    for (const suggestion of appError.suggestions) {
+      console.error(`- ${suggestion}`);
+    }
+  }
+  process.exit(typeof appError?.exitCode === "number" ? appError.exitCode : 1);
+});