source dump of claude code
1import type { ToolUseBlock } from '@anthropic-ai/sdk/resources';
2import { getRemoteSessionUrl } from '../../constants/product.js';
3import { OUTPUT_FILE_TAG, REMOTE_REVIEW_PROGRESS_TAG, REMOTE_REVIEW_TAG, STATUS_TAG, SUMMARY_TAG, TASK_ID_TAG, TASK_NOTIFICATION_TAG, TASK_TYPE_TAG, TOOL_USE_ID_TAG, ULTRAPLAN_TAG } from '../../constants/xml.js';
4import type { SDKAssistantMessage, SDKMessage } from '../../entrypoints/agentSdkTypes.js';
5import type { SetAppState, Task, TaskContext, TaskStateBase } from '../../Task.js';
6import { createTaskStateBase, generateTaskId } from '../../Task.js';
7import { TodoWriteTool } from '../../tools/TodoWriteTool/TodoWriteTool.js';
8import { type BackgroundRemoteSessionPrecondition, checkBackgroundRemoteSessionEligibility } from '../../utils/background/remote/remoteSession.js';
9import { logForDebugging } from '../../utils/debug.js';
10import { logError } from '../../utils/log.js';
11import { enqueuePendingNotification } from '../../utils/messageQueueManager.js';
12import { extractTag, extractTextContent } from '../../utils/messages.js';
13import { emitTaskTerminatedSdk } from '../../utils/sdkEventQueue.js';
14import { deleteRemoteAgentMetadata, listRemoteAgentMetadata, type RemoteAgentMetadata, writeRemoteAgentMetadata } from '../../utils/sessionStorage.js';
15import { jsonStringify } from '../../utils/slowOperations.js';
16import { appendTaskOutput, evictTaskOutput, getTaskOutputPath, initTaskOutput } from '../../utils/task/diskOutput.js';
17import { registerTask, updateTaskState } from '../../utils/task/framework.js';
18import { fetchSession } from '../../utils/teleport/api.js';
19import { archiveRemoteSession, pollRemoteSessionEvents } from '../../utils/teleport.js';
20import type { TodoList } from '../../utils/todo/types.js';
21import type { UltraplanPhase } from '../../utils/ultraplan/ccrSession.js';
22export type RemoteAgentTaskState = TaskStateBase & {
23 type: 'remote_agent';
24 remoteTaskType: RemoteTaskType;
25 /** Task-specific metadata (PR number, repo, etc.). */
26 remoteTaskMetadata?: RemoteTaskMetadata;
27 sessionId: string; // Original session ID for API calls
28 command: string;
29 title: string;
30 todoList: TodoList;
31 log: SDKMessage[];
32 /**
33 * Long-running agent that will not be marked as complete after the first `result`.
34 */
35 isLongRunning?: boolean;
36 /**
37 * When the local poller started watching this task (at spawn or on restore).
38 * Review timeout clocks from here so a restore doesn't immediately time out
39 * a task spawned >30min ago.
40 */
41 pollStartedAt: number;
42 /** True when this task was created by a teleported /ultrareview command. */
43 isRemoteReview?: boolean;
44 /** Parsed from the orchestrator's <remote-review-progress> heartbeat echoes. */
45 reviewProgress?: {
46 stage?: 'finding' | 'verifying' | 'synthesizing';
47 bugsFound: number;
48 bugsVerified: number;
49 bugsRefuted: number;
50 };
51 isUltraplan?: boolean;
52 /**
53 * Scanner-derived pill state. Undefined = running. `needs_input` when the
54 * remote asked a clarifying question and is idle; `plan_ready` when
55 * ExitPlanMode is awaiting browser approval. Surfaced in the pill badge
56 * and detail dialog status line.
57 */
58 ultraplanPhase?: Exclude<UltraplanPhase, 'running'>;
59};
60const REMOTE_TASK_TYPES = ['remote-agent', 'ultraplan', 'ultrareview', 'autofix-pr', 'background-pr'] as const;
61export type RemoteTaskType = (typeof REMOTE_TASK_TYPES)[number];
62function isRemoteTaskType(v: string | undefined): v is RemoteTaskType {
63 return (REMOTE_TASK_TYPES as readonly string[]).includes(v ?? '');
64}
65export type AutofixPrRemoteTaskMetadata = {
66 owner: string;
67 repo: string;
68 prNumber: number;
69};
70export type RemoteTaskMetadata = AutofixPrRemoteTaskMetadata;
71
72/**
73 * Called on every poll tick for tasks with a matching remoteTaskType. Return a
74 * non-null string to complete the task (string becomes the notification text),
75 * or null to keep polling. Checkers that hit external APIs should self-throttle.
76 */
77export type RemoteTaskCompletionChecker = (remoteTaskMetadata: RemoteTaskMetadata | undefined) => Promise<string | null>;
78const completionCheckers = new Map<RemoteTaskType, RemoteTaskCompletionChecker>();
79
80/**
81 * Register a completion checker for a remote task type. Invoked on every poll
82 * tick; survives --resume via the sidecar's remoteTaskType + remoteTaskMetadata.
83 */
84export function registerCompletionChecker(remoteTaskType: RemoteTaskType, checker: RemoteTaskCompletionChecker): void {
85 completionCheckers.set(remoteTaskType, checker);
86}
87
88/**
89 * Persist a remote-agent metadata entry to the session sidecar.
90 * Fire-and-forget — persistence failures must not block task registration.
91 */
92async function persistRemoteAgentMetadata(meta: RemoteAgentMetadata): Promise<void> {
93 try {
94 await writeRemoteAgentMetadata(meta.taskId, meta);
95 } catch (e) {
96 logForDebugging(`persistRemoteAgentMetadata failed: ${String(e)}`);
97 }
98}
99
100/**
101 * Remove a remote-agent metadata entry from the session sidecar.
102 * Called on task completion/kill so restored sessions don't resurrect
103 * tasks that already finished.
104 */
105async function removeRemoteAgentMetadata(taskId: string): Promise<void> {
106 try {
107 await deleteRemoteAgentMetadata(taskId);
108 } catch (e) {
109 logForDebugging(`removeRemoteAgentMetadata failed: ${String(e)}`);
110 }
111}
112
113// Precondition error result
114export type RemoteAgentPreconditionResult = {
115 eligible: true;
116} | {
117 eligible: false;
118 errors: BackgroundRemoteSessionPrecondition[];
119};
120
121/**
122 * Check eligibility for creating a remote agent session.
123 */
124export async function checkRemoteAgentEligibility({
125 skipBundle = false
126}: {
127 skipBundle?: boolean;
128} = {}): Promise<RemoteAgentPreconditionResult> {
129 const errors = await checkBackgroundRemoteSessionEligibility({
130 skipBundle
131 });
132 if (errors.length > 0) {
133 return {
134 eligible: false,
135 errors
136 };
137 }
138 return {
139 eligible: true
140 };
141}
142
143/**
144 * Format precondition error for display.
145 */
146export function formatPreconditionError(error: BackgroundRemoteSessionPrecondition): string {
147 switch (error.type) {
148 case 'not_logged_in':
149 return 'Please run /login and sign in with your Claude.ai account (not Console).';
150 case 'no_remote_environment':
151 return 'No cloud environment available. Set one up at https://claude.ai/code/onboarding?magic=env-setup';
152 case 'not_in_git_repo':
153 return 'Background tasks require a git repository. Initialize git or run from a git repository.';
154 case 'no_git_remote':
155 return 'Background tasks require a GitHub remote. Add one with `git remote add origin REPO_URL`.';
156 case 'github_app_not_installed':
157 return 'The Claude GitHub app must be installed on this repository first.\nhttps://github.com/apps/claude/installations/new';
158 case 'policy_blocked':
159 return "Remote sessions are disabled by your organization's policy. Contact your organization admin to enable them.";
160 }
161}
162
163/**
164 * Enqueue a remote task notification to the message queue.
165 */
166function enqueueRemoteNotification(taskId: string, title: string, status: 'completed' | 'failed' | 'killed', setAppState: SetAppState, toolUseId?: string): void {
167 // Atomically check and set notified flag to prevent duplicate notifications.
168 if (!markTaskNotified(taskId, setAppState)) return;
169 const statusText = status === 'completed' ? 'completed successfully' : status === 'failed' ? 'failed' : 'was stopped';
170 const toolUseIdLine = toolUseId ? `\n<${TOOL_USE_ID_TAG}>${toolUseId}</${TOOL_USE_ID_TAG}>` : '';
171 const outputPath = getTaskOutputPath(taskId);
172 const message = `<${TASK_NOTIFICATION_TAG}>
173<${TASK_ID_TAG}>${taskId}</${TASK_ID_TAG}>${toolUseIdLine}
174<${TASK_TYPE_TAG}>remote_agent</${TASK_TYPE_TAG}>
175<${OUTPUT_FILE_TAG}>${outputPath}</${OUTPUT_FILE_TAG}>
176<${STATUS_TAG}>${status}</${STATUS_TAG}>
177<${SUMMARY_TAG}>Remote task "${title}" ${statusText}</${SUMMARY_TAG}>
178</${TASK_NOTIFICATION_TAG}>`;
179 enqueuePendingNotification({
180 value: message,
181 mode: 'task-notification'
182 });
183}
184
185/**
186 * Atomically mark a task as notified. Returns true if this call flipped the
187 * flag (caller should enqueue), false if already notified (caller should skip).
188 */
189function markTaskNotified(taskId: string, setAppState: SetAppState): boolean {
190 let shouldEnqueue = false;
191 updateTaskState(taskId, setAppState, task => {
192 if (task.notified) {
193 return task;
194 }
195 shouldEnqueue = true;
196 return {
197 ...task,
198 notified: true
199 };
200 });
201 return shouldEnqueue;
202}
203
204/**
205 * Extract the plan content from the remote session log.
206 * Searches all assistant messages for <ultraplan>...</ultraplan> tags.
207 */
208export function extractPlanFromLog(log: SDKMessage[]): string | null {
209 // Walk backwards through assistant messages to find <ultraplan> content
210 for (let i = log.length - 1; i >= 0; i--) {
211 const msg = log[i];
212 if (msg?.type !== 'assistant') continue;
213 const fullText = extractTextContent(msg.message.content, '\n');
214 const plan = extractTag(fullText, ULTRAPLAN_TAG);
215 if (plan?.trim()) return plan.trim();
216 }
217 return null;
218}
219
220/**
221 * Enqueue an ultraplan-specific failure notification. Unlike enqueueRemoteNotification
222 * this does NOT instruct the model to read the raw output file (a JSONL dump that is
223 * useless for plan extraction).
224 */
225export function enqueueUltraplanFailureNotification(taskId: string, sessionId: string, reason: string, setAppState: SetAppState): void {
226 if (!markTaskNotified(taskId, setAppState)) return;
227 const sessionUrl = getRemoteTaskSessionUrl(sessionId);
228 const message = `<${TASK_NOTIFICATION_TAG}>
229<${TASK_ID_TAG}>${taskId}</${TASK_ID_TAG}>
230<${TASK_TYPE_TAG}>remote_agent</${TASK_TYPE_TAG}>
231<${STATUS_TAG}>failed</${STATUS_TAG}>
232<${SUMMARY_TAG}>Ultraplan failed: ${reason}</${SUMMARY_TAG}>
233</${TASK_NOTIFICATION_TAG}>
234The remote Ultraplan session did not produce a plan (${reason}). Inspect the session at ${sessionUrl} and tell the user to retry locally with plan mode.`;
235 enqueuePendingNotification({
236 value: message,
237 mode: 'task-notification'
238 });
239}
240
241/**
242 * Extract review content from the remote session log.
243 *
244 * Two producers, two event shapes:
245 * - bughunter mode: run_hunt.sh is a SessionStart hook; its echo lands as
246 * {type:'system', subtype:'hook_progress', stdout:'...'}. Claude never
247 * takes a turn so there are zero assistant messages.
248 * - prompt mode: a real assistant turn wraps the review in the tag.
249 *
250 * Scans hook_progress first since bughunter is the intended production path
251 * and prompt mode is the dev/fallback. Newest-first in both cases — the tag
252 * appears once at the end of the run so reverse iteration short-circuits.
253 */
254function extractReviewFromLog(log: SDKMessage[]): string | null {
255 for (let i = log.length - 1; i >= 0; i--) {
256 const msg = log[i];
257 // The final echo before hook exit may land in either the last
258 // hook_progress or the terminal hook_response depending on buffering;
259 // both have flat stdout.
260 if (msg?.type === 'system' && (msg.subtype === 'hook_progress' || msg.subtype === 'hook_response')) {
261 const tagged = extractTag(msg.stdout, REMOTE_REVIEW_TAG);
262 if (tagged?.trim()) return tagged.trim();
263 }
264 }
265 for (let i = log.length - 1; i >= 0; i--) {
266 const msg = log[i];
267 if (msg?.type !== 'assistant') continue;
268 const fullText = extractTextContent(msg.message.content, '\n');
269 const tagged = extractTag(fullText, REMOTE_REVIEW_TAG);
270 if (tagged?.trim()) return tagged.trim();
271 }
272
273 // Hook-stdout concat fallback: a single echo should land in one event, but
274 // large JSON payloads can flush across two if the pipe buffer fills
275 // mid-write. Per-message scan above misses a tag split across events.
276 const hookStdout = log.filter(msg => msg.type === 'system' && (msg.subtype === 'hook_progress' || msg.subtype === 'hook_response')).map(msg => msg.stdout).join('');
277 const hookTagged = extractTag(hookStdout, REMOTE_REVIEW_TAG);
278 if (hookTagged?.trim()) return hookTagged.trim();
279
280 // Fallback: concatenate all assistant text in chronological order.
281 const allText = log.filter((msg): msg is SDKAssistantMessage => msg.type === 'assistant').map(msg => extractTextContent(msg.message.content, '\n')).join('\n').trim();
282 return allText || null;
283}
284
285/**
286 * Tag-only variant of extractReviewFromLog for delta scanning.
287 *
288 * Returns non-null ONLY when an explicit <remote-review> tag is found.
289 * Unlike extractReviewFromLog, this does NOT fall back to concatenated
290 * assistant text. This is critical for the delta scan: in prompt mode,
291 * early untagged assistant messages (e.g. "I'm analyzing the diff...")
292 * would trigger the fallback and prematurely set cachedReviewContent,
293 * completing the review before the actual tagged output arrives.
294 */
295function extractReviewTagFromLog(log: SDKMessage[]): string | null {
296 // hook_progress / hook_response per-message scan (bughunter path)
297 for (let i = log.length - 1; i >= 0; i--) {
298 const msg = log[i];
299 if (msg?.type === 'system' && (msg.subtype === 'hook_progress' || msg.subtype === 'hook_response')) {
300 const tagged = extractTag(msg.stdout, REMOTE_REVIEW_TAG);
301 if (tagged?.trim()) return tagged.trim();
302 }
303 }
304
305 // assistant text per-message scan (prompt mode)
306 for (let i = log.length - 1; i >= 0; i--) {
307 const msg = log[i];
308 if (msg?.type !== 'assistant') continue;
309 const fullText = extractTextContent(msg.message.content, '\n');
310 const tagged = extractTag(fullText, REMOTE_REVIEW_TAG);
311 if (tagged?.trim()) return tagged.trim();
312 }
313
314 // Hook-stdout concat fallback for split tags
315 const hookStdout = log.filter(msg => msg.type === 'system' && (msg.subtype === 'hook_progress' || msg.subtype === 'hook_response')).map(msg => msg.stdout).join('');
316 const hookTagged = extractTag(hookStdout, REMOTE_REVIEW_TAG);
317 if (hookTagged?.trim()) return hookTagged.trim();
318 return null;
319}
320
321/**
322 * Enqueue a remote-review completion notification. Injects the review text
323 * directly into the message queue so the local model receives it on the next
324 * turn — no file indirection, no mode change. Session is kept alive so the
325 * claude.ai URL stays a durable record the user can revisit; TTL handles cleanup.
326 */
327function enqueueRemoteReviewNotification(taskId: string, reviewContent: string, setAppState: SetAppState): void {
328 if (!markTaskNotified(taskId, setAppState)) return;
329 const message = `<${TASK_NOTIFICATION_TAG}>
330<${TASK_ID_TAG}>${taskId}</${TASK_ID_TAG}>
331<${TASK_TYPE_TAG}>remote_agent</${TASK_TYPE_TAG}>
332<${STATUS_TAG}>completed</${STATUS_TAG}>
333<${SUMMARY_TAG}>Remote review completed</${SUMMARY_TAG}>
334</${TASK_NOTIFICATION_TAG}>
335The remote review produced the following findings:
336
337${reviewContent}`;
338 enqueuePendingNotification({
339 value: message,
340 mode: 'task-notification'
341 });
342}
343
344/**
345 * Enqueue a remote-review failure notification.
346 */
347function enqueueRemoteReviewFailureNotification(taskId: string, reason: string, setAppState: SetAppState): void {
348 if (!markTaskNotified(taskId, setAppState)) return;
349 const message = `<${TASK_NOTIFICATION_TAG}>
350<${TASK_ID_TAG}>${taskId}</${TASK_ID_TAG}>
351<${TASK_TYPE_TAG}>remote_agent</${TASK_TYPE_TAG}>
352<${STATUS_TAG}>failed</${STATUS_TAG}>
353<${SUMMARY_TAG}>Remote review failed: ${reason}</${SUMMARY_TAG}>
354</${TASK_NOTIFICATION_TAG}>
355Remote review did not produce output (${reason}). Tell the user to retry /ultrareview, or use /review for a local review instead.`;
356 enqueuePendingNotification({
357 value: message,
358 mode: 'task-notification'
359 });
360}
361
362/**
363 * Extract todo list from SDK messages (finds last TodoWrite tool use).
364 */
365function extractTodoListFromLog(log: SDKMessage[]): TodoList {
366 const todoListMessage = log.findLast((msg): msg is SDKAssistantMessage => msg.type === 'assistant' && msg.message.content.some(block => block.type === 'tool_use' && block.name === TodoWriteTool.name));
367 if (!todoListMessage) {
368 return [];
369 }
370 const input = todoListMessage.message.content.find((block): block is ToolUseBlock => block.type === 'tool_use' && block.name === TodoWriteTool.name)?.input;
371 if (!input) {
372 return [];
373 }
374 const parsedInput = TodoWriteTool.inputSchema.safeParse(input);
375 if (!parsedInput.success) {
376 return [];
377 }
378 return parsedInput.data.todos;
379}
380
381/**
382 * Register a remote agent task in the unified task framework.
383 * Bundles task ID generation, output init, state creation, registration, and polling.
384 * Callers remain responsible for custom pre-registration logic (git dialogs, transcript upload, teleport options).
385 */
386export function registerRemoteAgentTask(options: {
387 remoteTaskType: RemoteTaskType;
388 session: {
389 id: string;
390 title: string;
391 };
392 command: string;
393 context: TaskContext;
394 toolUseId?: string;
395 isRemoteReview?: boolean;
396 isUltraplan?: boolean;
397 isLongRunning?: boolean;
398 remoteTaskMetadata?: RemoteTaskMetadata;
399}): {
400 taskId: string;
401 sessionId: string;
402 cleanup: () => void;
403} {
404 const {
405 remoteTaskType,
406 session,
407 command,
408 context,
409 toolUseId,
410 isRemoteReview,
411 isUltraplan,
412 isLongRunning,
413 remoteTaskMetadata
414 } = options;
415 const taskId = generateTaskId('remote_agent');
416
417 // Create the output file before registering the task.
418 // RemoteAgentTask uses appendTaskOutput() (not TaskOutput), so
419 // the file must exist for readers before any output arrives.
420 void initTaskOutput(taskId);
421 const taskState: RemoteAgentTaskState = {
422 ...createTaskStateBase(taskId, 'remote_agent', session.title, toolUseId),
423 type: 'remote_agent',
424 remoteTaskType,
425 status: 'running',
426 sessionId: session.id,
427 command,
428 title: session.title,
429 todoList: [],
430 log: [],
431 isRemoteReview,
432 isUltraplan,
433 isLongRunning,
434 pollStartedAt: Date.now(),
435 remoteTaskMetadata
436 };
437 registerTask(taskState, context.setAppState);
438
439 // Persist identity to the session sidecar so --resume can reconnect to
440 // still-running remote sessions. Status is not stored — it's fetched
441 // fresh from CCR on restore.
442 void persistRemoteAgentMetadata({
443 taskId,
444 remoteTaskType,
445 sessionId: session.id,
446 title: session.title,
447 command,
448 spawnedAt: Date.now(),
449 toolUseId,
450 isUltraplan,
451 isRemoteReview,
452 isLongRunning,
453 remoteTaskMetadata
454 });
455
456 // Ultraplan lifecycle is owned by startDetachedPoll in ultraplan.tsx. Generic
457 // polling still runs so session.log populates for the detail view's progress
458 // counts; the result-lookup guard below prevents early completion.
459 // TODO(#23985): fold ExitPlanModeScanner into this poller, drop startDetachedPoll.
460 const stopPolling = startRemoteSessionPolling(taskId, context);
461 return {
462 taskId,
463 sessionId: session.id,
464 cleanup: stopPolling
465 };
466}
467
468/**
469 * Restore remote-agent tasks from the session sidecar on --resume.
470 *
471 * Scans remote-agents/, fetches live CCR status for each, reconstructs
472 * RemoteAgentTaskState into AppState.tasks, and restarts polling for sessions
473 * still running. Sessions that are archived or 404 have their sidecar file
474 * removed. Must run after switchSession() so getSessionId() points at the
475 * resumed session's sidecar directory.
476 */
477export async function restoreRemoteAgentTasks(context: TaskContext): Promise<void> {
478 try {
479 await restoreRemoteAgentTasksImpl(context);
480 } catch (e) {
481 logForDebugging(`restoreRemoteAgentTasks failed: ${String(e)}`);
482 }
483}
484async function restoreRemoteAgentTasksImpl(context: TaskContext): Promise<void> {
485 const persisted = await listRemoteAgentMetadata();
486 if (persisted.length === 0) return;
487 for (const meta of persisted) {
488 let remoteStatus: string;
489 try {
490 const session = await fetchSession(meta.sessionId);
491 remoteStatus = session.session_status;
492 } catch (e) {
493 // Only 404 means the CCR session is truly gone. Auth errors (401,
494 // missing OAuth token) are recoverable via /login — the remote
495 // session is still running. fetchSession throws plain Error for all
496 // 4xx (validateStatus treats <500 as success), so isTransientNetworkError
497 // can't distinguish them; match the 404 message instead.
498 if (e instanceof Error && e.message.startsWith('Session not found:')) {
499 logForDebugging(`restoreRemoteAgentTasks: dropping ${meta.taskId} (404: ${String(e)})`);
500 void removeRemoteAgentMetadata(meta.taskId);
501 } else {
502 logForDebugging(`restoreRemoteAgentTasks: skipping ${meta.taskId} (recoverable: ${String(e)})`);
503 }
504 continue;
505 }
506 if (remoteStatus === 'archived') {
507 // Session ended while the local client was offline. Don't resurrect.
508 void removeRemoteAgentMetadata(meta.taskId);
509 continue;
510 }
511 const taskState: RemoteAgentTaskState = {
512 ...createTaskStateBase(meta.taskId, 'remote_agent', meta.title, meta.toolUseId),
513 type: 'remote_agent',
514 remoteTaskType: isRemoteTaskType(meta.remoteTaskType) ? meta.remoteTaskType : 'remote-agent',
515 status: 'running',
516 sessionId: meta.sessionId,
517 command: meta.command,
518 title: meta.title,
519 todoList: [],
520 log: [],
521 isRemoteReview: meta.isRemoteReview,
522 isUltraplan: meta.isUltraplan,
523 isLongRunning: meta.isLongRunning,
524 startTime: meta.spawnedAt,
525 pollStartedAt: Date.now(),
526 remoteTaskMetadata: meta.remoteTaskMetadata as RemoteTaskMetadata | undefined
527 };
528 registerTask(taskState, context.setAppState);
529 void initTaskOutput(meta.taskId);
530 startRemoteSessionPolling(meta.taskId, context);
531 }
532}
533
534/**
535 * Start polling for remote session updates.
536 * Returns a cleanup function to stop polling.
537 */
538function startRemoteSessionPolling(taskId: string, context: TaskContext): () => void {
539 let isRunning = true;
540 const POLL_INTERVAL_MS = 1000;
541 const REMOTE_REVIEW_TIMEOUT_MS = 30 * 60 * 1000;
542 // Remote sessions flip to 'idle' between tool turns. With 100+ rapid
543 // turns, a 1s poll WILL catch a transient idle mid-run. Require stable
544 // idle (no log growth for N consecutive polls) before believing it.
545 const STABLE_IDLE_POLLS = 5;
546 let consecutiveIdlePolls = 0;
547 let lastEventId: string | null = null;
548 let accumulatedLog: SDKMessage[] = [];
549 // Cached across ticks so we don't re-scan the full log. Tag appears once
550 // at end of run; scanning only the delta (response.newEvents) is O(new).
551 let cachedReviewContent: string | null = null;
552 const poll = async (): Promise<void> => {
553 if (!isRunning) return;
554 try {
555 const appState = context.getAppState();
556 const task = appState.tasks?.[taskId] as RemoteAgentTaskState | undefined;
557 if (!task || task.status !== 'running') {
558 // Task was killed externally (TaskStopTool) or already terminal.
559 // Session left alive so the claude.ai URL stays valid — the run_hunt.sh
560 // post_stage() calls land as assistant events there, and the user may
561 // want to revisit them after closing the terminal. TTL reaps it.
562 return;
563 }
564 const response = await pollRemoteSessionEvents(task.sessionId, lastEventId);
565 lastEventId = response.lastEventId;
566 const logGrew = response.newEvents.length > 0;
567 if (logGrew) {
568 accumulatedLog = [...accumulatedLog, ...response.newEvents];
569 const deltaText = response.newEvents.map(msg => {
570 if (msg.type === 'assistant') {
571 return msg.message.content.filter(block => block.type === 'text').map(block => 'text' in block ? block.text : '').join('\n');
572 }
573 return jsonStringify(msg);
574 }).join('\n');
575 if (deltaText) {
576 appendTaskOutput(taskId, deltaText + '\n');
577 }
578 }
579 if (response.sessionStatus === 'archived') {
580 updateTaskState<RemoteAgentTaskState>(taskId, context.setAppState, t => t.status === 'running' ? {
581 ...t,
582 status: 'completed',
583 endTime: Date.now()
584 } : t);
585 enqueueRemoteNotification(taskId, task.title, 'completed', context.setAppState, task.toolUseId);
586 void evictTaskOutput(taskId);
587 void removeRemoteAgentMetadata(taskId);
588 return;
589 }
590 const checker = completionCheckers.get(task.remoteTaskType);
591 if (checker) {
592 const completionResult = await checker(task.remoteTaskMetadata);
593 if (completionResult !== null) {
594 updateTaskState<RemoteAgentTaskState>(taskId, context.setAppState, t => t.status === 'running' ? {
595 ...t,
596 status: 'completed',
597 endTime: Date.now()
598 } : t);
599 enqueueRemoteNotification(taskId, completionResult, 'completed', context.setAppState, task.toolUseId);
600 void evictTaskOutput(taskId);
601 void removeRemoteAgentMetadata(taskId);
602 return;
603 }
604 }
605
606 // Ultraplan: result(success) fires after every CCR turn, so it must not
607 // drive completion — startDetachedPoll owns that via ExitPlanMode scan.
608 // Long-running monitors (autofix-pr) emit result per notification cycle,
609 // so the same skip applies.
610 const result = task.isUltraplan || task.isLongRunning ? undefined : accumulatedLog.findLast(msg => msg.type === 'result');
611
612 // For remote-review: <remote-review> in hook_progress stdout is the
613 // bughunter path's completion signal. Scan only the delta to stay O(new);
614 // tag appears once at end of run so we won't miss it across ticks.
615 // For the failure signal, debounce idle: remote sessions briefly flip
616 // to 'idle' between every tool turn, so a single idle observation means
617 // nothing. Require STABLE_IDLE_POLLS consecutive idle polls with no log
618 // growth.
619 if (task.isRemoteReview && logGrew && cachedReviewContent === null) {
620 cachedReviewContent = extractReviewTagFromLog(response.newEvents);
621 }
622 // Parse live progress counts from the orchestrator's heartbeat echoes.
623 // hook_progress stdout is cumulative (every echo since hook start), so
624 // each event contains all progress tags. Grab the LAST occurrence —
625 // extractTag returns the first match which would always be the earliest
626 // value (0/0).
627 let newProgress: RemoteAgentTaskState['reviewProgress'];
628 if (task.isRemoteReview && logGrew) {
629 const open = `<${REMOTE_REVIEW_PROGRESS_TAG}>`;
630 const close = `</${REMOTE_REVIEW_PROGRESS_TAG}>`;
631 for (const ev of response.newEvents) {
632 if (ev.type === 'system' && (ev.subtype === 'hook_progress' || ev.subtype === 'hook_response')) {
633 const s = ev.stdout;
634 const closeAt = s.lastIndexOf(close);
635 const openAt = closeAt === -1 ? -1 : s.lastIndexOf(open, closeAt);
636 if (openAt !== -1 && closeAt > openAt) {
637 try {
638 const p = JSON.parse(s.slice(openAt + open.length, closeAt)) as {
639 stage?: 'finding' | 'verifying' | 'synthesizing';
640 bugs_found?: number;
641 bugs_verified?: number;
642 bugs_refuted?: number;
643 };
644 newProgress = {
645 stage: p.stage,
646 bugsFound: p.bugs_found ?? 0,
647 bugsVerified: p.bugs_verified ?? 0,
648 bugsRefuted: p.bugs_refuted ?? 0
649 };
650 } catch {
651 // ignore malformed progress
652 }
653 }
654 }
655 }
656 }
657 // Hook events count as output only for remote-review — bughunter's
658 // SessionStart hook produces zero assistant turns so stableIdle would
659 // never arm without this.
660 const hasAnyOutput = accumulatedLog.some(msg => msg.type === 'assistant' || task.isRemoteReview && msg.type === 'system' && (msg.subtype === 'hook_progress' || msg.subtype === 'hook_response'));
661 if (response.sessionStatus === 'idle' && !logGrew && hasAnyOutput) {
662 consecutiveIdlePolls++;
663 } else {
664 consecutiveIdlePolls = 0;
665 }
666 const stableIdle = consecutiveIdlePolls >= STABLE_IDLE_POLLS;
667 // stableIdle is a prompt-mode completion signal (Claude stops writing
668 // → session idles → done). In bughunter mode the session is "idle" the
669 // entire time the SessionStart hook runs; the previous guard checked
670 // hasAssistantEvents as a prompt-mode proxy, but post_stage() now
671 // writes assistant events in bughunter mode too, so that check
672 // misfires between heartbeats. Presence of a SessionStart hook event
673 // is the discriminator — bughunter mode always has one (run_hunt.sh),
674 // prompt mode never does — and it arrives before the kickoff
675 // post_stage so there's no race. When the hook is running, only the
676 // <remote-review> tag or the 30min timeout complete the task.
677 // Filtering on hook_event avoids a (theoretical) non-SessionStart hook
678 // in prompt mode from blocking stableIdle — the code_review container
679 // only registers SessionStart, but the 30min-hang failure mode is
680 // worth defending against.
681 const hasSessionStartHook = accumulatedLog.some(m => m.type === 'system' && (m.subtype === 'hook_started' || m.subtype === 'hook_progress' || m.subtype === 'hook_response') && (m as {
682 hook_event?: string;
683 }).hook_event === 'SessionStart');
684 const hasAssistantEvents = accumulatedLog.some(m => m.type === 'assistant');
685 const sessionDone = task.isRemoteReview && (cachedReviewContent !== null || !hasSessionStartHook && stableIdle && hasAssistantEvents);
686 const reviewTimedOut = task.isRemoteReview && Date.now() - task.pollStartedAt > REMOTE_REVIEW_TIMEOUT_MS;
687 const newStatus = result ? result.subtype === 'success' ? 'completed' as const : 'failed' as const : sessionDone || reviewTimedOut ? 'completed' as const : accumulatedLog.length > 0 ? 'running' as const : 'starting' as const;
688
689 // Update task state. Guard against terminal states — if stopTask raced
690 // while pollRemoteSessionEvents was in-flight (status set to 'killed',
691 // notified set to true), bail without overwriting status or proceeding to
692 // side effects (notification, permission-mode flip).
693 let raceTerminated = false;
694 updateTaskState<RemoteAgentTaskState>(taskId, context.setAppState, prevTask => {
695 if (prevTask.status !== 'running') {
696 raceTerminated = true;
697 return prevTask;
698 }
699 // No log growth and status unchanged → nothing to report. Return
700 // same ref so updateTaskState skips the spread and 18 s.tasks
701 // subscribers (REPL, Spinner, PromptInput, ...) don't re-render.
702 // newProgress only arrives via log growth (heartbeat echo is a
703 // hook_progress event), so !logGrew already covers no-update.
704 const statusUnchanged = newStatus === 'running' || newStatus === 'starting';
705 if (!logGrew && statusUnchanged) {
706 return prevTask;
707 }
708 return {
709 ...prevTask,
710 status: newStatus === 'starting' ? 'running' : newStatus,
711 log: accumulatedLog,
712 // Only re-scan for TodoWrite when log grew — log is append-only,
713 // so no growth means no new tool_use blocks. Avoids findLast +
714 // some + find + safeParse every second when idle.
715 todoList: logGrew ? extractTodoListFromLog(accumulatedLog) : prevTask.todoList,
716 reviewProgress: newProgress ?? prevTask.reviewProgress,
717 endTime: result || sessionDone || reviewTimedOut ? Date.now() : undefined
718 };
719 });
720 if (raceTerminated) return;
721
722 // Send notification if task completed or timed out
723 if (result || sessionDone || reviewTimedOut) {
724 const finalStatus = result && result.subtype !== 'success' ? 'failed' : 'completed';
725
726 // For remote-review tasks: inject the review text directly into the
727 // message queue. No mode change, no file indirection — the local model
728 // just sees the review appear as a task-notification on its next turn.
729 // Session kept alive — run_hunt.sh's post_stage() has already written
730 // the formatted findings as an assistant event, so the claude.ai URL
731 // stays a durable record the user can revisit. TTL handles cleanup.
732 if (task.isRemoteReview) {
733 // cachedReviewContent hit the tag in the delta scan. Full-log scan
734 // catches the stableIdle path where the tag arrived in an earlier
735 // tick but the delta scan wasn't wired yet (first poll after resume).
736 const reviewContent = cachedReviewContent ?? extractReviewFromLog(accumulatedLog);
737 if (reviewContent && finalStatus === 'completed') {
738 enqueueRemoteReviewNotification(taskId, reviewContent, context.setAppState);
739 void evictTaskOutput(taskId);
740 void removeRemoteAgentMetadata(taskId);
741 return; // Stop polling
742 }
743
744 // No output or remote error — mark failed with a review-specific message.
745 updateTaskState(taskId, context.setAppState, t => ({
746 ...t,
747 status: 'failed'
748 }));
749 const reason = result && result.subtype !== 'success' ? 'remote session returned an error' : reviewTimedOut && !sessionDone ? 'remote session exceeded 30 minutes' : 'no review output — orchestrator may have exited early';
750 enqueueRemoteReviewFailureNotification(taskId, reason, context.setAppState);
751 void evictTaskOutput(taskId);
752 void removeRemoteAgentMetadata(taskId);
753 return; // Stop polling
754 }
755 enqueueRemoteNotification(taskId, task.title, finalStatus, context.setAppState, task.toolUseId);
756 void evictTaskOutput(taskId);
757 void removeRemoteAgentMetadata(taskId);
758 return; // Stop polling
759 }
760 } catch (error) {
761 logError(error);
762 // Reset so an API error doesn't let non-consecutive idle polls accumulate.
763 consecutiveIdlePolls = 0;
764
765 // Check review timeout even when the API call fails — without this,
766 // persistent API errors skip the timeout check and poll forever.
767 try {
768 const appState = context.getAppState();
769 const task = appState.tasks?.[taskId] as RemoteAgentTaskState | undefined;
770 if (task?.isRemoteReview && task.status === 'running' && Date.now() - task.pollStartedAt > REMOTE_REVIEW_TIMEOUT_MS) {
771 updateTaskState(taskId, context.setAppState, t => ({
772 ...t,
773 status: 'failed',
774 endTime: Date.now()
775 }));
776 enqueueRemoteReviewFailureNotification(taskId, 'remote session exceeded 30 minutes', context.setAppState);
777 void evictTaskOutput(taskId);
778 void removeRemoteAgentMetadata(taskId);
779 return; // Stop polling
780 }
781 } catch {
782 // Best effort — if getAppState fails, continue polling
783 }
784 }
785
786 // Continue polling
787 if (isRunning) {
788 setTimeout(poll, POLL_INTERVAL_MS);
789 }
790 };
791
792 // Start polling
793 void poll();
794
795 // Return cleanup function
796 return () => {
797 isRunning = false;
798 };
799}
800
801/**
802 * RemoteAgentTask - Handles remote Claude.ai session execution.
803 *
804 * Replaces the BackgroundRemoteSession implementation from:
805 * - src/utils/background/remote/remoteSession.ts
806 * - src/components/tasks/BackgroundTaskStatus.tsx (polling logic)
807 */
808export const RemoteAgentTask: Task = {
809 name: 'RemoteAgentTask',
810 type: 'remote_agent',
811 async kill(taskId, setAppState) {
812 let toolUseId: string | undefined;
813 let description: string | undefined;
814 let sessionId: string | undefined;
815 let killed = false;
816 updateTaskState<RemoteAgentTaskState>(taskId, setAppState, task => {
817 if (task.status !== 'running') {
818 return task;
819 }
820 toolUseId = task.toolUseId;
821 description = task.description;
822 sessionId = task.sessionId;
823 killed = true;
824 return {
825 ...task,
826 status: 'killed',
827 notified: true,
828 endTime: Date.now()
829 };
830 });
831
832 // Close the task_started bookend for SDK consumers. The poll loop's
833 // early-return when status!=='running' won't emit a notification.
834 if (killed) {
835 emitTaskTerminatedSdk(taskId, 'stopped', {
836 toolUseId,
837 summary: description
838 });
839 // Archive the remote session so it stops consuming cloud resources.
840 if (sessionId) {
841 void archiveRemoteSession(sessionId).catch(e => logForDebugging(`RemoteAgentTask archive failed: ${String(e)}`));
842 }
843 }
844 void evictTaskOutput(taskId);
845 void removeRemoteAgentMetadata(taskId);
846 logForDebugging(`RemoteAgentTask ${taskId} killed, archiving session ${sessionId ?? 'unknown'}`);
847 }
848};
849
850/**
851 * Get the session URL for a remote task.
852 */
853export function getRemoteTaskSessionUrl(sessionId: string): string {
854 return getRemoteSessionUrl(sessionId, process.env.SESSION_INGRESS_URL);
855}
856//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["ToolUseBlock","getRemoteSessionUrl","OUTPUT_FILE_TAG","REMOTE_REVIEW_PROGRESS_TAG","REMOTE_REVIEW_TAG","STATUS_TAG","SUMMARY_TAG","TASK_ID_TAG","TASK_NOTIFICATION_TAG","TASK_TYPE_TAG","TOOL_USE_ID_TAG","ULTRAPLAN_TAG","SDKAssistantMessage","SDKMessage","SetAppState","Task","TaskContext","TaskStateBase","createTaskStateBase","generateTaskId","TodoWriteTool","BackgroundRemoteSessionPrecondition","checkBackgroundRemoteSessionEligibility","logForDebugging","logError","enqueuePendingNotification","extractTag","extractTextContent","emitTaskTerminatedSdk","deleteRemoteAgentMetadata","listRemoteAgentMetadata","RemoteAgentMetadata","writeRemoteAgentMetadata","jsonStringify","appendTaskOutput","evictTaskOutput","getTaskOutputPath","initTaskOutput","registerTask","updateTaskState","fetchSession","archiveRemoteSession","pollRemoteSessionEvents","TodoList","UltraplanPhase","RemoteAgentTaskState","type","remoteTaskType","RemoteTaskType","remoteTaskMetadata","RemoteTaskMetadata","sessionId","command","title","todoList","log","isLongRunning","pollStartedAt","isRemoteReview","reviewProgress","stage","bugsFound","bugsVerified","bugsRefuted","isUltraplan","ultraplanPhase","Exclude","REMOTE_TASK_TYPES","const","isRemoteTaskType","v","includes","AutofixPrRemoteTaskMetadata","owner","repo","prNumber","RemoteTaskCompletionChecker","Promise","completionCheckers","Map","registerCompletionChecker","checker","set","persistRemoteAgentMetadata","meta","taskId","e","String","removeRemoteAgentMetadata","RemoteAgentPreconditionResult","eligible","errors","checkRemoteAgentEligibility","skipBundle","length","formatPreconditionError","error","enqueueRemoteNotification","status","setAppState","toolUseId","markTaskNotified","statusText","toolUseIdLine","outputPath","message","value","mode","shouldEnqueue","task","notified","extractPlanFromLog","i","msg","fullText","content","plan","trim","enqueueUltraplanFailureNotification","reason","sessionUrl","getRemoteTaskSessionUrl","extractReviewFromLog","subtype","tagged","stdout","hookStdout","filter","map","join","hookTagged","allText","extractReviewTagFromLog","enqueueRemoteReviewNotification","reviewContent","enqueueRemoteReviewFailureNotification","extractTodoListFromLog","todoListMessage","findLast","some","block","name","input","find","parsedInput","inputSchema","safeParse","success","data","todos","registerRemoteAgentTask","options","session","id","context","cleanup","taskState","Date","now","spawnedAt","stopPolling","startRemoteSessionPolling","restoreRemoteAgentTasks","restoreRemoteAgentTasksImpl","persisted","remoteStatus","session_status","Error","startsWith","startTime","isRunning","POLL_INTERVAL_MS","REMOTE_REVIEW_TIMEOUT_MS","STABLE_IDLE_POLLS","consecutiveIdlePolls","lastEventId","accumulatedLog","cachedReviewContent","poll","appState","getAppState","tasks","response","logGrew","newEvents","deltaText","text","sessionStatus","t","endTime","get","completionResult","result","undefined","newProgress","open","close","ev","s","closeAt","lastIndexOf","openAt","p","JSON","parse","slice","bugs_found","bugs_verified","bugs_refuted","hasAnyOutput","stableIdle","hasSessionStartHook","m","hook_event","hasAssistantEvents","sessionDone","reviewTimedOut","newStatus","raceTerminated","prevTask","statusUnchanged","finalStatus","setTimeout","RemoteAgentTask","kill","description","killed","summary","catch","process","env","SESSION_INGRESS_URL"],"sources":["RemoteAgentTask.tsx"],"sourcesContent":["import type { ToolUseBlock } from '@anthropic-ai/sdk/resources'\nimport { getRemoteSessionUrl } from '../../constants/product.js'\nimport {\n  OUTPUT_FILE_TAG,\n  REMOTE_REVIEW_PROGRESS_TAG,\n  REMOTE_REVIEW_TAG,\n  STATUS_TAG,\n  SUMMARY_TAG,\n  TASK_ID_TAG,\n  TASK_NOTIFICATION_TAG,\n  TASK_TYPE_TAG,\n  TOOL_USE_ID_TAG,\n  ULTRAPLAN_TAG,\n} from '../../constants/xml.js'\nimport type {\n  SDKAssistantMessage,\n  SDKMessage,\n} from '../../entrypoints/agentSdkTypes.js'\nimport type {\n  SetAppState,\n  Task,\n  TaskContext,\n  TaskStateBase,\n} from '../../Task.js'\nimport { createTaskStateBase, generateTaskId } from '../../Task.js'\nimport { TodoWriteTool } from '../../tools/TodoWriteTool/TodoWriteTool.js'\nimport {\n  type BackgroundRemoteSessionPrecondition,\n  checkBackgroundRemoteSessionEligibility,\n} from '../../utils/background/remote/remoteSession.js'\nimport { logForDebugging } from '../../utils/debug.js'\nimport { logError } from '../../utils/log.js'\nimport { enqueuePendingNotification } from '../../utils/messageQueueManager.js'\nimport { extractTag, extractTextContent } from '../../utils/messages.js'\nimport { emitTaskTerminatedSdk } from '../../utils/sdkEventQueue.js'\nimport {\n  deleteRemoteAgentMetadata,\n  listRemoteAgentMetadata,\n  type RemoteAgentMetadata,\n  writeRemoteAgentMetadata,\n} from '../../utils/sessionStorage.js'\nimport { jsonStringify } from '../../utils/slowOperations.js'\nimport {\n  appendTaskOutput,\n  evictTaskOutput,\n  getTaskOutputPath,\n  initTaskOutput,\n} from '../../utils/task/diskOutput.js'\nimport { registerTask, updateTaskState } from '../../utils/task/framework.js'\nimport { fetchSession } from '../../utils/teleport/api.js'\nimport {\n  archiveRemoteSession,\n  pollRemoteSessionEvents,\n} from '../../utils/teleport.js'\nimport type { TodoList } from '../../utils/todo/types.js'\nimport type { UltraplanPhase } from '../../utils/ultraplan/ccrSession.js'\n\nexport type RemoteAgentTaskState = TaskStateBase & {\n  type: 'remote_agent'\n  remoteTaskType: RemoteTaskType\n  /** Task-specific metadata (PR number, repo, etc.). */\n  remoteTaskMetadata?: RemoteTaskMetadata\n  sessionId: string // Original session ID for API calls\n  command: string\n  title: string\n  todoList: TodoList\n  log: SDKMessage[]\n  /**\n   * Long-running agent that will not be marked as complete after the first `result`.\n   */\n  isLongRunning?: boolean\n  /**\n   * When the local poller started watching this task (at spawn or on restore).\n   * Review timeout clocks from here so a restore doesn't immediately time out\n   * a task spawned >30min ago.\n   */\n  pollStartedAt: number\n  /** True when this task was created by a teleported /ultrareview command. */\n  isRemoteReview?: boolean\n  /** Parsed from the orchestrator's <remote-review-progress> heartbeat echoes. */\n  reviewProgress?: {\n    stage?: 'finding' | 'verifying' | 'synthesizing'\n    bugsFound: number\n    bugsVerified: number\n    bugsRefuted: number\n  }\n  isUltraplan?: boolean\n  /**\n   * Scanner-derived pill state. Undefined = running. `needs_input` when the\n   * remote asked a clarifying question and is idle; `plan_ready` when\n   * ExitPlanMode is awaiting browser approval. Surfaced in the pill badge\n   * and detail dialog status line.\n   */\n  ultraplanPhase?: Exclude<UltraplanPhase, 'running'>\n}\n\nconst REMOTE_TASK_TYPES = [\n  'remote-agent',\n  'ultraplan',\n  'ultrareview',\n  'autofix-pr',\n  'background-pr',\n] as const\nexport type RemoteTaskType = (typeof REMOTE_TASK_TYPES)[number]\n\nfunction isRemoteTaskType(v: string | undefined): v is RemoteTaskType {\n  return (REMOTE_TASK_TYPES as readonly string[]).includes(v ?? '')\n}\n\nexport type AutofixPrRemoteTaskMetadata = {\n  owner: string\n  repo: string\n  prNumber: number\n}\n\nexport type RemoteTaskMetadata = AutofixPrRemoteTaskMetadata\n\n/**\n * Called on every poll tick for tasks with a matching remoteTaskType. Return a\n * non-null string to complete the task (string becomes the notification text),\n * or null to keep polling. Checkers that hit external APIs should self-throttle.\n */\nexport type RemoteTaskCompletionChecker = (\n  remoteTaskMetadata: RemoteTaskMetadata | undefined,\n) => Promise<string | null>\n\nconst completionCheckers = new Map<\n  RemoteTaskType,\n  RemoteTaskCompletionChecker\n>()\n\n/**\n * Register a completion checker for a remote task type. Invoked on every poll\n * tick; survives --resume via the sidecar's remoteTaskType + remoteTaskMetadata.\n */\nexport function registerCompletionChecker(\n  remoteTaskType: RemoteTaskType,\n  checker: RemoteTaskCompletionChecker,\n): void {\n  completionCheckers.set(remoteTaskType, checker)\n}\n\n/**\n * Persist a remote-agent metadata entry to the session sidecar.\n * Fire-and-forget — persistence failures must not block task registration.\n */\nasync function persistRemoteAgentMetadata(\n  meta: RemoteAgentMetadata,\n): Promise<void> {\n  try {\n    await writeRemoteAgentMetadata(meta.taskId, meta)\n  } catch (e) {\n    logForDebugging(`persistRemoteAgentMetadata failed: ${String(e)}`)\n  }\n}\n\n/**\n * Remove a remote-agent metadata entry from the session sidecar.\n * Called on task completion/kill so restored sessions don't resurrect\n * tasks that already finished.\n */\nasync function removeRemoteAgentMetadata(taskId: string): Promise<void> {\n  try {\n    await deleteRemoteAgentMetadata(taskId)\n  } catch (e) {\n    logForDebugging(`removeRemoteAgentMetadata failed: ${String(e)}`)\n  }\n}\n\n// Precondition error result\nexport type RemoteAgentPreconditionResult =\n  | {\n      eligible: true\n    }\n  | {\n      eligible: false\n      errors: BackgroundRemoteSessionPrecondition[]\n    }\n\n/**\n * Check eligibility for creating a remote agent session.\n */\nexport async function checkRemoteAgentEligibility({\n  skipBundle = false,\n}: {\n  skipBundle?: boolean\n} = {}): Promise<RemoteAgentPreconditionResult> {\n  const errors = await checkBackgroundRemoteSessionEligibility({ skipBundle })\n  if (errors.length > 0) {\n    return { eligible: false, errors }\n  }\n  return { eligible: true }\n}\n\n/**\n * Format precondition error for display.\n */\nexport function formatPreconditionError(\n  error: BackgroundRemoteSessionPrecondition,\n): string {\n  switch (error.type) {\n    case 'not_logged_in':\n      return 'Please run /login and sign in with your Claude.ai account (not Console).'\n    case 'no_remote_environment':\n      return 'No cloud environment available. Set one up at https://claude.ai/code/onboarding?magic=env-setup'\n    case 'not_in_git_repo':\n      return 'Background tasks require a git repository. Initialize git or run from a git repository.'\n    case 'no_git_remote':\n      return 'Background tasks require a GitHub remote. Add one with `git remote add origin REPO_URL`.'\n    case 'github_app_not_installed':\n      return 'The Claude GitHub app must be installed on this repository first.\\nhttps://github.com/apps/claude/installations/new'\n    case 'policy_blocked':\n      return \"Remote sessions are disabled by your organization's policy. Contact your organization admin to enable them.\"\n  }\n}\n\n/**\n * Enqueue a remote task notification to the message queue.\n */\nfunction enqueueRemoteNotification(\n  taskId: string,\n  title: string,\n  status: 'completed' | 'failed' | 'killed',\n  setAppState: SetAppState,\n  toolUseId?: string,\n): void {\n  // Atomically check and set notified flag to prevent duplicate notifications.\n  if (!markTaskNotified(taskId, setAppState)) return\n\n  const statusText =\n    status === 'completed'\n      ? 'completed successfully'\n      : status === 'failed'\n        ? 'failed'\n        : 'was stopped'\n\n  const toolUseIdLine = toolUseId\n    ? `\\n<${TOOL_USE_ID_TAG}>${toolUseId}</${TOOL_USE_ID_TAG}>`\n    : ''\n\n  const outputPath = getTaskOutputPath(taskId)\n  const message = `<${TASK_NOTIFICATION_TAG}>\n<${TASK_ID_TAG}>${taskId}</${TASK_ID_TAG}>${toolUseIdLine}\n<${TASK_TYPE_TAG}>remote_agent</${TASK_TYPE_TAG}>\n<${OUTPUT_FILE_TAG}>${outputPath}</${OUTPUT_FILE_TAG}>\n<${STATUS_TAG}>${status}</${STATUS_TAG}>\n<${SUMMARY_TAG}>Remote task \"${title}\" ${statusText}</${SUMMARY_TAG}>\n</${TASK_NOTIFICATION_TAG}>`\n\n  enqueuePendingNotification({ value: message, mode: 'task-notification' })\n}\n\n/**\n * Atomically mark a task as notified. Returns true if this call flipped the\n * flag (caller should enqueue), false if already notified (caller should skip).\n */\nfunction markTaskNotified(taskId: string, setAppState: SetAppState): boolean {\n  let shouldEnqueue = false\n  updateTaskState(taskId, setAppState, task => {\n    if (task.notified) {\n      return task\n    }\n    shouldEnqueue = true\n    return { ...task, notified: true }\n  })\n  return shouldEnqueue\n}\n\n/**\n * Extract the plan content from the remote session log.\n * Searches all assistant messages for <ultraplan>...</ultraplan> tags.\n */\nexport function extractPlanFromLog(log: SDKMessage[]): string | null {\n  // Walk backwards through assistant messages to find <ultraplan> content\n  for (let i = log.length - 1; i >= 0; i--) {\n    const msg = log[i]\n    if (msg?.type !== 'assistant') continue\n    const fullText = extractTextContent(msg.message.content, '\\n')\n    const plan = extractTag(fullText, ULTRAPLAN_TAG)\n    if (plan?.trim()) return plan.trim()\n  }\n  return null\n}\n\n/**\n * Enqueue an ultraplan-specific failure notification. Unlike enqueueRemoteNotification\n * this does NOT instruct the model to read the raw output file (a JSONL dump that is\n * useless for plan extraction).\n */\nexport function enqueueUltraplanFailureNotification(\n  taskId: string,\n  sessionId: string,\n  reason: string,\n  setAppState: SetAppState,\n): void {\n  if (!markTaskNotified(taskId, setAppState)) return\n\n  const sessionUrl = getRemoteTaskSessionUrl(sessionId)\n  const message = `<${TASK_NOTIFICATION_TAG}>\n<${TASK_ID_TAG}>${taskId}</${TASK_ID_TAG}>\n<${TASK_TYPE_TAG}>remote_agent</${TASK_TYPE_TAG}>\n<${STATUS_TAG}>failed</${STATUS_TAG}>\n<${SUMMARY_TAG}>Ultraplan failed: ${reason}</${SUMMARY_TAG}>\n</${TASK_NOTIFICATION_TAG}>\nThe remote Ultraplan session did not produce a plan (${reason}). Inspect the session at ${sessionUrl} and tell the user to retry locally with plan mode.`\n\n  enqueuePendingNotification({ value: message, mode: 'task-notification' })\n}\n\n/**\n * Extract review content from the remote session log.\n *\n * Two producers, two event shapes:\n * - bughunter mode: run_hunt.sh is a SessionStart hook; its echo lands as\n *   {type:'system', subtype:'hook_progress', stdout:'...'}. Claude never\n *   takes a turn so there are zero assistant messages.\n * - prompt mode: a real assistant turn wraps the review in the tag.\n *\n * Scans hook_progress first since bughunter is the intended production path\n * and prompt mode is the dev/fallback. Newest-first in both cases — the tag\n * appears once at the end of the run so reverse iteration short-circuits.\n */\nfunction extractReviewFromLog(log: SDKMessage[]): string | null {\n  for (let i = log.length - 1; i >= 0; i--) {\n    const msg = log[i]\n    // The final echo before hook exit may land in either the last\n    // hook_progress or the terminal hook_response depending on buffering;\n    // both have flat stdout.\n    if (\n      msg?.type === 'system' &&\n      (msg.subtype === 'hook_progress' || msg.subtype === 'hook_response')\n    ) {\n      const tagged = extractTag(msg.stdout, REMOTE_REVIEW_TAG)\n      if (tagged?.trim()) return tagged.trim()\n    }\n  }\n\n  for (let i = log.length - 1; i >= 0; i--) {\n    const msg = log[i]\n    if (msg?.type !== 'assistant') continue\n    const fullText = extractTextContent(msg.message.content, '\\n')\n    const tagged = extractTag(fullText, REMOTE_REVIEW_TAG)\n    if (tagged?.trim()) return tagged.trim()\n  }\n\n  // Hook-stdout concat fallback: a single echo should land in one event, but\n  // large JSON payloads can flush across two if the pipe buffer fills\n  // mid-write. Per-message scan above misses a tag split across events.\n  const hookStdout = log\n    .filter(\n      msg =>\n        msg.type === 'system' &&\n        (msg.subtype === 'hook_progress' || msg.subtype === 'hook_response'),\n    )\n    .map(msg => msg.stdout)\n    .join('')\n  const hookTagged = extractTag(hookStdout, REMOTE_REVIEW_TAG)\n  if (hookTagged?.trim()) return hookTagged.trim()\n\n  // Fallback: concatenate all assistant text in chronological order.\n  const allText = log\n    .filter((msg): msg is SDKAssistantMessage => msg.type === 'assistant')\n    .map(msg => extractTextContent(msg.message.content, '\\n'))\n    .join('\\n')\n    .trim()\n\n  return allText || null\n}\n\n/**\n * Tag-only variant of extractReviewFromLog for delta scanning.\n *\n * Returns non-null ONLY when an explicit <remote-review> tag is found.\n * Unlike extractReviewFromLog, this does NOT fall back to concatenated\n * assistant text. This is critical for the delta scan: in prompt mode,\n * early untagged assistant messages (e.g. \"I'm analyzing the diff...\")\n * would trigger the fallback and prematurely set cachedReviewContent,\n * completing the review before the actual tagged output arrives.\n */\nfunction extractReviewTagFromLog(log: SDKMessage[]): string | null {\n  // hook_progress / hook_response per-message scan (bughunter path)\n  for (let i = log.length - 1; i >= 0; i--) {\n    const msg = log[i]\n    if (\n      msg?.type === 'system' &&\n      (msg.subtype === 'hook_progress' || msg.subtype === 'hook_response')\n    ) {\n      const tagged = extractTag(msg.stdout, REMOTE_REVIEW_TAG)\n      if (tagged?.trim()) return tagged.trim()\n    }\n  }\n\n  // assistant text per-message scan (prompt mode)\n  for (let i = log.length - 1; i >= 0; i--) {\n    const msg = log[i]\n    if (msg?.type !== 'assistant') continue\n    const fullText = extractTextContent(msg.message.content, '\\n')\n    const tagged = extractTag(fullText, REMOTE_REVIEW_TAG)\n    if (tagged?.trim()) return tagged.trim()\n  }\n\n  // Hook-stdout concat fallback for split tags\n  const hookStdout = log\n    .filter(\n      msg =>\n        msg.type === 'system' &&\n        (msg.subtype === 'hook_progress' || msg.subtype === 'hook_response'),\n    )\n    .map(msg => msg.stdout)\n    .join('')\n  const hookTagged = extractTag(hookStdout, REMOTE_REVIEW_TAG)\n  if (hookTagged?.trim()) return hookTagged.trim()\n\n  return null\n}\n\n/**\n * Enqueue a remote-review completion notification. Injects the review text\n * directly into the message queue so the local model receives it on the next\n * turn — no file indirection, no mode change. Session is kept alive so the\n * claude.ai URL stays a durable record the user can revisit; TTL handles cleanup.\n */\nfunction enqueueRemoteReviewNotification(\n  taskId: string,\n  reviewContent: string,\n  setAppState: SetAppState,\n): void {\n  if (!markTaskNotified(taskId, setAppState)) return\n\n  const message = `<${TASK_NOTIFICATION_TAG}>\n<${TASK_ID_TAG}>${taskId}</${TASK_ID_TAG}>\n<${TASK_TYPE_TAG}>remote_agent</${TASK_TYPE_TAG}>\n<${STATUS_TAG}>completed</${STATUS_TAG}>\n<${SUMMARY_TAG}>Remote review completed</${SUMMARY_TAG}>\n</${TASK_NOTIFICATION_TAG}>\nThe remote review produced the following findings:\n\n${reviewContent}`\n\n  enqueuePendingNotification({ value: message, mode: 'task-notification' })\n}\n\n/**\n * Enqueue a remote-review failure notification.\n */\nfunction enqueueRemoteReviewFailureNotification(\n  taskId: string,\n  reason: string,\n  setAppState: SetAppState,\n): void {\n  if (!markTaskNotified(taskId, setAppState)) return\n\n  const message = `<${TASK_NOTIFICATION_TAG}>\n<${TASK_ID_TAG}>${taskId}</${TASK_ID_TAG}>\n<${TASK_TYPE_TAG}>remote_agent</${TASK_TYPE_TAG}>\n<${STATUS_TAG}>failed</${STATUS_TAG}>\n<${SUMMARY_TAG}>Remote review failed: ${reason}</${SUMMARY_TAG}>\n</${TASK_NOTIFICATION_TAG}>\nRemote review did not produce output (${reason}). Tell the user to retry /ultrareview, or use /review for a local review instead.`\n\n  enqueuePendingNotification({ value: message, mode: 'task-notification' })\n}\n\n/**\n * Extract todo list from SDK messages (finds last TodoWrite tool use).\n */\nfunction extractTodoListFromLog(log: SDKMessage[]): TodoList {\n  const todoListMessage = log.findLast(\n    (msg): msg is SDKAssistantMessage =>\n      msg.type === 'assistant' &&\n      msg.message.content.some(\n        block => block.type === 'tool_use' && block.name === TodoWriteTool.name,\n      ),\n  )\n  if (!todoListMessage) {\n    return []\n  }\n\n  const input = todoListMessage.message.content.find(\n    (block): block is ToolUseBlock =>\n      block.type === 'tool_use' && block.name === TodoWriteTool.name,\n  )?.input\n  if (!input) {\n    return []\n  }\n\n  const parsedInput = TodoWriteTool.inputSchema.safeParse(input)\n  if (!parsedInput.success) {\n    return []\n  }\n\n  return parsedInput.data.todos\n}\n\n/**\n * Register a remote agent task in the unified task framework.\n * Bundles task ID generation, output init, state creation, registration, and polling.\n * Callers remain responsible for custom pre-registration logic (git dialogs, transcript upload, teleport options).\n */\nexport function registerRemoteAgentTask(options: {\n  remoteTaskType: RemoteTaskType\n  session: { id: string; title: string }\n  command: string\n  context: TaskContext\n  toolUseId?: string\n  isRemoteReview?: boolean\n  isUltraplan?: boolean\n  isLongRunning?: boolean\n  remoteTaskMetadata?: RemoteTaskMetadata\n}): {\n  taskId: string\n  sessionId: string\n  cleanup: () => void\n} {\n  const {\n    remoteTaskType,\n    session,\n    command,\n    context,\n    toolUseId,\n    isRemoteReview,\n    isUltraplan,\n    isLongRunning,\n    remoteTaskMetadata,\n  } = options\n  const taskId = generateTaskId('remote_agent')\n\n  // Create the output file before registering the task.\n  // RemoteAgentTask uses appendTaskOutput() (not TaskOutput), so\n  // the file must exist for readers before any output arrives.\n  void initTaskOutput(taskId)\n\n  const taskState: RemoteAgentTaskState = {\n    ...createTaskStateBase(taskId, 'remote_agent', session.title, toolUseId),\n    type: 'remote_agent',\n    remoteTaskType,\n    status: 'running',\n    sessionId: session.id,\n    command,\n    title: session.title,\n    todoList: [],\n    log: [],\n    isRemoteReview,\n    isUltraplan,\n    isLongRunning,\n    pollStartedAt: Date.now(),\n    remoteTaskMetadata,\n  }\n\n  registerTask(taskState, context.setAppState)\n\n  // Persist identity to the session sidecar so --resume can reconnect to\n  // still-running remote sessions. Status is not stored — it's fetched\n  // fresh from CCR on restore.\n  void persistRemoteAgentMetadata({\n    taskId,\n    remoteTaskType,\n    sessionId: session.id,\n    title: session.title,\n    command,\n    spawnedAt: Date.now(),\n    toolUseId,\n    isUltraplan,\n    isRemoteReview,\n    isLongRunning,\n    remoteTaskMetadata,\n  })\n\n  // Ultraplan lifecycle is owned by startDetachedPoll in ultraplan.tsx. Generic\n  // polling still runs so session.log populates for the detail view's progress\n  // counts; the result-lookup guard below prevents early completion.\n  // TODO(#23985): fold ExitPlanModeScanner into this poller, drop startDetachedPoll.\n  const stopPolling = startRemoteSessionPolling(taskId, context)\n\n  return {\n    taskId,\n    sessionId: session.id,\n    cleanup: stopPolling,\n  }\n}\n\n/**\n * Restore remote-agent tasks from the session sidecar on --resume.\n *\n * Scans remote-agents/, fetches live CCR status for each, reconstructs\n * RemoteAgentTaskState into AppState.tasks, and restarts polling for sessions\n * still running. Sessions that are archived or 404 have their sidecar file\n * removed. Must run after switchSession() so getSessionId() points at the\n * resumed session's sidecar directory.\n */\nexport async function restoreRemoteAgentTasks(\n  context: TaskContext,\n): Promise<void> {\n  try {\n    await restoreRemoteAgentTasksImpl(context)\n  } catch (e) {\n    logForDebugging(`restoreRemoteAgentTasks failed: ${String(e)}`)\n  }\n}\n\nasync function restoreRemoteAgentTasksImpl(\n  context: TaskContext,\n): Promise<void> {\n  const persisted = await listRemoteAgentMetadata()\n  if (persisted.length === 0) return\n\n  for (const meta of persisted) {\n    let remoteStatus: string\n    try {\n      const session = await fetchSession(meta.sessionId)\n      remoteStatus = session.session_status\n    } catch (e) {\n      // Only 404 means the CCR session is truly gone. Auth errors (401,\n      // missing OAuth token) are recoverable via /login — the remote\n      // session is still running. fetchSession throws plain Error for all\n      // 4xx (validateStatus treats <500 as success), so isTransientNetworkError\n      // can't distinguish them; match the 404 message instead.\n      if (e instanceof Error && e.message.startsWith('Session not found:')) {\n        logForDebugging(\n          `restoreRemoteAgentTasks: dropping ${meta.taskId} (404: ${String(e)})`,\n        )\n        void removeRemoteAgentMetadata(meta.taskId)\n      } else {\n        logForDebugging(\n          `restoreRemoteAgentTasks: skipping ${meta.taskId} (recoverable: ${String(e)})`,\n        )\n      }\n      continue\n    }\n\n    if (remoteStatus === 'archived') {\n      // Session ended while the local client was offline. Don't resurrect.\n      void removeRemoteAgentMetadata(meta.taskId)\n      continue\n    }\n\n    const taskState: RemoteAgentTaskState = {\n      ...createTaskStateBase(\n        meta.taskId,\n        'remote_agent',\n        meta.title,\n        meta.toolUseId,\n      ),\n      type: 'remote_agent',\n      remoteTaskType: isRemoteTaskType(meta.remoteTaskType)\n        ? meta.remoteTaskType\n        : 'remote-agent',\n      status: 'running',\n      sessionId: meta.sessionId,\n      command: meta.command,\n      title: meta.title,\n      todoList: [],\n      log: [],\n      isRemoteReview: meta.isRemoteReview,\n      isUltraplan: meta.isUltraplan,\n      isLongRunning: meta.isLongRunning,\n      startTime: meta.spawnedAt,\n      pollStartedAt: Date.now(),\n      remoteTaskMetadata: meta.remoteTaskMetadata as\n        | RemoteTaskMetadata\n        | undefined,\n    }\n\n    registerTask(taskState, context.setAppState)\n    void initTaskOutput(meta.taskId)\n    startRemoteSessionPolling(meta.taskId, context)\n  }\n}\n\n/**\n * Start polling for remote session updates.\n * Returns a cleanup function to stop polling.\n */\nfunction startRemoteSessionPolling(\n  taskId: string,\n  context: TaskContext,\n): () => void {\n  let isRunning = true\n  const POLL_INTERVAL_MS = 1000\n  const REMOTE_REVIEW_TIMEOUT_MS = 30 * 60 * 1000\n  // Remote sessions flip to 'idle' between tool turns. With 100+ rapid\n  // turns, a 1s poll WILL catch a transient idle mid-run. Require stable\n  // idle (no log growth for N consecutive polls) before believing it.\n  const STABLE_IDLE_POLLS = 5\n  let consecutiveIdlePolls = 0\n  let lastEventId: string | null = null\n  let accumulatedLog: SDKMessage[] = []\n  // Cached across ticks so we don't re-scan the full log. Tag appears once\n  // at end of run; scanning only the delta (response.newEvents) is O(new).\n  let cachedReviewContent: string | null = null\n\n  const poll = async (): Promise<void> => {\n    if (!isRunning) return\n\n    try {\n      const appState = context.getAppState()\n      const task = appState.tasks?.[taskId] as RemoteAgentTaskState | undefined\n      if (!task || task.status !== 'running') {\n        // Task was killed externally (TaskStopTool) or already terminal.\n        // Session left alive so the claude.ai URL stays valid — the run_hunt.sh\n        // post_stage() calls land as assistant events there, and the user may\n        // want to revisit them after closing the terminal. TTL reaps it.\n        return\n      }\n\n      const response = await pollRemoteSessionEvents(\n        task.sessionId,\n        lastEventId,\n      )\n      lastEventId = response.lastEventId\n      const logGrew = response.newEvents.length > 0\n      if (logGrew) {\n        accumulatedLog = [...accumulatedLog, ...response.newEvents]\n        const deltaText = response.newEvents\n          .map(msg => {\n            if (msg.type === 'assistant') {\n              return msg.message.content\n                .filter(block => block.type === 'text')\n                .map(block => ('text' in block ? block.text : ''))\n                .join('\\n')\n            }\n            return jsonStringify(msg)\n          })\n          .join('\\n')\n        if (deltaText) {\n          appendTaskOutput(taskId, deltaText + '\\n')\n        }\n      }\n\n      if (response.sessionStatus === 'archived') {\n        updateTaskState<RemoteAgentTaskState>(taskId, context.setAppState, t =>\n          t.status === 'running'\n            ? { ...t, status: 'completed', endTime: Date.now() }\n            : t,\n        )\n        enqueueRemoteNotification(\n          taskId,\n          task.title,\n          'completed',\n          context.setAppState,\n          task.toolUseId,\n        )\n        void evictTaskOutput(taskId)\n        void removeRemoteAgentMetadata(taskId)\n        return\n      }\n\n      const checker = completionCheckers.get(task.remoteTaskType)\n      if (checker) {\n        const completionResult = await checker(task.remoteTaskMetadata)\n        if (completionResult !== null) {\n          updateTaskState<RemoteAgentTaskState>(\n            taskId,\n            context.setAppState,\n            t =>\n              t.status === 'running'\n                ? { ...t, status: 'completed', endTime: Date.now() }\n                : t,\n          )\n          enqueueRemoteNotification(\n            taskId,\n            completionResult,\n            'completed',\n            context.setAppState,\n            task.toolUseId,\n          )\n          void evictTaskOutput(taskId)\n          void removeRemoteAgentMetadata(taskId)\n          return\n        }\n      }\n\n      // Ultraplan: result(success) fires after every CCR turn, so it must not\n      // drive completion — startDetachedPoll owns that via ExitPlanMode scan.\n      // Long-running monitors (autofix-pr) emit result per notification cycle,\n      // so the same skip applies.\n      const result =\n        task.isUltraplan || task.isLongRunning\n          ? undefined\n          : accumulatedLog.findLast(msg => msg.type === 'result')\n\n      // For remote-review: <remote-review> in hook_progress stdout is the\n      // bughunter path's completion signal. Scan only the delta to stay O(new);\n      // tag appears once at end of run so we won't miss it across ticks.\n      // For the failure signal, debounce idle: remote sessions briefly flip\n      // to 'idle' between every tool turn, so a single idle observation means\n      // nothing. Require STABLE_IDLE_POLLS consecutive idle polls with no log\n      // growth.\n      if (task.isRemoteReview && logGrew && cachedReviewContent === null) {\n        cachedReviewContent = extractReviewTagFromLog(response.newEvents)\n      }\n      // Parse live progress counts from the orchestrator's heartbeat echoes.\n      // hook_progress stdout is cumulative (every echo since hook start), so\n      // each event contains all progress tags. Grab the LAST occurrence —\n      // extractTag returns the first match which would always be the earliest\n      // value (0/0).\n      let newProgress: RemoteAgentTaskState['reviewProgress']\n      if (task.isRemoteReview && logGrew) {\n        const open = `<${REMOTE_REVIEW_PROGRESS_TAG}>`\n        const close = `</${REMOTE_REVIEW_PROGRESS_TAG}>`\n        for (const ev of response.newEvents) {\n          if (\n            ev.type === 'system' &&\n            (ev.subtype === 'hook_progress' || ev.subtype === 'hook_response')\n          ) {\n            const s = ev.stdout\n            const closeAt = s.lastIndexOf(close)\n            const openAt = closeAt === -1 ? -1 : s.lastIndexOf(open, closeAt)\n            if (openAt !== -1 && closeAt > openAt) {\n              try {\n                const p = JSON.parse(\n                  s.slice(openAt + open.length, closeAt),\n                ) as {\n                  stage?: 'finding' | 'verifying' | 'synthesizing'\n                  bugs_found?: number\n                  bugs_verified?: number\n                  bugs_refuted?: number\n                }\n                newProgress = {\n                  stage: p.stage,\n                  bugsFound: p.bugs_found ?? 0,\n                  bugsVerified: p.bugs_verified ?? 0,\n                  bugsRefuted: p.bugs_refuted ?? 0,\n                }\n              } catch {\n                // ignore malformed progress\n              }\n            }\n          }\n        }\n      }\n      // Hook events count as output only for remote-review — bughunter's\n      // SessionStart hook produces zero assistant turns so stableIdle would\n      // never arm without this.\n      const hasAnyOutput = accumulatedLog.some(\n        msg =>\n          msg.type === 'assistant' ||\n          (task.isRemoteReview &&\n            msg.type === 'system' &&\n            (msg.subtype === 'hook_progress' ||\n              msg.subtype === 'hook_response')),\n      )\n      if (response.sessionStatus === 'idle' && !logGrew && hasAnyOutput) {\n        consecutiveIdlePolls++\n      } else {\n        consecutiveIdlePolls = 0\n      }\n      const stableIdle = consecutiveIdlePolls >= STABLE_IDLE_POLLS\n      // stableIdle is a prompt-mode completion signal (Claude stops writing\n      // → session idles → done). In bughunter mode the session is \"idle\" the\n      // entire time the SessionStart hook runs; the previous guard checked\n      // hasAssistantEvents as a prompt-mode proxy, but post_stage() now\n      // writes assistant events in bughunter mode too, so that check\n      // misfires between heartbeats. Presence of a SessionStart hook event\n      // is the discriminator — bughunter mode always has one (run_hunt.sh),\n      // prompt mode never does — and it arrives before the kickoff\n      // post_stage so there's no race. When the hook is running, only the\n      // <remote-review> tag or the 30min timeout complete the task.\n      // Filtering on hook_event avoids a (theoretical) non-SessionStart hook\n      // in prompt mode from blocking stableIdle — the code_review container\n      // only registers SessionStart, but the 30min-hang failure mode is\n      // worth defending against.\n      const hasSessionStartHook = accumulatedLog.some(\n        m =>\n          m.type === 'system' &&\n          (m.subtype === 'hook_started' ||\n            m.subtype === 'hook_progress' ||\n            m.subtype === 'hook_response') &&\n          (m as { hook_event?: string }).hook_event === 'SessionStart',\n      )\n      const hasAssistantEvents = accumulatedLog.some(\n        m => m.type === 'assistant',\n      )\n      const sessionDone =\n        task.isRemoteReview &&\n        (cachedReviewContent !== null ||\n          (!hasSessionStartHook && stableIdle && hasAssistantEvents))\n      const reviewTimedOut =\n        task.isRemoteReview &&\n        Date.now() - task.pollStartedAt > REMOTE_REVIEW_TIMEOUT_MS\n      const newStatus = result\n        ? result.subtype === 'success'\n          ? ('completed' as const)\n          : ('failed' as const)\n        : sessionDone || reviewTimedOut\n          ? ('completed' as const)\n          : accumulatedLog.length > 0\n            ? ('running' as const)\n            : ('starting' as const)\n\n      // Update task state. Guard against terminal states — if stopTask raced\n      // while pollRemoteSessionEvents was in-flight (status set to 'killed',\n      // notified set to true), bail without overwriting status or proceeding to\n      // side effects (notification, permission-mode flip).\n      let raceTerminated = false\n      updateTaskState<RemoteAgentTaskState>(\n        taskId,\n        context.setAppState,\n        prevTask => {\n          if (prevTask.status !== 'running') {\n            raceTerminated = true\n            return prevTask\n          }\n          // No log growth and status unchanged → nothing to report. Return\n          // same ref so updateTaskState skips the spread and 18 s.tasks\n          // subscribers (REPL, Spinner, PromptInput, ...) don't re-render.\n          // newProgress only arrives via log growth (heartbeat echo is a\n          // hook_progress event), so !logGrew already covers no-update.\n          const statusUnchanged =\n            newStatus === 'running' || newStatus === 'starting'\n          if (!logGrew && statusUnchanged) {\n            return prevTask\n          }\n          return {\n            ...prevTask,\n            status: newStatus === 'starting' ? 'running' : newStatus,\n            log: accumulatedLog,\n            // Only re-scan for TodoWrite when log grew — log is append-only,\n            // so no growth means no new tool_use blocks. Avoids findLast +\n            // some + find + safeParse every second when idle.\n            todoList: logGrew\n              ? extractTodoListFromLog(accumulatedLog)\n              : prevTask.todoList,\n            reviewProgress: newProgress ?? prevTask.reviewProgress,\n            endTime:\n              result || sessionDone || reviewTimedOut ? Date.now() : undefined,\n          }\n        },\n      )\n      if (raceTerminated) return\n\n      // Send notification if task completed or timed out\n      if (result || sessionDone || reviewTimedOut) {\n        const finalStatus =\n          result && result.subtype !== 'success' ? 'failed' : 'completed'\n\n        // For remote-review tasks: inject the review text directly into the\n        // message queue. No mode change, no file indirection — the local model\n        // just sees the review appear as a task-notification on its next turn.\n        // Session kept alive — run_hunt.sh's post_stage() has already written\n        // the formatted findings as an assistant event, so the claude.ai URL\n        // stays a durable record the user can revisit. TTL handles cleanup.\n        if (task.isRemoteReview) {\n          // cachedReviewContent hit the tag in the delta scan. Full-log scan\n          // catches the stableIdle path where the tag arrived in an earlier\n          // tick but the delta scan wasn't wired yet (first poll after resume).\n          const reviewContent =\n            cachedReviewContent ?? extractReviewFromLog(accumulatedLog)\n          if (reviewContent && finalStatus === 'completed') {\n            enqueueRemoteReviewNotification(\n              taskId,\n              reviewContent,\n              context.setAppState,\n            )\n            void evictTaskOutput(taskId)\n            void removeRemoteAgentMetadata(taskId)\n            return // Stop polling\n          }\n\n          // No output or remote error — mark failed with a review-specific message.\n          updateTaskState(taskId, context.setAppState, t => ({\n            ...t,\n            status: 'failed',\n          }))\n          const reason =\n            result && result.subtype !== 'success'\n              ? 'remote session returned an error'\n              : reviewTimedOut && !sessionDone\n                ? 'remote session exceeded 30 minutes'\n                : 'no review output — orchestrator may have exited early'\n          enqueueRemoteReviewFailureNotification(\n            taskId,\n            reason,\n            context.setAppState,\n          )\n          void evictTaskOutput(taskId)\n          void removeRemoteAgentMetadata(taskId)\n          return // Stop polling\n        }\n\n        enqueueRemoteNotification(\n          taskId,\n          task.title,\n          finalStatus,\n          context.setAppState,\n          task.toolUseId,\n        )\n        void evictTaskOutput(taskId)\n        void removeRemoteAgentMetadata(taskId)\n        return // Stop polling\n      }\n    } catch (error) {\n      logError(error)\n      // Reset so an API error doesn't let non-consecutive idle polls accumulate.\n      consecutiveIdlePolls = 0\n\n      // Check review timeout even when the API call fails — without this,\n      // persistent API errors skip the timeout check and poll forever.\n      try {\n        const appState = context.getAppState()\n        const task = appState.tasks?.[taskId] as\n          | RemoteAgentTaskState\n          | undefined\n        if (\n          task?.isRemoteReview &&\n          task.status === 'running' &&\n          Date.now() - task.pollStartedAt > REMOTE_REVIEW_TIMEOUT_MS\n        ) {\n          updateTaskState(taskId, context.setAppState, t => ({\n            ...t,\n            status: 'failed',\n            endTime: Date.now(),\n          }))\n          enqueueRemoteReviewFailureNotification(\n            taskId,\n            'remote session exceeded 30 minutes',\n            context.setAppState,\n          )\n          void evictTaskOutput(taskId)\n          void removeRemoteAgentMetadata(taskId)\n          return // Stop polling\n        }\n      } catch {\n        // Best effort — if getAppState fails, continue polling\n      }\n    }\n\n    // Continue polling\n    if (isRunning) {\n      setTimeout(poll, POLL_INTERVAL_MS)\n    }\n  }\n\n  // Start polling\n  void poll()\n\n  // Return cleanup function\n  return () => {\n    isRunning = false\n  }\n}\n\n/**\n * RemoteAgentTask - Handles remote Claude.ai session execution.\n *\n * Replaces the BackgroundRemoteSession implementation from:\n * - src/utils/background/remote/remoteSession.ts\n * - src/components/tasks/BackgroundTaskStatus.tsx (polling logic)\n */\nexport const RemoteAgentTask: Task = {\n  name: 'RemoteAgentTask',\n  type: 'remote_agent',\n  async kill(taskId, setAppState) {\n    let toolUseId: string | undefined\n    let description: string | undefined\n    let sessionId: string | undefined\n    let killed = false\n    updateTaskState<RemoteAgentTaskState>(taskId, setAppState, task => {\n      if (task.status !== 'running') {\n        return task\n      }\n      toolUseId = task.toolUseId\n      description = task.description\n      sessionId = task.sessionId\n      killed = true\n      return {\n        ...task,\n        status: 'killed',\n        notified: true,\n        endTime: Date.now(),\n      }\n    })\n\n    // Close the task_started bookend for SDK consumers. The poll loop's\n    // early-return when status!=='running' won't emit a notification.\n    if (killed) {\n      emitTaskTerminatedSdk(taskId, 'stopped', {\n        toolUseId,\n        summary: description,\n      })\n      // Archive the remote session so it stops consuming cloud resources.\n      if (sessionId) {\n        void archiveRemoteSession(sessionId).catch(e =>\n          logForDebugging(`RemoteAgentTask archive failed: ${String(e)}`),\n        )\n      }\n    }\n\n    void evictTaskOutput(taskId)\n    void removeRemoteAgentMetadata(taskId)\n    logForDebugging(\n      `RemoteAgentTask ${taskId} killed, archiving session ${sessionId ?? 'unknown'}`,\n    )\n  },\n}\n\n/**\n * Get the session URL for a remote task.\n */\nexport function getRemoteTaskSessionUrl(sessionId: string): string {\n  return getRemoteSessionUrl(sessionId, process.env.SESSION_INGRESS_URL)\n}\n"],"mappings":"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","ignoreList":[]}