@oar-sh/oar 0.9.13 → 0.9.14

package/server/claude-cloud-worker/claude-cloud-session-process.mjs

@@ -4,6 +4,7 @@ import fs from 'node:fs';
 import { createAskUserBridge } from '../../shared/ask-user-bridge.mjs';
 import { createRelayQuestion } from '../../shared/question-wait.mjs';
 import { DEFAULT_QUESTION_TIMEOUT_MS } from '../../shared/question-timeout.mjs';
+import { readApprovalAnswer } from '../../shared/question-answer-rule.mjs';
 import { EMPTY_TURN_COMPLETION_NOTE } from '../../shared/empty-turn-completion.mjs';
 import { stripModelTierSuffix } from '../../shared/claude-cloud/repo-url.mjs';
 import { resolveDeliveredAttribution, sameClaudeAttribution } from '../../shared/claude-attribution.mjs';
@@ -27,6 +28,7 @@ const PERMISSION_ALLOW = 'Allow';
 const PERMISSION_DENY = 'Deny';
 const QUESTION_UNANSWERED_MESSAGE = 'The user did not answer. Continue without this, or end the turn and say what you need.';
 const PERMISSION_DENIED_MESSAGE = 'The user denied this tool use.';
+const PERMISSION_UNREADABLE_MESSAGE = 'The permission card was answered with neither Allow nor Deny, so the tool use is not allowed.';
 // A catch-up after a worker restart reads the events of one unfinished turn;
 // the cap only stops a cursor that never advances.
 const MAX_CATCH_UP_PAGES = 200;
