ctx-switch 2.0.5 → 2.0.7

package/dist/index.mjs

@@ -32,6 +32,8 @@ function parseArgs(argv) {
     refine: false,
     help: false,
     version: false,
+    pickUser: false,
+    fromUser: null,
     session: null,
     model: null,
     provider: "openrouter",
@@ -59,6 +61,12 @@ function parseArgs(argv) {
       case "--refine":
         options.refine = true;
         break;
+      case "--pick-user":
+        options.pickUser = true;
+        break;
+      case "--from-user":
+        options.fromUser = Number(requireValue(arg, args));
+        break;
       case "--session":
         options.session = requireValue(arg, args);
         break;
@@ -122,6 +130,9 @@ function parseArgs(argv) {
   if (!Number.isInteger(options.limit) || options.limit <= 0) {
     throw new Error(`Invalid limit "${options.limit}". Expected a positive integer.`);
   }
+  if (options.fromUser !== null && (!Number.isInteger(options.fromUser) || options.fromUser <= 0)) {
+    throw new Error(`Invalid --from-user value "${options.fromUser}". Expected a positive integer.`);
+  }
   return options;
 }
 function getHelpText({ name, version }) {
@@ -142,6 +153,8 @@ 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",
+    "      --pick-user         Interactively choose the starting user prompt for preserved context",
+    "      --from-user <n>     Start preserved context from the nth substantive user prompt",
     "      --target <name>     Prompt target: generic, claude, codex, cursor, chatgpt",
     "  -n, --limit <count>     Limit rows for the sessions command (default: 10)",
     "",
@@ -163,6 +176,8 @@ function getHelpText({ name, version }) {
     `  ${name} --source codex --target claude`,
     `  ${name} --source codex --target codex`,
     `  ${name} --source opencode`,
+    `  ${name} --pick-user`,
+    `  ${name} --from-user 2`,
     `  ${name} --refine --model openrouter/free`,
     `  ${name} --output ./handoff.md`,
     `  ${name} doctor`,
@@ -829,7 +844,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 +900,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 +960,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 +973,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 +1001,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 +1025,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
@@ -1040,6 +1099,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 +1135,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 +1148,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);
         }
@@ -1257,6 +1337,10 @@ function compactText(text, maxChars = 800) {
 function unique(list) {
   return [...new Set(list.filter(Boolean))];
 }
+function isLocalCommandMarkup(text) {
+  const trimmed = text.trim().toLowerCase();
+  return trimmed.includes("<local-command-caveat>") || trimmed.includes("<command-name>") || trimmed.includes("<command-message>") || trimmed.includes("<command-args>") || trimmed.includes("<local-command-stdout>");
+}
 function extractFilePath2(input) {
   const value = input.file_path || input.path || input.target_file || input.filePath;
   return typeof value === "string" ? value : null;
@@ -1265,10 +1349,13 @@ function extractCommand2(input) {
   const value = input.command || input.cmd;
   return typeof value === "string" ? value : null;
 }
+function getSubstantiveUserIndexes(messages) {
+  return messages.map((message, index) => ({ message, index })).filter(({ message }) => message.role === "user" && message.content && !isNoiseMessage(message.content)).map(({ index }) => index);
+}
 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,11 +1363,12 @@ 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) {
   const trimmed = text.trim().toLowerCase();
+  if (isLocalCommandMarkup(trimmed)) return true;
   const normalized = trimmed.replace(/[^\p{L}\p{N}\s]/gu, " ").replace(/\s+/g, " ").trim();
   if (trimmed.length < 5) return true;
   const noise = [
@@ -1311,17 +1399,27 @@ function isNoiseMessage(text) {
   if (trimmed.startsWith("[request interrupted")) return true;
   return false;
 }
+function isAssistantNoiseMessage(text) {
+  const trimmed = text.trim().toLowerCase();
+  if (!trimmed) return true;
+  if (isLocalCommandMarkup(trimmed)) return true;
+  return trimmed.includes("you're out of extra usage") || trimmed.includes("resets 3:30pm") || trimmed.includes("rate limit") || trimmed.includes("login interrupted");
+}
 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());
+  const all = messages.filter((m) => m.role === "user" && m.content).map((m) => m.content.trim()).filter((msg) => !isNoiseMessage(msg));
   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));
+  const middle = all.slice(1, -1);
   return [first, ...middle, last];
 }
 function extractUnresolvedErrors(messages) {
@@ -1344,21 +1442,21 @@ 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));
     }
   }
   return decisions.slice(-5);
 }
