@koreanhole/opencodex 2.97.0 → 2.99.0

package/src/adapters/cli-agent/cline/settings.ts

@@ -1,13 +1,7 @@
-import { spawn } from "node:child_process";
-import { link, mkdir, mkdtemp, readFile, rm, stat, symlink, writeFile } from "node:fs/promises";
+import { link, mkdir, mkdtemp, readFile, rm, symlink, writeFile } from "node:fs/promises";
 import { homedir, tmpdir } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import { baseScopedEnv } from "../env";
-import { commandInvocation } from "../../../lib/win-exec";
-
-const MAX_PREFLIGHT_STDOUT_BYTES = 2 * 1024 * 1024;
-const MAX_PREFLIGHT_STDERR_BYTES = 8 * 1024;
-const PREFLIGHT_TIMEOUT_MS = 15_000;
 
 /** Built-in, subagent, and team tools that a model-only Cline turn must never enable. */
 export const CLINE_DISABLED_TOOL_IDS = Object.freeze([
@@ -65,31 +59,15 @@ export interface ClineStagedTurn {
   providerSettingsPath: string;
   globalSettingsPath: string;
   mcpSettingsPath: string;
+  catalogPath: string;
   cleanup: () => Promise<void>;
 }
 
-export interface ClineEnabledTool {
-  id: string;
-  kind: "builtin";
-}
-
-export interface ClineToolPreflightResult {
-  ok: boolean;
-  unsupported?: boolean;
-  detail?: string;
-  enabledTools?: readonly ClineEnabledTool[];
-}
-
 export interface ClineSelection {
   providerId: string;
   model?: string;
 }
 
-export interface ClineFlagCapabilities {
-  providerFlag?: "--provider";
-  modelFlag?: "--model" | "--modelid";
-}
-
 interface ClineSelectionCandidate {
   providerId: string;
   model?: string;
@@ -280,8 +258,8 @@ export async function assertClineSelectionSafe(providerSettingsPath: string): Pr
 }
 
 /**
- * The vendor store is advisory in one-shot mode: absence or another schema is Cline's
- * business. Only an explicit route back through this proxy remains a hard refusal.
+ * The vendor store is advisory: absence or another schema is Cline's business.
+ * Only an explicit route back through this proxy remains a hard refusal.
  */
 export async function assertClineAdvisoryDestinationSafe(providerSettingsPath: string): Promise<void> {
   try {
@@ -296,10 +274,7 @@ function clineGlobalSettings(): Record<string, unknown> {
   return {
     telemetryOptOut: true,
     autoUpdateEnabled: false,
-    // Built-in and plugin tools are disabled below; auto-approval lets only the
-    // capture-only MCP server receive the model's tool call, where it hangs until
-    // the runner observes the completed intent batch and stops the child.
-    toolAutoApprove: true,
+    toolAutoApprove: false,
     compactionEnabled: false,
     disabledTools: [...CLINE_DISABLED_TOOL_IDS],
     tools: {
@@ -310,33 +285,11 @@ function clineGlobalSettings(): Record<string, unknown> {
   };
 }
 
-export type ClineMcpLaunch =
-  | { kind: "module"; modulePath: string }
-  | { kind: "entrypoint"; entrypoint: string };
-
-function clineMcpArgs(launch: ClineMcpLaunch, catalogPath: string): string[] {
-  return launch.kind === "module"
-    ? [launch.modulePath, catalogPath]
-    : [launch.entrypoint, catalogPath];
+function clineMcpSettings(): Record<string, unknown> {
+  return { mcpServers: {} };
 }
 
-function clineMcpSettings(launch: ClineMcpLaunch | undefined, catalogPath: string): Record<string, unknown> {
-  if (!launch) return { mcpServers: {} };
-  return {
-    mcpServers: {
-      opencodex: {
-        transport: {
-          type: "stdio",
-          command: process.execPath,
-          args: clineMcpArgs(launch, catalogPath),
-        },
-        disabled: false,
-      },
-    },
-  };
-}
-
-/** Share a staged file at a vendor-default path without copying its bytes. */
+/** Share a staged file at a vendor-default path. */
 async function linkClineFile(target: string, path: string): Promise<void> {
   try {
     await symlink(resolve(target), path);
@@ -349,15 +302,28 @@ async function linkClineFile(target: string, path: string): Promise<void> {
   }
 }
 
+/** Copy the auth source into the private turn root so vendor refreshes cannot mutate it. */
+async function copyClineProviderSettings(source: string, target: string): Promise<boolean> {
+  let bytes: Buffer;
+  try {
+    bytes = await readFile(source);
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") return false;
+    throw error;
+  }
+  await writeFile(target, bytes, { mode: 0o600, flag: "wx" });
+  return true;
+}
+
 /**
  * A fork that ignores CLINE_PROVIDER_SETTINGS_PATH still looks at ~/.cline or
- * CLINE_DIR/data/settings. Link the real provider store and the staged settings there.
+ * CLINE_DIR/data/settings. Link the staged provider copy and settings there.
  */
 async function linkClineSettings(input: {
   dataDir: string;
   configDir: string;
   homeDir: string;
-  providerSettingsPath: string;
+  providerSettingsPath?: string;
   globalSettingsPath: string;
   mcpSettingsPath: string;
 }): Promise<void> {
@@ -367,7 +333,9 @@ async function linkClineSettings(input: {
     { dir: join(input.homeDir, ".cline", "data", "settings"), settings: true },
   ];
   for (const target of targets) {
-    await linkClineFile(input.providerSettingsPath, join(target.dir, "providers.json"));
+    if (input.providerSettingsPath) {
+      await linkClineFile(input.providerSettingsPath, join(target.dir, "providers.json"));
+    }
     if (!target.settings) continue;
     await linkClineFile(input.globalSettingsPath, join(target.dir, "global-settings.json"));
     await linkClineFile(input.mcpSettingsPath, join(target.dir, "cline_mcp_settings.json"));
@@ -378,7 +346,6 @@ async function linkClineSettings(input: {
 export async function stageClineTurn(options: {
   providerSettingsPath: string;
   catalog: readonly Record<string, unknown>[];
-  mcpLaunch?: ClineMcpLaunch;
 }): Promise<ClineStagedTurn> {
   const root = await mkdtemp(join(tmpdir(), "ocx-cline-cli-"));
   const configDir = join(root, "config");
@@ -389,6 +356,7 @@ export async function stageClineTurn(options: {
   const logDir = join(root, "logs");
   const globalSettingsPath = join(dataDir, "settings", "global-settings.json");
   const mcpSettingsPath = join(dataDir, "settings", "cline_mcp_settings.json");
+  const providerSettingsPath = join(homeDir, ".cline", "data", "settings", "providers.json");
   const catalogPath = join(root, "tool-catalog.json");
 
   const cleanup = async (): Promise<void> => {
@@ -401,6 +369,8 @@ export async function stageClineTurn(options: {
       mkdir(dirname(globalSettingsPath), { recursive: true, mode: 0o700 }),
       mkdir(join(configDir, "data", "settings"), { recursive: true, mode: 0o700 }),
       mkdir(join(homeDir, ".cline", "data", "settings"), { recursive: true, mode: 0o700 }),
+      mkdir(join(homeDir, ".config"), { recursive: true, mode: 0o700 }),
+      mkdir(join(homeDir, ".cache"), { recursive: true, mode: 0o700 }),
       mkdir(homeDir, { recursive: true, mode: 0o700 }),
       mkdir(workspaceDir, { recursive: true, mode: 0o700 }),
       mkdir(hooksDir, { recursive: true, mode: 0o700 }),
@@ -408,14 +378,15 @@ export async function stageClineTurn(options: {
     ]);
     await Promise.all([
       writeFile(globalSettingsPath, `${JSON.stringify(clineGlobalSettings(), null, 2)}\n`, { encoding: "utf8", mode: 0o600, flag: "wx" }),
-      writeFile(mcpSettingsPath, `${JSON.stringify(clineMcpSettings(options.mcpLaunch, catalogPath), null, 2)}\n`, { encoding: "utf8", mode: 0o600, flag: "wx" }),
+      writeFile(mcpSettingsPath, `${JSON.stringify(clineMcpSettings(), null, 2)}\n`, { encoding: "utf8", mode: 0o600, flag: "wx" }),
       writeFile(catalogPath, JSON.stringify(options.catalog), { encoding: "utf8", mode: 0o600, flag: "wx" }),
     ]);
+    const copiedProviderStore = await copyClineProviderSettings(options.providerSettingsPath, providerSettingsPath);
     await linkClineSettings({
       dataDir,
       configDir,
       homeDir,
-      providerSettingsPath: options.providerSettingsPath,
+      ...(copiedProviderStore ? { providerSettingsPath } : {}),
       globalSettingsPath,
       mcpSettingsPath,
     });
@@ -426,9 +397,10 @@ export async function stageClineTurn(options: {
       homeDir,
       workspaceDir,
       hooksDir,
-      providerSettingsPath: options.providerSettingsPath,
+      providerSettingsPath,
       globalSettingsPath,
       mcpSettingsPath,
+      catalogPath,
       cleanup,
     };
   } catch (error) {
@@ -439,18 +411,10 @@ export async function stageClineTurn(options: {
 
 export function buildClineChildEnv(staged: ClineStagedTurn, sourceEnv: NodeJS.ProcessEnv = process.env): Record<string, string> {
   const env = baseScopedEnv();
-  // A locally authenticated Cline fork may ignore the CLINE_* path overrides and
-  // resolve auth from the operator's real HOME/XDG. Preserve that environment; the
-  // staged CLINE_* paths below still win for a CLI that honors them.
-  const realHome = nonEmpty(sourceEnv.HOME) ?? nonEmpty(sourceEnv.USERPROFILE) ?? homedir();
-  if (realHome) {
-    env.HOME = realHome;
-    env.USERPROFILE = realHome;
-  }
-  const xdgConfig = nonEmpty(sourceEnv.XDG_CONFIG_HOME);
-  if (xdgConfig) env.XDG_CONFIG_HOME = xdgConfig;
-  const xdgCache = nonEmpty(sourceEnv.XDG_CACHE_HOME);
-  if (xdgCache) env.XDG_CACHE_HOME = xdgCache;
+  env.HOME = staged.homeDir;
+  env.USERPROFILE = staged.homeDir;
+  env.XDG_CONFIG_HOME = join(staged.homeDir, ".config");
+  env.XDG_CACHE_HOME = join(staged.homeDir, ".cache");
   const user = sourceEnv.USER ?? sourceEnv.LOGNAME;
   if (user) env.USER = user;
   if (sourceEnv.LOGNAME) env.LOGNAME = sourceEnv.LOGNAME;
@@ -475,189 +439,3 @@ export function buildClineChildEnv(staged: ClineStagedTurn, sourceEnv: NodeJS.Pr
   });
   return env;
 }
-
-function runPreflightProcess(
-  binary: string,
-  args: readonly string[],
-  env: Record<string, string>,
-  cwd: string,
-): Promise<{ exitCode: number; stdout: string; stderr: string }> {
-  return new Promise((resolve, reject) => {
-    const invocation = commandInvocation(binary, [...args], process.platform, { env });
-    const child = spawn(invocation.file, invocation.args, {
-      ...invocation.options,
-      cwd,
-      env,
-      stdio: ["ignore", "pipe", "pipe"],
-      windowsHide: true,
-    });
-    const stdout: Buffer[] = [];
-    const stderr: Buffer[] = [];
-    let stdoutBytes = 0;
-    let stderrBytes = 0;
-    let settled = false;
-    const finish = (fn: () => void): void => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timer);
-      fn();
-    };
-    const timer = setTimeout(() => {
-      try { child.kill("SIGKILL"); } catch { /* ignore */ }
-      finish(() => reject(new Error("Cline tool preflight timed out.")));
-    }, PREFLIGHT_TIMEOUT_MS);
-
-    child.stdout.on("data", (chunk: Buffer) => {
-      if (stdoutBytes >= MAX_PREFLIGHT_STDOUT_BYTES) return;
-      const remaining = MAX_PREFLIGHT_STDOUT_BYTES - stdoutBytes;
-      const admitted = chunk.subarray(0, remaining);
-      stdout.push(admitted);
-      stdoutBytes += admitted.byteLength;
-    });
-    child.stderr.on("data", (chunk: Buffer) => {
-      if (stderrBytes >= MAX_PREFLIGHT_STDERR_BYTES) return;
-      const remaining = MAX_PREFLIGHT_STDERR_BYTES - stderrBytes;
-      const admitted = chunk.subarray(0, remaining);
-      stderr.push(admitted);
-      stderrBytes += admitted.byteLength;
-    });
-    child.once("error", (error) => finish(() => reject(error)));
-    child.once("close", (code) => finish(() => resolve({
-      exitCode: code ?? 1,
-      stdout: Buffer.concat(stdout).toString("utf8"),
-      stderr: Buffer.concat(stderr).toString("utf8"),
-    })));
-  });
-}
-
-/** Merge discovered built-in IDs into the turn's private staged disable list. */
-export async function mergeClineDisabledTools(
-  staged: Pick<ClineStagedTurn, "globalSettingsPath">,
-  ids: readonly string[],
-): Promise<void> {
-  let parsed: unknown;
-  try {
-    parsed = JSON.parse(await readFile(staged.globalSettingsPath, "utf8"));
-  } catch {
-    throw new ClineSettingsError(
-      "Cline global settings are malformed; the tool preflight cannot be repaired.",
-      500,
-      "cline_cli_setup_failed",
-    );
-  }
-  const settings = asRecord(parsed);
-  if (!settings) {
-    throw new ClineSettingsError(
-      "Cline global settings are malformed; the tool preflight cannot be repaired.",
-      500,
-      "cline_cli_setup_failed",
-    );
-  }
-  const current = Array.isArray(settings.disabledTools)
-    ? settings.disabledTools.filter((value): value is string => typeof value === "string")
-    : [];
-  const merged = [...new Set([...current, ...ids])];
-  await writeFile(
-    staged.globalSettingsPath,
-    `${JSON.stringify({ ...settings, disabledTools: merged }, null, 2)}\n`,
-    { encoding: "utf8", mode: 0o600 },
-  );
-}
-
-/** Verify the isolated Cline config advertises no executable built-in or plugin tool. */
-export function validateClineToolCatalog(parsed: unknown): ClineToolPreflightResult {
-  if (!Array.isArray(parsed)) return { ok: false, detail: "Cline tool preflight returned a non-array catalog." };
-  const enabledTools: ClineEnabledTool[] = [];
-  let pluginDetail: string | undefined;
-  for (const item of parsed) {
-    const record = asRecord(item);
-    if (!record) continue;
-    if (record.type === "plugin") {
-      if (record.enabled === true) {
-        pluginDetail ??= `Cline enabled plugin tool ${String(record.name ?? "unknown")}.`;
-      }
-      continue;
-    }
-    if (record.defaultEnabled !== true) continue;
-    const id = nonEmpty(record.id);
-    if (!id) return { ok: false, detail: "Cline enabled a built-in tool without an id." };
-    enabledTools.push({ id, kind: "builtin" });
-  }
-  if (pluginDetail) return { ok: false, detail: pluginDetail };
-  if (enabledTools.length > 0) {
-    return {
-      ok: false,
-      detail: `Cline enabled built-in tool ${enabledTools[0]!.id}.`,
-      enabledTools,
-    };
-  }
-  return { ok: true };
-}
-
-export function parseClineHelpCapabilities(text: string): ClineFlagCapabilities {
-  const providerFlag = /(?:^|\s)--provider(?:\s|,|<|$)/.test(text) ? "--provider" as const : undefined;
-  const modelFlag = /(?:^|\s)--model(?:\s|,|<|$)/.test(text)
-    ? "--model" as const
-    : /(?:^|\s)--modelid(?:\s|,|<|$)/.test(text)
-      ? "--modelid" as const
-      : undefined;
-  return {
-    ...(providerFlag ? { providerFlag } : {}),
-    ...(modelFlag ? { modelFlag } : {}),
-  };
-}
-
-const FLAG_CACHE = new Map<string, { mtimeMs: number; size: number; capabilities: ClineFlagCapabilities }>();
-
-/** Detect the local CLI's session flags from `--help`; cached by binary fingerprint. */
-export async function probeClineFlagCapabilities(
-  binary: string,
-  env: Record<string, string>,
-): Promise<ClineFlagCapabilities> {
-  let fingerprint: { mtimeMs: number; size: number } | undefined;
-  try {
-    const value = await stat(binary);
-    fingerprint = { mtimeMs: value.mtimeMs, size: value.size };
-  } catch {
-    fingerprint = undefined;
-  }
-  const key = resolve(binary);
-  if (fingerprint) {
-    const cached = FLAG_CACHE.get(key);
-    if (cached && cached.mtimeMs === fingerprint.mtimeMs && cached.size === fingerprint.size) {
-      return cached.capabilities;
-    }
-  }
-  let capabilities: ClineFlagCapabilities = {};
-  try {
-    const result = await runPreflightProcess(binary, ["--help"], env, homedir());
-    capabilities = parseClineHelpCapabilities(`${result.stdout}\n${result.stderr}`);
-  } catch {
-    // No flags: the CLI's current selection remains the fallback.
-  }
-  if (fingerprint) FLAG_CACHE.set(key, { ...fingerprint, capabilities });
-  return capabilities;
-}
-
-export async function preflightClineTools(input: {
-  binary: string;
-  env: Record<string, string>;
-  cwd: string;
-}): Promise<ClineToolPreflightResult> {
-  let result: Awaited<ReturnType<typeof runPreflightProcess>>;
-  try {
-    result = await runPreflightProcess(input.binary, ["config", "tools", "--json"], input.env, input.cwd);
-  } catch (error) {
-    return { ok: false, unsupported: true, detail: error instanceof Error ? error.message : String(error) };
-  }
-  if (result.exitCode !== 0) {
-    return { ok: false, unsupported: true, detail: result.stderr.trim() || `Cline tool preflight exited with code ${result.exitCode}.` };
-  }
-  let parsed: unknown;
-  try {
-    parsed = JSON.parse(result.stdout);
-  } catch {
-    return { ok: false, unsupported: true, detail: "Cline tool preflight returned non-JSON output." };
-  }
-  return validateClineToolCatalog(parsed);
-}

package/src/adapters/cli-agent/cline/stream.ts

@@ -1,9 +1,7 @@
-import type { AdapterEvent, OcxUsage } from "../../../types";
+import type { AdapterEvent } from "../../../types";
 import type { CliAgentStreamState } from "../types";
 import { mapToolIntent, ToolIntentError } from "../tool-intent";
 
-const MAX_ERROR_CHARS = 2_048;
-
 export class ClineStreamProtocolError extends Error {
   readonly code = "cli_protocol_error";
   readonly status = 502;
@@ -29,63 +27,7 @@ export function createClineStreamState(): CliAgentStreamState {
   };
 }
 
-function asRecord(value: unknown): Record<string, unknown> | undefined {
-  return value && typeof value === "object" && !Array.isArray(value)
-    ? value as Record<string, unknown>
-    : undefined;
-}
-
-function asString(value: unknown): string | undefined {
-  return typeof value === "string" ? value : undefined;
-}
-
-function safeMessage(value: unknown): string {
-  const raw = typeof value === "string"
-    ? value
-    : value instanceof Error
-      ? value.message
-      : value === undefined
-        ? "Cline reported an error."
-        : JSON.stringify(value) ?? String(value);
-  return raw
-    .replace(/\bsk-[A-Za-z0-9_-]{6,}\b/g, "[redacted]")
-    .replace(/(authorization\s*[:=]\s*)\S+/gi, "$1[redacted]")
-    .slice(0, MAX_ERROR_CHARS);
-}
-
-function classifyError(message: string): { status: number; errorType: string; code: string; retryable: boolean } {
-  if (/not logged in|please (?:run )?\/?login|sign in|authentication (?:failed|required)|unauthorized|invalid (?:api )?key/i.test(message)) {
-    return { status: 401, errorType: "authentication_error", code: "cline_cli_not_logged_in", retryable: false };
-  }
-  if (/rate limit|too many requests|quota|credit|usage limit|daily limit/i.test(message)) {
-    return { status: 429, errorType: "rate_limit_error", code: "rate_limit_exceeded", retryable: true };
-  }
-  if (/model (?:is )?(?:not found|unavailable|unsupported)|invalid model/i.test(message)) {
-    return { status: 400, errorType: "invalid_request_error", code: "model_not_found", retryable: false };
-  }
-  return { status: 502, errorType: "upstream_error", code: "cli_protocol_error", retryable: false };
-}
-
-function usageFrom(value: unknown): OcxUsage | undefined {
-  const record = asRecord(value);
-  if (!record) return undefined;
-  const count = (input: unknown): number =>
-    typeof input === "number" && Number.isFinite(input) && input >= 0 ? Math.floor(input) : 0;
-  const inputTokens = count(record.inputTokens);
-  const outputTokens = count(record.outputTokens);
-  const cacheRead = count(record.cacheReadTokens);
-  const cacheWrite = count(record.cacheWriteTokens);
-  if (inputTokens === 0 && outputTokens === 0 && cacheRead === 0 && cacheWrite === 0) return undefined;
-  return {
-    inputTokens,
-    outputTokens,
-    totalTokens: inputTokens + outputTokens,
-    ...(cacheRead > 0 ? { cachedInputTokens: cacheRead, cacheReadInputTokens: cacheRead } : {}),
-    ...(cacheWrite > 0 ? { cacheCreationInputTokens: cacheWrite } : {}),
-  };
-}
-
-/** Map a validated tool intent from either Cline's NDJSON or ACP event shape. */
+/** Map a validated Cline ACP tool intent into events owned by Codex. */
 export function mapClineToolIntent(
   vendorName: string,
   toolCallId: string | undefined,
@@ -100,159 +42,3 @@ export function mapClineToolIntent(
     throw error;
   }
 }
-
-function mapToolCall(
-  event: Record<string, unknown>,
-  state: CliAgentStreamState,
-  options: ClineStreamOptions,
-): AdapterEvent[] {
-  return mapClineToolIntent(asString(event.toolName) ?? "", asString(event.toolCallId), event.input, state, options);
-}
-
-function mapAgentEvent(
-  event: Record<string, unknown>,
-  state: CliAgentStreamState,
-  options: ClineStreamOptions,
-): AdapterEvent[] {
-  const type = asString(event.type);
-  if (type === "content_start") {
-    const contentType = asString(event.contentType);
-    if (contentType === "text") {
-      const text = asString(event.text);
-      if (text) {
-        state.sawText = true;
-        return [{ type: "text_delta", text }];
-      }
-      return [];
-    }
-    if (contentType === "reasoning") {
-      const thinking = asString(event.reasoning);
-      if (thinking) {
-        state.sawThinking = true;
-        return [{ type: "thinking_delta", thinking }];
-      }
-      return [];
-    }
-    if (contentType === "tool") return mapToolCall(event, state, options);
-    return [];
-  }
-
-  if (type === "content_end") {
-    const contentType = asString(event.contentType);
-    if (contentType === "text" && !state.sawText) {
-      const text = asString(event.text);
-      if (text) {
-        state.sawText = true;
-        return [{ type: "text_delta", text }];
-      }
-    }
-    if (contentType === "reasoning" && !state.sawThinking) {
-      const thinking = asString(event.reasoning);
-      if (thinking) {
-        state.sawThinking = true;
-        return [{ type: "thinking_delta", thinking }];
-      }
-    }
-    return [];
-  }
-
-  if (type === "usage") {
-    const usage = usageFrom(event);
-    if (usage) state.usage = usage;
-    return [];
-  }
-
-  if (type === "error") {
-    if (event.recoverable === true) return [];
-    const message = safeMessage(asRecord(event.error)?.message ?? event.error ?? "Cline reported an error.");
-    state.lastError = message;
-    state.terminal = true;
-    return [{ type: "error", message, ...classifyError(message) }];
-  }
-
-  if (type === "done") {
-    state.terminal = true;
-    if (state.toolCalls > 0) return [];
-    const events: AdapterEvent[] = [];
-    if (!state.sawText) {
-      const text = asString(event.text);
-      if (text) {
-        state.sawText = true;
-        events.push({ type: "text_delta", text });
-      }
-    }
-    const usage = usageFrom(event.usage) ?? state.usage;
-    events.push({ type: "done", stopReason: "stop", ...(usage ? { usage } : {}) });
-    return events;
-  }
-
-  if (type === "notice") return [];
-  return [];
-}
-
-/** Map one bounded Cline NDJSON frame to AdapterEvents. */
-export function mapClineMessage(
-  message: Record<string, unknown>,
-  state: CliAgentStreamState,
-  options: ClineStreamOptions,
-): AdapterEvent[] {
-  const type = asString(message.type);
-  if (type === "agent_event") {
-    const event = asRecord(message.event);
-    return event ? mapAgentEvent(event, state, options) : [];
-  }
-
-  if (type === "run_result") {
-    if (state.toolCalls > 0) return [];
-    const usage = usageFrom(message.usage) ?? state.usage;
-    if (usage) state.usage = usage;
-    const finishReason = asString(message.finishReason);
-    if (finishReason && finishReason !== "completed" && finishReason !== "stop") {
-      const messageText = safeMessage(message.text ?? `Cline finished with ${finishReason}.`);
-      state.terminal = true;
-      return [{ type: "error", message: messageText, ...classifyError(messageText) }];
-    }
-    state.terminal = true;
-    const events: AdapterEvent[] = [];
-    if (!state.sawText) {
-      const text = asString(message.text);
-      if (text) {
-        state.sawText = true;
-        events.push({ type: "text_delta", text });
-      }
-    }
-    events.push({ type: "done", stopReason: "stop", ...(usage ? { usage } : {}) });
-    return events;
-  }
-
-  if (type === "run_aborted") {
-    state.terminal = true;
-    return [{
-      type: "error",
-      message: safeMessage(message.message ?? "Cline aborted the turn."),
-      status: 499,
-      errorType: "invalid_request_error",
-      code: "client_cancelled",
-      retryable: false,
-    }];
-  }
-
-  if (type === "error") {
-    const detail = safeMessage(message.message ?? "Cline reported an error.");
-    state.lastError = detail;
-    state.terminal = true;
-    return [{ type: "error", message: detail, ...classifyError(detail) }];
-  }
-
-  return [];
-}
-
-/** Convert a nonzero process exit into a stable terminal error. */
-export function classifyClineFailure(exitCode: number, stderr: string): Extract<AdapterEvent, { type: "error" }> {
-  const detail = safeMessage(stderr.trim() || `Cline exited with code ${exitCode}.`);
-  return {
-    type: "error",
-    message: detail,
-    ...classifyError(detail),
-  };
-}