@@ -253,8 +255,8 @@ export function createClaudeCloudSessionRunner({
     const requested = String(message?.model || '').trim();
     const perTurn = requested && requested.toLowerCase() !== 'auto' ? requested : '';
     // The delivered message names the conversation's current model; the launch
-    // model is what it was when the worker started, and the model may still be
-    // changed until the first message creates the cloud session.
+    // model is what it was when the worker started. A change after the first
+    // message is applied before the next one (applyModel).
     return stripModelTierSuffix(String(message?.providerModel || '').trim() || perTurn || defaultModel);
   }
 
@@ -723,8 +725,12 @@ export function createClaudeCloudSessionRunner({
     });
     const result = await askUserBridge.waitForRelayQuestionAnswer(questionId, { signal });
     if (result.timedOut || signal.aborted) return { behavior: 'deny', message: QUESTION_UNANSWERED_MESSAGE };
-    if (result.answer === PERMISSION_ALLOW) return { behavior: 'allow', updatedInput: request.input };
-    return { behavior: 'deny', message: PERMISSION_DENIED_MESSAGE };
+    const decision = readApprovalAnswer(result.answer, { approve: PERMISSION_ALLOW, deny: PERMISSION_DENY });
+    if (decision === 'approve') return { behavior: 'allow', updatedInput: request.input };
+    if (decision === 'deny') return { behavior: 'deny', message: PERMISSION_DENIED_MESSAGE };
+    // The relay takes only the choices on this card; anything else is no
+    // decision of the user's, and the agent is told so.
+    return { behavior: 'deny', message: PERMISSION_UNREADABLE_MESSAGE };
   }
 
   async function askUser(t, request, signal) {

package/server/claude-worker/claude-session-process.mjs

@@ -39,11 +39,13 @@ import {
   isStaleAttemptError,
 } from './claude-turn-publisher.mjs';
 import { createSubagentTimelineRecorder } from './subagent-timeline-recorder.mjs';
+import { SUBAGENT_TASK_TYPES } from '../../shared/subagent-timeline.mjs';
 import { createAskUserBridge } from '../../shared/ask-user-bridge.mjs';
 import { createRemoteRelayToolGate } from '../../shared/remote-relay-tool-core.mjs';
 import { buildRelayStopFailure } from '../../shared/relay-stop-failure.mjs';
 import { createTurnLiveness, resolveTurnStallWindows } from '../../shared/worker-runtime/turn-liveness.mjs';
 import { createKeptPosts } from '../../shared/worker-runtime/kept-posts.mjs';
+import { explainLaunchFailure, missingWorkingDirectoryError } from '../../shared/worker-runtime/working-directory.mjs';
 import {
   ANSWERED_ELSEWHERE_KIND,
   DELIVERY_ANSWERED_ELSEWHERE_TEXT,
@@ -82,8 +84,6 @@ function modeAppendClass(relayMode) {
 
 export { STEER_FOLDED_TEXT, STEER_STOPPED_TEXT };
 
-/** Task types that run a model of their own (vs. bash/monitor/workflow). */
-const AGENT_TASK_TYPES = new Set(['local_agent', 'agent', 'subagent']);
 const MAX_TASK_TOOL_CALL_CHARS = 300;
 /** Output paths remembered per process (one per backgrounded shell). */
 const MAX_TASK_OUTPUT_PATHS = 200;
@@ -459,6 +459,9 @@ export function createClaudeSessionRunner({
   readContextUsageImpl = readContextUsage,
   readPlanUsageImpl = readPlanUsage,
   relocateTranscriptImpl = relocateClaudeTranscriptForCwd,
+  // The error a spawn in `cwd` fails with up front, or null
+  // (shared/worker-runtime/working-directory.mjs).
+  checkWorkingDirectoryImpl = missingWorkingDirectoryError,
   idleShutdownMs = 10 * 60_000,
   getBackgroundTaskTimeoutMs = () => 0,
   // The per-conversation auto-compact window (token count, null = Auto). Read
@@ -1763,7 +1766,7 @@ export function createClaudeSessionRunner({
         // agent-like task runs on the session model. Resolved at publish
         // time so the spawn block landing after task_started still heals on
         // the next publish. Bash & co. get no model at all.
-        const agentLike = AGENT_TASK_TYPES.has(String(task.taskType || ''));
+        const agentLike = SUBAGENT_TASK_TYPES.has(String(task.taskType || ''));
         const pinnedModel = (task.toolUseId && processRef.subagentSpawns.get(task.toolUseId)) || '';
         const activity = (task.toolUseId && processRef.subagentActivity.get(task.toolUseId)) || {};
         const model = agentLike ? (activity.model || pinnedModel || processRef.initModel || null) : null;
@@ -1777,6 +1780,7 @@ export function createClaudeSessionRunner({
           lastToolCall: (agentLike && activity.lastToolCall) || null,
           totalTokens: task.totalTokens ?? null,
           toolUseId: task.toolUseId || null,
+          ...(task.taskRunId ? { taskRunId: task.taskRunId } : {}),
           subagentType: task.subagentType || null,
           model,
           modelInherited: Boolean(model && !pinnedModel && !activity.model),
@@ -2215,7 +2219,7 @@ export function createClaudeSessionRunner({
   // alias like "opus") and the full input of the tool it is calling now.
   // Single-lined and capped: the panel crops it to its width.
   function recordSubagentActivity(sdkMessage) {
-    const parentId = String(sdkMessage?.parent_tool_use_id || '').trim();
+    const parentId = timelineRecorder.runIdFor(sdkMessage?.parent_tool_use_id);
     if (!parentId) return;
     const entry = proc.subagentActivity.get(parentId) || {};
     const before = `${entry.model || ''}\n${entry.lastToolCall || ''}`;
@@ -2591,11 +2595,15 @@ export function createClaudeSessionRunner({
         .filter((task) => String(task?.task_id || '').trim())
         .map((task) => {
           const taskId = String(task.task_id).trim();
-          const known = previous.get(taskId) || {};
+          const runId = String(task?.run_id || '').trim();
+          // Another run of a task still listed (resumed at once): its own row.
+          const listed = previous.get(taskId) || {};
+          const known = runId && listed.taskRunId && listed.taskRunId !== runId ? {} : listed;
           return [taskId, {
             ...known,
             taskType: String(task?.task_type || '').trim() || known.taskType || '',
             description: String(task?.description || '').trim() || known.description || '',
+            taskRunId: runId || known.taskRunId || '',
             startedAt: known.startedAt || Date.now(),
           }];
         }));
@@ -2651,8 +2659,14 @@ export function createClaudeSessionRunner({
         known.subagentType = String(sdkMessage.subagent_type || '').trim() || known.subagentType || '';
         // The task's spawning tool_use id is the same identity the subagent
         // bubbles key on — recorded so the panel and the bubbles can be
-        // correlated (and a targeted stop can find its task).
-        known.toolUseId = String(sdkMessage.tool_use_id || '').trim() || known.toolUseId || '';
+        // correlated (and a targeted stop can find its task). A resumed agent
+        // names the call that resumed it (SendMessage); the recorder leads
+        // that back to the agent's run.
+        const toolUseId = String(sdkMessage.tool_use_id || '').trim();
+        known.toolUseId = timelineRecorder.runIdFor(toolUseId) || known.toolUseId || '';
+        // Which run of the task this is: the SDK's run id, else (an older
+        // CLI) the tool use that started it, which differs per run too.
+        known.taskRunId = String(sdkMessage.run_id || '').trim() || known.taskRunId || toolUseId;
         // task_started can be the first event carrying the task_type; a
         // workflow revealed here must start its poller too.
         syncWorkflowPoller(proc);
@@ -2667,7 +2681,7 @@ export function createClaudeSessionRunner({
         known.summary = String(sdkMessage.summary || '').trim() || known.summary;
         known.lastToolName = String(sdkMessage.last_tool_name || '').trim() || known.lastToolName;
         known.subagentType = String(sdkMessage.subagent_type || '').trim() || known.subagentType || '';
-        known.toolUseId = String(sdkMessage.tool_use_id || '').trim() || known.toolUseId || '';
+        known.toolUseId = timelineRecorder.runIdFor(sdkMessage.tool_use_id) || known.toolUseId || '';
         const totalTokens = Number(sdkMessage.usage?.total_tokens);
         if (Number.isFinite(totalTokens)) known.totalTokens = totalTokens;
         // The sub-agent's tool calls so far: the panel row's step count.
@@ -2701,13 +2715,15 @@ export function createClaudeSessionRunner({
         proc.taskCommands.delete(taskId);
         const exitCode = shellLike ? exitCodeFromSummary(sdkMessage.summary) : null;
         const toolUses = Number(sdkMessage.usage?.tool_uses);
-        const steps = AGENT_TASK_TYPES.has(String(published?.taskType || '')) && Number.isFinite(toolUses) && toolUses >= 0
+        const steps = SUBAGENT_TASK_TYPES.has(String(published?.taskType || '')) && Number.isFinite(toolUses) && toolUses >= 0
           ? Math.floor(toolUses)
           : null;
+        const settledRunId = String(sdkMessage.run_id || published?.taskRunId || '').trim();
         void keptTaskSettles.post('/api/background-task-settled', {
           conversationId: sdkSessionId,
           taskId,
-          toolUseId: String(sdkMessage.tool_use_id || published?.toolUseId || '').trim() || null,
+          toolUseId: timelineRecorder.runIdFor(sdkMessage.tool_use_id) || published?.toolUseId || null,
+          ...(settledRunId ? { taskRunId: settledRunId } : {}),
           status: String(sdkMessage.status || '').trim() || 'completed',
           summary: String(sdkMessage.summary || '').trim().slice(0, 500) || null,
           ...(sdkMessage.reason ? { reason: String(sdkMessage.reason).slice(0, 40) } : {}),
@@ -3501,6 +3517,7 @@ export function createClaudeSessionRunner({
             message: ctx.message,
             errorText: String(streamError?.message || streamError || 'unknown error'),
             usageLimit: usageLimit.classifyException(streamError),
+            error: streamError,
           }).catch(() => {});
         }
         continue;
@@ -3522,6 +3539,11 @@ export function createClaudeSessionRunner({
   // Spawn / adapt
 
   function spawnProcess(message, { resume: resumeOverride = '' } = {}) {
+    // A spawn in a folder that is gone fails with ENOENT, which the SDK
+    // reports as a native binary that does not match the libc. Thrown here,
+    // the delivery fails with the folder's name instead (handlePendingPayload).
+    const missingFolder = checkWorkingDirectoryImpl(cwd);
+    if (missingFolder) throw missingFolder;
     const relayMode = message.relayMode || 'agent';
     const model = resolvePerTurnModel(message);
     const effort = normalizeClaudeEffort(message.reasoningEffort);
@@ -3742,7 +3764,11 @@ export function createClaudeSessionRunner({
           syncDeliveryReadiness();
         }
       } catch (error) {
-        if (!processRef.aborted && !abortController.signal.aborted) streamError = error;
+        // A launch that failed because the folder went away after the check
+        // above is told as that, too.
+        if (!processRef.aborted && !abortController.signal.aborted) {
+          streamError = explainLaunchFailure(error, cwd, { check: checkWorkingDirectoryImpl });
+        }
       } finally {
         try {
           processRef.turn.endInput?.();
@@ -4221,7 +4247,7 @@ export function createClaudeSessionRunner({
       settingsWindowOpen = false;
       const errorText = String(error?.message || error || 'unknown error');
       dbg('claude turn failed', message.id, errorText);
-      await publisher.publishTurnException({ message, errorText, usageLimit: usageLimit.classifyException(error) });
+      await publisher.publishTurnException({ message, errorText, usageLimit: usageLimit.classifyException(error), error });
       return true;
     } finally {
       endAdmission();
@@ -4262,7 +4288,7 @@ export function createClaudeSessionRunner({
    * subagents have no task id and remain full-turn-Stop only.
    */
   async function stopBackgroundTaskByToolUseId(toolUseId) {
-    const normalized = String(toolUseId || '').trim();
+    const normalized = timelineRecorder.runIdFor(toolUseId);
     if (!normalized || !proc) return false;
     for (const [taskId, task] of proc.liveTasks.entries()) {
       if (String(task?.toolUseId || '').trim() === normalized) {

package/server/claude-worker/claude-turn-publisher.mjs

@@ -4,6 +4,7 @@ import { countPlanLikeLines } from '../../shared/plan-lines.mjs';
 import { EMPTY_TURN_COMPLETION_NOTE } from '../../shared/empty-turn-completion.mjs';
 import { buildSteerSettleFailure, steerSettleFailureText } from '../../shared/steer-settle-failure.mjs';
 import { buildUsageLimitFailure } from '../../shared/claude-usage-limit.mjs';
+import { WORKING_DIRECTORY_MISSING_CODE, isWorkingDirectoryMissingError } from '../../shared/worker-runtime/working-directory.mjs';
 
 const PLAN_BOARD_ACTIONS = [
   { id: 'autopilot', label: 'Implement in autopilot', mode: 'autopilot' },
@@ -390,7 +391,7 @@ export function createClaudeTurnPublisher({ api, dbg = () => {}, takeWorkflowRun
     });
   }
 
-  async function publishTurnException({ message, errorText, usageLimit = null }) {
+  async function publishTurnException({ message, errorText, usageLimit = null, error = null }) {
     if (usageLimit) {
       await publishResponse(message, {
         text: usageLimit.text || errorText,
@@ -399,6 +400,24 @@ export function createClaudeTurnPublisher({ api, dbg = () => {}, takeWorkflowRun
       });
       return;
     }
+    // The conversation's folder is gone: the error names it and says what to
+    // do, which neither a retry nor a sign-in changes.
+    if (isWorkingDirectoryMissingError(error)) {
+      await publishResponse(message, {
+        text: `System note: ${error.message} ${error.guidance}`,
+        model: null,
+        terminalError: {
+          kind: 'claude-turn-failed',
+          code: WORKING_DIRECTORY_MISSING_CODE,
+          stableCode: `claude.${WORKING_DIRECTORY_MISSING_CODE}`,
+          message: error.message,
+          guidance: error.guidance,
+          failedAt: new Date().toISOString(),
+          queueMessageId: String(message.id || '') || null,
+        },
+      });
+      return;
+    }
     const isAuthError = /authentication|logged in|login|credential|api key/i.test(errorText);
     await publishResponse(message, {
       text: isAuthError

package/server/claude-worker/subagent-timeline-recorder.mjs

@@ -1,6 +1,7 @@
 import crypto from 'node:crypto';
 import { displayToolName, isBackgroundLaunch, isSubagentToolName } from './sdk-message-normalizer.mjs';
 import {
+  SUBAGENT_TASK_TYPES,
   SUBAGENT_TIMELINE_ENTRY_MAX_CHARS,
   SUBAGENT_TIMELINE_MAX_ENTRIES,
   cutSubagentTimelineText,
@@ -8,6 +9,8 @@ import {
 } from '../../shared/subagent-timeline.mjs';
 
 const MAX_TRACKED_RUNS = 200;
+// Task ids and resume ids remembered to find a resumed agent's run.
+const MAX_TRACKED_TASKS = 500;
 
 export function toolResultText(content) {
   if (typeof content === 'string') return content;
@@ -53,6 +56,16 @@ function capText(text) {
  *
  * It also answers which turn owns a run's live lanes (`ownsRun`): only the
  * turn that spawned an agent shows its frames in its in-turn lanes.
+ *
+ * A finished background agent that the session sends a new message
+ * (SendMessage) runs again as the same task: task_started names its task id
+ * again, with the SendMessage call as its tool_use_id. That id leads to the
+ * run of the task's first start (`runIdFor`), so the record goes on under the
+ * agent's run, running again, with a note where it resumed. A start the
+ * recorder already saw (same run id) adds nothing, and an event of an
+ * earlier run (a lower run id) is late and left out. Every post names
+ * the run's task id too: a relay that knows the run by the task alone (this
+ * recorder did not see the first start) places it there.
  */
 export function createSubagentTimelineRecorder({
   api,
@@ -66,6 +79,9 @@ export function createSubagentTimelineRecorder({
   writerId = crypto.randomBytes(4).toString('hex'),
 } = {}) {
   const runs = new Map(); // runId -> run state, in registration order
+  const taskRuns = new Map(); // taskId -> the run its first start named
+  const resumeRuns = new Map(); // tool_use_id of a later start -> that run
+  const latestRuns = new Map(); // taskId -> the SDK run id of its latest start
   let flushTimer = null;
   let flushing = null;
   let localCounter = 0;
@@ -75,6 +91,26 @@ export function createSubagentTimelineRecorder({
     return `${writerId}:${localCounter}`;
   }
 
+  /** The run an id belongs to: a resumed agent's later tool use leads to its first run. */
+  function runIdFor(id) {
+    const key = String(id || '').trim();
+    return resumeRuns.get(key) || key;
+  }
+
+  // An event of an earlier run of a task than its latest start: late (the
+  // run ids of one task sort in the order the runs opened). Without run ids,
+  // every event counts.
+  function isEarlierRun(taskId, sdkRunId) {
+    const latest = taskId ? latestRuns.get(taskId) : '';
+    return !!sdkRunId && !!latest && sdkRunId < latest;
+  }
+
+  function remember(map, key, value) {
+    map.delete(key);
+    map.set(key, value);
+    while (map.size > MAX_TRACKED_TASKS) map.delete(map.keys().next().value);
+  }
+
   function ensureRun(runId, { parentId = null, displayName = '', subagentType = '' } = {}) {
     const id = String(runId || '').trim();
     if (!id) return null;
@@ -221,7 +257,7 @@ export function createSubagentTimelineRecorder({
   }
 
   function observeAssistant(sdkMessage) {
-    const parentId = String(sdkMessage?.parent_tool_use_id || '').trim();
+    const parentId = runIdFor(sdkMessage?.parent_tool_use_id);
     const content = Array.isArray(sdkMessage?.message?.content) ? sdkMessage.message.content : [];
     if (!parentId) {
       // The main thread: only the agents it spawns matter here.
@@ -261,7 +297,7 @@ export function createSubagentTimelineRecorder({
   }
 
   function observeStreamEvent(sdkMessage) {
-    const parentId = String(sdkMessage?.parent_tool_use_id || '').trim();
+    const parentId = runIdFor(sdkMessage?.parent_tool_use_id);
     if (!parentId) return;
     const run = ensureRun(parentId);
     const event = sdkMessage?.event || {};
@@ -309,7 +345,7 @@ export function createSubagentTimelineRecorder({
   }
 
   function observeUser(sdkMessage) {
-    const parentId = String(sdkMessage?.parent_tool_use_id || '').trim();
+    const parentId = runIdFor(sdkMessage?.parent_tool_use_id);
     const content = Array.isArray(sdkMessage?.message?.content) ? sdkMessage.message.content : [];
     for (const block of content) {
       if (block?.type !== 'tool_result') continue;
@@ -346,17 +382,46 @@ export function createSubagentTimelineRecorder({
     const subtype = String(sdkMessage?.subtype || '');
     const toolUseId = String(sdkMessage?.tool_use_id || '').trim();
     if (!toolUseId) return;
+    const taskId = String(sdkMessage?.task_id || '').trim();
+    const sdkRunId = String(sdkMessage?.run_id || '').trim();
     if (subtype === 'task_started') {
-      const run = ensureRun(toolUseId, { subagentType: String(sdkMessage.subagent_type || '').trim() });
+      // Only sub-agents are resumed; shells and the rest are not remembered.
+      const taskType = String(sdkMessage.task_type || '').trim();
+      const agent = !!taskId && (!taskType || SUBAGENT_TASK_TYPES.has(taskType));
+      if (agent && sdkRunId) {
+        // The same start again, or an earlier run's start arriving late.
+        const latest = latestRuns.get(taskId);
+        if (latest && sdkRunId <= latest) return;
+        remember(latestRuns, taskId, sdkRunId);
+      }
+      const firstRun = agent ? taskRuns.get(taskId) : '';
+      if (firstRun && firstRun !== toolUseId) remember(resumeRuns, toolUseId, firstRun);
+      else if (agent && !firstRun) remember(taskRuns, taskId, toolUseId);
+      const run = ensureRun(runIdFor(toolUseId), { subagentType: String(sdkMessage.subagent_type || '').trim() });
+      // The same task started again (under another tool use, or after it
+      // ended): resumed.
+      const resumed = !!firstRun && (firstRun !== toolUseId || run.settled);
+      run.settled = false;
       if (sdkMessage.is_backgrounded === true) run.background = true;
+      if (resumed) {
+        const prompt = String(sdkMessage.prompt || '').trim();
+        addEntry(run, {
+          kind: 'note',
+          text: capText(prompt ? `Resumed with a new message: ${prompt}` : 'Resumed with a new message'),
+          metadata: { resumed: true },
+        });
+      }
+      // Running: a start, and for a resumed agent its return from the end.
       patchHeader(run, {
-        taskId: String(sdkMessage.task_id || '').trim() || null,
+        status: 'running',
+        taskId: taskId || null,
         subagentType: String(sdkMessage.subagent_type || '').trim() || null,
         background: sdkMessage.is_backgrounded === true ? true : null,
       });
       return;
     }
-    const run = runs.get(toolUseId);
+    if (isEarlierRun(taskId, sdkRunId)) return;
+    const run = runs.get(runIdFor(toolUseId));
     if (!run) return;
     if (subtype === 'task_updated') {
       if (sdkMessage?.patch?.is_backgrounded === true) {
@@ -413,7 +478,7 @@ export function createSubagentTimelineRecorder({
   }
 
   function ownsRun(runId, owner) {
-    const run = runs.get(String(runId || '').trim());
+    const run = runs.get(runIdFor(runId));
     if (!run || !owner) return false;
     if (!run.owner && run.parentId) run.owner = runs.get(run.parentId)?.owner || null;
     return run.owner === owner;
@@ -426,7 +491,7 @@ export function createSubagentTimelineRecorder({
    * carries it now; an unknown run keeps the old behaviour.
    */
   function isForeignRun(runId, owner) {
-    let run = runs.get(String(runId || '').trim());
+    let run = runs.get(runIdFor(runId));
     if (!run) return false;
     const spawnOwner = run.owner || null;
     let background = false;
@@ -469,6 +534,7 @@ export function createSubagentTimelineRecorder({
       await api('POST', '/api/subagent-timeline', {
         conversationId,
         subagentRunId: run.id,
+        ...(run.header.taskId ? { taskId: run.header.taskId } : {}),
         entries,
         ...(header ? { header } : {}),
       });
@@ -566,6 +632,7 @@ export function createSubagentTimelineRecorder({
     flush,
     processEnded,
     hasPending,
+    runIdFor,
     // For tests and diagnostics.
     runState: (runId) => runs.get(String(runId || '').trim()) || null,
   };

package/server/copilot-worker/copilot-ask-user-tool.mjs

@@ -40,7 +40,7 @@ export const RELAY_ASK_USER_TOOL_PARAMETERS = Object.freeze({
     choices: {
       type: 'array',
       items: { type: 'string' },
-      description: 'Optional list of choices for a multiple choice question. Prefer providing choices when possible.',
+      description: 'Optional list of choices for a multiple choice question. Prefer providing choices when possible. The relay keeps the first 8 choices and drops the rest.',
     },
     multi_select: {
       type: 'boolean',

package/server/copilot-worker/copilot-prompt-context.mjs

@@ -80,7 +80,9 @@ export function createCopilotPromptContextBuilder({
     if (includeInstructions) {
       // Advisory: a preview lookup that fails costs the block, never the turn.
       const previewBlock = typeof getPreviewInstructions === 'function'
-        ? await Promise.resolve().then(getPreviewInstructions).catch(() => '')
+        ? await Promise.resolve()
+          .then(() => getPreviewInstructions({ conversationId: String(message?.conversationId || '') }))
+          .catch(() => '')
         : '';
       instructions = applyMediaEmbedInstructions(applyPreviewInstructions(toolInstructions, previewBlock));
     }

package/server/copilot-worker/copilot-question-bridge.mjs

@@ -25,6 +25,7 @@
 import { createAskUserBridge } from '../../shared/ask-user-bridge.mjs';
 import { createRelayQuestion } from '../../shared/question-wait.mjs';
 import { looksLikeMultiSelectQuestion } from '../../shared/question-multi-select.mjs';
+import { readApprovalAnswer } from '../../shared/question-answer-rule.mjs';
 import {
   DEFAULT_QUESTION_TIMEOUT_MS,
   QUESTION_TIMEOUT_CONTINUATION_TEXT,
@@ -262,9 +263,10 @@ export function createCopilotQuestionBridge({
   /**
    * `onPermissionRequest` in ask mode → an approve/deny card.
    *
-   * Freeform is allowed and anything that is not exactly "Approve" denies —
-   * so a human can type *why* they are refusing and the model receives it as
-   * feedback instead of a bare refusal.
+   * Freeform is allowed and anything but the approve choice (by the shared
+   * rule: trimmed, any case) denies — so a human can type *why* they are
+   * refusing and the model receives it as feedback instead of a bare refusal.
+   * The card's rationale says so, since a typed "yes" refuses too.
    */
   async function askToolApproval(request, { signal, message } = {}) {
     const description = describePermissionRequest(request);
@@ -273,21 +275,24 @@ export function createCopilotQuestionBridge({
       choices: [PERMISSION_APPROVE_CHOICE, PERMISSION_DENY_CHOICE],
       allowFreeform: true,
       source: 'onPermissionRequest',
-      rationale: 'Copilot requested permission to run a tool in ask mode.',
+      rationale: 'Copilot requested permission to run a tool in ask mode. Approve runs it; Deny or a typed reply refuses it, and a typed reply tells Copilot why.',
       extra: {
         requestId: String(request?.requestId || '') || undefined,
         permissionKind: String(request?.kind || '') || undefined,
       },
     }, { signal, message });
     const answer = String(result?.answer ?? '').trim();
-    const approved = !result?.timedOut && answer.toLowerCase() === PERMISSION_APPROVE_CHOICE.toLowerCase();
+    const decision = result?.timedOut
+      ? null
+      : readApprovalAnswer(answer, { approve: PERMISSION_APPROVE_CHOICE, deny: PERMISSION_DENY_CHOICE });
+    const approved = decision === 'approve';
     // The denial note is composed HERE rather than in the permission handler so
     // the handler never needs to know the card's choice labels — that would be
     // an import cycle (this module already imports the request describer from
     // the adapter). A freeform denial carries the human's own reason; a plain
     // "Deny" click does not, so echoing the button label back at the model as
     // though it were an explanation is avoided.
-    const feedback = answer && answer.toLowerCase() !== PERMISSION_DENY_CHOICE.toLowerCase()
+    const feedback = answer && decision !== 'deny'
       ? answer
       : 'The user declined this action.';
     return { approved, answer, feedback, timedOut: result?.timedOut === true, description };

package/server/copilot-worker/copilot-sdk-adapter.mjs

@@ -32,6 +32,7 @@ import {
 } from './copilot-model-switch.mjs';
 import { copilotRuntimeEntry } from '../copilot-sdk-runtime.mjs';
 import { describeTurnStall, isTurnStalledError } from '../../shared/worker-runtime/turn-liveness.mjs';
+import { WORKING_DIRECTORY_MISSING_CODE, isWorkingDirectoryMissingError } from '../../shared/worker-runtime/working-directory.mjs';
 
 const VERSION_DIR_RE = /^\d+\.\d+\.\d+$/;
 
@@ -510,6 +511,16 @@ export const COPILOT_TURN_CONTINUE_GUIDANCE =
  */
 export function classifyCopilotTurnException(error) {
   const detail = String(error?.message || error || '').trim() || 'unknown error';
+  // The conversation's folder is gone; the message names it.
+  if (isWorkingDirectoryMissingError(error)) {
+    return {
+      code: WORKING_DIRECTORY_MISSING_CODE,
+      stableCode: `copilot.${WORKING_DIRECTORY_MISSING_CODE}`,
+      text: detail,
+      guidance: error.guidance,
+      detail,
+    };
+  }
   // An unconfirmed explicit model selection (audit #13). The error's own
   // message already names requested vs actual model, so it IS the user-facing
   // text; the stable code is what lets the UI (and tests) key on it.

package/server/copilot-worker/copilot-sdk-session-process.mjs

@@ -124,6 +124,7 @@ import { createTaskOutputSpool } from '../../shared/worker-runtime/task-output-s
 import { createShellOutputMirror } from './copilot-shell-output-mirror.mjs';
 import { isTransientProgressText, settleForTask, shellExitFromEvent } from './copilot-task-settle.mjs';
 import { createKeptPosts } from '../../shared/worker-runtime/kept-posts.mjs';
+import { explainLaunchFailure, missingWorkingDirectoryError } from '../../shared/worker-runtime/working-directory.mjs';
 
 // How long the runtime may sit with no session activity before the worker
 // closes it. The worker process itself stays up and reconnects lazily on the
@@ -369,6 +370,9 @@ export function createCopilotSdkSessionRunner({
   // module imports the real SDK (that lives in copilot-sdk-adapter.mjs).
   resolvePathsImpl = resolveCopilotSdkPaths,
   startClientImpl = startCopilotClient,
+  // The error a runtime started in `cwd` fails with up front, or null
+  // (shared/worker-runtime/working-directory.mjs).
+  checkWorkingDirectoryImpl = missingWorkingDirectoryError,
   createNormalizerImpl = createCopilotEventNormalizer,
   buildMessageOptionsImpl = buildCopilotMessageOptions,
   // BYOK: `COPILOT_PROVIDER_*` in this worker's env become
@@ -2622,8 +2626,17 @@ export function createCopilotSdkSessionRunner({
     if (client) return client;
     if (starting) return starting;
     starting = (async () => {
+      // The runtime is spawned in the conversation's folder: a folder that is
+      // gone fails the turn with its name, not with the spawn's ENOENT.
+      const missingFolder = checkWorkingDirectoryImpl(cwd);
+      if (missingFolder) throw missingFolder;
       sdkPaths = resolvePathsImpl({ env });
-      const started = await startClientImpl({ paths: sdkPaths, cwd, clientName, logLevel, dbg });
+      let started;
+      try {
+        started = await startClientImpl({ paths: sdkPaths, cwd, clientName, logLevel, dbg });
+      } catch (error) {
+        throw explainLaunchFailure(error, cwd, { check: checkWorkingDirectoryImpl });
+      }
       client = started.client;
       detachRuntimeExit = observeRuntimeExit(client, handleRuntimeExit);
       runtimeTree = watchRuntimeTree(client);

package/server/cursor-worker/cursor-ask-user-tool.mjs

@@ -10,7 +10,7 @@ export const ASK_USER_TOOL_DESCRIPTION =
   + 'This is the ONLY way to ask the user anything: a question written as plain '
   + 'reply text is NOT shown interactively and ends the turn unanswered. Call '
   + 'this tool whenever user input would materially change the result, before '
-  + 'making assumptions. Provide 2-4 concise options per question; the user can '
+  + 'making assumptions. Provide 2-6 concise options per question; the user can '
   + 'always answer in free text instead. This tool blocks until the user '
   + 'responds; on timeout it returns an instruction to continue under the '
   + 'current relay mode.';

package/server/cursor-worker/cursor-sdk-adapter.mjs

@@ -8,6 +8,7 @@ import {
   isTurnStalledError,
   resolveTurnStallWindows,
 } from '../../shared/worker-runtime/turn-liveness.mjs';
+import { WORKING_DIRECTORY_MISSING_CODE, isWorkingDirectoryMissingError } from '../../shared/worker-runtime/working-directory.mjs';
 
 /**
  * The only module in the repo that imports `@cursor/sdk` (and its
@@ -422,6 +423,19 @@ export function classifyCursorError(error) {
   const message = String(error?.message || error);
   const isRetryable = error?.isRetryable === true;
   const name = String(error?.name || '');
+  // The conversation's folder is gone; the message names it.
+  if (isWorkingDirectoryMissingError(error)) {
+    return {
+      isAuth: false,
+      isBusy: false,
+      isRetryable: false,
+      code: WORKING_DIRECTORY_MISSING_CODE,
+      stableCode: `cursor.${WORKING_DIRECTORY_MISSING_CODE}`,
+      message,
+      text: message,
+      guidance: error.guidance,
+    };
+  }
   if (isTurnStalledError(error)) {
     return {
       isAuth: false,
@@ -611,12 +625,13 @@ const modelParameterDefsCache = new Map();
 
 /**
  * Map the composer's reasoning effort onto the model params Cursor expects on
- * `agent.send`. Effort lives in a per-model parameter named 'effort' or
- * 'reasoning' ('extra-high' is Cursor's spelling of 'xhigh'); models that also
- * expose a boolean 'thinking' parameter only honor the higher tiers with
- * thinking enabled, so an explicit effort turns thinking on and 'none' turns it
- * off. Best-effort like readModelContextWindow: null on any failure or when the
- * model has no matching parameter, which sends the model's default variant.
+ * `agent.send`. Effort lives in a per-model parameter named 'effort',
+ * 'reasoning' or 'reasoning_effort', consulted in that order ('extra-high' is
+ * Cursor's spelling of 'xhigh'); models that also expose a boolean 'thinking'
+ * parameter only honor the higher tiers with thinking enabled, so an explicit
+ * effort turns thinking on and 'none' turns it off. Best-effort like
+ * readModelContextWindow: null on any failure or when the model has no
+ * matching parameter, which sends the model's default variant.
  */
 export async function resolveCursorReasoningParams({
   apiKey,
@@ -651,7 +666,7 @@ export async function resolveCursorReasoningParams({
   const paramsById = new Map(
     parameters.map((param) => [String(param?.id || '').trim().toLowerCase(), param]),
   );
-  const effortParam = paramsById.get('effort') || paramsById.get('reasoning');
+  const effortParam = paramsById.get('effort') || paramsById.get('reasoning') || paramsById.get('reasoning_effort');
   const hasThinkingParam = paramsById.has('thinking');
   const effortValues = new Set(
     (Array.isArray(effortParam?.values) ? effortParam.values : [])