-function findFocusedWindow(messages) {
+function findFocusedWindowFrom(messages, fromUserMessage) {
   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);
+  const substantiveUserIndexes = getSubstantiveUserIndexes(messages);
   if (substantiveUserIndexes.length === 0) {
     return { messages, sessionAppearsComplete: false };
   }
@@ -1368,7 +1466,9 @@ function findFocusedWindow(messages) {
   );
   const postToolUsers = substantiveUserIndexes.filter((index) => index > lastToolIndex);
   let startIndex = 0;
-  if (postToolUsers.length > 0) {
+  if (typeof fromUserMessage === "number" && fromUserMessage > 0) {
+    startIndex = substantiveUserIndexes[Math.min(fromUserMessage - 1, substantiveUserIndexes.length - 1)] ?? 0;
+  } else if (postToolUsers.length > 0) {
     startIndex = postToolUsers[0];
   } else if (lastToolIndex >= 0) {
     startIndex = substantiveUserIndexes.filter((index) => index <= lastToolIndex).at(-1) ?? 0;
@@ -1376,7 +1476,7 @@ function findFocusedWindow(messages) {
     startIndex = substantiveUserIndexes.at(-1) ?? 0;
   }
   const startMessage = messages[startIndex];
-  if (startMessage?.role === "user" && isReferentialMessage(startMessage.content)) {
+  if ((fromUserMessage === null || typeof fromUserMessage === "undefined") && startMessage?.role === "user" && isReferentialMessage(startMessage.content)) {
     const previousSubstantive = substantiveUserIndexes.filter((index) => index < startIndex).at(-1);
     if (typeof previousSubstantive === "number") {
       startIndex = previousSubstantive;
@@ -1384,10 +1484,25 @@ function findFocusedWindow(messages) {
   }
   const focused = messages.slice(startIndex);
   const hasToolActivity = focused.some((message) => message.role === "assistant" && message.toolCalls.length > 0);
-  const lastMessage = focused.at(-1);
+  const lastMessage = [...focused].reverse().find((message) => {
+    if (!message.content.trim() && message.toolCalls.length === 0) return false;
+    if (message.role === "assistant" && message.content.trim() && isAssistantNoiseMessage(message.content)) {
+      return false;
+    }
+    if (message.role === "user" && message.content.trim() && isNoiseMessage(message.content)) {
+      return false;
+    }
+    return true;
+  });
   const sessionAppearsComplete = Boolean(lastMessage) && lastMessage.role === "assistant" && lastMessage.toolCalls.length === 0 && !hasToolActivity;
   return { messages: focused, sessionAppearsComplete };
 }
+function listSubstantiveUserMessages(messages) {
+  return getSubstantiveUserIndexes(messages).map((messageIndex, index) => ({
+    index: index + 1,
+    text: messages[messageIndex]?.content.trim() || ""
+  }));
+}
 function extractWorkSummary(messages) {
   const filesModified = /* @__PURE__ */ new Set();
   const commands = [];
@@ -1413,12 +1528,124 @@ function extractWorkSummary(messages) {
 function extractLastAssistantAnswer(messages) {
   for (let i = messages.length - 1; i >= 0; i--) {
     const message = messages[i];
-    if (message.role === "assistant" && message.content.trim()) {
+    if (message.role === "assistant" && message.content.trim() && !isAssistantNoiseMessage(message.content)) {
       return compactText(message.content, 500);
     }
   }
   return null;
 }
+function summarizeToolCall(toolCall) {
+  const filePath = extractFilePath2(toolCall.input);
+  const command = extractCommand2(toolCall.input);
+  const url = typeof toolCall.input.url === "string" ? toolCall.input.url : null;
+  const query = typeof toolCall.input.query === "string" ? toolCall.input.query : null;
+  const description = typeof toolCall.input.description === "string" ? toolCall.input.description : typeof toolCall.input.prompt === "string" ? toolCall.input.prompt : null;
+  if (filePath) return `${toolCall.tool} ${filePath}`;
+  if (command) return `${toolCall.tool}: ${summarizeCommand(command)}`;
+  if (url) return `${toolCall.tool}: ${compactText(url, 120)}`;
+  if (description) return `${toolCall.tool}: ${compactText(description, 120)}`;
+  if (query) return `${toolCall.tool}: ${compactText(query, 120)}`;
+  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() && isAssistantNoiseMessage(message.content)) 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,
+  lastAssistantAnswer
+}) {
+  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 && lastAssistantAnswer) {
+    hints.push("Continue from the last meaningful assistant answer above. This session appears to have stalled after planning or approval, not after code changes.");
+  }
+  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) {
+  const sanitizeHistoryMessages = (messages) => messages.filter((message) => {
+    if (message.role === "assistant" && message.content.trim() && isMetaQualityAssistantMessage(message.content)) {
+      return false;
+    }
+    if (message.role === "assistant" && message.content.trim() && isAssistantNoiseMessage(message.content)) {
+      return false;
+    }
+    if (message.role === "user" && message.content && isNoiseMessage(message.content)) {
+      return false;
+    }
+    return Boolean(message.content.trim()) || message.toolCalls.length > 0;
+  });
+  if (sessionAppearsComplete) return sanitizeHistoryMessages(focusedMessages);
+  const hasAssistantActivity = focusedMessages.some(
+    (message) => message.role === "assistant" && (message.content.trim() || message.toolCalls.length > 0)
+  );
+  if (focusedMessages.length >= 3 && hasAssistantActivity) return sanitizeHistoryMessages(focusedMessages);
+  const filtered = sanitizeHistoryMessages(allMessages);
+  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) || isAssistantNoiseMessage(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);
 }
@@ -1444,7 +1671,7 @@ function extractFocusFiles(ctx, work) {
   ]).slice(0, 6);
 }
 function buildRawPrompt(ctx, options = {}) {
-  const focused = findFocusedWindow(ctx.messages);
+  const focused = findFocusedWindowFrom(ctx.messages, options.fromUserMessage);
   const userMessages = filterUserMessages(focused.messages);
   const errors = extractUnresolvedErrors(focused.messages);
   const decisions = extractKeyDecisions(focused.messages);
@@ -1452,6 +1679,16 @@ 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,
+    lastAssistantAnswer
+  });
+  const sessionHistory = buildSessionHistory(focused.messages, ctx.messages, focused.sessionAppearsComplete);
   let prompt = "";
   prompt += "# Task\n\n";
   prompt += `Project: \`${ctx.sessionCwd}\`
@@ -1479,6 +1716,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 +1788,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 +1806,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 +1836,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"}. **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 rerun or extend the relevant commands/checks above 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;
@@ -1929,6 +2190,9 @@ function formatRunSummary({
   lines.push(`  Messages: ${ctx.messages.length}`);
   lines.push(`  Files: ${ctx.filesModified.length} modified, ${ctx.filesRead.length} read`);
   lines.push(`  Git: ${summarizeGitContext(ctx.gitContext)}`);
+  if (options.fromUser) {
+    lines.push(`  Focus: user prompt #${options.fromUser}`);
+  }
   lines.push(`  Target: ${options.target}`);
   lines.push(`  Mode: ${mode === "raw" ? "raw" : `refined via ${options.provider}${model ? ` (${model})` : ""}`}`);
   return lines.join("\n");
