src/tasks/RemoteAgentTask/RemoteAgentTask.tsx

import type { ToolUseBlock } from '@anthropic-ai/sdk/resources';
import { getRemoteSessionUrl } from '../../constants/product.js';
import { 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';
import type { SDKAssistantMessage, SDKMessage } from '../../entrypoints/agentSdkTypes.js';
import type { SetAppState, Task, TaskContext, TaskStateBase } from '../../Task.js';
import { createTaskStateBase, generateTaskId } from '../../Task.js';
import { TodoWriteTool } from '../../tools/TodoWriteTool/TodoWriteTool.js';
import { type BackgroundRemoteSessionPrecondition, checkBackgroundRemoteSessionEligibility } from '../../utils/background/remote/remoteSession.js';
import { logForDebugging } from '../../utils/debug.js';
import { logError } from '../../utils/log.js';
import { enqueuePendingNotification } from '../../utils/messageQueueManager.js';
import { extractTag, extractTextContent } from '../../utils/messages.js';
import { emitTaskTerminatedSdk } from '../../utils/sdkEventQueue.js';
import { deleteRemoteAgentMetadata, listRemoteAgentMetadata, type RemoteAgentMetadata, writeRemoteAgentMetadata } from '../../utils/sessionStorage.js';
import { jsonStringify } from '../../utils/slowOperations.js';
import { appendTaskOutput, evictTaskOutput, getTaskOutputPath, initTaskOutput } from '../../utils/task/diskOutput.js';
import { registerTask, updateTaskState } from '../../utils/task/framework.js';
import { fetchSession } from '../../utils/teleport/api.js';
import { archiveRemoteSession, pollRemoteSessionEvents } from '../../utils/teleport.js';
import type { TodoList } from '../../utils/todo/types.js';
import type { UltraplanPhase } from '../../utils/ultraplan/ccrSession.js';
export type RemoteAgentTaskState = TaskStateBase & {
  type: 'remote_agent';
  remoteTaskType: RemoteTaskType;
  /** Task-specific metadata (PR number, repo, etc.). */
  remoteTaskMetadata?: RemoteTaskMetadata;
  sessionId: string; // Original session ID for API calls
  command: string;
  title: string;
  todoList: TodoList;
  log: SDKMessage[];
  /**
   * Long-running agent that will not be marked as complete after the first `result`.
   */
  isLongRunning?: boolean;
  /**
   * When the local poller started watching this task (at spawn or on restore).
   * Review timeout clocks from here so a restore doesn't immediately time out
   * a task spawned >30min ago.
   */
  pollStartedAt: number;
  /** True when this task was created by a teleported /ultrareview command. */
  isRemoteReview?: boolean;
  /** Parsed from the orchestrator's <remote-review-progress> heartbeat echoes. */
  reviewProgress?: {
    stage?: 'finding' | 'verifying' | 'synthesizing';
    bugsFound: number;
    bugsVerified: number;
    bugsRefuted: number;
  };
  isUltraplan?: boolean;
  /**
   * Scanner-derived pill state. Undefined = running. `needs_input` when the
   * remote asked a clarifying question and is idle; `plan_ready` when
   * ExitPlanMode is awaiting browser approval. Surfaced in the pill badge
   * and detail dialog status line.
   */
  ultraplanPhase?: Exclude<UltraplanPhase, 'running'>;
};
const REMOTE_TASK_TYPES = ['remote-agent', 'ultraplan', 'ultrareview', 'autofix-pr', 'background-pr'] as const;
export type RemoteTaskType = (typeof REMOTE_TASK_TYPES)[number];
function isRemoteTaskType(v: string | undefined): v is RemoteTaskType {
  return (REMOTE_TASK_TYPES as readonly string[]).includes(v ?? '');
}
export type AutofixPrRemoteTaskMetadata = {
  owner: string;
  repo: string;
  prNumber: number;
};
export type RemoteTaskMetadata = AutofixPrRemoteTaskMetadata;

/**
 * Called on every poll tick for tasks with a matching remoteTaskType. Return a
 * non-null string to complete the task (string becomes the notification text),
 * or null to keep polling. Checkers that hit external APIs should self-throttle.
 */
export type RemoteTaskCompletionChecker = (remoteTaskMetadata: RemoteTaskMetadata | undefined) => Promise<string | null>;
const completionCheckers = new Map<RemoteTaskType, RemoteTaskCompletionChecker>();

/**
 * Register a completion checker for a remote task type. Invoked on every poll
 * tick; survives --resume via the sidecar's remoteTaskType + remoteTaskMetadata.
 */
export function registerCompletionChecker(remoteTaskType: RemoteTaskType, checker: RemoteTaskCompletionChecker): void {
  completionCheckers.set(remoteTaskType, checker);
}

/**
 * Persist a remote-agent metadata entry to the session sidecar.
 * Fire-and-forget — persistence failures must not block task registration.
 */
async function persistRemoteAgentMetadata(meta: RemoteAgentMetadata): Promise<void> {
  try {
    await writeRemoteAgentMetadata(meta.taskId, meta);
  } catch (e) {
    logForDebugging(`persistRemoteAgentMetadata failed: ${String(e)}`);
  }
}

/**
 * Remove a remote-agent metadata entry from the session sidecar.
 * Called on task completion/kill so restored sessions don't resurrect
 * tasks that already finished.
 */
async function removeRemoteAgentMetadata(taskId: string): Promise<void> {
  try {
    await deleteRemoteAgentMetadata(taskId);
  } catch (e) {
    logForDebugging(`removeRemoteAgentMetadata failed: ${String(e)}`);
  }
}

// Precondition error result
export type RemoteAgentPreconditionResult = {
  eligible: true;
} | {
  eligible: false;
  errors: BackgroundRemoteSessionPrecondition[];
};

/**
 * Check eligibility for creating a remote agent session.
 */
export async function checkRemoteAgentEligibility({
  skipBundle = false
}: {
  skipBundle?: boolean;
} = {}): Promise<RemoteAgentPreconditionResult> {
  const errors = await checkBackgroundRemoteSessionEligibility({
    skipBundle
  });
  if (errors.length > 0) {
    return {
      eligible: false,
      errors
    };
  }
  return {
    eligible: true
  };
}

/**
 * Format precondition error for display.
 */
export function formatPreconditionError(error: BackgroundRemoteSessionPrecondition): string {
  switch (error.type) {
    case 'not_logged_in':
      return 'Please run /login and sign in with your Claude.ai account (not Console).';
    case 'no_remote_environment':
      return 'No cloud environment available. Set one up at https://claude.ai/code/onboarding?magic=env-setup';
    case 'not_in_git_repo':
      return 'Background tasks require a git repository. Initialize git or run from a git repository.';
    case 'no_git_remote':
      return 'Background tasks require a GitHub remote. Add one with `git remote add origin REPO_URL`.';
    case 'github_app_not_installed':
      return 'The Claude GitHub app must be installed on this repository first.\nhttps://github.com/apps/claude/installations/new';
    case 'policy_blocked':
      return "Remote sessions are disabled by your organization's policy. Contact your organization admin to enable them.";
  }
}

/**
 * Enqueue a remote task notification to the message queue.
 */
function enqueueRemoteNotification(taskId: string, title: string, status: 'completed' | 'failed' | 'killed', setAppState: SetAppState, toolUseId?: string): void {
  // Atomically check and set notified flag to prevent duplicate notifications.
  if (!markTaskNotified(taskId, setAppState)) return;
  const statusText = status === 'completed' ? 'completed successfully' : status === 'failed' ? 'failed' : 'was stopped';
  const toolUseIdLine = toolUseId ? `\n<${TOOL_USE_ID_TAG}>${toolUseId}</${TOOL_USE_ID_TAG}>` : '';
  const outputPath = getTaskOutputPath(taskId);
  const message = `<${TASK_NOTIFICATION_TAG}>
<${TASK_ID_TAG}>${taskId}</${TASK_ID_TAG}>${toolUseIdLine}
<${TASK_TYPE_TAG}>remote_agent</${TASK_TYPE_TAG}>
<${OUTPUT_FILE_TAG}>${outputPath}</${OUTPUT_FILE_TAG}>
<${STATUS_TAG}>${status}</${STATUS_TAG}>
<${SUMMARY_TAG}>Remote task "${title}" ${statusText}</${SUMMARY_TAG}>
</${TASK_NOTIFICATION_TAG}>`;
  enqueuePendingNotification({
    value: message,
    mode: 'task-notification'
  });
}

/**
 * Atomically mark a task as notified. Returns true if this call flipped the
 * flag (caller should enqueue), false if already notified (caller should skip).
 */
function markTaskNotified(taskId: string, setAppState: SetAppState): boolean {
  let shouldEnqueue = false;
  updateTaskState(taskId, setAppState, task => {
    if (task.notified) {
      return task;
    }
    shouldEnqueue = true;
    return {
      ...task,
      notified: true
    };
  });
  return shouldEnqueue;
}

/**
 * Extract the plan content from the remote session log.
 * Searches all assistant messages for <ultraplan>...</ultraplan> tags.
 */
export function extractPlanFromLog(log: SDKMessage[]): string | null {
  // Walk backwards through assistant messages to find <ultraplan> content
  for (let i = log.length - 1; i >= 0; i--) {
    const msg = log[i];
    if (msg?.type !== 'assistant') continue;
    const fullText = extractTextContent(msg.message.content, '\n');
    const plan = extractTag(fullText, ULTRAPLAN_TAG);
    if (plan?.trim()) return plan.trim();
  }
  return null;
}

/**
 * Enqueue an ultraplan-specific failure notification. Unlike enqueueRemoteNotification
 * this does NOT instruct the model to read the raw output file (a JSONL dump that is
 * useless for plan extraction).
 */
export function enqueueUltraplanFailureNotification(taskId: string, sessionId: string, reason: string, setAppState: SetAppState): void {
  if (!markTaskNotified(taskId, setAppState)) return;
  const sessionUrl = getRemoteTaskSessionUrl(sessionId);
  const message = `<${TASK_NOTIFICATION_TAG}>
<${TASK_ID_TAG}>${taskId}</${TASK_ID_TAG}>
<${TASK_TYPE_TAG}>remote_agent</${TASK_TYPE_TAG}>
<${STATUS_TAG}>failed</${STATUS_TAG}>
<${SUMMARY_TAG}>Ultraplan failed: ${reason}</${SUMMARY_TAG}>
</${TASK_NOTIFICATION_TAG}>
The remote Ultraplan session did not produce a plan (${reason}). Inspect the session at ${sessionUrl} and tell the user to retry locally with plan mode.`;
  enqueuePendingNotification({
    value: message,
    mode: 'task-notification'
  });
}

/**
 * Extract review content from the remote session log.
 *
 * Two producers, two event shapes:
 * - bughunter mode: run_hunt.sh is a SessionStart hook; its echo lands as
 *   {type:'system', subtype:'hook_progress', stdout:'...'}. Claude never
 *   takes a turn so there are zero assistant messages.
 * - prompt mode: a real assistant turn wraps the review in the tag.
 *
 * Scans hook_progress first since bughunter is the intended production path
 * and prompt mode is the dev/fallback. Newest-first in both cases — the tag
 * appears once at the end of the run so reverse iteration short-circuits.
 */
function extractReviewFromLog(log: SDKMessage[]): string | null {
  for (let i = log.length - 1; i >= 0; i--) {
    const msg = log[i];
    // The final echo before hook exit may land in either the last
    // hook_progress or the terminal hook_response depending on buffering;
    // both have flat stdout.
    if (msg?.type === 'system' && (msg.subtype === 'hook_progress' || msg.subtype === 'hook_response')) {
      const tagged = extractTag(msg.stdout, REMOTE_REVIEW_TAG);
      if (tagged?.trim()) return tagged.trim();
    }
  }
  for (let i = log.length - 1; i >= 0; i--) {
    const msg = log[i];
    if (msg?.type !== 'assistant') continue;
    const fullText = extractTextContent(msg.message.content, '\n');
    const tagged = extractTag(fullText, REMOTE_REVIEW_TAG);
    if (tagged?.trim()) return tagged.trim();
  }

  // Hook-stdout concat fallback: a single echo should land in one event, but
  // large JSON payloads can flush across two if the pipe buffer fills
  // mid-write. Per-message scan above misses a tag split across events.
  const hookStdout = log.filter(msg => msg.type === 'system' && (msg.subtype === 'hook_progress' || msg.subtype === 'hook_response')).map(msg => msg.stdout).join('');
  const hookTagged = extractTag(hookStdout, REMOTE_REVIEW_TAG);
  if (hookTagged?.trim()) return hookTagged.trim();

  // Fallback: concatenate all assistant text in chronological order.
  const allText = log.filter((msg): msg is SDKAssistantMessage => msg.type === 'assistant').map(msg => extractTextContent(msg.message.content, '\n')).join('\n').trim();
  return allText || null;
}

/**
 * Tag-only variant of extractReviewFromLog for delta scanning.
 *
 * Returns non-null ONLY when an explicit <remote-review> tag is found.
 * Unlike extractReviewFromLog, this does NOT fall back to concatenated
 * assistant text. This is critical for the delta scan: in prompt mode,
 * early untagged assistant messages (e.g. "I'm analyzing the diff...")
 * would trigger the fallback and prematurely set cachedReviewContent,
 * completing the review before the actual tagged output arrives.
 */
function extractReviewTagFromLog(log: SDKMessage[]): string | null {
  // hook_progress / hook_response per-message scan (bughunter path)
  for (let i = log.length - 1; i >= 0; i--) {
    const msg = log[i];
    if (msg?.type === 'system' && (msg.subtype === 'hook_progress' || msg.subtype === 'hook_response')) {
      const tagged = extractTag(msg.stdout, REMOTE_REVIEW_TAG);
      if (tagged?.trim()) return tagged.trim();
    }
  }

  // assistant text per-message scan (prompt mode)
  for (let i = log.length - 1; i >= 0; i--) {
    const msg = log[i];
    if (msg?.type !== 'assistant') continue;
    const fullText = extractTextContent(msg.message.content, '\n');
    const tagged = extractTag(fullText, REMOTE_REVIEW_TAG);
    if (tagged?.trim()) return tagged.trim();
  }

  // Hook-stdout concat fallback for split tags
  const hookStdout = log.filter(msg => msg.type === 'system' && (msg.subtype === 'hook_progress' || msg.subtype === 'hook_response')).map(msg => msg.stdout).join('');
  const hookTagged = extractTag(hookStdout, REMOTE_REVIEW_TAG);
  if (hookTagged?.trim()) return hookTagged.trim();
  return null;
}

/**
 * Enqueue a remote-review completion notification. Injects the review text
 * directly into the message queue so the local model receives it on the next
 * turn — no file indirection, no mode change. Session is kept alive so the
 * claude.ai URL stays a durable record the user can revisit; TTL handles cleanup.
 */
function enqueueRemoteReviewNotification(taskId: string, reviewContent: string, setAppState: SetAppState): void {
  if (!markTaskNotified(taskId, setAppState)) return;
  const message = `<${TASK_NOTIFICATION_TAG}>
<${TASK_ID_TAG}>${taskId}</${TASK_ID_TAG}>
<${TASK_TYPE_TAG}>remote_agent</${TASK_TYPE_TAG}>
<${STATUS_TAG}>completed</${STATUS_TAG}>
<${SUMMARY_TAG}>Remote review completed</${SUMMARY_TAG}>
</${TASK_NOTIFICATION_TAG}>
The remote review produced the following findings:

${reviewContent}`;
  enqueuePendingNotification({
    value: message,
    mode: 'task-notification'
  });
}

/**
 * Enqueue a remote-review failure notification.
 */
function enqueueRemoteReviewFailureNotification(taskId: string, reason: string, setAppState: SetAppState): void {
  if (!markTaskNotified(taskId, setAppState)) return;
  const message = `<${TASK_NOTIFICATION_TAG}>
<${TASK_ID_TAG}>${taskId}</${TASK_ID_TAG}>
<${TASK_TYPE_TAG}>remote_agent</${TASK_TYPE_TAG}>
<${STATUS_TAG}>failed</${STATUS_TAG}>
<${SUMMARY_TAG}>Remote review failed: ${reason}</${SUMMARY_TAG}>
</${TASK_NOTIFICATION_TAG}>
Remote review did not produce output (${reason}). Tell the user to retry /ultrareview, or use /review for a local review instead.`;
  enqueuePendingNotification({
    value: message,
    mode: 'task-notification'
  });
}

/**
 * Extract todo list from SDK messages (finds last TodoWrite tool use).
 */
function extractTodoListFromLog(log: SDKMessage[]): TodoList {
  const todoListMessage = log.findLast((msg): msg is SDKAssistantMessage => msg.type === 'assistant' && msg.message.content.some(block => block.type === 'tool_use' && block.name === TodoWriteTool.name));
  if (!todoListMessage) {
    return [];
  }
  const input = todoListMessage.message.content.find((block): block is ToolUseBlock => block.type === 'tool_use' && block.name === TodoWriteTool.name)?.input;
  if (!input) {
    return [];
  }
  const parsedInput = TodoWriteTool.inputSchema.safeParse(input);
  if (!parsedInput.success) {
    return [];
  }
  return parsedInput.data.todos;
}

/**
 * Register a remote agent task in the unified task framework.
 * Bundles task ID generation, output init, state creation, registration, and polling.
 * Callers remain responsible for custom pre-registration logic (git dialogs, transcript upload, teleport options).
 */
export function registerRemoteAgentTask(options: {
  remoteTaskType: RemoteTaskType;
  session: {
    id: string;
    title: string;
  };
  command: string;
  context: TaskContext;
  toolUseId?: string;
  isRemoteReview?: boolean;
  isUltraplan?: boolean;
  isLongRunning?: boolean;
  remoteTaskMetadata?: RemoteTaskMetadata;
}): {
  taskId: string;
  sessionId: string;
  cleanup: () => void;
} {
  const {
    remoteTaskType,
    session,
    command,
    context,
    toolUseId,
    isRemoteReview,
    isUltraplan,
    isLongRunning,
    remoteTaskMetadata
  } = options;
  const taskId = generateTaskId('remote_agent');

  // Create the output file before registering the task.
  // RemoteAgentTask uses appendTaskOutput() (not TaskOutput), so
  // the file must exist for readers before any output arrives.
  void initTaskOutput(taskId);
  const taskState: RemoteAgentTaskState = {
    ...createTaskStateBase(taskId, 'remote_agent', session.title, toolUseId),
    type: 'remote_agent',
    remoteTaskType,
    status: 'running',
    sessionId: session.id,
    command,
    title: session.title,
    todoList: [],
    log: [],
    isRemoteReview,
    isUltraplan,
    isLongRunning,
    pollStartedAt: Date.now(),
    remoteTaskMetadata
  };
  registerTask(taskState, context.setAppState);

  // Persist identity to the session sidecar so --resume can reconnect to
  // still-running remote sessions. Status is not stored — it's fetched
  // fresh from CCR on restore.
  void persistRemoteAgentMetadata({
    taskId,
    remoteTaskType,
    sessionId: session.id,
    title: session.title,
    command,
    spawnedAt: Date.now(),
    toolUseId,
    isUltraplan,
    isRemoteReview,
    isLongRunning,
    remoteTaskMetadata
  });

  // Ultraplan lifecycle is owned by startDetachedPoll in ultraplan.tsx. Generic
  // polling still runs so session.log populates for the detail view's progress
  // counts; the result-lookup guard below prevents early completion.
  // TODO(#23985): fold ExitPlanModeScanner into this poller, drop startDetachedPoll.
  const stopPolling = startRemoteSessionPolling(taskId, context);
  return {
    taskId,
    sessionId: session.id,
    cleanup: stopPolling
  };
}

/**
 * Restore remote-agent tasks from the session sidecar on --resume.
 *
 * Scans remote-agents/, fetches live CCR status for each, reconstructs
 * RemoteAgentTaskState into AppState.tasks, and restarts polling for sessions
 * still running. Sessions that are archived or 404 have their sidecar file
 * removed. Must run after switchSession() so getSessionId() points at the
 * resumed session's sidecar directory.
 */
export async function restoreRemoteAgentTasks(context: TaskContext): Promise<void> {
  try {
    await restoreRemoteAgentTasksImpl(context);
  } catch (e) {
    logForDebugging(`restoreRemoteAgentTasks failed: ${String(e)}`);
  }
}
async function restoreRemoteAgentTasksImpl(context: TaskContext): Promise<void> {
  const persisted = await listRemoteAgentMetadata();
  if (persisted.length === 0) return;
  for (const meta of persisted) {
    let remoteStatus: string;
    try {
      const session = await fetchSession(meta.sessionId);
      remoteStatus = session.session_status;
    } catch (e) {
      // Only 404 means the CCR session is truly gone. Auth errors (401,
      // missing OAuth token) are recoverable via /login — the remote
      // session is still running. fetchSession throws plain Error for all
      // 4xx (validateStatus treats <500 as success), so isTransientNetworkError
      // can't distinguish them; match the 404 message instead.
      if (e instanceof Error && e.message.startsWith('Session not found:')) {
        logForDebugging(`restoreRemoteAgentTasks: dropping ${meta.taskId} (404: ${String(e)})`);
        void removeRemoteAgentMetadata(meta.taskId);
      } else {
        logForDebugging(`restoreRemoteAgentTasks: skipping ${meta.taskId} (recoverable: ${String(e)})`);
      }
      continue;
    }
    if (remoteStatus === 'archived') {
      // Session ended while the local client was offline. Don't resurrect.
      void removeRemoteAgentMetadata(meta.taskId);
      continue;
    }
    const taskState: RemoteAgentTaskState = {
      ...createTaskStateBase(meta.taskId, 'remote_agent', meta.title, meta.toolUseId),
      type: 'remote_agent',
      remoteTaskType: isRemoteTaskType(meta.remoteTaskType) ? meta.remoteTaskType : 'remote-agent',
      status: 'running',
      sessionId: meta.sessionId,
      command: meta.command,
      title: meta.title,
      todoList: [],
      log: [],
      isRemoteReview: meta.isRemoteReview,
      isUltraplan: meta.isUltraplan,
      isLongRunning: meta.isLongRunning,
      startTime: meta.spawnedAt,
      pollStartedAt: Date.now(),
      remoteTaskMetadata: meta.remoteTaskMetadata as RemoteTaskMetadata | undefined
    };
    registerTask(taskState, context.setAppState);
    void initTaskOutput(meta.taskId);
    startRemoteSessionPolling(meta.taskId, context);
  }
}

/**
 * Start polling for remote session updates.
 * Returns a cleanup function to stop polling.
 */
function startRemoteSessionPolling(taskId: string, context: TaskContext): () => void {
  let isRunning = true;
  const POLL_INTERVAL_MS = 1000;
  const REMOTE_REVIEW_TIMEOUT_MS = 30 * 60 * 1000;
  // Remote sessions flip to 'idle' between tool turns. With 100+ rapid
  // turns, a 1s poll WILL catch a transient idle mid-run. Require stable
  // idle (no log growth for N consecutive polls) before believing it.
  const STABLE_IDLE_POLLS = 5;
  let consecutiveIdlePolls = 0;
  let lastEventId: string | null = null;
  let accumulatedLog: SDKMessage[] = [];
  // Cached across ticks so we don't re-scan the full log. Tag appears once
  // at end of run; scanning only the delta (response.newEvents) is O(new).
  let cachedReviewContent: string | null = null;
  const poll = async (): Promise<void> => {
    if (!isRunning) return;
    try {
      const appState = context.getAppState();
      const task = appState.tasks?.[taskId] as RemoteAgentTaskState | undefined;
      if (!task || task.status !== 'running') {
        // Task was killed externally (TaskStopTool) or already terminal.
        // Session left alive so the claude.ai URL stays valid — the run_hunt.sh
        // post_stage() calls land as assistant events there, and the user may
        // want to revisit them after closing the terminal. TTL reaps it.
        return;
      }
      const response = await pollRemoteSessionEvents(task.sessionId, lastEventId);
      lastEventId = response.lastEventId;
      const logGrew = response.newEvents.length > 0;
      if (logGrew) {
        accumulatedLog = [...accumulatedLog, ...response.newEvents];
        const deltaText = response.newEvents.map(msg => {
          if (msg.type === 'assistant') {
            return msg.message.content.filter(block => block.type === 'text').map(block => 'text' in block ? block.text : '').join('\n');
          }
          return jsonStringify(msg);
        }).join('\n');
        if (deltaText) {
          appendTaskOutput(taskId, deltaText + '\n');
        }
      }
      if (response.sessionStatus === 'archived') {
        updateTaskState<RemoteAgentTaskState>(taskId, context.setAppState, t => t.status === 'running' ? {
          ...t,
          status: 'completed',
          endTime: Date.now()
        } : t);
        enqueueRemoteNotification(taskId, task.title, 'completed', context.setAppState, task.toolUseId);
        void evictTaskOutput(taskId);
        void removeRemoteAgentMetadata(taskId);
        return;
      }
      const checker = completionCheckers.get(task.remoteTaskType);
      if (checker) {
        const completionResult = await checker(task.remoteTaskMetadata);
        if (completionResult !== null) {
          updateTaskState<RemoteAgentTaskState>(taskId, context.setAppState, t => t.status === 'running' ? {
            ...t,
            status: 'completed',
            endTime: Date.now()
          } : t);
          enqueueRemoteNotification(taskId, completionResult, 'completed', context.setAppState, task.toolUseId);
          void evictTaskOutput(taskId);
          void removeRemoteAgentMetadata(taskId);
          return;
        }
      }

      // Ultraplan: result(success) fires after every CCR turn, so it must not
      // drive completion — startDetachedPoll owns that via ExitPlanMode scan.
      // Long-running monitors (autofix-pr) emit result per notification cycle,
      // so the same skip applies.
      const result = task.isUltraplan || task.isLongRunning ? undefined : accumulatedLog.findLast(msg => msg.type === 'result');

      // For remote-review: <remote-review> in hook_progress stdout is the
      // bughunter path's completion signal. Scan only the delta to stay O(new);
      // tag appears once at end of run so we won't miss it across ticks.
      // For the failure signal, debounce idle: remote sessions briefly flip
      // to 'idle' between every tool turn, so a single idle observation means
      // nothing. Require STABLE_IDLE_POLLS consecutive idle polls with no log
      // growth.
      if (task.isRemoteReview && logGrew && cachedReviewContent === null) {
        cachedReviewContent = extractReviewTagFromLog(response.newEvents);
      }
      // Parse live progress counts from the orchestrator's heartbeat echoes.
      // hook_progress stdout is cumulative (every echo since hook start), so
      // each event contains all progress tags. Grab the LAST occurrence —
      // extractTag returns the first match which would always be the earliest
      // value (0/0).
      let newProgress: RemoteAgentTaskState['reviewProgress'];
      if (task.isRemoteReview && logGrew) {
        const open = `<${REMOTE_REVIEW_PROGRESS_TAG}>`;
        const close = `</${REMOTE_REVIEW_PROGRESS_TAG}>`;
        for (const ev of response.newEvents) {
          if (ev.type === 'system' && (ev.subtype === 'hook_progress' || ev.subtype === 'hook_response')) {
            const s = ev.stdout;
            const closeAt = s.lastIndexOf(close);
            const openAt = closeAt === -1 ? -1 : s.lastIndexOf(open, closeAt);
            if (openAt !== -1 && closeAt > openAt) {
              try {
                const p = JSON.parse(s.slice(openAt + open.length, closeAt)) as {
                  stage?: 'finding' | 'verifying' | 'synthesizing';
                  bugs_found?: number;
                  bugs_verified?: number;
                  bugs_refuted?: number;
                };
                newProgress = {
                  stage: p.stage,
                  bugsFound: p.bugs_found ?? 0,
                  bugsVerified: p.bugs_verified ?? 0,
                  bugsRefuted: p.bugs_refuted ?? 0
                };
              } catch {
                // ignore malformed progress
              }
            }
          }
        }
      }
      // Hook events count as output only for remote-review — bughunter's
      // SessionStart hook produces zero assistant turns so stableIdle would
      // never arm without this.
      const hasAnyOutput = accumulatedLog.some(msg => msg.type === 'assistant' || task.isRemoteReview && msg.type === 'system' && (msg.subtype === 'hook_progress' || msg.subtype === 'hook_response'));
      if (response.sessionStatus === 'idle' && !logGrew && hasAnyOutput) {
        consecutiveIdlePolls++;
      } else {
        consecutiveIdlePolls = 0;
      }
      const stableIdle = consecutiveIdlePolls >= STABLE_IDLE_POLLS;
      // stableIdle is a prompt-mode completion signal (Claude stops writing
      // → session idles → done). In bughunter mode the session is "idle" the
      // entire time the SessionStart hook runs; the previous guard checked
      // hasAssistantEvents as a prompt-mode proxy, but post_stage() now
      // writes assistant events in bughunter mode too, so that check
      // misfires between heartbeats. Presence of a SessionStart hook event
      // is the discriminator — bughunter mode always has one (run_hunt.sh),
      // prompt mode never does — and it arrives before the kickoff
      // post_stage so there's no race. When the hook is running, only the
      // <remote-review> tag or the 30min timeout complete the task.
      // Filtering on hook_event avoids a (theoretical) non-SessionStart hook
      // in prompt mode from blocking stableIdle — the code_review container
      // only registers SessionStart, but the 30min-hang failure mode is
      // worth defending against.
      const hasSessionStartHook = accumulatedLog.some(m => m.type === 'system' && (m.subtype === 'hook_started' || m.subtype === 'hook_progress' || m.subtype === 'hook_response') && (m as {
        hook_event?: string;
      }).hook_event === 'SessionStart');
      const hasAssistantEvents = accumulatedLog.some(m => m.type === 'assistant');
      const sessionDone = task.isRemoteReview && (cachedReviewContent !== null || !hasSessionStartHook && stableIdle && hasAssistantEvents);
      const reviewTimedOut = task.isRemoteReview && Date.now() - task.pollStartedAt > REMOTE_REVIEW_TIMEOUT_MS;
      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;

      // Update task state. Guard against terminal states — if stopTask raced
      // while pollRemoteSessionEvents was in-flight (status set to 'killed',
      // notified set to true), bail without overwriting status or proceeding to
      // side effects (notification, permission-mode flip).
      let raceTerminated = false;
      updateTaskState<RemoteAgentTaskState>(taskId, context.setAppState, prevTask => {
        if (prevTask.status !== 'running') {
          raceTerminated = true;
          return prevTask;
        }
        // No log growth and status unchanged → nothing to report. Return
        // same ref so updateTaskState skips the spread and 18 s.tasks
        // subscribers (REPL, Spinner, PromptInput, ...) don't re-render.
        // newProgress only arrives via log growth (heartbeat echo is a
        // hook_progress event), so !logGrew already covers no-update.
        const statusUnchanged = newStatus === 'running' || newStatus === 'starting';
        if (!logGrew && statusUnchanged) {
          return prevTask;
        }
        return {
          ...prevTask,
          status: newStatus === 'starting' ? 'running' : newStatus,
          log: accumulatedLog,
          // Only re-scan for TodoWrite when log grew — log is append-only,
          // so no growth means no new tool_use blocks. Avoids findLast +
          // some + find + safeParse every second when idle.
          todoList: logGrew ? extractTodoListFromLog(accumulatedLog) : prevTask.todoList,
          reviewProgress: newProgress ?? prevTask.reviewProgress,
          endTime: result || sessionDone || reviewTimedOut ? Date.now() : undefined
        };
      });
      if (raceTerminated) return;

      // Send notification if task completed or timed out
      if (result || sessionDone || reviewTimedOut) {
        const finalStatus = result && result.subtype !== 'success' ? 'failed' : 'completed';

        // For remote-review tasks: inject the review text directly into the
        // message queue. No mode change, no file indirection — the local model
        // just sees the review appear as a task-notification on its next turn.
        // Session kept alive — run_hunt.sh's post_stage() has already written
        // the formatted findings as an assistant event, so the claude.ai URL
        // stays a durable record the user can revisit. TTL handles cleanup.
        if (task.isRemoteReview) {
          // cachedReviewContent hit the tag in the delta scan. Full-log scan
          // catches the stableIdle path where the tag arrived in an earlier
          // tick but the delta scan wasn't wired yet (first poll after resume).
          const reviewContent = cachedReviewContent ?? extractReviewFromLog(accumulatedLog);
          if (reviewContent && finalStatus === 'completed') {
            enqueueRemoteReviewNotification(taskId, reviewContent, context.setAppState);
            void evictTaskOutput(taskId);
            void removeRemoteAgentMetadata(taskId);
            return; // Stop polling
          }

          // No output or remote error — mark failed with a review-specific message.
          updateTaskState(taskId, context.setAppState, t => ({
            ...t,
            status: 'failed'
          }));
          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';
          enqueueRemoteReviewFailureNotification(taskId, reason, context.setAppState);
          void evictTaskOutput(taskId);
          void removeRemoteAgentMetadata(taskId);
          return; // Stop polling
        }
        enqueueRemoteNotification(taskId, task.title, finalStatus, context.setAppState, task.toolUseId);
        void evictTaskOutput(taskId);
        void removeRemoteAgentMetadata(taskId);
        return; // Stop polling
      }
    } catch (error) {
      logError(error);
      // Reset so an API error doesn't let non-consecutive idle polls accumulate.
      consecutiveIdlePolls = 0;

      // Check review timeout even when the API call fails — without this,
      // persistent API errors skip the timeout check and poll forever.
      try {
        const appState = context.getAppState();
        const task = appState.tasks?.[taskId] as RemoteAgentTaskState | undefined;
        if (task?.isRemoteReview && task.status === 'running' && Date.now() - task.pollStartedAt > REMOTE_REVIEW_TIMEOUT_MS) {
          updateTaskState(taskId, context.setAppState, t => ({
            ...t,
            status: 'failed',
            endTime: Date.now()
          }));
          enqueueRemoteReviewFailureNotification(taskId, 'remote session exceeded 30 minutes', context.setAppState);
          void evictTaskOutput(taskId);
          void removeRemoteAgentMetadata(taskId);
          return; // Stop polling
        }
      } catch {
        // Best effort — if getAppState fails, continue polling
      }
    }

    // Continue polling
    if (isRunning) {
      setTimeout(poll, POLL_INTERVAL_MS);
    }
  };

  // Start polling
  void poll();

  // Return cleanup function
  return () => {
    isRunning = false;
  };
}

/**
 * RemoteAgentTask - Handles remote Claude.ai session execution.
 *
 * Replaces the BackgroundRemoteSession implementation from:
 * - src/utils/background/remote/remoteSession.ts
 * - src/components/tasks/BackgroundTaskStatus.tsx (polling logic)
 */
export const RemoteAgentTask: Task = {
  name: 'RemoteAgentTask',
  type: 'remote_agent',
  async kill(taskId, setAppState) {
    let toolUseId: string | undefined;
    let description: string | undefined;
    let sessionId: string | undefined;
    let killed = false;
    updateTaskState<RemoteAgentTaskState>(taskId, setAppState, task => {
      if (task.status !== 'running') {
        return task;
      }
      toolUseId = task.toolUseId;
      description = task.description;
      sessionId = task.sessionId;
      killed = true;
      return {
        ...task,
        status: 'killed',
        notified: true,
        endTime: Date.now()
      };
    });

    // Close the task_started bookend for SDK consumers. The poll loop's
    // early-return when status!=='running' won't emit a notification.
    if (killed) {
      emitTaskTerminatedSdk(taskId, 'stopped', {
        toolUseId,
        summary: description
      });
      // Archive the remote session so it stops consuming cloud resources.
      if (sessionId) {
        void archiveRemoteSession(sessionId).catch(e => logForDebugging(`RemoteAgentTask archive failed: ${String(e)}`));
      }
    }
    void evictTaskOutput(taskId);
    void removeRemoteAgentMetadata(taskId);
    logForDebugging(`RemoteAgentTask ${taskId} killed, archiving session ${sessionId ?? 'unknown'}`);
  }
};

/**
 * Get the session URL for a remote task.
 */
export function getRemoteTaskSessionUrl(sessionId: string): string {
  return getRemoteSessionUrl(sessionId, process.env.SESSION_INGRESS_URL);
}
//# 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":[]}