ctx-switch 2.0.4 → 2.0.6

package/dist/index.mjs

@@ -14,7 +14,7 @@ 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_TARGETS = ["generic", "claude", "codex", "cursor", "chatgpt"];
 var SUPPORTED_SOURCES = ["claude", "codex", "opencode"];
 
 // src/args.ts
@@ -142,7 +142,7 @@ function getHelpText({ name, 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",
+    "      --target <name>     Prompt target: generic, claude, codex, cursor, chatgpt",
     "  -n, --limit <count>     Limit rows for the sessions command (default: 10)",
     "",
     "Refinement (optional)",
@@ -160,6 +160,7 @@ function getHelpText({ name, version }) {
     "Examples",
     `  ${name}                              # interactive source picker`,
     `  ${name} --source claude               # use Claude Code sessions`,
+    `  ${name} --source codex --target claude`,
     `  ${name} --source codex --target codex`,
     `  ${name} --source opencode`,
     `  ${name} --refine --model openrouter/free`,
@@ -600,6 +601,60 @@ 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 parseJsonRecord(line) {
+  try {
+    return JSON.parse(line);
+  } catch {
+    return null;
+  }
+}
+function parseFunctionArguments(raw) {
+  if (!raw) return {};
+  try {
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function parseCustomToolInput(toolName, raw) {
+  if (!raw) return {};
+  if (typeof raw !== "string") return raw;
+  const trimmed = raw.trim();
+  if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (parsed && typeof parsed === "object") {
+        return parsed;
+      }
+    } catch {
+    }
+  }
+  if (toolName === "apply_patch") {
+    return { patch: raw };
+  }
+  return { input: raw };
+}
+function parseToolOutput(raw) {
+  if (!raw) return { text: "" };
+  let text = raw;
+  let exitCode;
+  try {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.output === "string") {
+      text = parsed.output;
+    }
+    if (typeof parsed.metadata?.exit_code === "number") {
+      exitCode = parsed.metadata.exit_code;
+    }
+  } catch {
+  }
+  const isError = exitCode !== void 0 ? exitCode !== 0 : /Process exited with code [^0]/.test(text) || /error|Error|ERROR/.test(text.slice(0, 200));
+  return {
+    text: text.slice(0, 1500),
+    isError: isError || void 0
+  };
+}
 function listSessionsForProject2(cwd) {
   if (!fs4.existsSync(CODEX_SESSIONS_DIR)) {
     return [];
@@ -680,12 +735,8 @@ function parseSession2(sessionPath) {
     }
   }
   for (const line of lines) {
-    let record;
-    try {
-      record = JSON.parse(line);
-    } catch {
-      continue;
-    }
+    const record = parseJsonRecord(line);
+    if (!record) continue;
     if (record.type === "session_meta") {
       const payload2 = record.payload;
       if (payload2.cwd) meta.cwd = payload2.cwd;
@@ -693,6 +744,21 @@ function parseSession2(sessionPath) {
       if (payload2.id) meta.sessionId = payload2.id;
       continue;
     }
+    if (record.type === "event_msg" && record.payload.type === "exec_command_end" && record.payload.call_id) {
+      const tc = pendingCalls.get(record.payload.call_id);
+      if (tc) {
+        if (Array.isArray(record.payload.parsed_cmd)) {
+          tc.input.parsed_cmd = record.payload.parsed_cmd;
+        }
+        if (typeof record.payload.aggregated_output === "string" && !tc.result) {
+          tc.result = record.payload.aggregated_output.slice(0, 1500);
+        }
+        if (typeof record.payload.exit_code === "number") {
+          tc.isError = record.payload.exit_code !== 0;
+        }
+      }
+      continue;
+    }
     if (record.type !== "response_item") continue;
     const payload = record.payload;
     const payloadType = payload.type;
@@ -718,11 +784,7 @@ function parseSession2(sessionPath) {
       continue;
     }
     if (payloadType === "function_call" && payload.name) {
-      let input = {};
-      try {
-        input = JSON.parse(payload.arguments || "{}");
-      } catch {
-      }
+      const input = parseFunctionArguments(payload.arguments);
       const tc = {
         id: payload.call_id || null,
         tool: payload.name,
@@ -734,12 +796,26 @@ function parseSession2(sessionPath) {
       }
       continue;
     }
-    if (payloadType === "function_call_output" && payload.call_id) {
+    if (payloadType === "custom_tool_call" && payload.name) {
+      const tc = {
+        id: payload.call_id || null,
+        tool: payload.name,
+        input: parseCustomToolInput(payload.name, payload.input)
+      };
+      currentToolCalls.push(tc);
+      if (payload.call_id) {
+        pendingCalls.set(payload.call_id, tc);
+      }
+      continue;
+    }
+    if ((payloadType === "function_call_output" || payloadType === "custom_tool_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));
+        const parsed = parseToolOutput(payload.output);
+        tc.result = parsed.text;
+        if (parsed.isError !== void 0) {
+          tc.isError = parsed.isError;
+        }
       }
       continue;
     }
@@ -753,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",
@@ -806,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,
@@ -842,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 {
@@ -854,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,
@@ -874,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",
@@ -894,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;
+  }
+  if (tool === "apply_patch" && typeof normalized.patchText === "string" && !normalized.patch) {
+    normalized.patch = normalized.patchText;
   }
-  return input;
+  return normalized;
 }
 
 // src/session.ts
@@ -950,6 +1070,37 @@ function extractCommand(input) {
   const value = input.command || input.cmd;
   return typeof value === "string" ? value : null;
 }
+function resolveSessionFilePath(filePath, cwd) {
+  return path7.isAbsolute(filePath) ? filePath : path7.resolve(cwd, filePath);
+}
+function extractPatchFilePaths(input, cwd) {
+  const patch = input.patch;
+  if (typeof patch !== "string") return [];
+  const matches = [...patch.matchAll(/^\*\*\* (?:Update|Add|Delete) File: (.+)$/gm)];
+  return matches.map((match) => resolveSessionFilePath(match[1].trim(), cwd));
+}
+function extractParsedCommands(input) {
+  const parsed = input.parsed_cmd;
+  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,
@@ -967,10 +1118,23 @@ function buildSessionContext({
         const toolName = String(toolCall.tool || "").toLowerCase();
         const filePath = extractFilePath(toolCall.input);
         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(filePath);
+          filesModified.add(resolveSessionFilePath(filePath, cwd));
         } else if (filePath && /(read|grep|glob|search)/.test(toolName)) {
-          filesRead.add(filePath);
+          filesRead.add(resolveSessionFilePath(filePath, cwd));
+        }
+        for (const patchPath of patchPaths) {
+          filesModified.add(patchPath);
+        }
+        for (const parsedCommand of parsedCommands) {
+          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);
@@ -985,8 +1149,10 @@ function buildSessionContext({
       const toolSummary = message.toolCalls.map((toolCall) => {
         const filePath = extractFilePath(toolCall.input);
         const command = extractCommand(toolCall.input);
+        const patchPaths = extractPatchFilePaths(toolCall.input, cwd);
         let summary = "";
-        if (filePath) summary = `${toolCall.tool} ${filePath}`;
+        if (filePath) summary = `${toolCall.tool} ${resolveSessionFilePath(filePath, cwd)}`;
+        else if (patchPaths.length > 0) summary = `${toolCall.tool} ${patchPaths.join(", ")}`;
         else if (command) summary = `${toolCall.tool}: ${command}`;
         else summary = toolCall.tool;
         if (toolCall.isError && toolCall.result) {
@@ -1156,8 +1322,18 @@ function compactText(text, maxChars = 800) {
 function unique(list) {
   return [...new Set(list.filter(Boolean))];
 }
+function extractFilePath2(input) {
+  const value = input.file_path || input.path || input.target_file || input.filePath;
+  return typeof value === "string" ? value : null;
+}
+function extractCommand2(input) {
+  const value = input.command || input.cmd;
+  return typeof value === "string" ? value : null;
+}
 function buildTargetGuidance(target) {
   switch (target) {
+    case "claude":
+      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":
@@ -1165,19 +1341,20 @@ 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 continue the interrupted work from the current workspace state without 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) {
   const trimmed = text.trim().toLowerCase();
+  const normalized = trimmed.replace(/[^\p{L}\p{N}\s]/gu, " ").replace(/\s+/g, " ").trim();
   if (trimmed.length < 5) return true;
   const noise = [
     "yes",
+    "yes please",
     "no",
     "ok",
     "okay",
     "try",
-    "try?",
     "sure",
     "do it",
     "go ahead",
@@ -1194,11 +1371,20 @@ function isNoiseMessage(text) {
     "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 (noise.includes(normalized)) return true;
+  if (/^(try|yes|ok|sure|test|run)\s/i.test(normalized) && normalized.length < 40) return true;
   if (trimmed.startsWith("[request interrupted")) return true;
   return false;
 }
+function isReferentialMessage(text) {
+  const normalized = text.trim().toLowerCase().replace(/[^\p{L}\p{N}\s]/gu, " ").replace(/\s+/g, " ").trim();
+  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;
@@ -1227,31 +1413,267 @@ function extractKeyDecisions(messages) {
   const decisions = [];
   for (const msg of messages) {
     if (msg.role !== "assistant" || !msg.content) continue;
+    if (isMetaQualityAssistantMessage(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")) {
+    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));
     }
   }
   return decisions.slice(-5);
 }
+function findFocusedWindow(messages) {
+  if (messages.length === 0) {
+    return { messages, sessionAppearsComplete: false };
+  }
+  const substantiveUserIndexes = messages.map((message, index) => ({ message, index })).filter(({ message }) => message.role === "user" && message.content && !isNoiseMessage(message.content)).map(({ index }) => index);
+  if (substantiveUserIndexes.length === 0) {
+    return { messages, sessionAppearsComplete: false };
+  }
+  const lastToolIndex = messages.reduce(
+    (last, message, index) => message.role === "assistant" && message.toolCalls.length > 0 ? index : last,
+    -1
+  );
+  const postToolUsers = substantiveUserIndexes.filter((index) => index > lastToolIndex);
+  let startIndex = 0;
+  if (postToolUsers.length > 0) {
+    startIndex = postToolUsers[0];
+  } else if (lastToolIndex >= 0) {
+    startIndex = substantiveUserIndexes.filter((index) => index <= lastToolIndex).at(-1) ?? 0;
+  } else {
+    startIndex = substantiveUserIndexes.at(-1) ?? 0;
+  }
+  const startMessage = messages[startIndex];
+  if (startMessage?.role === "user" && isReferentialMessage(startMessage.content)) {
+    const previousSubstantive = substantiveUserIndexes.filter((index) => index < startIndex).at(-1);
+    if (typeof previousSubstantive === "number") {
+      startIndex = previousSubstantive;
+    }
+  }
+  const focused = messages.slice(startIndex);
+  const hasToolActivity = focused.some((message) => message.role === "assistant" && message.toolCalls.length > 0);
+  const lastMessage = focused.at(-1);
+  const sessionAppearsComplete = Boolean(lastMessage) && lastMessage.role === "assistant" && lastMessage.toolCalls.length === 0 && !hasToolActivity;
+  return { messages: focused, sessionAppearsComplete };
+}
+function extractWorkSummary(messages) {
+  const filesModified = /* @__PURE__ */ new Set();
+  const commands = [];
+  for (const message of messages) {
+    if (message.role !== "assistant" || message.toolCalls.length === 0) continue;
+    for (const toolCall of message.toolCalls) {
+      const toolName = String(toolCall.tool || "").toLowerCase();
+      const filePath = extractFilePath2(toolCall.input);
+      const command = extractCommand2(toolCall.input);
+      if (filePath && /(edit|write|create|multi_edit)/.test(toolName)) {
+        filesModified.add(filePath);
+      }
+      if (command && /(bash|command|run|exec_command)/.test(toolName)) {
+        commands.push(command);
+      }
+    }
+  }
+  return {
+    filesModified: [...filesModified],
+    commands
+  };
+}
+function extractLastAssistantAnswer(messages) {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const message = messages[i];
+    if (message.role === "assistant" && message.content.trim()) {
+      return compactText(message.content, 500);
+    }
+  }
+  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);
+}
+function extractRecentCommands(commands) {
+  return unique(commands.map(summarizeCommand)).slice(-6);
+}
+function extractStatusPaths(status) {
+  if (!status) return [];
+  return status.split("\n").map((line) => line.trim()).filter(Boolean).map((line) => {
+    const renamed = line.includes(" -> ") ? line.split(" -> ").at(-1)?.trim() || "" : "";
+    if (renamed) {
+      return renamed.replace(/^(?:\?\?|[A-Z?!]{1,2})\s+/, "");
+    }
+    const match = line.match(/^(?:\?\?|[A-Z?!]{1,2})\s+(.*)$/);
+    return match?.[1]?.trim() || line;
+  }).filter(Boolean);
+}
+function extractFocusFiles(ctx, work) {
+  return unique([
+    ...work.filesModified,
+    ...extractStatusPaths(ctx.gitContext.status),
+    ...ctx.gitContext.untracked.map((file) => file.path)
+  ]).slice(0, 6);
+}
 function buildRawPrompt(ctx, options = {}) {
-  const userMessages = filterUserMessages(ctx.messages);
-  const errors = extractUnresolvedErrors(ctx.messages);
-  const decisions = extractKeyDecisions(ctx.messages);
+  const focused = findFocusedWindow(ctx.messages);
+  const userMessages = filterUserMessages(focused.messages);
+  const errors = extractUnresolvedErrors(focused.messages);
+  const decisions = extractKeyDecisions(focused.messages);
+  const work = extractWorkSummary(focused.messages);
+  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}\`
 `;
   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";
+  if (focused.sessionAppearsComplete) {
+    prompt += "\nThe latest exchange in this session appears complete. ";
+    prompt += "Use the focused context below only if the user wants to continue from that point.\n\n";
+  } else {
+    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 (${focused.sessionAppearsComplete ? "recent focus" : "chronological"})
+
+`;
   for (const msg of userMessages) {
     prompt += `- ${compactText(msg, 500)}
 `;
   }
   prompt += "\n";
+  if (focused.sessionAppearsComplete && lastAssistantAnswer) {
+    prompt += "## Last Answer Already Given\n\n";
+    prompt += `- ${lastAssistantAnswer}
+
+`;
+  }
+  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";
@@ -1269,39 +1691,59 @@ function buildRawPrompt(ctx, options = {}) {
     }
     prompt += "\n";
   }
-  prompt += "## Work Already Completed\n\n";
-  if (unique(ctx.filesModified).length > 0) {
+  if (work.filesModified.length > 0) {
+    prompt += "## Work Already Completed\n\n";
+  }
+  if (work.filesModified.length > 0) {
     prompt += "**Files modified:**\n";
-    for (const filePath of unique(ctx.filesModified)) {
+    for (const filePath of unique(work.filesModified)) {
       prompt += `- \`${filePath}\`
 `;
     }
     prompt += "\n";
   }
-  if (ctx.gitContext.recentCommits) {
+  if (!focused.sessionAppearsComplete && work.filesModified.length > 0 && ctx.gitContext.recentCommits) {
     prompt += "**Recent commits:**\n```\n";
     prompt += `${ctx.gitContext.recentCommits}
 `;
     prompt += "```\n\n";
   }
-  if (ctx.gitContext.committedDiff) {
+  if (!focused.sessionAppearsComplete && work.filesModified.length > 0 && ctx.gitContext.committedDiff) {
     prompt += "**Files changed in recent commits:**\n```\n";
     prompt += `${ctx.gitContext.committedDiff}
 `;
     prompt += "```\n\n";
   }
+  if (recentCommands.length > 0) {
+    prompt += "## Recent Commands / Checks\n\n";
+    for (const command of recentCommands) {
+      prompt += `- \`${command}\`
+`;
+    }
+    prompt += "\n";
+  }
+  if (focusFiles.length > 0) {
+    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";
+  }
   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";
@@ -1317,19 +1759,30 @@ function buildRawPrompt(ctx, options = {}) {
     }
   }
   prompt += "## Your Instructions\n\n";
-  prompt += `${buildTargetGuidance(options.target)}
+  if (focused.sessionAppearsComplete) {
+    prompt += "The latest thread appears finished. Do not resume older tasks unless the user explicitly asks for them.\n\n";
+    prompt += "1. **Start from the recent focus above** \u2014 ignore stale history unless the user points back to it.\n";
+    prompt += "2. **Use the last answer as prior context** \u2014 avoid restating or redoing already completed work.\n";
+    prompt += `3. **Inspect the workspace only as needed** \u2014 respond to follow-up questions or new work from the current repo state${focusFiles.length > 0 ? `, starting with ${focusFiles.map((filePath) => `\`${filePath}\``).join(", ")}` : ""}.
+`;
+  } else {
+    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 += `1. **Read the active files first** \u2014 verify their current state before changing anything${focusFiles.length > 0 ? `: ${focusFiles.map((filePath) => `\`${filePath}\``).join(", ")}` : ""}.
+`;
+    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"}. **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"}. **Do the remaining work** \u2014 pick up exactly where the previous agent stopped.
+    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 ? "5" : "4"}. **Verify** \u2014 run tests/builds to confirm everything works.
+    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 ? "6" : "5"}. **Verify** \u2014 rerun or extend the relevant commands/checks above to confirm everything works.
+`;
+  }
   return prompt;
 }
 function buildRefinementDump(ctx, options = {}) {
@@ -1828,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.4" };
+  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.4",
+  "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",