@@ -2080,9 +2344,50 @@ async function promptForSource() {
     });
   });
 }
+function summarizePromptChoice(text) {
+  return text.replace(/\s+/g, " ").trim().slice(0, 100);
+}
+async function promptForUserStart(messages) {
+  const userPrompts = listSubstantiveUserMessages(messages);
+  if (userPrompts.length === 0) {
+    return null;
+  }
+  if (userPrompts.length === 1) {
+    process.stderr.write("\nOnly one substantive user prompt was found. Using it automatically.\n");
+    return 1;
+  }
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stderr
+  });
+  process.stderr.write("\nSelect the user prompt to preserve context from:\n\n");
+  for (const prompt of userPrompts) {
+    process.stderr.write(`  ${prompt.index}) ${summarizePromptChoice(prompt.text)}
+`);
+  }
+  process.stderr.write("\n");
+  return new Promise((resolve) => {
+    rl.question(`Enter choice (1-${userPrompts.length}): `, (answer) => {
+      rl.close();
+      const trimmed = answer.trim();
+      if (!trimmed) {
+        process.stderr.write("Invalid choice, using automatic focus.\n");
+        resolve(null);
+        return;
+      }
+      const idx = Number.parseInt(trimmed, 10);
+      if (idx >= 1 && idx <= userPrompts.length) {
+        resolve(idx);
+      } else {
+        process.stderr.write("Invalid choice, using automatic focus.\n");
+        resolve(null);
+      }
+    });
+  });
+}
 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.7" };
   const ui = createTheme(process.stderr);
   if (options.help) {
     process.stdout.write(`${getHelpText(pkgInfo)}
@@ -2145,6 +2450,20 @@ async function main(argv = process.argv.slice(2)) {
   if (messages.length === 0) {
     fail(`Parsed zero usable messages from ${sessionPath}`);
   }
+  let fromUserMessage = options.fromUser;
+  const userPrompts = listSubstantiveUserMessages(messages);
+  if (fromUserMessage !== null && fromUserMessage > userPrompts.length) {
+    fail(
+      `Requested --from-user ${fromUserMessage}, but only ${userPrompts.length} substantive user prompt(s) were found.`,
+      {
+        suggestions: ["Run `ctx-switch --pick-user` to choose interactively.", "Omit `--from-user` to use automatic focus."]
+      }
+    );
+  }
+  if (options.pickUser && process.stdin.isTTY) {
+    ui.step("Choosing preserved context start");
+    fromUserMessage = await promptForUserStart(messages);
+  }
   ui.step("Capturing git context");
   const gitContext = getGitContext(cwd);
   const ctx = buildSessionContext({
@@ -2159,7 +2478,7 @@ async function main(argv = process.argv.slice(2)) {
   let activeModel = null;
   if (!options.refine) {
     ui.step("Building continuation prompt");
-    finalPrompt = buildRawPrompt(ctx, { target: options.target });
+    finalPrompt = buildRawPrompt(ctx, { target: options.target, fromUserMessage });
   } else {
     const provider = options.provider;
     let apiKey = getApiKey({
@@ -2197,7 +2516,7 @@ async function main(argv = process.argv.slice(2)) {
         apiKey,
         model,
         systemPrompt: buildRefinementSystemPrompt(options.target),
-        userPrompt: buildRefinementDump(ctx, { target: options.target }),
+        userPrompt: buildRefinementDump(ctx, { target: options.target, fromUserMessage }),
         timeoutMs: 0,
         onStatus: (status) => {
           if (!streamStarted) reporter.update(status);
@@ -2230,7 +2549,7 @@ async function main(argv = process.argv.slice(2)) {
           ui.note(`Provider detail: ${refined.rawError}`);
         }
         ui.note("Falling back to the raw structured prompt.");
-        finalPrompt = buildRawPrompt(ctx, { target: options.target });
+        finalPrompt = buildRawPrompt(ctx, { target: options.target, fromUserMessage });
       }
     }
   }

package/package.json

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