ctx-switch 2.0.5 → 2.0.6

package/dist/index.mjs

@@ -829,7 +829,10 @@ 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) {
+function getOpenCodeDbPath() {
+  return process.env.CTX_SWITCH_OPENCODE_DB_PATH || OPENCODE_DB_PATH;
+}
+function runSqlite(query, dbPath = getOpenCodeDbPath()) {
   try {
     const stdout = execFileSync2("sqlite3", ["-json", dbPath, query], {
       encoding: "utf8",
@@ -882,7 +885,31 @@ function resolveSessionPath3(selection, cwd) {
   const match = sessions.find((s) => s.id === selection || s.id.includes(selection));
   return match ? match.id : null;
 }
+function detectToolError(tool, status, output) {
+  if (status === "error") return true;
+  if (!output) return void 0;
+  if (/Process exited with code [1-9]\d*/.test(output)) return true;
+  if (/^npm ERR!/m.test(output)) return true;
+  if (/^(Error|TypeError|ReferenceError|SyntaxError):/m.test(output)) return true;
+  if (/^(bash|sh|zsh):/m.test(output)) return true;
+  if (tool === "read" || tool === "glob" || tool === "grep") return void 0;
+  return void 0;
+}
+function extractDelegatedSessionId(part) {
+  const metadataSessionId = part.state?.metadata?.sessionId;
+  if (typeof metadataSessionId === "string" && metadataSessionId.trim()) {
+    return metadataSessionId.trim();
+  }
+  const output = part.state?.output;
+  if (typeof output !== "string") return null;
+  const match = output.match(/\btask_id:\s*(ses_[^\s)]+)/);
+  return match?.[1] || null;
+}
 function parseSession3(sessionId) {
+  return parseSessionInternal(sessionId, /* @__PURE__ */ new Set());
+}
+function parseSessionInternal(sessionId, seenSessions) {
+  seenSessions.add(sessionId);
   const messages = [];
   const meta = {
     cwd: null,
@@ -918,6 +945,7 @@ function parseSession3(sessionId) {
     if (!role || role !== "user" && role !== "assistant") continue;
     const textParts = [];
     const toolCalls = [];
+    const delegatedAssistantMessages = [];
     for (const partRow of partRows) {
       let part;
       try {
@@ -930,9 +958,17 @@ function parseSession3(sessionId) {
       } 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 isError = detectToolError(part.tool, part.state?.status, output);
         const toolName = normalizeToolName(part.tool);
         const normalizedInput = normalizeInput(part.tool, input);
+        if (toolName === "task") {
+          const delegatedSessionId = extractDelegatedSessionId(part);
+          if (delegatedSessionId && !seenSessions.has(delegatedSessionId)) {
+            normalizedInput.delegated_session_id = delegatedSessionId;
+            const delegated = parseSessionInternal(delegatedSessionId, seenSessions);
+            delegatedAssistantMessages.push(...delegated.messages.filter((message) => message.role === "assistant"));
+          }
+        }
         toolCalls.push({
           id: part.callID || null,
           tool: toolName,
@@ -950,11 +986,15 @@ function parseSession3(sessionId) {
       toolCalls,
       timestamp: null
     });
+    if (role === "assistant" && delegatedAssistantMessages.length > 0) {
+      messages.push(...delegatedAssistantMessages);
+    }
   }
   return { messages, meta };
 }
 function normalizeToolName(tool) {
   const mapping = {
+    apply_patch: "apply_patch",
     read: "read",
     edit: "edit",
     write: "write",
@@ -970,10 +1010,14 @@ function normalizeToolName(tool) {
   return mapping[tool.toLowerCase()] || tool;
 }
 function normalizeInput(tool, input) {
-  if (input.filePath && !input.file_path) {
-    return { ...input, file_path: input.filePath };
+  const normalized = { ...input };
+  if (normalized.filePath && !normalized.file_path) {
+    normalized.file_path = normalized.filePath;
   }
-  return input;
+  if (tool === "apply_patch" && typeof normalized.patchText === "string" && !normalized.patch) {
+    normalized.patch = normalized.patchText;
+  }
+  return normalized;
 }
 
 // src/session.ts
@@ -1040,6 +1084,23 @@ function extractParsedCommands(input) {
   if (!Array.isArray(parsed)) return [];
   return parsed.filter((entry) => Boolean(entry) && typeof entry === "object");
 }
+function tokenizeShellCommand(command) {
+  const matches = command.match(/"[^"]*"|'[^']*'|\S+/g) ?? [];
+  return matches.map((token) => token.replace(/^['"]|['"]$/g, ""));
+}
+function looksLikeFilePath(token) {
+  if (!token || token.startsWith("-")) return false;
+  if (/[|<>;$()]/.test(token)) return false;
+  return token.includes("/") || token.includes(".");
+}
+function extractReadPathsFromCommand(command, cwd) {
+  const tokens = tokenizeShellCommand(command.trim());
+  if (tokens.length === 0) return [];
+  const base = path7.basename(tokens[0]);
+  const readCommands = /* @__PURE__ */ new Set(["cat", "head", "tail", "sed", "nl", "wc"]);
+  if (!readCommands.has(base)) return [];
+  return tokens.slice(1).filter((token) => looksLikeFilePath(token)).filter((token) => !/^\d+(,\d+)?p?$/.test(token)).map((token) => resolveSessionFilePath(token, cwd));
+}
 function buildSessionContext({
   messages,
   meta,
@@ -1059,6 +1120,7 @@ function buildSessionContext({
         const command = extractCommand(toolCall.input);
         const patchPaths = extractPatchFilePaths(toolCall.input, cwd);
         const parsedCommands = extractParsedCommands(toolCall.input);
+        const commandReadPaths = command ? extractReadPathsFromCommand(command, cwd) : [];
         if (filePath && /(edit|write|create|multi_edit)/.test(toolName)) {
           filesModified.add(resolveSessionFilePath(filePath, cwd));
         } else if (filePath && /(read|grep|glob|search)/.test(toolName)) {
@@ -1071,6 +1133,9 @@ function buildSessionContext({
           if (parsedCommand.type !== "read" || typeof parsedCommand.path !== "string") continue;
           filesRead.add(resolveSessionFilePath(parsedCommand.path, cwd));
         }
+        for (const readPath of commandReadPaths) {
+          filesRead.add(readPath);
+        }
         if (command && /(bash|command|run|exec_command)/.test(toolName)) {
           commands.push(command);
         }
@@ -1268,7 +1333,7 @@ function extractCommand2(input) {
 function buildTargetGuidance(target) {
   switch (target) {
     case "claude":
-      return "The next agent is Claude Code. It should read the active files first, trust the current workspace and git diff over stale transcript details, and continue the implementation or debugging directly.";
+      return "The next agent is Claude Code. It should read the active files first, inspect the current workspace with git commands, and continue the implementation or debugging directly.";
     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":
@@ -1276,7 +1341,7 @@ function buildTargetGuidance(target) {
     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 read the active files first, trust the current workspace and git diff over stale transcript details, continue the interrupted work directly, and avoid redoing completed steps.";
+      return "The next agent should read the active files first, inspect the current workspace with git commands, continue the interrupted work directly, and avoid redoing completed steps.";
   }
 }
 function isNoiseMessage(text) {
@@ -1316,6 +1381,10 @@ function isReferentialMessage(text) {
   if (!normalized || normalized.length > 220) return false;
   return /^(ok|okay|alright|now|so)\b/.test(normalized) || /\b(it|that|again|better|same|continue|still|also|another|more)\b/.test(normalized);
 }
+function isMetaQualityAssistantMessage(text) {
+  const lower = text.toLowerCase();
+  return /\b(handoff|prompt)\b/.test(lower) && /\b(good|bad|better|worse|quality)\b/.test(lower);
+}
 function filterUserMessages(messages) {
   const all = messages.filter((m) => m.role === "user" && m.content).map((m) => m.content.trim());
   if (all.length <= 2) return all;
@@ -1344,10 +1413,10 @@ function extractKeyDecisions(messages) {
   const decisions = [];
   for (const msg of messages) {
     if (msg.role !== "assistant" || !msg.content) continue;
-    const lower = msg.content.toLowerCase();
-    if (/\b(handoff|prompt)\b/.test(lower) && /\b(good|bad|better|worse|quality)\b/.test(lower)) {
+    if (isMetaQualityAssistantMessage(msg.content)) {
       continue;
     }
+    const lower = msg.content.toLowerCase();
     if (/\b(root cause|the issue is|the problem is|caused by|failed because|failing because|need to)\b/.test(lower) || /\b(exposed|revealed|showed)\b.*\b(gap|issue|problem|bug)\b/.test(lower) || /\bmissing\b/.test(lower)) {
       decisions.push(compactText(msg.content, 300));
     }
@@ -1419,6 +1488,103 @@ function extractLastAssistantAnswer(messages) {
   }
   return null;
 }
+function summarizeToolCall(toolCall) {
+  const filePath = extractFilePath2(toolCall.input);
+  const command = extractCommand2(toolCall.input);
+  if (filePath) return `${toolCall.tool} ${filePath}`;
+  if (command) return `${toolCall.tool}: ${summarizeCommand(command)}`;
+  return toolCall.tool;
+}
+function findLastActiveAssistant(messages) {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const message = messages[i];
+    if (message.role !== "assistant") continue;
+    if (message.content.trim() || message.toolCalls.length > 0) {
+      return message;
+    }
+  }
+  return null;
+}
+function buildCurrentStatus(messages, errors, sessionAppearsComplete) {
+  const lastAssistant = findLastActiveAssistant(messages);
+  const lastStep = lastAssistant?.content?.trim() ? compactText(lastAssistant.content, 400) : null;
+  const lastToolActions = lastAssistant ? lastAssistant.toolCalls.slice(-4).map(summarizeToolCall) : [];
+  let status = "In progress";
+  if (sessionAppearsComplete) {
+    status = "Latest exchange complete";
+  } else if (errors.length > 0) {
+    status = "Blocked by unresolved errors";
+  } else if (lastAssistant?.toolCalls.length) {
+    status = "Mid-task after recent tool activity";
+  } else if (lastAssistant?.content.trim()) {
+    status = "Awaiting the next concrete action";
+  }
+  return { status, lastStep, lastToolActions };
+}
+function buildRemainingWorkHints({
+  sessionAppearsComplete,
+  errors,
+  work,
+  focusFiles,
+  recentCommands
+}) {
+  if (sessionAppearsComplete) return [];
+  const hints = [];
+  if (errors.length > 0) {
+    hints.push("Resolve the unresolved errors above before extending the implementation.");
+  }
+  if (work.filesModified.length > 0) {
+    hints.push(`Inspect the in-progress changes in ${work.filesModified.map((filePath) => `\`${filePath}\``).join(", ")} and decide what still needs to be finished or verified.`);
+  } else if (focusFiles.length > 0) {
+    hints.push(`Start by reading ${focusFiles.map((filePath) => `\`${filePath}\``).join(", ")} to reconstruct the current working set.`);
+  }
+  if (recentCommands.length > 0) {
+    hints.push("Rerun or extend the recent checks to confirm the current state before making further changes.");
+  }
+  if (focusFiles.length > 0) {
+    hints.push("Run `git diff --` on the active files to see the exact in-progress changes before editing further.");
+  }
+  if (hints.length === 0) {
+    hints.push("Inspect the active files and run `git diff` to determine the next concrete implementation step.");
+  }
+  return hints;
+}
+function selectSessionHistoryMessages(focusedMessages, allMessages, sessionAppearsComplete) {
+  if (sessionAppearsComplete) return focusedMessages;
+  const hasAssistantActivity = focusedMessages.some(
+    (message) => message.role === "assistant" && (message.content.trim() || message.toolCalls.length > 0)
+  );
+  if (focusedMessages.length >= 3 && hasAssistantActivity) return focusedMessages;
+  const filtered = allMessages.filter((message) => {
+    if (message.role === "assistant" && message.content.trim() && isMetaQualityAssistantMessage(message.content)) {
+      return false;
+    }
+    if (message.role === "user" && message.content && isNoiseMessage(message.content)) {
+      return false;
+    }
+    return Boolean(message.content.trim()) || message.toolCalls.length > 0;
+  });
+  return filtered.slice(-8);
+}
+function buildSessionHistory(focusedMessages, allMessages, sessionAppearsComplete) {
+  const historyMessages = selectSessionHistoryMessages(focusedMessages, allMessages, sessionAppearsComplete);
+  const entries = historyMessages.map((message) => {
+    const parts = [];
+    if (message.content.trim()) {
+      if (message.role === "assistant" && isMetaQualityAssistantMessage(message.content)) {
+        return null;
+      }
+      parts.push(compactText(message.content, 220));
+    }
+    if (message.role === "assistant" && message.toolCalls.length > 0) {
+      parts.push(`[tools] ${message.toolCalls.slice(-4).map(summarizeToolCall).join(", ")}`);
+    }
+    if (parts.length === 0) return null;
+    return `${message.role.toUpperCase()}: ${parts.join(" | ")}`;
+  }).filter((entry) => Boolean(entry));
+  if (entries.length <= 8) return entries;
+  return [entries[0], "...", ...entries.slice(-6)];
+}
 function summarizeCommand(command) {
   return compactText(command.replace(/\s+/g, " ").trim(), 140);
 }
@@ -1452,6 +1618,15 @@ function buildRawPrompt(ctx, options = {}) {
   const focusFiles = extractFocusFiles(ctx, work);
   const recentCommands = extractRecentCommands(work.commands);
   const lastAssistantAnswer = extractLastAssistantAnswer(focused.messages);
+  const currentStatus = buildCurrentStatus(focused.messages, errors, focused.sessionAppearsComplete);
+  const remainingWorkHints = buildRemainingWorkHints({
+    sessionAppearsComplete: focused.sessionAppearsComplete,
+    errors,
+    work,
+    focusFiles,
+    recentCommands
+  });
+  const sessionHistory = buildSessionHistory(focused.messages, ctx.messages, focused.sessionAppearsComplete);
   let prompt = "";
   prompt += "# Task\n\n";
   prompt += `Project: \`${ctx.sessionCwd}\`
@@ -1479,6 +1654,26 @@ function buildRawPrompt(ctx, options = {}) {
 
 `;
   }
+  prompt += "## Current Status\n\n";
+  prompt += `- Status: ${currentStatus.status}
+`;
+  if (currentStatus.lastStep) {
+    prompt += `- Last active step: ${currentStatus.lastStep}
+`;
+  }
+  if (currentStatus.lastToolActions.length > 0) {
+    prompt += `- Last tool actions: ${currentStatus.lastToolActions.join(", ")}
+`;
+  }
+  prompt += "\n";
+  if (sessionHistory.length > 0) {
+    prompt += "## Session History\n\n";
+    for (const entry of sessionHistory) {
+      prompt += `- ${entry}
+`;
+    }
+    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";
@@ -1531,6 +1726,14 @@ function buildRawPrompt(ctx, options = {}) {
     prompt += "## Read These Files First\n\n";
     for (const filePath of focusFiles) {
       prompt += `- \`${filePath}\`
+`;
+    }
+    prompt += "\n";
+  }
+  if (remainingWorkHints.length > 0) {
+    prompt += "## Likely Remaining Work\n\n";
+    for (const hint of remainingWorkHints) {
+      prompt += `- ${hint}
 `;
     }
     prompt += "\n";
@@ -1541,12 +1744,6 @@ function buildRawPrompt(ctx, options = {}) {
     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";
@@ -1577,11 +1774,13 @@ function buildRawPrompt(ctx, options = {}) {
     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 use the recent commands, active files, and git state above as the source of truth for the current thread.
+    prompt += `${errors.length > 0 ? "3" : "2"}. **Inspect the workspace state explicitly** \u2014 run \`git status --short\`, \`git diff --stat\`, and \`git diff -- ${focusFiles.length > 0 ? focusFiles.slice(0, 4).join(" ") : "."}\` before changing code.
+`;
+    prompt += `${errors.length > 0 ? "4" : "3"}. **Identify what's done vs what remains** \u2014 use the Current Status, Session History, Likely Remaining Work, recent commands, active files, and git state above as the source of truth for the current thread.
 `;
-    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"}. **Continue from the last active step** \u2014 if the stop point is still ambiguous, inspect the read-first files and rerun the recent commands before changing code.
 `;
-    prompt += `${errors.length > 0 ? "5" : "4"}. **Verify** \u2014 rerun or extend the relevant commands/checks above to confirm everything works.
+    prompt += `${errors.length > 0 ? "6" : "5"}. **Verify** \u2014 rerun or extend the relevant commands/checks above to confirm everything works.
 `;
   }
   return prompt;
@@ -2082,7 +2281,7 @@ async function promptForSource() {
 }
 async function main(argv = process.argv.slice(2)) {
   const options = parseArgs(argv);
-  const pkgInfo = { name: "ctx-switch", version: "2.0.5" };
+  const pkgInfo = { name: "ctx-switch", version: "2.0.6" };
   const ui = createTheme(process.stderr);
   if (options.help) {
     process.stdout.write(`${getHelpText(pkgInfo)}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ctx-switch",
-  "version": "2.0.5",
+  "version": "2.0.6",
   "description": "Switch coding agents without losing context. Generate handoff prompts across Claude Code, Codex, and OpenCode.",
   "type": "module",
   "main": "./dist/index.mjs",