@oar-sh/oar 0.9.12 → 0.9.14

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
@@ -1567,6 +1571,7 @@ export function createCopilotSdkSessionRunner({
       taskId: shell.shellId,
       taskType: 'local_bash',
       description: shell.description || 'Detached shell',
+      ...(shell.command ? { command: shell.command } : {}),
       startedAt: shell.startedAt || null,
       stoppable: false,
     }));
@@ -1587,6 +1592,7 @@ export function createCopilotSdkSessionRunner({
           taskId: task.id,
           taskType: 'local_bash',
           description: task.description || task.command || 'Background shell',
+          ...shellCommandField(task),
           startedAt,
           stoppable: true,
           ...(task.progressSummary ? { summary: task.progressSummary } : {}),
@@ -1616,6 +1622,12 @@ export function createCopilotSdkSessionRunner({
     return cards;
   }
 
+  /** A registry shell's command line, bounded (the relay scrubs, then cuts it to 2,000). */
+  function shellCommandField(task) {
+    const command = typeof task?.command === 'string' ? task.command.trim().slice(0, 8000) : '';
+    return command ? { command } : {};
+  }
+
   /** Where the task console reads a shell's output: its own log, or the spool mirror. */
   function shellOutputFields(task) {
     const logPath = String(task.logPath || '').trim();
@@ -1869,6 +1881,7 @@ export function createCopilotSdkSessionRunner({
       postTaskSettle(task.id, {
         ...settleForTask(finished, { exitCode: shell ? (shellExitCodes.get(task.id) ?? null) : null }),
         description: task.description || task.displayName || task.command || (shell ? 'Background shell' : 'Background agent'),
+        ...(shell ? shellCommandField(task) : {}),
         taskType: shell ? 'local_bash' : 'local_agent',
         startedAt: Date.parse(String(task.startedAt || '')) || null,
         ...(task.toolCallId ? { toolUseId: String(task.toolCallId) } : {}),
@@ -2135,6 +2148,7 @@ export function createCopilotSdkSessionRunner({
         postTaskSettle(shell.shellId, {
           ...settleForTask({ type: 'shell', status: '' }, { exitCode: shellExitCodes.get(shell.shellId) ?? null }),
           description: shell.description || 'Detached shell',
+          ...(shell.command ? { command: shell.command } : {}),
           taskType: 'local_bash',
           startedAt: shell.startedAt || null,
         });
@@ -2612,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 : [])

package/server/cursor-worker/cursor-session-worker.mjs

@@ -17,6 +17,7 @@ import { installWorkerLogFile } from '../../shared/worker-runtime/worker-log-fil
 import { createControlPoller } from '../../shared/control-poller.mjs';
 import { installWorkerCrashGuard } from '../../shared/worker-crash-guard.mjs';
 import { createCursorTurnRunner } from './cursor-turn-runner.mjs';
+import { resolveCursorSessionStoreDir } from '../services/cursor-session-root-service.mjs';
 
 // Windows console launch: the launcher names the worker log, this copies
 // stdout/stderr into it. A no-op wherever the launcher redirects instead.
@@ -57,8 +58,14 @@ async function main() {
     // renewal hint, which is more visible to the user than a dead worker.
     console.warn('cursor-session-worker: CURSOR_API_KEY is not set; turns will fail until it is provided');
   }
-  const storeDir = String(process.env.CURSOR_AGENT_STORE_DIR || '').trim()
-    || path.resolve(__dirname, '..', 'data', 'cursor-agents');
+  // `$CURSOR_AGENT_STORE_DIR`, else `cursor-agents` in the relay's data dir:
+  // the same folder the relay's Session root looks in.
+  const storeDir = resolveCursorSessionStoreDir({
+    env: process.env,
+    serverDir: path.resolve(__dirname, '..'),
+    configPath,
+    sdkSessionId,
+  });
 
   const api = createApiClient({
     serverUrl,

package/server/cursor-worker/cursor-turn-runner.mjs

@@ -23,6 +23,7 @@ import { renderMediaEmbedInstructionBlock } from '../../shared/media-embed-instr
 import { EMPTY_TURN_COMPLETION_NOTE } from '../../shared/empty-turn-completion.mjs';
 import { resolveFallbackContextLimitTokens } from '../../shared/context-window-fallbacks.mjs';
 import { countPlanLikeLines } from '../../shared/plan-lines.mjs';
+import { explainLaunchFailure, missingWorkingDirectoryError } from '../../shared/worker-runtime/working-directory.mjs';
 
 // Stale-auth recovery budget per turn: expiry is routine on long-lived
 // handles, and one retry proved too small in practice (an orchestrator turn
@@ -122,6 +123,9 @@ export function createCursorTurnRunner({
   resolveModelParamsImpl = resolveCursorReasoningParams,
   createNormalizerImpl = createSdkMessageNormalizer,
   buildUserMessageImpl = buildCursorUserMessage,
+  // The error an agent started in `cwd` fails with up front, or null
+  // (shared/worker-runtime/working-directory.mjs).
+  checkWorkingDirectoryImpl = missingWorkingDirectoryError,
   // Whether agent handles carry the relay's `remote_relay` tool
   // (shared/remote-relay-tool-core.mjs). Default: ask the relay.
   remoteRelayToolGate = null,
@@ -174,7 +178,9 @@ export function createCursorTurnRunner({
   // plain refusal the model can relay instead of a failed turn.
   const previewTool = createPreviewTool({
     api,
-    getConversationId: () => activeMessage?.conversationId || '',
+    // Between turns, the worker's own session (as remote_relay below): list
+    // and close are scoped to a conversation and refused without one.
+    getConversationId: () => activeMessage?.conversationId || sdkSessionId || '',
     dbg,
   });
   const customTools = {
@@ -301,6 +307,10 @@ export function createCursorTurnRunner({
       agentHandle = null;
     }
     if (!agentHandle) {
+      // The agent works in the conversation's folder: a folder that is gone
+      // fails the turn with its name (and is no reason to drop the agent).
+      const missingFolder = checkWorkingDirectoryImpl(cwd);
+      if (missingFolder) throw missingFolder;
       const durableId = String(message.cursorAgentId || '').trim() || cursorAgentId;
       const agents = buildCursorSubagentAgents(rosterModels);
       await remoteRelayGate.ready();
@@ -309,11 +319,15 @@ export function createCursorTurnRunner({
       try {
         agentHandle = await createAgentHandleImpl({ ...options, agentId: durableId });
       } catch (error) {
-        if (!durableId) throw error;
+        if (!durableId) throw explainLaunchFailure(error, cwd, { check: checkWorkingDirectoryImpl });
         // The durable agent may have been pruned server-side; fall back to a
         // fresh agent rather than wedging the conversation.
         dbg('cursor agent resume failed, creating fresh agent', error?.message || String(error));
-        agentHandle = await createAgentHandleImpl({ ...options, agentId: '' });
+        try {
+          agentHandle = await createAgentHandleImpl({ ...options, agentId: '' });
+        } catch (freshError) {
+          throw explainLaunchFailure(freshError, cwd, { check: checkWorkingDirectoryImpl });
+        }
       }
     }
     // Only recorded once a handle exists: a create that threw leaves the
@@ -787,6 +801,7 @@ export function createCursorTurnRunner({
           // A stall is told in the user's terms, and with its own advice: the
           // run was cancelled, so sending the message again is all it takes.
           message: classified.text || classified.message,
+          ...(classified.guidance ? { guidance: classified.guidance } : {}),
           ...(classified.isStalled ? { guidance: 'Send the message again to retry.' } : {}),
           failedAt: new Date().toISOString(),
           queueMessageId: String(message.id || '') || null,

package/server/db-schema.mjs

@@ -23,6 +23,7 @@ import { migrateConversationGroups } from './migrations/0014-conversation-groups
 import { migrateConversationGroupPosition } from './migrations/0015-conversation-group-position.mjs';
 import { migrateShareAccessLog } from './migrations/0016-share-access-log.mjs';
 import { migrateConversationHistoryIndexes } from './migrations/0017-conversation-history-indexes.mjs';
+import { migrateBackgroundTaskRows } from './migrations/0018-background-task-rows.mjs';
 import { migrateImageConversationSchema } from './repositories/image-conversation-repository.mjs';
 
 // Mirrors DEFAULT_RELAY_MODE in server-runtime.mjs; used only by the one-time
@@ -845,6 +846,15 @@ try {
   console.warn(`[history] migration 0017 failed; retrying on next boot: ${error?.message || error}`);
 }
 
+// The task console's rows across a restart: one new table. The task store
+// checks for it and keeps its rows in memory only without it, so a failure is
+// logged and retried next boot like 0017.
+try {
+  migrateBackgroundTaskRows(db);
+} catch (error) {
+  console.warn(`[background-tasks] migration 0018 failed; retrying on next boot: ${error?.message || error}`);
+}
+
 const runtimeSessionColumns = db.prepare(`PRAGMA table_info(runtime_sessions)`).all().map((c) => c.name);
 if (runtimeSessionColumns.length) {
   if (!runtimeSessionColumns.includes('strategy')) {

package/server/grok-worker/acp-host-services.mjs

@@ -37,6 +37,9 @@ export function createAcpHostServices({
   platform = process.platform,
   spawnImpl = spawn,
   spawnSyncImpl = spawnSync,
+  // Full path of a program Windows ships (taskkill, Windows PowerShell), or
+  // its bare name when it is not where Windows keeps it.
+  systemToolPath = windowsSystemToolPath,
   fsImpl = fs,
   // Told about every terminal's life (grok-background-tasks.mjs publishes
   // them as background tasks): `started`, `output`, `killed`, `released`,
@@ -65,9 +68,9 @@ export function createAcpHostServices({
         timeout: 10_000,
         stdio: 'ignore',
       });
-      cachedWindowsShell = probe && probe.status === 0 ? 'pwsh' : windowsSystemToolPath('powershell');
+      cachedWindowsShell = probe && probe.status === 0 ? 'pwsh' : systemToolPath('powershell');
     } catch {
-      cachedWindowsShell = windowsSystemToolPath('powershell');
+      cachedWindowsShell = systemToolPath('powershell');
     }
     return cachedWindowsShell;
   }
@@ -210,7 +213,7 @@ export function createAcpHostServices({
     if (platform === 'win32' && entry.proc.pid) {
       // proc.kill() only reaches the shell; shells leave grandchildren behind.
       try {
-        spawnImpl(windowsSystemToolPath('taskkill'), ['/pid', String(entry.proc.pid), '/t', '/f'], {
+        spawnImpl(systemToolPath('taskkill'), ['/pid', String(entry.proc.pid), '/t', '/f'], {
           stdio: 'ignore',
           windowsHide: true,
         });

package/server/grok-worker/grok-background-tasks.mjs

@@ -15,6 +15,8 @@ import { createKeptPosts } from '../../shared/worker-runtime/kept-posts.mjs';
 import { createTaskOutputSpool } from '../../shared/worker-runtime/task-output-spool.mjs';
 
 const MAX_DESCRIPTION_CHARS = 500;
+// A bound on the post: the relay scrubs the command, then cuts it to 2,000.
+const MAX_COMMAND_CHARS = 8000;
 const SPOOL_SWEEP_INTERVAL_MS = 60 * 60 * 1000;
 // Ended terminals remembered for a late exit after their release.
 const MAX_TRACKED_TERMINALS = 200;
@@ -68,6 +70,7 @@ export function createGrokTaskPublisher({
       taskId: entry.taskId,
       taskType: 'local_bash',
       description: entry.description,
+      ...(entry.command ? { command: entry.command } : {}),
       startedAt: entry.startedAt,
       stoppable: true,
       ...(outputPath ? { outputPath, outputKind: 'spool' } : {}),
@@ -117,6 +120,9 @@ export function createGrokTaskPublisher({
     const entry = {
       taskId,
       description: String(command || '').trim().slice(0, MAX_DESCRIPTION_CHARS) || 'Terminal',
+      // The whole command line (the description is cut shorter), for the
+      // console's `| tail` marker.
+      command: String(command || '').trim().slice(0, MAX_COMMAND_CHARS),
       startedAt,
       kill,
       live: false,
@@ -196,6 +202,7 @@ export function createGrokTaskPublisher({
       status,
       summary: exitCode !== null ? `exit code ${exitCode}` : (signal ? `killed by ${signal}` : null),
       description: entry.description,
+      ...(entry.command ? { command: entry.command } : {}),
       taskType: 'local_bash',
       startedAt: entry.startedAt,
       // Absent rather than null: a killed process has no exit code.

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

@@ -6,12 +6,26 @@ import { AcpClient, extractGrokModelsFromInitialize, pickAllowOnceOptionId } fro
 import { createAcpHostServices } from './acp-host-services.mjs';
 import { createSdkMessageNormalizer } from './sdk-message-normalizer.mjs';
 import { describeTurnStall, isTurnStalledError } from '../../shared/worker-runtime/turn-liveness.mjs';
+import { WORKING_DIRECTORY_MISSING_CODE, isWorkingDirectoryMissingError } from '../../shared/worker-runtime/working-directory.mjs';
 
 export { extractGrokModelsFromInitialize };
 
 export function classifyGrokError(error) {
   const message = String(error?.message || error || '').trim();
   const lower = message.toLowerCase();
+  // First, and above all before the ENOENT branch: a spawn in a folder that
+  // is gone fails with ENOENT too, and the runner puts it down to the folder,
+  // whose path may hold any of the words matched below.
+  if (isWorkingDirectoryMissingError(error)) {
+    return {
+      code: `grok.${WORKING_DIRECTORY_MISSING_CODE}`,
+      message,
+      text: message,
+      guidance: error.guidance,
+      isAuth: false,
+      isBusy: false,
+    };
+  }
   // No bare 'auth' token: it would match unrelated words ("author…") in
   // arbitrary agent error text and misclassify them as login failures.
   if (

package/server/grok-worker/grok-turn-runner.mjs

@@ -12,6 +12,7 @@ import { fetchRemoteRelayInflight } from '../../shared/remote-relay-tool-core.mj
 import { renderMediaEmbedInstructionBlock } from '../../shared/media-embed-instructions.mjs';
 import { countPlanLikeLines } from '../../shared/plan-lines.mjs';
 import { EMPTY_TURN_COMPLETION_NOTE } from '../../shared/empty-turn-completion.mjs';
+import { explainLaunchFailure, missingWorkingDirectoryError } from '../../shared/worker-runtime/working-directory.mjs';
 
 const PLAN_BOARD_ACTIONS = [
   { id: 'autopilot', label: 'Implement in autopilot', mode: 'autopilot' },
@@ -64,6 +65,7 @@ function buildGrokTerminalError(classified, message) {
     code: classified.code,
     stableCode: classified.code,
     message: classified.text || classified.message,
+    ...(classified.guidance ? { guidance: classified.guidance } : {}),
     // A stalled turn was cancelled and its agent is restarted for the next
     // message, so sending the message again is all it takes.
     ...(classified.isStalled ? { guidance: 'Send the message again to retry.' } : {}),
@@ -115,6 +117,9 @@ export function createGrokTurnRunner({
   createAgentHandleImpl = createGrokAgentHandle,
   startGrokTurnImpl = startGrokTurn,
   classifyErrorImpl = classifyGrokError,
+  // The error a Grok CLI started in `cwd` fails with up front, or null
+  // (shared/worker-runtime/working-directory.mjs).
+  checkWorkingDirectoryImpl = missingWorkingDirectoryError,
   getPreviewInstructions = createPreviewInstructionsProvider({ api }),
   env = process.env,
   nodePath = process.execPath,
@@ -200,6 +205,11 @@ export function createGrokTurnRunner({
 
   async function ensureAgentHandle(message, model) {
     if (agentHandle) return agentHandle;
+    // The CLI is spawned in the conversation's folder; a folder that is gone
+    // fails with ENOENT, which would otherwise read as a CLI that is not
+    // installed (classifyGrokError).
+    const missingFolder = checkWorkingDirectoryImpl(cwd);
+    if (missingFolder) throw missingFolder;
     const resumeId = String(message.grokNativeSessionId || grokNativeSessionId || '').trim();
     agentHandle = await createAgentHandleImpl({
       command,
@@ -215,7 +225,7 @@ export function createGrokTurnRunner({
         ? { AcpClientImpl: withAcpMcpServers(AcpClient, acpMcpServers), mcpServers: acpMcpServers }
         : {}),
       dbg,
-    });
+    }).catch((error) => { throw explainLaunchFailure(error, cwd, { check: checkWorkingDirectoryImpl }); });
     if (agentHandle.sessionId) {
       await persistNativeSessionId(message, agentHandle.sessionId);
     }
@@ -427,7 +437,7 @@ export function createGrokTurnRunner({
     const previewBlock = previewInstructionsSent || acpMcpServers.length
       ? ''
       : await Promise.resolve()
-        .then(() => getPreviewInstructions?.())
+        .then(() => getPreviewInstructions?.({ conversationId: message.conversationId || sdkSessionId || '' }))
         .catch(() => '');
     const mediaBlock = mediaInstructionsSent ? '' : renderMediaEmbedInstructionBlock();
     const promptText = [previewBlock, mediaBlock, modeNudge, userText].filter(Boolean).join('\n\n');
@@ -594,7 +604,7 @@ export function createGrokTurnRunner({
         : classified.isStalled
           ? classified.text
             || `System note: the Grok turn stalled and was stopped (${classified.message}). Send a new message to retry.`
-          : `System note: the Grok turn failed (${classified.message}).`;
+          : classified.text || `System note: the Grok turn failed (${classified.message}).`;
       await publishResponse(message, {
         text: noteText,
         model: message.providerModel || defaultModel || null,

package/server/migrations/0018-background-task-rows.mjs

@@ -0,0 +1,101 @@
+'use strict';
+
+/**
+ * Migration: the task console's rows outlive a relay restart.
+ *
+ * `background_task_rows` holds what the relay keeps of a background task
+ * that has a console (a shell or Monitor task naming its output file), per
+ * store key (the id the worker posts under, its SDK session id) and task:
+ *
+ * - `state` 'live': a task of the worker's last set. After a restart it is
+ *   held back until the worker reports again: the worker's set decides which
+ *   are still running, and those of a worker that does not report are marked
+ *   ended, never shown as running again.
+ * - `state` 'ended': the dimmed row the panel keeps for an hour after the end,
+ *   with its status and exit code. `ended_at` (epoch ms) is what the hour
+ *   counts from.
+ * - `row_json` the task row as the store holds it, without the health
+ *   reading (the poller reads the file again).
+ *
+ * Rows go when the hour is up, when the conversation is deleted, and live
+ * rows when the worker's set no longer names them.
+ *
+ * Additive and idempotent. Safe to run on every boot. An older build never
+ * reads the table; its consoles start empty after a restart as before.
+ *
+ * Usage: node server/migrations/0018-background-task-rows.mjs [path/to/copilot.db]
+ */
+
+import { fileURLToPath } from 'url';
+import path from 'path';
+import process from 'process';
+import Database from 'better-sqlite3';
+
+export const BACKGROUND_TASK_ROWS_COLUMNS = Object.freeze(['store_key', 'task_id', 'state', 'row_json', 'ended_at', 'updated_at']);
+
+function tableExists(db, name) {
+  return !!db
+    .prepare(`SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?`)
+    .get(name);
+}
+
+/** Why the table cannot be used (a table of that name with other columns), or ''. */
+export function backgroundTaskRowsTableProblem(db) {
+  if (!tableExists(db, 'background_task_rows')) return 'no background_task_rows table';
+  const present = new Set(db.prepare(`PRAGMA table_info(background_task_rows)`).all().map((column) => column.name));
+  const missing = BACKGROUND_TASK_ROWS_COLUMNS.filter((name) => !present.has(name));
+  return missing.length ? `background_task_rows lacks ${missing.join(', ')}` : '';
+}
+
+export function migrateBackgroundTaskRows(db) {
+  let tablesAdded = 0;
+  if (!tableExists(db, 'background_task_rows')) {
+    db.exec(`
+      CREATE TABLE background_task_rows (
+        store_key  TEXT NOT NULL,
+        task_id    TEXT NOT NULL,
+        state      TEXT NOT NULL CHECK (state IN ('live', 'ended')),
+        row_json   TEXT NOT NULL,
+        ended_at   INTEGER,
+        updated_at INTEGER NOT NULL,
+        PRIMARY KEY (store_key, task_id)
+      )
+    `);
+    tablesAdded += 1;
+  }
+  db.exec(`
+    CREATE INDEX IF NOT EXISTS idx_background_task_rows_ended
+    ON background_task_rows(state, ended_at)
+  `);
+  return { applied: tablesAdded > 0, tablesAdded };
+}
+
+function defaultDbPath() {
+  const here = path.dirname(fileURLToPath(import.meta.url));
+  return path.resolve(here, '..', 'data', 'copilot.db');
+}
+
+export function migrate(dbPath, options = {}) {
+  const db = new Database(dbPath, options);
+  try {
+    return migrateBackgroundTaskRows(db);
+  } finally {
+    db.close();
+  }
+}
+
+const isMain = process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+if (isMain) {
+  const dbPath = process.argv[2] ? path.resolve(process.argv[2]) : defaultDbPath();
+  try {
+    const result = migrate(dbPath);
+    console.log(`Migration 0018 on ${dbPath}`);
+    console.log(result.applied
+      ? `  background task rows: tables added ${result.tablesAdded}`
+      : '  skipped: nothing to change');
+    process.exit(0);
+  } catch (err) {
+    console.error(`Migration 0018 failed: ${err?.message || err}`);
+    process.exit(1);
+  }
+}