import path from 'node:path';
import process from 'node:process';
import { spawn } from 'node:child_process';
import { closeSync, mkdirSync, openSync, readFileSync } from 'node:fs';
import { fileURLToPath } from 'node:url';

import { Cli, z } from 'incur';

import {
  DEFAULT_BROWSER_ENDPOINT,
  downloadThreadAttachment,
  exportThreadSnapshot,
  isCaptureIdentityDigest,
  parseThreadCaptureIdentity,
  type ThreadCaptureIdentity,
} from './chatgpt-thread-lib.mjs';
import { collectThreadDiagnostics } from './chatgpt-thread-diagnostics-lib.mjs';
import { formatCodexHomeForDisplay, formatPathForDisplay } from './codex-session-lib.mjs';
import { chatIdFromUrl, parseWakeDelayToMs, runWakeFlow, type WakeRecursiveInfo } from './chatgpt-thread-wake-lib.mjs';

const cliEntryPath = fileURLToPath(new URL('./bin.mjs', import.meta.url));

function normalizeConversationUrl(chatUrl: string): string {
  try {
    const parsed = new URL(chatUrl);
    const match = parsed.pathname.match(/^\/c\/([^/?#]+)\/?$/u);
    const chatId = match?.[1];
    if (!chatId) {
      throw new Error('missing-chat-id');
    }
    return `${parsed.origin}/c/${chatId}`;
  } catch {
    throw new Error(
      `Expected a full ChatGPT conversation URL like https://chatgpt.com/c/<thread-id>; received ${chatUrl}`,
    );
  }
}

function defaultWakeOutputDir(chatUrl: string): string {
  const chatId = chatIdFromUrl(chatUrl);
  const timestamp = new Date().toISOString().replaceAll(':', '').replace(/\.\d{3}Z$/u, 'Z');
  return path.join(process.cwd(), 'output-packages', 'chatgpt-watch', `${chatId}-${timestamp}`);
}

type DetachedWakeCliOptions = {
  browserEndpoint: string;
  captureMetadata?: string;
  chatUrl: string;
  codexHome?: string;
  delay: string;
  detach: boolean;
  downloadTimeoutMs: number;
  fullAuto: boolean;
  outputDir: string;
  pollInterval: string;
  pollJitter: string;
  pollTimeout?: string;
  pollUntilComplete: boolean;
  recursiveDepth: number;
  recursivePrompt?: string;
  repoDir: string;
  resumePrompt?: string;
  sessionId?: string;
  skipResume: boolean;
  tabLifecycle: 'keep' | 'close-created' | 'close-harvested';
};

export function buildDetachedWakeCommandArgs(options: DetachedWakeCliOptions): string[] {
  const args = [
    cliEntryPath,
    'thread',
    'wake',
    '--browser-endpoint',
    options.browserEndpoint,
    '--chat-url',
    options.chatUrl,
    '--delay',
    options.delay,
    '--download-timeout-ms',
    String(options.downloadTimeoutMs),
    '--output-dir',
    options.outputDir,
    '--poll-interval',
    options.pollInterval,
    '--poll-jitter',
    options.pollJitter,
    '--recursive-depth',
    String(options.recursiveDepth),
    '--repo-dir',
    options.repoDir,
    '--tab-lifecycle',
    options.tabLifecycle,
  ];

  if (options.codexHome) {
    args.push('--codex-home', options.codexHome);
  }
  if (options.captureMetadata) {
    args.push('--capture-metadata', options.captureMetadata);
  }
  if (options.fullAuto) {
    args.push('--full-auto');
  }
  if (options.pollTimeout) {
    args.push('--poll-timeout', options.pollTimeout);
  }
  if (options.pollUntilComplete === false) {
    args.push('--no-poll-until-complete');
  }
  if (options.recursivePrompt) {
    args.push('--recursive-prompt', options.recursivePrompt);
  }
  if (options.resumePrompt) {
    args.push('--resume-prompt', options.resumePrompt);
  }
  if (options.sessionId) {
    args.push('--session-id', options.sessionId);
  }
  if (options.skipResume) {
    args.push('--skip-resume');
  }

  return args;
}

export function launchDetachedWakeProcess(input: {
  args: string[];
  cwd: string;
  env?: NodeJS.ProcessEnv;
  logPath: string;
}): { wakePid: number } {
  mkdirSync(path.dirname(input.logPath), { recursive: true });
  const logFd = openSync(input.logPath, 'a');
  try {
    const child = spawn(process.execPath, input.args, {
      cwd: input.cwd,
      env: input.env ?? process.env,
      detached: true,
      stdio: ['ignore', logFd, logFd],
    });
    child.unref();
    if (!child.pid) {
      throw new Error('Detached wake launch did not return a process id.');
    }
    return { wakePid: child.pid };
  } finally {
    closeSync(logFd);
  }
}

function formatWakeRecursiveInfoForDisplay(recursive: WakeRecursiveInfo | undefined, repoDir: string) {
  if (!recursive) {
    return undefined;
  }
  return {
    descendantOutputDir: formatPathForDisplay(recursive.descendantOutputDir, repoDir),
    descendantStatusPath: formatPathForDisplay(recursive.descendantStatusPath, repoDir),
    descendantWakeLaunchPath: formatPathForDisplay(recursive.descendantWakeLaunchPath, repoDir),
    descendantWakeLogPath: formatPathForDisplay(recursive.descendantWakeLogPath, repoDir),
    followupReceiptPath: formatPathForDisplay(recursive.followupReceiptPath, repoDir),
    followupScriptPath: formatPathForDisplay(recursive.followupScriptPath, repoDir),
    nextDepth: recursive.nextDepth,
    reviewDiagnosticsLaunchPath: formatPathForDisplay(recursive.reviewDiagnosticsLaunchPath, repoDir),
    reviewDiagnosticsLogPath: formatPathForDisplay(recursive.reviewDiagnosticsLogPath, repoDir),
    reviewDiagnosticsOutputDir: formatPathForDisplay(recursive.reviewDiagnosticsOutputDir, repoDir),
    reviewDiagnosticsStatusPath: formatPathForDisplay(recursive.reviewDiagnosticsStatusPath, repoDir),
    requestedDepth: recursive.requestedDepth,
    reviewSendLogPath: formatPathForDisplay(recursive.reviewSendLogPath, repoDir),
    reviewTimeoutMs: recursive.reviewTimeoutMs,
  };
}

function loadCaptureMetadata(filePath: string | undefined): ThreadCaptureIdentity | undefined {
  if (!filePath) return undefined;
  const resolvedPath = path.resolve(filePath);
  const filename = path.basename(resolvedPath);
  if (filename === '.env' || filename.startsWith('.env.')) {
    throw new Error('Capture metadata must not be loaded from an environment file.');
  }
  try {
    return parseThreadCaptureIdentity(JSON.parse(readFileSync(resolvedPath, 'utf8')));
  } catch (error) {
    const message = error instanceof Error ? error.message : String(error);
    throw new Error(`Could not load exact ReviewGPT capture metadata: ${message}`);
  }
}

export function createThreadCli() {
  const cli = Cli.create('thread', {
    description: 'Export ChatGPT threads, download patch, diff, or zip attachments, and launch delayed Codex follow-up work.',
  });

  cli.command('export', {
    description: 'Export the visible contents of an authenticated ChatGPT thread from the managed browser.',
    options: z.object({
      browserEndpoint: z.string().default(DEFAULT_BROWSER_ENDPOINT).describe('Remote debugging endpoint for the managed browser.'),
      captureMetadata: z.string().optional().describe('Exact capture metadata emitted by a waited send; fail closed unless the same target, response, and artifacts are present.'),
      chatUrl: z.string().describe('Full ChatGPT conversation URL (/c/<thread-id>) to export.'),
      output: z.string().describe('Output JSON file path.'),
    }),
    examples: [
      {
        description: 'Export a ChatGPT thread snapshot',
        options: {
          chatUrl: 'https://chatgpt.com/c/69c71d43-0e38-8330-9df8-c4e10f5bf536',
          output: 'output-packages/thread.json',
        },
      },
    ],
    output: z.object({
      exportPath: z.string().describe('Thread export JSON path.'),
    }),
    async run(c) {
      const chatUrl = normalizeConversationUrl(c.options.chatUrl);
      const outputPath = path.resolve(c.options.output);
      const captureIdentity = loadCaptureMetadata(c.options.captureMetadata);
      await exportThreadSnapshot(c.options.browserEndpoint, chatUrl, outputPath, { captureIdentity });
      return {
        exportPath: formatPathForDisplay(outputPath),
      };
    },
  });

  cli.command('download', {
    description: 'Download an assistant-owned attachment or artifact from an authenticated ChatGPT thread.',
    options: z.object({
      artifactIndex: z.number().int().min(0).optional().describe('Assistant artifact index from the latest request in thread.json. Prefer this over button text when possible.'),
      attachmentText: z.string().optional().describe('Legacy attachment button label to click and download.'),
      browserEndpoint: z.string().default(DEFAULT_BROWSER_ENDPOINT).describe('Remote debugging endpoint for the managed browser.'),
      captureMetadata: z.string().optional().describe('Exact capture metadata emitted by a waited send; constrain the download to that assistant turn and artifact identity.'),
      chatUrl: z.string().describe('Full ChatGPT conversation URL (/c/<thread-id>) containing the attachment.'),
      outputDir: z.string().describe('Directory where the download should be written.'),
      timeoutMs: z.number().default(30_000).describe('Attachment download timeout in milliseconds.'),
    }),
    examples: [
      {
        description: 'Download an attachment from a thread',
        options: {
          artifactIndex: 0,
          chatUrl: 'https://chatgpt.com/c/69c71d43-0e38-8330-9df8-c4e10f5bf536',
          outputDir: 'output-packages/downloads',
        },
      },
    ],
    output: z.object({
      downloadedFile: z.string().describe('Downloaded attachment path.'),
    }),
    async run(c) {
      const chatUrl = normalizeConversationUrl(c.options.chatUrl);
      const captureIdentity = loadCaptureMetadata(c.options.captureMetadata);
      if (c.options.artifactIndex === undefined && !c.options.attachmentText?.trim()) {
        throw new Error('thread download requires --artifact-index or --attachment-text.');
      }
      if (captureIdentity && !captureIdentity.assistantResponse) {
        throw new Error('Exact capture metadata cannot download an artifact before the assistant response identity is captured.');
      }
      if (captureIdentity?.assistantResponse) {
        if (c.options.artifactIndex === undefined) {
          throw new Error('Exact capture metadata requires --artifact-index for an unambiguous download.');
        }
        if (!captureIdentity.artifacts[c.options.artifactIndex]) {
          throw new Error('Requested artifact index is not present in the exact waited capture metadata.');
        }
      }
      const capturedArtifact = c.options.artifactIndex === undefined
        ? undefined
        : captureIdentity?.artifacts[c.options.artifactIndex];
      const downloadedFile = await downloadThreadAttachment(
        c.options.browserEndpoint,
        chatUrl,
        c.options.attachmentText?.trim() ||
          (capturedArtifact && !isCaptureIdentityDigest(capturedArtifact.label) ? capturedArtifact.label : ''),
        path.resolve(c.options.outputDir),
        c.options.timeoutMs,
        {
          artifactIndex: c.options.artifactIndex,
          artifactIndexInAssistantTurn: c.options.artifactIndex === undefined
            ? undefined
            : capturedArtifact?.artifactIndexInAssistantTurn,
          assistantTurnId: captureIdentity?.assistantResponse?.assistantTurnId,
          assistantTurnIndex: captureIdentity?.assistantResponse?.assistantTurnIndex,
          ...(capturedArtifact && !isCaptureIdentityDigest(capturedArtifact.href)
            ? { href: capturedArtifact.href }
            : {}),
        },
        { captureIdentity },
      );
      return {
        downloadedFile: formatPathForDisplay(downloadedFile),
      };
    },
  });

  cli.command('diagnose', {
    description: 'Capture a structured diagnostics bundle for a ChatGPT thread send/wake failure from the managed browser.',
    options: z.object({
      browserEndpoint: z.string().default(DEFAULT_BROWSER_ENDPOINT).describe('Remote debugging endpoint for the managed browser.'),
      chatUrl: z.string().describe('Full ChatGPT conversation URL (/c/<thread-id>) to inspect.'),
      commandLabel: z.string().default('review:gpt').describe('Short label for the failing command, used in the diagnostics bundle name.'),
      exitCode: z.number().optional().describe('Optional exit code recorded in the diagnostics status file.'),
      logFile: z.string().optional().describe('Optional failing command log file to copy into the diagnostics bundle.'),
      outputDir: z.string().optional().describe('Optional diagnostics output directory. Defaults to output-packages/review-gpt-diagnostics/<timestamp>-<label>-<chat-id>-<pid>.'),
      receiptPath: z.string().optional().describe('Optional recursive follow-up receipt JSON to copy into the diagnostics bundle.'),
    }),
    examples: [
      {
        description: 'Capture diagnostics for a failed same-thread send',
        options: {
          chatUrl: 'https://chatgpt.com/c/69c71d43-0e38-8330-9df8-c4e10f5bf536',
          commandLabel: 'review:gpt',
          logFile: 'output-packages/chatgpt-watch/run/recursive-review-send.log',
          receiptPath: 'output-packages/chatgpt-watch/run/recursive-followup.json',
        },
      },
    ],
    output: z.object({
      outputDir: z.string().describe('Diagnostics bundle directory.'),
      statusPath: z.string().describe('Diagnostics status JSON path.'),
    }),
    async run(c) {
      const chatUrl = normalizeConversationUrl(c.options.chatUrl);
      const result = await collectThreadDiagnostics({
        browserEndpoint: c.options.browserEndpoint,
        chatUrl,
        commandLabel: c.options.commandLabel,
        cwd: process.cwd(),
        exitCode: c.options.exitCode,
        logFilePath: c.options.logFile ? path.resolve(c.options.logFile) : undefined,
        outputDir: c.options.outputDir ? path.resolve(c.options.outputDir) : undefined,
        receiptPath: c.options.receiptPath ? path.resolve(c.options.receiptPath) : undefined,
      });

      return {
        outputDir: formatPathForDisplay(result.outputDir),
        statusPath: formatPathForDisplay(result.statusPath),
      };
    },
  });

  cli.command('wake', {
    description: 'Wait, export a ChatGPT thread, retain the latest assistant text, validate response-declared patch filenames, download all assistant-owned artifacts from the latest user request, then hand off to an interactive Codex session in the owning Codex home.',
    options: z.object({
      browserEndpoint: z.string().default(DEFAULT_BROWSER_ENDPOINT).describe('Remote debugging endpoint for the managed browser.'),
      captureMetadata: z.string().optional().describe('Exact capture metadata emitted by send; reuse its target and fail closed if a completed response or artifact identity is ambiguous.'),
      chatUrl: z.string().describe('Full ChatGPT conversation URL (/c/<thread-id>) to revisit later.'),
      codexHome: z.string().optional().describe('Explicit Codex home to use. If omitted, wake trusts inherited CODEX_HOME before using metadata-only local discovery.'),
      delay: z.string().default('70m').describe('Delay before checking the thread, for example 70m or 1h30m. The managed browser is not touched until this delay elapses.'),
      detach: z.boolean().default(false).describe('Launch the wake loop in a detached background process that survives the current terminal or parent process exiting. Recommended for long-lived waits and recursive follow-up wakes.'),
      downloadTimeoutMs: z.number().default(30_000).describe('Attachment download timeout in milliseconds.'),
      fullAuto: z.boolean().default(false).describe('Pass --full-auto to the launched Codex session. Disabled by default so wake matches a normal interactive launch.'),
      outputDir: z.string().optional().describe('Output directory for thread export, downloads, and Codex output.'),
      pollInterval: z.string().default('1m').describe('When polling is enabled, re-check the thread at this base interval after the initial delay.'),
      pollJitter: z.string().default('1m').describe('Optional extra random delay added after each polling cycle. Defaults to 1m, so the default wake cadence retries after 60-120s and also adds a small startup spread before the first export. Use 0s to disable jitter.'),
      pollTimeout: z.string().optional().describe('Optional overall timeout for polling after the initial delay, for example 20m or 2h.'),
      pollUntilComplete: z.boolean().default(true).describe('Poll until the thread no longer looks busy before downloading or launching the child run. Wake reuses the same thread tab, forces one same-tab reload before the first export, and only forces another reload after repeated identical no-artifact snapshots. Disable with --no-poll-until-complete for the old one-shot behavior.'),
      recursiveDepth: z.number().int().min(0).default(0).describe('After each resumed child lands a patch, request the built-in same-thread bug/simplification review, arm another wake on the same thread, and decrement this counter until it reaches zero.'),
      recursivePrompt: z.string().optional().describe('Override the built-in same-thread recursive review prompt. This prompt is reused by recursive descendant wakes until the counter reaches zero.'),
      repoDir: z.string().default('.').describe('Repo working directory for the spawned Codex child process.'),
      resumePrompt: z.string().optional().describe('Append extra instructions to the spawned Codex child prompt after patch download. Supports {{chat_url}} and {{chat_id}} placeholders for the watched thread.'),
      sessionId: z.string().optional().describe('Origin Codex session ID recorded for lineage and metadata-only home discovery when CODEX_HOME is unavailable. Defaults to CODEX_THREAD_ID when set.'),
      skipResume: z.boolean().default(false).describe('Export and download only; do not launch the Codex child process.'),
      tabLifecycle: z.enum(['keep', 'close-created', 'close-harvested']).default('close-harvested').describe('Close the exact harvested thread tab by default; use keep to retain every tab or close-created to close only targets created during this wake, including on failure.'),
    }),
    examples: [
      {
        description: 'Wait 70 minutes, then poll/export/download and launch a new child session in the same Codex home',
        options: {
          chatUrl: 'https://chatgpt.com/c/69c71d43-0e38-8330-9df8-c4e10f5bf536',
          delay: '70m',
          sessionId: '019d36e3-f6a2-7873-910a-2bdbd4f9748c',
        },
      },
      {
        description: 'Check right away with the default small startup spread, then poll every minute until the thread finishes before launching the child session',
        options: {
          chatUrl: 'https://chatgpt.com/c/69c71d43-0e38-8330-9df8-c4e10f5bf536',
          delay: '0s',
          pollInterval: '1m',
          pollJitter: '1m',
          sessionId: '019d36e3-f6a2-7873-910a-2bdbd4f9748c',
        },
      },
      {
        description: 'Run the old one-shot export/download path without polling',
        options: {
          chatUrl: 'https://chatgpt.com/c/69c71d43-0e38-8330-9df8-c4e10f5bf536',
          delay: '0s',
          pollUntilComplete: false,
          skipResume: true,
        },
      },
      {
        description: 'Append custom follow-up instructions for the launched Codex session',
        options: {
          chatUrl: 'https://chatgpt.com/c/69c71d43-0e38-8330-9df8-c4e10f5bf536',
          delay: '0s',
          resumePrompt:
            'After applying the returned patch, run pnpm review:gpt --send --chat-url {{chat_url}} and ask for final bug and simplification feedback.',
          sessionId: '019d36e3-f6a2-7873-910a-2bdbd4f9748c',
        },
      },
      {
        description: 'After the first patch lands, request one same-thread bug/simplification review patch and wake again to apply it',
        options: {
          chatUrl: 'https://chatgpt.com/c/69c71d43-0e38-8330-9df8-c4e10f5bf536',
          delay: '0s',
          pollInterval: '1m',
          pollTimeout: '120m',
          recursiveDepth: 1,
          recursivePrompt:
            'Review the returned plan only after the thread responds. Then implement the plan as a clean long-term patch with tests and return a .patch attachment.',
          sessionId: '019d36e3-f6a2-7873-910a-2bdbd4f9748c',
        },
      },
    ],
    output: z.object({
      attemptCount: z.number().describe('Number of export checks performed before download or child launch.'),
      assistantResponseMetaPath: z.string().optional().describe('Metadata JSON for the retained assistant text response from the latest request.'),
      assistantResponsePath: z.string().optional().describe('Markdown file containing the retained assistant text response from the latest request.'),
      assistantResponseSource: z.enum(['latest-assistant', 'none']).optional().describe('Where the retained assistant text response came from.'),
      assistantResponseTextLength: z.number().optional().describe('Character count of retained assistant text.'),
      childSessionPersistence: z.enum(['pending', 'verified']).optional().describe('Whether the spawned child session already had a canonical ID-bearing rollout filename in the resolved Codex home at handoff time.'),
      completionStatus: z.enum(['checked-once', 'completed']).describe('Whether the wake flow only checked once or actively waited for the thread to finish.'),
      childSessionId: z.string().optional().describe('Spawned Codex session ID after wake verifies the child launch from the child event stream.'),
      childRolloutPath: z.string().optional().describe('Captured child Codex rollout/session log path, when already discovered in the resolved Codex home at handoff time.'),
      codexBin: z.string().optional().describe('Resolved Codex binary path label, when the child run launched.'),
      codexHome: z.string().optional().describe('Resolved Codex home label used for the child run.'),
      downloadErrors: z.array(z.string()).optional().describe('Artifact download failures that were logged but did not prevent wake handoff.'),
      downloadedArtifacts: z.array(z.string()).optional().describe('Downloaded assistant artifacts from the latest request.'),
      downloadedPatches: z.array(z.string()).describe('Backward-compatible alias for downloaded assistant artifacts.'),
      eventsPath: z.string().optional().describe('Captured child Codex JSON event stream path, when available from the spawned codex exec launcher.'),
      exportPath: z.string().describe('Thread export JSON path.'),
      handoffKind: z.enum(['artifact', 'text', 'none']).optional().describe('Primary handoff material passed to the child Codex run.'),
      launcherPid: z.number().optional().describe('PID of the spawned child Codex process, when available.'),
      outputDir: z.string().describe('Directory containing the wake artifacts.'),
      recursive: z.object({
        descendantOutputDir: z.string().describe('Deterministic output directory for the next recursive wake hop.'),
        descendantStatusPath: z.string().describe('Expected status.json path for the next recursive wake hop.'),
        descendantWakeLaunchPath: z.string().describe('Path where the generated recursive helper stores the detached wake launch JSON.'),
        descendantWakeLogPath: z.string().describe('Path where the generated recursive helper stores the detached wake stderr log.'),
        followupReceiptPath: z.string().describe('Path where the generated recursive helper records follow-up send and next-wake status.'),
        followupScriptPath: z.string().describe('Generated helper script that sends the recursive same-thread review and arms the next wake.'),
        nextDepth: z.number().describe('Recursive depth that will be passed to the next wake hop.'),
        reviewDiagnosticsLaunchPath: z.string().describe('Path where the generated recursive helper stores thread diagnose stdout after a failed same-thread send.'),
        reviewDiagnosticsLogPath: z.string().describe('Path where the generated recursive helper stores thread diagnose stderr after a failed same-thread send.'),
        reviewDiagnosticsOutputDir: z.string().describe('Output directory where failed same-thread send diagnostics are captured.'),
        reviewDiagnosticsStatusPath: z.string().describe('Status JSON for the failed same-thread send diagnostics bundle.'),
        requestedDepth: z.number().describe('Recursive depth requested for this wake handoff.'),
        reviewSendLogPath: z.string().describe('Path where the generated recursive helper stores the same-thread review send log.'),
        reviewTimeoutMs: z.number().describe('Autosend timeout used by the generated recursive same-thread review helper.'),
      }).optional().describe('Generated recursive helper paths and deterministic descendant wake metadata, when --recursive-depth is enabled.'),
      replayCommandsPath: z.string().optional().describe('Shell helper file with direct export/download replay commands that bypass pnpm exec in the consumer repo.'),
      repoDir: z.string().describe('Repo directory used for the spawned Codex child process.'),
      stderrPath: z.string().optional().describe('Captured child Codex stderr log path, when available from the spawned codex exec launcher.'),
      resumeOutputPath: z.string().optional().describe('Captured last Codex message path, when available from the underlying launcher.'),
      sessionId: z.string().optional().describe('Origin Codex session ID used to resolve the owning Codex home.'),
      statusPath: z.string().optional().describe('Wake status JSON path.'),
      wakeLogPath: z.string().optional().describe('Detached wake stdout/stderr log path, when --detach launches a background wake process.'),
      wakePid: z.number().optional().describe('Detached wake process id, when --detach launches a background wake process.'),
    }),
    async run(c) {
      const sessionId = c.options.sessionId ?? process.env.CODEX_THREAD_ID;
      if (!c.options.skipResume && !sessionId) {
        throw new Error('thread wake requires --session-id unless --skip-resume is set or CODEX_THREAD_ID is available.');
      }

      const chatUrl = normalizeConversationUrl(c.options.chatUrl);
      const repoDir = path.resolve(c.options.repoDir);
      const outputDir = path.resolve(c.options.outputDir ?? defaultWakeOutputDir(chatUrl));
      const statusPath = path.join(outputDir, 'status.json');
      const wakeLogPath = path.join(outputDir, 'wake.log');

      if (c.options.detach) {
        const args = buildDetachedWakeCommandArgs({
          ...c.options,
          chatUrl,
          detach: false,
          outputDir,
          repoDir,
          sessionId,
        });
        const { wakePid } = launchDetachedWakeProcess({
          args,
          cwd: repoDir,
          env: process.env,
          logPath: wakeLogPath,
        });
        return {
          attemptCount: 0,
          completionStatus: 'checked-once' as const,
          downloadedPatches: [],
          outputDir: formatPathForDisplay(outputDir, repoDir),
          repoDir: formatPathForDisplay(repoDir, repoDir),
          sessionId,
          statusPath: formatPathForDisplay(statusPath, repoDir),
          wakeLogPath: formatPathForDisplay(wakeLogPath, repoDir),
          wakePid,
          exportPath: formatPathForDisplay(path.join(outputDir, 'thread.json'), repoDir),
        };
      }

      const captureIdentity = loadCaptureMetadata(c.options.captureMetadata);
      const result = await runWakeFlow({
        browserEndpoint: c.options.browserEndpoint,
        captureIdentity,
        captureMetadataPath: c.options.captureMetadata ? path.resolve(c.options.captureMetadata) : undefined,
        chatUrl,
        codexHome: c.options.codexHome,
        delayMs: parseWakeDelayToMs(c.options.delay),
        downloadTimeoutMs: c.options.downloadTimeoutMs,
        fullAuto: c.options.fullAuto,
        outputDir,
        pollJitterMs: parseWakeDelayToMs(c.options.pollJitter),
        pollIntervalMs: parseWakeDelayToMs(c.options.pollInterval),
        pollTimeoutMs: c.options.pollTimeout ? parseWakeDelayToMs(c.options.pollTimeout) : undefined,
        pollUntilComplete: c.options.pollUntilComplete,
        recursiveDepth: c.options.recursiveDepth,
        recursivePrompt: c.options.recursivePrompt,
        repoDir,
        resumePrompt: c.options.resumePrompt,
        sessionId,
        skipResume: c.options.skipResume,
        tabLifecycle: c.options.tabLifecycle,
      });

      return {
        attemptCount: result.attemptCount,
        assistantResponseMetaPath: result.assistantResponseMetaPath ? formatPathForDisplay(result.assistantResponseMetaPath, repoDir) : undefined,
        assistantResponsePath: result.assistantResponsePath ? formatPathForDisplay(result.assistantResponsePath, repoDir) : undefined,
        assistantResponseSource: result.assistantResponseSource,
        assistantResponseTextLength: result.assistantResponseTextLength,
        childSessionId: result.childSessionId,
        childRolloutPath: result.childRolloutPath ? formatPathForDisplay(result.childRolloutPath, repoDir) : undefined,
        completionStatus: result.completionStatus,
        codexBin: result.codexBin ? formatPathForDisplay(result.codexBin, repoDir) : undefined,
        codexHome: result.codexHome ? formatCodexHomeForDisplay(result.codexHome) : undefined,
        downloadErrors: result.downloadErrors,
        downloadedArtifacts: result.downloadedArtifacts?.map((filePath) => formatPathForDisplay(filePath, repoDir)),
        downloadedPatches: result.downloadedPatches.map((filePath) => formatPathForDisplay(filePath, repoDir)),
        eventsPath: result.eventsPath ? formatPathForDisplay(result.eventsPath, repoDir) : undefined,
        exportPath: formatPathForDisplay(result.exportPath, repoDir),
        handoffKind: result.handoffKind,
        launcherPid: result.launcherPid,
        outputDir: formatPathForDisplay(result.outputDir, repoDir),
        recursive: formatWakeRecursiveInfoForDisplay(result.recursive, repoDir),
        replayCommandsPath: result.replayCommandsPath ? formatPathForDisplay(result.replayCommandsPath, repoDir) : undefined,
        repoDir: formatPathForDisplay(result.repoDir, repoDir),
        stderrPath: result.stderrPath ? formatPathForDisplay(result.stderrPath, repoDir) : undefined,
        resumeOutputPath: result.resumeOutputPath ? formatPathForDisplay(result.resumeOutputPath, repoDir) : undefined,
        sessionId: result.sessionId,
        statusPath: result.statusPath ? formatPathForDisplay(result.statusPath, repoDir) : undefined,
        wakeLogPath: undefined,
        wakePid: undefined,
      };
    },
  });

  return cli;
}