@gh-symphony/cli 0.0.20 → 0.0.22

package/dist/worker-entry.js

@@ -1,448 +1,31 @@
 #!/usr/bin/env node
 import {
+  getCodexObservabilityEventName,
+  launchCodexAppServer,
+  loadLauncherEnvironment,
+  normalizeCodexRuntimeEvents,
+  prepareCodexRuntimePlan,
+  resolveLocalRuntimeLaunchConfig
+} from "./chunk-2UW7NQLX.js";
+import {
+  DEFAULT_AGENT_INPUT_REQUIRED_REASON,
   classifySessionExit,
+  createClaudePrintRuntimeAdapter,
+  extractEnvForClaude,
+  formatClaudePreflightText,
+  isClaudeRuntimeCommand,
   parseWorkflowMarkdown,
-  readEnvFile
-} from "./chunk-M3IFVLQS.js";
+  resolveClaudeCommandBinary,
+  resolveWorkflowRuntimeCommand,
+  runClaudePreflight
+} from "./chunk-EEQQWTXS.js";
 
-// ../worker/dist/index.js
+// ../worker/src/index.ts
 import { spawn as spawn2 } from "child_process";
-import { readFile as readFile2 } from "fs/promises";
-import { join as join3 } from "path";
-
-// ../runtime-codex/dist/runtime.js
-import { spawn } from "child_process";
-import { copyFile, mkdir, writeFile } from "fs/promises";
-import { join } from "path";
-import { homedir } from "os";
-import { fileURLToPath } from "url";
-var DEFAULT_GITHUB_GRAPHQL_API_URL = "https://api.github.com/graphql";
-var DEFAULT_GITHUB_GIT_HOST = "github.com";
-var DEFAULT_GITHUB_GIT_USERNAME = "x-access-token";
-var AgentRuntimeResolutionError = class extends Error {
-};
-function createGitHubGraphQLToolDefinition(config) {
-  return {
-    name: "github_graphql",
-    description: "Execute GitHub GraphQL queries for the active workspace so the agent can mutate project and issue state directly.",
-    command: "node",
-    args: [fileURLToPath(new URL("./github-graphql-mcp-server.js", import.meta.url))],
-    env: {
-      GITHUB_GRAPHQL_API_URL: config.githubGraphqlApiUrl ?? DEFAULT_GITHUB_GRAPHQL_API_URL,
-      ...config.githubToken ? {
-        GITHUB_GRAPHQL_TOKEN: config.githubToken
-      } : {},
-      ...config.githubTokenBrokerUrl ? {
-        GITHUB_TOKEN_BROKER_URL: config.githubTokenBrokerUrl
-      } : {},
-      ...config.githubTokenBrokerSecret ? {
-        GITHUB_TOKEN_BROKER_SECRET: config.githubTokenBrokerSecret
-      } : {},
-      ...config.githubTokenCachePath ? {
-        GITHUB_TOKEN_CACHE_PATH: config.githubTokenCachePath
-      } : {},
-      ...config.githubProjectId ? {
-        GITHUB_PROJECT_ID: config.githubProjectId
-      } : {}
-    },
-    inputSchema: {
-      type: "object",
-      properties: {
-        query: {
-          type: "string",
-          description: "GraphQL query or mutation document."
-        },
-        variables: {
-          type: "object",
-          description: "Variables for the GraphQL document."
-        },
-        operationName: {
-          type: "string",
-          description: "Optional GraphQL operation name."
-        }
-      },
-      required: ["query"],
-      additionalProperties: false
-    }
-  };
-}
-function buildCodexRuntimePlan(config) {
-  const tool = createGitHubGraphQLToolDefinition(config);
-  const gitCredentialHelper = createGitCredentialHelperEnvironment(config);
-  const shellCmd = (() => {
-    const cmd = config.agentCommand ?? "codex app-server";
-    return cmd.startsWith("bash -lc ") ? cmd.slice("bash -lc ".length) : cmd;
-  })();
-  return {
-    cwd: config.workingDirectory,
-    command: "bash",
-    args: ["-lc", shellCmd],
-    env: {
-      ...process.env,
-      ...config.extraEnv,
-      ...config.agentEnv,
-      CODEX_PROJECT_ID: config.projectId,
-      GITHUB_PROJECT_ID: config.githubProjectId ?? "",
-      GITHUB_GRAPHQL_TOOL_NAME: tool.name,
-      GITHUB_GRAPHQL_TOOL_COMMAND: [tool.command, ...tool.args].join(" "),
-      // Point codex to an isolated config dir so personal MCPs (playwright,
-      // chrome-devtools, context7, etc.) from the operator's ~/.codex/config.toml
-      // are not loaded and do not confuse the implementation agent.
-      CODEX_HOME: join(config.workingDirectory, ".codex-agent"),
-      ...gitCredentialHelper,
-      ...tool.env
-    },
-    tools: [tool]
-  };
-}
-function launchCodexAppServer(plan, spawnImpl = spawn) {
-  return spawnImpl(plan.command, plan.args, {
-    cwd: plan.cwd,
-    env: plan.env,
-    stdio: "pipe"
-  });
-}
-async function prepareCodexRuntimePlan(config, dependencies = {}) {
-  const agentEnv = await resolveAgentRuntimeEnvironment(config, dependencies);
-  const codexHomeDir = join(config.workingDirectory, ".codex-agent");
-  const mkdirImpl = dependencies.mkdirImpl ?? mkdir;
-  await mkdirImpl(codexHomeDir, { recursive: true });
-  const writeFileImpl = dependencies.writeFileImpl ?? writeFile;
-  await writeFileImpl(join(codexHomeDir, "config.toml"), "# Isolated agent config \u2014 no personal MCP servers\n", "utf8");
-  const realCodexHome = process.env.CODEX_HOME ?? join(homedir(), ".codex");
-  const copyFileImpl = dependencies.copyFileImpl ?? copyFile;
-  try {
-    await copyFileImpl(join(realCodexHome, "auth.json"), join(codexHomeDir, "auth.json"));
-  } catch {
-  }
-  return buildCodexRuntimePlan({
-    ...config,
-    agentEnv
-  });
-}
-function createGitCredentialHelperEnvironment(config) {
-  return {
-    GITHUB_GIT_HOST: DEFAULT_GITHUB_GIT_HOST,
-    GITHUB_GIT_USERNAME: DEFAULT_GITHUB_GIT_USERNAME,
-    GIT_TERMINAL_PROMPT: "0",
-    GIT_CONFIG_COUNT: "1",
-    GIT_CONFIG_KEY_0: "credential.helper",
-    GIT_CONFIG_VALUE_0: `!node ${fileURLToPath(new URL("./git-credential-helper.js", import.meta.url))}`,
-    ...config.githubToken ? {
-      GITHUB_GRAPHQL_TOKEN: config.githubToken
-    } : {},
-    ...config.githubTokenBrokerUrl ? {
-      GITHUB_TOKEN_BROKER_URL: config.githubTokenBrokerUrl
-    } : {},
-    ...config.githubTokenBrokerSecret ? {
-      GITHUB_TOKEN_BROKER_SECRET: config.githubTokenBrokerSecret
-    } : {},
-    ...config.githubTokenCachePath ? {
-      GITHUB_TOKEN_CACHE_PATH: config.githubTokenCachePath
-    } : {}
-  };
-}
-async function resolveAgentRuntimeEnvironment(config, dependencies = {}) {
-  if (config.agentEnv) {
-    return config.agentEnv;
-  }
-  if (!config.agentCredentialBrokerUrl || !config.agentCredentialBrokerSecret) {
-    return {};
-  }
-  const fetchImpl = dependencies.fetchImpl ?? fetch;
-  const response = await fetchImpl(config.agentCredentialBrokerUrl, {
-    method: "POST",
-    headers: {
-      accept: "application/json",
-      authorization: `Bearer ${config.agentCredentialBrokerSecret}`
-    }
-  });
-  const payload = await response.json();
-  if (!response.ok || !payload.env || Object.keys(payload.env).length === 0) {
-    throw new AgentRuntimeResolutionError(payload.error ?? `Agent credential broker request failed with status ${response.status}.`);
-  }
-  if (config.agentCredentialCachePath) {
-    const writeFileImpl = dependencies.writeFileImpl ?? writeFile;
-    await writeFileImpl(config.agentCredentialCachePath, JSON.stringify(payload), "utf8");
-  }
-  return payload.env;
-}
-
-// ../runtime-codex/dist/launcher.js
-import { dirname, resolve } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
-var LocalRuntimeLauncherError = class extends Error {
-};
-function resolveLocalRuntimeLaunchConfig(env = process.env) {
-  const projectId = env.PROJECT_ID ?? env.CODEX_PROJECT_ID;
-  const workingDirectory = env.WORKING_DIRECTORY;
-  if (!projectId) {
-    throw new LocalRuntimeLauncherError("PROJECT_ID or CODEX_PROJECT_ID is required.");
-  }
-  if (!workingDirectory) {
-    throw new LocalRuntimeLauncherError("WORKING_DIRECTORY is required.");
-  }
-  return {
-    projectId,
-    workingDirectory,
-    githubToken: env.GITHUB_GRAPHQL_TOKEN,
-    githubTokenBrokerUrl: env.GITHUB_TOKEN_BROKER_URL,
-    githubTokenBrokerSecret: env.GITHUB_TOKEN_BROKER_SECRET,
-    githubTokenCachePath: env.GITHUB_TOKEN_CACHE_PATH,
-    agentEnv: readDirectAgentEnvironment(env),
-    agentCredentialBrokerUrl: env.AGENT_CREDENTIAL_BROKER_URL,
-    agentCredentialBrokerSecret: env.AGENT_CREDENTIAL_BROKER_SECRET,
-    agentCredentialCachePath: env.AGENT_CREDENTIAL_CACHE_PATH,
-    githubProjectId: env.GITHUB_PROJECT_ID,
-    githubGraphqlApiUrl: env.GITHUB_GRAPHQL_API_URL,
-    agentCommand: env.SYMPHONY_AGENT_COMMAND
-  };
-}
-async function runLocalRuntimeLauncher(env = process.env) {
-  const launcherEnv2 = loadLauncherEnvironment(env);
-  const config = resolveLocalRuntimeLaunchConfig(launcherEnv2);
-  const plan = await prepareCodexRuntimePlan(config);
-  emitLaunchSummary(config);
-  const child = launchCodexAppServer(plan);
-  process.stdout.write(`[worker] codex app-server started (pid: ${child.pid ?? "unknown"})
-`);
-  child.stdout?.pipe(process.stdout);
-  child.stderr?.pipe(process.stderr);
-  return await waitForChildProcess(child);
-}
-function loadLauncherEnvironment(env = process.env, cwd = process.cwd()) {
-  const mergedEnv = {
-    ...readEnvFile(resolve(dirname(fileURLToPath2(import.meta.url)), "..", ".env")),
-    ...readEnvFile(resolve(cwd, ".env")),
-    ...env
-  };
-  return mergedEnv;
-}
-function readDirectAgentEnvironment(env) {
-  const agentEnv = {};
-  for (const key of [
-    "OPENAI_API_KEY",
-    "OPENAI_BASE_URL",
-    "OPENAI_ORG_ID",
-    "OPENAI_PROJECT"
-  ]) {
-    const value = env[key];
-    if (value) {
-      agentEnv[key] = value;
-    }
-  }
-  return Object.keys(agentEnv).length ? agentEnv : void 0;
-}
-function waitForChildProcess(child) {
-  return new Promise((resolve2, reject) => {
-    child.once("error", reject);
-    child.once("exit", (code, signal) => {
-      if (signal) {
-        reject(new LocalRuntimeLauncherError(`codex app-server exited on ${signal}.`));
-        return;
-      }
-      resolve2(code ?? 0);
-    });
-  });
-}
-async function main() {
-  const exitCode = await runLocalRuntimeLauncher(process.env);
-  process.exitCode = exitCode;
-}
-if (import.meta.url === new URL(process.argv[1] ?? "", "file:").href) {
-  main().catch((error) => {
-    const message = error instanceof Error ? error.message : "Unknown error";
-    process.stderr.write(`${message}
-`);
-    process.exitCode = 1;
-  });
-}
-function emitLaunchSummary(config) {
-  const githubAuthMode = config.githubToken ? "direct token" : config.githubTokenBrokerUrl && config.githubTokenBrokerSecret ? "broker" : "missing";
-  const agentAuthMode = config.agentEnv?.OPENAI_API_KEY ? "direct env" : config.agentCredentialBrokerUrl && config.agentCredentialBrokerSecret ? "broker" : "local codex auth or inherited environment";
-  process.stdout.write([
-    "[worker] starting local codex runtime",
-    `[worker] project: ${config.projectId}`,
-    `[worker] cwd: ${config.workingDirectory}`,
-    `[worker] github project: ${config.githubProjectId ?? "(unset)"}`,
-    `[worker] github auth: ${githubAuthMode}`,
-    `[worker] agent auth: ${agentAuthMode}`,
-    "[worker] note: codex app-server does not proactively read GitHub issues.",
-    "[worker] note: it waits for a client request or tool invocation."
-  ].join("\n") + "\n");
-}
-
-// ../runtime-codex/dist/github-graphql-tool.js
-import { readFile, writeFile as writeFile2 } from "fs/promises";
-var DEFAULT_GITHUB_GRAPHQL_API_URL2 = "https://api.github.com/graphql";
-var TOKEN_REUSE_WINDOW_MS = 60 * 1e3;
-async function executeGitHubGraphQL(invocation, config, fetchImpl = fetch) {
-  const token = await resolveGitHubGraphQLToken(config, {
-    fetchImpl
-  });
-  const response = await fetchImpl(config.apiUrl ?? DEFAULT_GITHUB_GRAPHQL_API_URL2, {
-    method: "POST",
-    headers: {
-      "content-type": "application/json",
-      authorization: `Bearer ${token}`
-    },
-    body: JSON.stringify(invocation)
-  });
-  const payload = await response.json();
-  if (!response.ok) {
-    throw new Error(`GitHub GraphQL request failed with status ${response.status}: ${JSON.stringify(payload)}`);
-  }
-  if (payload.errors?.length) {
-    throw new Error(payload.errors.map((error) => error.message).join("; "));
-  }
-  return payload;
-}
-async function resolveGitHubGraphQLToken(config, dependencies = {}) {
-  if (config.token) {
-    return config.token;
-  }
-  if (!config.tokenBrokerUrl || !config.tokenBrokerSecret) {
-    throw new Error("Either GITHUB_GRAPHQL_TOKEN or the runtime token broker configuration is required.");
-  }
-  const now = dependencies.now ?? /* @__PURE__ */ new Date();
-  const readFileImpl = dependencies.readFileImpl ?? readFile;
-  const writeFileImpl = dependencies.writeFileImpl ?? writeFile2;
-  const cachedToken = config.tokenCachePath ? await readCachedToken(config.tokenCachePath, readFileImpl) : null;
-  if (cachedToken && cachedToken.expiresAt.getTime() - now.getTime() > TOKEN_REUSE_WINDOW_MS) {
-    return cachedToken.token;
-  }
-  const fetchImpl = dependencies.fetchImpl ?? fetch;
-  const response = await fetchImpl(config.tokenBrokerUrl, {
-    method: "POST",
-    headers: {
-      accept: "application/json",
-      authorization: `Bearer ${config.tokenBrokerSecret}`
-    }
-  });
-  const payload = await response.json();
-  if (!response.ok || !payload.token || !payload.expiresAt) {
-    throw new Error(payload.error ?? `Runtime token broker request failed with status ${response.status}.`);
-  }
-  if (config.tokenCachePath) {
-    await writeFileImpl(config.tokenCachePath, JSON.stringify(payload), "utf8");
-  }
-  return payload.token;
-}
-async function readStdin() {
-  const chunks = [];
-  for await (const chunk of process.stdin) {
-    chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
-  }
-  return Buffer.concat(chunks).toString("utf8");
-}
-async function main2() {
-  const rawInput = await readStdin();
-  const invocation = JSON.parse(rawInput);
-  const result = await executeGitHubGraphQL(invocation, {
-    token: process.env.GITHUB_GRAPHQL_TOKEN,
-    apiUrl: process.env.GITHUB_GRAPHQL_API_URL,
-    tokenBrokerUrl: process.env.GITHUB_TOKEN_BROKER_URL,
-    tokenBrokerSecret: process.env.GITHUB_TOKEN_BROKER_SECRET,
-    tokenCachePath: process.env.GITHUB_TOKEN_CACHE_PATH
-  });
-  process.stdout.write(`${JSON.stringify(result)}
-`);
-}
-if (import.meta.url === new URL(process.argv[1] ?? "", "file:").href) {
-  main2().catch((error) => {
-    const message = error instanceof Error ? error.message : "Unknown error";
-    process.stderr.write(`${message}
-`);
-    process.exitCode = 1;
-  });
-}
-async function readCachedToken(path, readFileImpl) {
-  try {
-    const payload = JSON.parse(await readFileImpl(path, "utf8"));
-    if (!payload.token || !payload.expiresAt) {
-      return null;
-    }
-    return {
-      token: payload.token,
-      expiresAt: new Date(payload.expiresAt)
-    };
-  } catch {
-    return null;
-  }
-}
-
-// ../runtime-codex/dist/git-credential-helper.js
-var DEFAULT_GITHUB_GIT_HOST2 = "github.com";
-var DEFAULT_GITHUB_GIT_USERNAME2 = "x-access-token";
-async function resolveGitCredential(request, config, fetchImpl = fetch) {
-  const requestHost = request.host?.trim();
-  const requestProtocol = request.protocol?.trim();
-  if (!requestHost || requestProtocol && requestProtocol !== "https") {
-    return "";
-  }
-  const expectedHost = normalizeGitHost(config.gitHost ?? DEFAULT_GITHUB_GIT_HOST2);
-  if (normalizeGitHost(requestHost) !== expectedHost) {
-    return "";
-  }
-  const token = await resolveGitHubGraphQLToken(config, {
-    fetchImpl
-  });
-  return formatGitCredentialResponse({
-    protocol: requestProtocol || "https",
-    host: requestHost,
-    username: config.gitUsername ?? DEFAULT_GITHUB_GIT_USERNAME2,
-    password: token
-  });
-}
-function parseGitCredentialRequest(rawInput) {
-  return rawInput.split("\n").map((line) => line.trim()).filter(Boolean).reduce((request, line) => {
-    const separatorIndex = line.indexOf("=");
-    if (separatorIndex === -1) {
-      return request;
-    }
-    const key = line.slice(0, separatorIndex);
-    const value = line.slice(separatorIndex + 1);
-    request[key] = value;
-    return request;
-  }, {});
-}
-function formatGitCredentialResponse(value) {
-  return `${Object.entries(value).map(([key, entry]) => `${key}=${entry}`).join("\n")}
-
-`;
-}
-async function readStdin2() {
-  const chunks = [];
-  for await (const chunk of process.stdin) {
-    chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
-  }
-  return Buffer.concat(chunks).toString("utf8");
-}
-async function main3() {
-  const request = parseGitCredentialRequest(await readStdin2());
-  const response = await resolveGitCredential(request, {
-    token: process.env.GITHUB_GRAPHQL_TOKEN,
-    tokenBrokerUrl: process.env.GITHUB_TOKEN_BROKER_URL,
-    tokenBrokerSecret: process.env.GITHUB_TOKEN_BROKER_SECRET,
-    tokenCachePath: process.env.GITHUB_TOKEN_CACHE_PATH,
-    gitHost: process.env.GITHUB_GIT_HOST,
-    gitUsername: process.env.GITHUB_GIT_USERNAME
-  });
-  process.stdout.write(response);
-}
-if (import.meta.url === new URL(process.argv[1] ?? "", "file:").href) {
-  main3().catch((error) => {
-    const message = error instanceof Error ? error.message : "Unknown error";
-    process.stderr.write(`${message}
-`);
-    process.exitCode = 1;
-  });
-}
-function normalizeGitHost(host) {
-  return host.trim().toLowerCase();
-}
+import { readFile } from "fs/promises";
+import { join as join2 } from "path";
 
-// ../worker/dist/execution-phase.js
+// ../worker/src/execution-phase.ts
 function resolveInitialExecutionPhase(input) {
   const { issueState, blockerCheckStates, activeStates } = input;
   if (!issueState) {
@@ -472,7 +55,7 @@ function resolveFinalExecutionPhase(input) {
   return resolvePausedExecutionPhase(input.currentPhase) ?? input.currentPhase;
 }
 
-// ../worker/dist/codex-policy.js
+// ../worker/src/codex-policy.ts
 function resolveCodexPolicySettings(env) {
   return {
     approvalPolicy: env.SYMPHONY_APPROVAL_POLICY || "never",
@@ -481,7 +64,7 @@ function resolveCodexPolicySettings(env) {
   };
 }
 
-// ../worker/dist/convergence-detection.js
+// ../worker/src/convergence-detection.ts
 import { spawnSync } from "child_process";
 var DEFAULT_MAX_NONPRODUCTIVE_TURNS = 3;
 function resolveMaxNonProductiveTurns(env) {
@@ -490,10 +73,14 @@ function resolveMaxNonProductiveTurns(env) {
   return Number.isInteger(parsed) && parsed > 0 ? parsed : DEFAULT_MAX_NONPRODUCTIVE_TURNS;
 }
 function captureTurnWorkspaceSnapshot(cwd) {
-  const result = spawnSync("git", ["status", "--porcelain=v1", "--untracked-files=all"], {
-    cwd,
-    encoding: "utf8"
-  });
+  const result = spawnSync(
+    "git",
+    ["status", "--porcelain=v1", "--untracked-files=all"],
+    {
+      cwd,
+      encoding: "utf8"
+    }
+  );
   if (result.status !== 0) {
     return {
       fingerprint: null,
@@ -539,7 +126,153 @@ function normalizeError(value) {
   return normalized.length > 0 ? normalized : null;
 }
 
-// ../worker/dist/run-phase.js
+// ../worker/src/non-codex-runtime.ts
+import {
+  spawn
+} from "child_process";
+import { finished } from "stream/promises";
+var CustomCommandWorkerRuntimeAdapter = class {
+  constructor(config, dependencies = {}) {
+    this.config = config;
+    this.dependencies = dependencies;
+  }
+  activeChild = null;
+  prepare() {
+  }
+  async spawnTurn(input) {
+    const command = this.config.command;
+    const args = [...this.config.args];
+    const cwd = input.cwd ?? this.config.workingDirectory;
+    const child = (this.dependencies.spawnImpl ?? spawn)(command, args, {
+      cwd,
+      env: {
+        ...this.config.env,
+        ...input.env,
+        SYMPHONY_RENDERED_PROMPT: input.prompt
+      },
+      stdio: "pipe"
+    });
+    this.activeChild = child;
+    this.config.onSpawned?.(child);
+    let stdout = "";
+    let stderr = "";
+    let spawnError;
+    child.stdout?.setEncoding("utf8");
+    child.stderr?.setEncoding("utf8");
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk;
+    });
+    child.stderr?.on("data", (chunk) => {
+      stderr += chunk;
+    });
+    child.once("error", (error) => {
+      spawnError = error.message;
+    });
+    if (child.stdin && !child.stdin.destroyed) {
+      child.stdin.end(input.prompt);
+    }
+    const { exitCode, signal } = await waitForChildExit(child);
+    await Promise.all([
+      child.stdout ? finished(child.stdout).catch(() => void 0) : void 0,
+      child.stderr ? finished(child.stderr).catch(() => void 0) : void 0
+    ]);
+    this.activeChild = null;
+    const result = exitCode === 0 && signal === null && !spawnError ? "success" : "process-error";
+    return {
+      command,
+      args,
+      cwd,
+      stdout,
+      stderr,
+      exitCode,
+      signal,
+      result,
+      errorMessage: spawnError
+    };
+  }
+  onEvent(_handler) {
+    return () => {
+    };
+  }
+  resolveCredentials(brokerResponse) {
+    if (!this.config.authEnvKey) {
+      return {};
+    }
+    return extractEnvForClaude(brokerResponse.env, this.config.authEnvKey);
+  }
+  shutdown() {
+    this.stopActiveChild();
+  }
+  cancel() {
+    this.stopActiveChild();
+  }
+  stopActiveChild() {
+    if (!this.activeChild || this.activeChild.killed) {
+      this.activeChild = null;
+      return;
+    }
+    this.activeChild.kill("SIGTERM");
+    this.activeChild = null;
+  }
+};
+function createWorkerNonCodexRuntimeAdapter(workflow, context) {
+  const runtime = workflow.runtime;
+  if (!runtime || runtime.kind === "codex-app-server") {
+    throw new Error(
+      "Worker non-Codex runtime adapter requested for a Codex runtime."
+    );
+  }
+  switch (runtime.kind) {
+    case "claude-print":
+      return createClaudePrintRuntimeAdapter(
+        {
+          workingDirectory: context.workingDirectory,
+          runtimeRoot: context.runtimeRoot,
+          runtimeDirectory: context.runtimeDirectory,
+          command: runtime.command,
+          args: runtime.args,
+          env: context.env,
+          authEnvKey: runtime.auth.env ?? void 0,
+          isolation: {
+            bare: runtime.isolation.bare,
+            strictMcpConfig: runtime.isolation.strictMcpConfig
+          }
+        },
+        {
+          ...context.claudeDependencies,
+          onSpawned: context.onSpawned
+        }
+      );
+    case "custom":
+      return new CustomCommandWorkerRuntimeAdapter(
+        {
+          workingDirectory: context.workingDirectory,
+          command: runtime.command,
+          args: runtime.args,
+          env: context.env,
+          authEnvKey: runtime.auth.env ?? void 0,
+          onSpawned: context.onSpawned
+        },
+        context.customDependencies
+      );
+  }
+}
+function waitForChildExit(child) {
+  return new Promise((resolve) => {
+    let settled = false;
+    const settle = (exitCode, signal) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      resolve({ exitCode, signal });
+    };
+    child.once("exit", settle);
+    child.once("error", () => settle(1, null));
+  });
+}
+
+// ../worker/src/run-phase.ts
 var TERMINAL_RUN_PHASES = /* @__PURE__ */ new Set([
   "succeeded",
   "failed",
@@ -554,7 +287,16 @@ function resolveExitRunPhase(currentRunPhase, exit) {
   return exit.code === 0 && !exit.signal ? "succeeded" : "failed";
 }
 
-// ../worker/dist/thread-resume.js
+// ../worker/src/runtime-routing.ts
+function resolveWorkerRuntimeRoute(workflow) {
+  const kind = workflow.runtime?.kind;
+  if (!kind || kind === "codex-app-server") {
+    return "codex-app-server";
+  }
+  return "runtime-adapter";
+}
+
+// ../worker/src/thread-resume.ts
 var DEFAULT_CONTINUATION_GUIDANCE = "Continue working on the issue. Review your progress and complete any remaining tasks.";
 function parseNonNegativeInteger(value) {
   const parsed = typeof value === "number" ? value : Number.parseInt(value ?? "", 10);
@@ -563,11 +305,17 @@ function parseNonNegativeInteger(value) {
   }
   return Math.floor(parsed);
 }
-function buildContinuationTurnInput({ continuationGuidance, lastTurnSummary, cumulativeTurnCount = 0 }) {
+function buildContinuationTurnInput({
+  continuationGuidance,
+  lastTurnSummary,
+  cumulativeTurnCount = 0
+}) {
   const template = continuationGuidance?.trim() || DEFAULT_CONTINUATION_GUIDANCE;
   return renderContinuationGuidance(template, {
     lastTurnSummary: normalizeContinuationVariable(lastTurnSummary) ?? "No previous turn summary was captured.",
-    cumulativeTurnCount: String(Math.max(0, parseNonNegativeInteger(cumulativeTurnCount)))
+    cumulativeTurnCount: String(
+      Math.max(0, parseNonNegativeInteger(cumulativeTurnCount))
+    )
   });
 }
 function normalizeContinuationVariable(value) {
@@ -576,7 +324,9 @@ function normalizeContinuationVariable(value) {
 }
 function renderContinuationGuidance(template, variables) {
   if (template.includes("{%") || template.includes("%}")) {
-    throw new Error("template_parse_error: continuation guidance does not support Liquid tags.");
+    throw new Error(
+      "template_parse_error: continuation guidance does not support Liquid tags."
+    );
   }
   let rendered = "";
   let lastIndex = 0;
@@ -587,7 +337,9 @@ function renderContinuationGuidance(template, variables) {
     const index = match.index ?? 0;
     rendered += template.slice(lastIndex, index);
     if (!(expression in variables)) {
-      throw new Error(`template_render_error: unsupported continuation guidance variable '${expression}'.`);
+      throw new Error(
+        `template_render_error: unsupported continuation guidance variable '${expression}'.`
+      );
     }
     rendered += variables[expression] ?? "";
     lastIndex = index + matchedText.length;
@@ -595,12 +347,14 @@ function renderContinuationGuidance(template, variables) {
   rendered += template.slice(lastIndex);
   const strayLiquidExpression = rendered.match(/\{\{[^}]*\}\}/);
   if (strayLiquidExpression) {
-    throw new Error(`template_parse_error: invalid continuation guidance expression '${strayLiquidExpression[0]}'.`);
+    throw new Error(
+      `template_parse_error: invalid continuation guidance expression '${strayLiquidExpression[0]}'.`
+    );
   }
   return rendered;
 }
 
-// ../worker/dist/turn-limits.js
+// ../worker/src/turn-limits.ts
 var DEFAULT_SESSION_MAX_TURNS = 20;
 function resolveMaxTurns(value) {
   const parsed = typeof value === "number" ? value : Number(value);
@@ -623,21 +377,27 @@ function resolveMaxTurns(value) {
   };
 }
 
-// ../worker/dist/token-usage.js
-import { mkdir as mkdir2, writeFile as writeFile3 } from "fs/promises";
-import { dirname as dirname2, join as join2 } from "path";
+// ../worker/src/token-usage.ts
+import { mkdir, writeFile } from "fs/promises";
+import { dirname, join } from "path";
 async function persistTokenUsageArtifact(env, tokenUsage) {
   const artifactPath = resolveTokenUsageArtifactPath(env);
   if (!artifactPath) {
     return;
   }
   try {
-    await mkdir2(dirname2(artifactPath), { recursive: true });
-    await writeFile3(artifactPath, JSON.stringify(tokenUsage, null, 2) + "\n", "utf8");
+    await mkdir(dirname(artifactPath), { recursive: true });
+    await writeFile(
+      artifactPath,
+      JSON.stringify(tokenUsage, null, 2) + "\n",
+      "utf8"
+    );
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
-    process.stderr.write(`[worker] failed to persist token usage artifact: ${message}
-`);
+    process.stderr.write(
+      `[worker] failed to persist token usage artifact: ${message}
+`
+    );
   }
 }
 function resolveTokenUsageArtifactPath(env) {
@@ -645,10 +405,10 @@ function resolveTokenUsageArtifactPath(env) {
   if (!workspaceRuntimeDir) {
     return null;
   }
-  return join2(workspaceRuntimeDir, "token-usage.json");
+  return join(workspaceRuntimeDir, "token-usage.json");
 }
 
-// ../worker/dist/index.js
+// ../worker/src/index.ts
 var launcherEnv = loadLauncherEnvironment(process.env);
 var runtimeState = {
   status: launcherEnv.SYMPHONY_RUN_ID ? "starting" : "idle",
@@ -684,11 +444,18 @@ var runtimeState = {
     exitClassification: null
   }
 };
-console.log(JSON.stringify({
-  package: "@gh-symphony/worker",
-  runtime: "self-hosted-sample"
-}, null, 2));
+console.log(
+  JSON.stringify(
+    {
+      package: "@gh-symphony/worker",
+      runtime: "self-hosted-sample"
+    },
+    null,
+    2
+  )
+);
 var childProcess = null;
+var runtimeAdapter = null;
 var shutdownPromise = null;
 var orchestratorChannelDrainPending = false;
 var pendingOrchestratorChannelPayloads = [];
@@ -719,10 +486,13 @@ function shutdown(signal) {
       } catch {
       }
     }
+    await runtimeAdapter?.cancel(`worker received ${signal}`);
     stopOrchestratorHeartbeatTimer();
     emitOrchestratorHeartbeat();
     await persistSessionTokenUsageArtifact(launcherEnv);
-    await waitForPendingOrchestratorChannelFlush(resolveTerminalOrchestratorChannelFlushTimeoutMs());
+    await waitForPendingOrchestratorChannelFlush(
+      resolveTerminalOrchestratorChannelFlushTimeoutMs()
+    );
     console.log(`Worker stopped on ${signal}`);
     process.exit(0);
   })();
@@ -755,13 +525,13 @@ function waitForPendingOrchestratorChannelFlush(timeoutMs = ORCHESTRATOR_CHANNEL
   if (!orchestratorChannelDrainPending && pendingOrchestratorChannelPayloads.length === 0) {
     return Promise.resolve();
   }
-  return new Promise((resolve2) => {
+  return new Promise((resolve) => {
     let settled = false;
     let timeout = setTimeout(() => {
       settled = true;
       process.stderr.removeListener("drain", handleDrain);
       timeout = null;
-      resolve2();
+      resolve();
     }, timeoutMs);
     const handleDrain = () => {
       if (orchestratorChannelDrainPending || pendingOrchestratorChannelPayloads.length > 0) {
@@ -776,14 +546,17 @@ function waitForPendingOrchestratorChannelFlush(timeoutMs = ORCHESTRATOR_CHANNEL
         timeout = null;
       }
       process.stderr.removeListener("drain", handleDrain);
-      resolve2();
+      resolve();
     };
     process.stderr.on("drain", handleDrain);
   });
 }
 function resolveTerminalOrchestratorChannelFlushTimeoutMs() {
   const pendingPayloadCount = pendingOrchestratorChannelPayloads.length + (orchestratorChannelDrainPending ? 1 : 0);
-  return Math.max(ORCHESTRATOR_CHANNEL_FLUSH_TIMEOUT_MS, pendingPayloadCount * ORCHESTRATOR_CHANNEL_FLUSH_TIMEOUT_MS);
+  return Math.max(
+    ORCHESTRATOR_CHANNEL_FLUSH_TIMEOUT_MS,
+    pendingPayloadCount * ORCHESTRATOR_CHANNEL_FLUSH_TIMEOUT_MS
+  );
 }
 function writeOrQueueOrchestratorChannelPayload(serializedPayload) {
   if (orchestratorChannelDrainPending) {
@@ -861,9 +634,18 @@ function cloneTokenUsageSnapshot() {
 }
 function resolveTurnTokenUsageDelta(baseline) {
   return {
-    inputTokens: Math.max(0, runtimeState.tokenUsage.inputTokens - baseline.inputTokens),
-    outputTokens: Math.max(0, runtimeState.tokenUsage.outputTokens - baseline.outputTokens),
-    totalTokens: Math.max(0, runtimeState.tokenUsage.totalTokens - baseline.totalTokens)
+    inputTokens: Math.max(
+      0,
+      runtimeState.tokenUsage.inputTokens - baseline.inputTokens
+    ),
+    outputTokens: Math.max(
+      0,
+      runtimeState.tokenUsage.outputTokens - baseline.outputTokens
+    ),
+    totalTokens: Math.max(
+      0,
+      runtimeState.tokenUsage.totalTokens - baseline.totalTokens
+    )
   };
 }
 function resolveSessionTokenUsageDelta() {
@@ -900,7 +682,10 @@ function emitTurnCompletedEvent(turn) {
     issueId,
     startedAt: turn.startedAt,
     completedAt,
-    durationMs: Math.max(0, new Date(completedAt).getTime() - new Date(turn.startedAt).getTime()),
+    durationMs: Math.max(
+      0,
+      new Date(completedAt).getTime() - new Date(turn.startedAt).getTime()
+    ),
     threadId: turn.threadId,
     turnId: turn.turnId,
     turnCount: turn.turnCount,
@@ -921,7 +706,10 @@ function emitTurnFailedEvent(turn, error) {
     issueId,
     startedAt: turn.startedAt,
     failedAt,
-    durationMs: Math.max(0, new Date(failedAt).getTime() - new Date(turn.startedAt).getTime()),
+    durationMs: Math.max(
+      0,
+      new Date(failedAt).getTime() - new Date(turn.startedAt).getTime()
+    ),
     threadId: turn.threadId,
     turnId: turn.turnId,
     turnCount: turn.turnCount,
@@ -934,17 +722,44 @@ function emitTurnFailedEvent(turn, error) {
 }
 async function startAssignedRun() {
   try {
-    const workflowPath = launcherEnv.SYMPHONY_WORKFLOW_PATH || join3(launcherEnv.WORKING_DIRECTORY, "WORKFLOW.md");
+    const workflowPath = launcherEnv.SYMPHONY_WORKFLOW_PATH || join2(launcherEnv.WORKING_DIRECTORY, "WORKFLOW.md");
     runtimeState.runPhase = "building_prompt";
-    const workflow = parseWorkflowMarkdown(await readFile2(workflowPath, "utf8"), launcherEnv);
+    const workflow = parseWorkflowMarkdown(
+      await readFile(workflowPath, "utf8"),
+      launcherEnv
+    );
+    const route = resolveWorkerRuntimeRoute(workflow);
+    if (route === "runtime-adapter" && workflow.runtime?.kind === "claude-print" && isClaudeRuntimeCommand(resolveWorkflowRuntimeCommand(workflow))) {
+      const hasGitHubGraphqlToken = typeof launcherEnv.GITHUB_GRAPHQL_TOKEN === "string" && launcherEnv.GITHUB_GRAPHQL_TOKEN.trim().length > 0;
+      const preflight = await runClaudePreflight({
+        cwd: launcherEnv.WORKING_DIRECTORY,
+        env: launcherEnv,
+        command: resolveClaudeCommandBinary(workflow.codex.command) ?? void 0,
+        includeGhAuth: !hasGitHubGraphqlToken
+      });
+      process.stderr.write(
+        `[worker] ${formatClaudePreflightText(preflight)}
+`
+      );
+      if (!preflight.ok) {
+        await exitWorkerStartupFailure(
+          "Claude runtime preflight failed before agent launch."
+        );
+        return;
+      }
+    }
     runtimeState.executionPhase = resolveInitialExecutionPhase({
       issueState: runtimeState.run?.state,
       blockerCheckStates: workflow.lifecycle.blockerCheckStates,
       activeStates: workflow.lifecycle.activeStates
     });
-    const config = resolveLocalRuntimeLaunchConfig(launcherEnv);
-    config.agentCommand = workflow.codex.command;
     runtimeState.runPhase = "launching_agent";
+    if (route === "runtime-adapter") {
+      await runNonCodexRuntimeAdapterLifecycle(workflow, launcherEnv);
+      return;
+    }
+    const config = resolveLocalRuntimeLaunchConfig(launcherEnv);
+    config.agentCommand = resolveWorkflowRuntimeCommand(workflow);
     const plan = await prepareCodexRuntimePlan(config);
     childProcess = launchCodexAppServer(plan);
     runtimeState.status = "running";
@@ -955,24 +770,27 @@ async function startAssignedRun() {
     void runCodexClientProtocol(childProcess, plan, launcherEnv, {
       continuationGuidance: workflow.continuationGuidance
     });
-    childProcess.once("exit", (code, signal) => {
-      const currentRunPhase = runtimeState.runPhase;
-      const nextRunPhase = resolveExitRunPhase(currentRunPhase, {
-        code,
-        signal
-      });
-      const preservesTerminalPhase = currentRunPhase != null && nextRunPhase === currentRunPhase;
-      if (!preservesTerminalPhase) {
-        runtimeState.status = code === 0 && !signal ? "completed" : "failed";
-      }
-      runtimeState.runPhase = nextRunPhase;
-      if (runtimeState.run) {
+    childProcess.once(
+      "exit",
+      (code, signal) => {
+        const currentRunPhase = runtimeState.runPhase;
+        const nextRunPhase = resolveExitRunPhase(currentRunPhase, {
+          code,
+          signal
+        });
+        const preservesTerminalPhase = currentRunPhase != null && nextRunPhase === currentRunPhase;
         if (!preservesTerminalPhase) {
-          runtimeState.run.lastError = code === 0 && !signal ? null : `codex app-server exited with ${signal ?? code ?? "unknown"}`;
+          runtimeState.status = code === 0 && !signal ? "completed" : "failed";
+        }
+        runtimeState.runPhase = nextRunPhase;
+        if (runtimeState.run) {
+          if (!preservesTerminalPhase) {
+            runtimeState.run.lastError = code === 0 && !signal ? null : `codex app-server exited with ${signal ?? code ?? "unknown"}`;
+          }
         }
+        void persistSessionTokenUsageArtifact(launcherEnv);
       }
-      void persistSessionTokenUsageArtifact(launcherEnv);
-    });
+    );
     childProcess.once("error", (error) => {
       runtimeState.status = "failed";
       runtimeState.runPhase = "failed";
@@ -982,25 +800,243 @@ async function startAssignedRun() {
       void persistSessionTokenUsageArtifact(launcherEnv);
     });
   } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown worker startup error";
     runtimeState.status = "failed";
     runtimeState.runPhase = "failed";
     if (runtimeState.run) {
-      runtimeState.run.lastError = error instanceof Error ? error.message : "Unknown worker startup error";
+      runtimeState.run.lastError = message;
     }
+    process.stderr.write(`[worker] startup failed: ${message}
+`);
     await persistSessionTokenUsageArtifact(launcherEnv);
   }
 }
+async function runNonCodexRuntimeAdapterLifecycle(workflow, env) {
+  const renderedPrompt = env.SYMPHONY_RENDERED_PROMPT;
+  if (!renderedPrompt) {
+    await exitWorkerStartupFailure(
+      "SYMPHONY_RENDERED_PROMPT not set; cannot run runtime adapter lifecycle."
+    );
+    return;
+  }
+  const runId = env.SYMPHONY_RUN_ID;
+  if (!runId) {
+    await exitWorkerStartupFailure(
+      "SYMPHONY_RUN_ID not set; cannot prepare runtime adapter lifecycle."
+    );
+    return;
+  }
+  const runtimeKind = workflow.runtime?.kind;
+  if (runtimeKind !== "claude-print" && runtimeKind !== "custom") {
+    await exitWorkerStartupFailure(
+      "Runtime adapter lifecycle requested for an unsupported runtime kind."
+    );
+    return;
+  }
+  const adapter = createWorkerNonCodexRuntimeAdapter(workflow, {
+    workingDirectory: env.WORKING_DIRECTORY,
+    env,
+    runtimeRoot: env.WORKSPACE_RUNTIME_DIR,
+    runtimeDirectory: env.WORKSPACE_RUNTIME_DIR,
+    onSpawned: (child) => {
+      childProcess = child;
+      if (runtimeState.run) {
+        runtimeState.run.processId = child.pid ?? null;
+      }
+    }
+  });
+  runtimeAdapter = adapter;
+  let terminalFailure = null;
+  const unsubscribe = adapter.onEvent((event) => {
+    const agentEvent = event;
+    handleNonCodexRuntimeEvent(agentEvent);
+    if (agentEvent.name === "agent.inputRequired") {
+      terminalFailure = agentEvent.payload.reason;
+    }
+    if (agentEvent.name === "agent.turnFailed" || agentEvent.name === "agent.error") {
+      terminalFailure = agentEvent.name === "agent.error" ? agentEvent.payload.error : JSON.stringify(agentEvent.payload.params);
+    }
+  });
+  const turnTelemetry = {
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    threadId: null,
+    turnId: `${runId}-turn-1`,
+    turnCount: 1,
+    sessionId: runId,
+    tokenUsageBaseline: cloneTokenUsageSnapshot()
+  };
+  try {
+    await adapter.prepare({
+      runId
+    });
+    runtimeState.status = "running";
+    runtimeState.runPhase = "streaming_turn";
+    runtimeState.sessionInfo = {
+      threadId: turnTelemetry.threadId,
+      turnId: turnTelemetry.turnId,
+      turnCount: turnTelemetry.turnCount,
+      sessionId: turnTelemetry.sessionId,
+      exitClassification: null
+    };
+    runtimeState.sessionId = turnTelemetry.sessionId;
+    emitTurnStartedEvent(turnTelemetry);
+    const result = await spawnNonCodexRuntimeTurn(
+      adapter,
+      runtimeKind,
+      renderedPrompt,
+      env
+    );
+    if (isNonCodexTurnFailure(result)) {
+      terminalFailure = describeNonCodexTurnFailure(result);
+    }
+    runtimeState.status = terminalFailure ? "failed" : "completed";
+    runtimeState.runPhase = terminalFailure ? "failed" : "succeeded";
+    if (runtimeState.run) {
+      runtimeState.run.lastError = terminalFailure;
+    }
+    runtimeState.sessionInfo.exitClassification = classifySessionExit({
+      runPhase: runtimeState.runPhase,
+      userInputRequired: terminalFailure === DEFAULT_AGENT_INPUT_REQUIRED_REASON || terminalFailure?.startsWith("turn_input_required:") === true,
+      budgetExceeded: false,
+      convergenceDetected: false,
+      maxTurnsReached: false
+    });
+    if (terminalFailure) {
+      emitTurnFailedEvent(turnTelemetry, terminalFailure);
+    } else {
+      emitTurnCompletedEvent(turnTelemetry);
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown runtime adapter lifecycle error";
+    runtimeState.status = "failed";
+    runtimeState.runPhase = "failed";
+    if (runtimeState.run) {
+      runtimeState.run.lastError = message;
+    }
+    runtimeState.sessionInfo.exitClassification = classifySessionExit({
+      runPhase: runtimeState.runPhase,
+      userInputRequired: false,
+      budgetExceeded: false,
+      convergenceDetected: false,
+      maxTurnsReached: false
+    });
+    emitTurnFailedEvent(turnTelemetry, message);
+  } finally {
+    unsubscribe();
+    await adapter.shutdown();
+    runtimeAdapter = null;
+    childProcess = null;
+    runtimeState.runPhase = runtimeState.runPhase ?? "failed";
+    stopOrchestratorHeartbeatTimer();
+    emitOrchestratorHeartbeat();
+    await persistSessionTokenUsageArtifact(env);
+    await waitForPendingOrchestratorChannelFlush(
+      resolveTerminalOrchestratorChannelFlushTimeoutMs()
+    );
+    setTimeout(() => {
+      process.exit(runtimeState.status === "completed" ? 0 : 1);
+    }, 1500);
+  }
+}
+async function spawnNonCodexRuntimeTurn(adapter, runtimeKind, renderedPrompt, env) {
+  if (runtimeKind === "claude-print") {
+    return await adapter.spawnTurn({
+      messages: [{ type: "user", text: renderedPrompt }],
+      cwd: env.WORKING_DIRECTORY,
+      env
+    });
+  }
+  return await adapter.spawnTurn({
+    prompt: renderedPrompt,
+    cwd: env.WORKING_DIRECTORY,
+    env
+  });
+}
+function handleNonCodexRuntimeEvent(event) {
+  if (event.payload.suppressUpdate) {
+    return;
+  }
+  runtimeState.lastEventAt = (/* @__PURE__ */ new Date()).toISOString();
+  switch (event.name) {
+    case "agent.tokenUsageUpdated": {
+      const tokenUsage = extractAbsoluteTokenUsage(event.payload.params);
+      if (tokenUsage) {
+        applyTokenUsageUpdate(
+          event.payload.observabilityEvent ?? event.name,
+          tokenUsage
+        );
+      }
+      break;
+    }
+    case "agent.rateLimit": {
+      const rateLimits = extractRateLimitPayload(event.payload.params);
+      if (rateLimits) {
+        applyRateLimitUpdate(
+          event.payload.observabilityEvent ?? event.name,
+          rateLimits,
+          "runtime-adapter"
+        );
+      }
+      break;
+    }
+    case "agent.inputRequired":
+      runtimeState.status = "failed";
+      if (runtimeState.run) {
+        runtimeState.run.lastError = event.payload.reason;
+      }
+      break;
+    case "agent.turnFailed":
+    case "agent.turnCancelled":
+    case "agent.error":
+      runtimeState.status = "failed";
+      if (runtimeState.run) {
+        runtimeState.run.lastError = event.name === "agent.error" ? event.payload.error : JSON.stringify(event.payload.params);
+      }
+      break;
+    default:
+      break;
+  }
+  emitOrchestratorChannelEvent(event.payload.observabilityEvent ?? event.name);
+}
+function isNonCodexTurnFailure(result) {
+  return result.result !== "success";
+}
+function describeNonCodexTurnFailure(result) {
+  return result.errorMessage ?? `${result.command} exited with ${result.signal ?? result.exitCode ?? "unknown"}`;
+}
+async function exitWorkerStartupFailure(message) {
+  runtimeState.status = "failed";
+  runtimeState.runPhase = "failed";
+  if (runtimeState.run) {
+    runtimeState.run.lastError = message;
+  }
+  process.stderr.write(`[worker] ${message}
+`);
+  stopOrchestratorHeartbeatTimer();
+  emitOrchestratorHeartbeat();
+  await persistSessionTokenUsageArtifact(launcherEnv);
+  await waitForPendingOrchestratorChannelFlush(
+    resolveTerminalOrchestratorChannelFlushTimeoutMs()
+  );
+  process.exit(1);
+}
 async function runCodexClientProtocol(child, plan, env, options) {
   const renderedPrompt = env.SYMPHONY_RENDERED_PROMPT;
   if (!renderedPrompt) {
-    process.stderr.write("[worker] SYMPHONY_RENDERED_PROMPT not set; skipping codex client protocol\n");
+    process.stderr.write(
+      "[worker] SYMPHONY_RENDERED_PROMPT not set; skipping codex client protocol\n"
+    );
     return;
   }
   if (!child.stdin || !child.stdout) {
-    process.stderr.write("[worker] codex process has no stdio pipes; cannot run client protocol\n");
+    process.stderr.write(
+      "[worker] codex process has no stdio pipes; cannot run client protocol\n"
+    );
     return;
   }
-  const { maxTurns, exhaustedBeforeStart } = resolveMaxTurns(env.SYMPHONY_MAX_TURNS);
+  const { maxTurns, exhaustedBeforeStart } = resolveMaxTurns(
+    env.SYMPHONY_MAX_TURNS
+  );
   const readTimeoutMs = Number(env.SYMPHONY_READ_TIMEOUT_MS) || 5e3;
   const turnTimeoutMs = Number(env.SYMPHONY_TURN_TIMEOUT_MS) || 36e5;
   const maxNonProductiveTurns = resolveMaxNonProductiveTurns(env);
@@ -1015,10 +1051,11 @@ async function runCodexClientProtocol(child, plan, env, options) {
   let lineBuffer = "";
   let deltaBuffer = null;
   function flushDeltaBuffer() {
-    if (!deltaBuffer)
-      return;
-    process.stderr.write(`[worker] codex \u2192 agent_message [accumulated] ${JSON.stringify({ text: deltaBuffer.text }).slice(0, 500)}
-`);
+    if (!deltaBuffer) return;
+    process.stderr.write(
+      `[worker] codex \u2192 agent_message [accumulated] ${JSON.stringify({ text: deltaBuffer.text }).slice(0, 500)}
+`
+    );
     deltaBuffer = null;
   }
   const pendingRequests = /* @__PURE__ */ new Map();
@@ -1035,7 +1072,8 @@ async function runCodexClientProtocol(child, plan, env, options) {
     }
   }
   function describeTurnTerminalEvent(event, params) {
-    const fallback = event === "turn/failed" ? "turn_failed: codex reported turn failure" : "turn_cancelled: codex reported turn cancellation";
+    const errorPrefix = event === "agent.turnFailed" ? "turn_failed" : "turn_cancelled";
+    const fallback = event === "agent.turnFailed" ? "turn_failed: codex reported turn failure" : "turn_cancelled: codex reported turn cancellation";
     if (!params || typeof params !== "object") {
       return fallback;
     }
@@ -1044,18 +1082,18 @@ async function runCodexClientProtocol(child, plan, env, options) {
     for (const key of directReasonKeys) {
       const value = record[key];
       if (typeof value === "string" && value.trim()) {
-        return `${event.replace("/", "_")}: ${value.trim()}`;
+        return `${errorPrefix}: ${value.trim()}`;
       }
       if (value && typeof value === "object" && typeof value.message === "string") {
         const nested = value;
         const nestedMessage = String(nested.message).trim();
         if (nestedMessage) {
-          return `${event.replace("/", "_")}: ${nestedMessage}`;
+          return `${errorPrefix}: ${nestedMessage}`;
         }
       }
     }
     const serialized = JSON.stringify(params).slice(0, 300);
-    return serialized && serialized !== "{}" ? `${event.replace("/", "_")}: ${serialized}` : fallback;
+    return serialized && serialized !== "{}" ? `${errorPrefix}: ${serialized}` : fallback;
   }
   function markTurnTerminalFailure(runPhase, lastError) {
     runtimeState.status = "failed";
@@ -1075,36 +1113,45 @@ async function runCodexClientProtocol(child, plan, env, options) {
     child.stdin?.write(line);
   }
   function sendRequest(id, method, params) {
-    return new Promise((resolve2, reject) => {
-      pendingRequests.set(id, { resolve: resolve2, reject });
+    return new Promise((resolve, reject) => {
+      pendingRequests.set(id, { resolve, reject });
       sendMessage({ jsonrpc: "2.0", id, method, params });
     });
   }
   function sendRequestWithTimeout(id, method, params) {
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve, reject) => {
       const timer = setTimeout(() => {
         pendingRequests.delete(id);
-        reject(new Error(`response_timeout: ${method} timed out after ${readTimeoutMs}ms`));
+        reject(
+          new Error(
+            `response_timeout: ${method} timed out after ${readTimeoutMs}ms`
+          )
+        );
       }, readTimeoutMs);
-      sendRequest(id, method, params).then((result) => {
-        clearTimeout(timer);
-        resolve2(result);
-      }, (error) => {
-        clearTimeout(timer);
-        reject(error);
-      });
+      sendRequest(id, method, params).then(
+        (result) => {
+          clearTimeout(timer);
+          resolve(result);
+        },
+        (error) => {
+          clearTimeout(timer);
+          reject(error);
+        }
+      );
     });
   }
   function waitForTurnCompletion() {
-    return new Promise((resolve2) => {
-      turnCompletedResolve = resolve2;
+    return new Promise((resolve) => {
+      turnCompletedResolve = resolve;
     });
   }
   function waitForTurnWithTimeout() {
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve, reject) => {
       const timer = setTimeout(() => {
-        process.stderr.write(`[worker] turn_timeout: turn exceeded ${turnTimeoutMs}ms \u2014 killing codex process
-`);
+        process.stderr.write(
+          `[worker] turn_timeout: turn exceeded ${turnTimeoutMs}ms \u2014 killing codex process
+`
+        );
         if (child.pid) {
           try {
             process.kill(child.pid, "SIGTERM");
@@ -1113,20 +1160,27 @@ async function runCodexClientProtocol(child, plan, env, options) {
         }
         reject(new Error("turn_timeout: turn exceeded time limit"));
       }, turnTimeoutMs);
-      waitForTurnCompletion().then(() => {
-        clearTimeout(timer);
-        resolve2();
-      }, (error) => {
-        clearTimeout(timer);
-        reject(error);
-      });
+      waitForTurnCompletion().then(
+        () => {
+          clearTimeout(timer);
+          resolve();
+        },
+        (error) => {
+          clearTimeout(timer);
+          reject(error);
+        }
+      );
     });
   }
   async function dispatchDynamicToolCall(callId, toolName, threadId, turnId, args) {
-    const toolDef = plan.tools.find((t) => t.name === toolName);
+    const toolDef = plan.tools.find(
+      (t) => t.name === toolName
+    );
     if (!toolDef) {
-      process.stderr.write(`[worker] unknown dynamic tool: ${toolName}; sending error response
-`);
+      process.stderr.write(
+        `[worker] unknown dynamic tool: ${toolName}; sending error response
+`
+      );
       sendMessage({
         jsonrpc: "2.0",
         method: "dynamic_tool_call_response",
@@ -1146,8 +1200,10 @@ async function runCodexClientProtocol(child, plan, env, options) {
       return;
     }
     const inputJson = JSON.stringify(args ?? {});
-    process.stderr.write(`[worker] executing dynamic tool "${toolName}" (callId=${callId})
-`);
+    process.stderr.write(
+      `[worker] executing dynamic tool "${toolName}" (callId=${callId})
+`
+    );
     try {
       const output = await runToolProcess(toolDef, inputJson);
       sendMessage({
@@ -1178,138 +1234,185 @@ async function runCodexClientProtocol(child, plan, env, options) {
       });
     }
   }
-  function handleServerMessage(msg) {
-    if ("id" in msg && msg.id != null && ("result" in msg || "error" in msg)) {
-      const id = String(msg.id);
-      const pending = pendingRequests.get(id);
-      if (pending) {
-        pendingRequests.delete(id);
-        if ("error" in msg) {
-          pending.reject(new Error(JSON.stringify(msg.error)));
-        } else {
-          pending.resolve(msg.result);
-        }
-      }
+  function emitObservedAgentEvent(event) {
+    if (event.payload.suppressUpdate) {
       return;
     }
-    runtimeState.lastEventAt = (/* @__PURE__ */ new Date()).toISOString();
-    const orchestratorEventName = typeof msg.method === "string" ? msg.method : void 0;
-    if (msg.method === "dynamic_tool_call_request" && msg.params != null) {
-      const params = msg.params;
-      void dispatchDynamicToolCall(params.callId, params.tool, params.threadId, params.turnId, params.arguments);
-      emitOrchestratorChannelEvent(orchestratorEventName);
-      return;
+    emitOrchestratorChannelEvent(getCodexObservabilityEventName(event));
+  }
+  function handleInputRequired(reason, event) {
+    process.stderr.write(
+      "[worker] user_input_required detected \u2014 terminating agent process\n"
+    );
+    userInputRequired = true;
+    runtimeState.status = "failed";
+    if (runtimeState.run) {
+      runtimeState.run.lastError = reason;
     }
-    if (msg.method === "item/tool/requestUserInput") {
-      process.stderr.write("[worker] user_input_required detected \u2014 terminating codex process\n");
-      userInputRequired = true;
-      runtimeState.status = "failed";
-      if (runtimeState.run) {
-        runtimeState.run.lastError = "turn_input_required: agent requires user input";
-      }
-      if (child.pid) {
-        try {
-          process.kill(child.pid, "SIGTERM");
-        } catch {
-        }
-      }
-      if (activeTurnTelemetry) {
-        emitTurnFailedEvent(activeTurnTelemetry, runtimeState.run?.lastError ?? null);
-        activeTurnTelemetry = null;
+    if (child.pid) {
+      try {
+        process.kill(child.pid, "SIGTERM");
+      } catch {
       }
-      resolvePendingTurnCompletion();
-      emitOrchestratorChannelEvent(orchestratorEventName);
-      return;
     }
-    if (msg.method === "turn/completed") {
-      flushDeltaBuffer();
-      const turnParams = msg.params ?? {};
-      const turnUsage = extractAbsoluteTokenUsage(turnParams.usage);
-      if (turnUsage) {
-        applyTokenUsageUpdate("turn/completed", turnUsage);
+    if (activeTurnTelemetry) {
+      emitTurnFailedEvent(
+        activeTurnTelemetry,
+        runtimeState.run?.lastError ?? null
+      );
+      activeTurnTelemetry = null;
+    }
+    resolvePendingTurnCompletion();
+    emitObservedAgentEvent(event);
+  }
+  function handleAgentEvent(event) {
+    switch (event.name) {
+      case "agent.turnStarted":
+        emitObservedAgentEvent(event);
+        return true;
+      case "agent.toolCallRequested":
+        if (!event.payload.threadId || !event.payload.turnId) {
+          process.stderr.write(
+            `[worker] dynamic tool call ${event.payload.callId} is missing threadId/turnId; cannot send response
+`
+          );
+          emitObservedAgentEvent(event);
+          return true;
+        }
+        void dispatchDynamicToolCall(
+          event.payload.callId,
+          event.payload.toolName,
+          event.payload.threadId,
+          event.payload.turnId,
+          event.payload.arguments
+        );
+        emitObservedAgentEvent(event);
+        return true;
+      case "agent.inputRequired":
+        handleInputRequired(event.payload.reason, event);
+        return true;
+      case "agent.tokenUsageUpdated": {
+        const tokenUsage = extractAbsoluteTokenUsage(event.payload.params);
+        if (tokenUsage) {
+          applyTokenUsageUpdate(
+            getCodexObservabilityEventName(event) ?? event.name,
+            tokenUsage
+          );
+        }
+        emitObservedAgentEvent(event);
+        return true;
       }
-      const rateLimits2 = extractRateLimitPayload(turnParams);
-      if (rateLimits2) {
-        applyRateLimitUpdate("turn/completed", rateLimits2);
+      case "agent.rateLimit": {
+        const rateLimits = extractRateLimitPayload(event.payload.params);
+        if (rateLimits) {
+          applyRateLimitUpdate(
+            getCodexObservabilityEventName(event) ?? event.name,
+            rateLimits
+          );
+        }
+        emitObservedAgentEvent(event);
+        return true;
       }
-      if (turnParams.inputRequired === true) {
-        process.stderr.write("[worker] user_input_required detected \u2014 terminating codex process\n");
-        userInputRequired = true;
-        runtimeState.status = "failed";
-        if (runtimeState.run) {
-          runtimeState.run.lastError = "turn_input_required: agent requires user input";
+      case "agent.messageDelta": {
+        const { delta, itemId } = event.payload;
+        if (deltaBuffer?.itemId !== itemId) {
+          flushDeltaBuffer();
+          deltaBuffer = { itemId, text: delta };
+        } else {
+          deltaBuffer.text += delta;
         }
-        if (child.pid) {
-          try {
-            process.kill(child.pid, "SIGTERM");
-          } catch {
-          }
+        emitObservedAgentEvent(event);
+        return true;
+      }
+      case "agent.turnCompleted":
+        flushDeltaBuffer();
+        if (event.payload.inputRequired) {
+          handleInputRequired(DEFAULT_AGENT_INPUT_REQUIRED_REASON, event);
+          return true;
         }
+        emitObservedAgentEvent(event);
         if (activeTurnTelemetry) {
-          emitTurnFailedEvent(activeTurnTelemetry, runtimeState.run?.lastError ?? null);
+          emitTurnCompletedEvent(activeTurnTelemetry);
           activeTurnTelemetry = null;
         }
+        process.stderr.write("[worker] agent turn completed\n");
         resolvePendingTurnCompletion();
-        emitOrchestratorChannelEvent(orchestratorEventName);
-        return;
+        return true;
+      case "agent.turnFailed": {
+        flushDeltaBuffer();
+        const lastError = describeTurnTerminalEvent(
+          "agent.turnFailed",
+          event.payload.params
+        );
+        process.stderr.write(
+          `[worker] agent turn failed ${JSON.stringify(event.payload.params).slice(0, 300)}
+`
+        );
+        markTurnTerminalFailure("failed", lastError);
+        emitObservedAgentEvent(event);
+        return true;
       }
-      emitOrchestratorChannelEvent(orchestratorEventName);
-      if (activeTurnTelemetry) {
-        emitTurnCompletedEvent(activeTurnTelemetry);
-        activeTurnTelemetry = null;
+      case "agent.turnCancelled": {
+        flushDeltaBuffer();
+        const lastError = describeTurnTerminalEvent(
+          "agent.turnCancelled",
+          event.payload.params
+        );
+        process.stderr.write(
+          `[worker] agent turn cancelled ${JSON.stringify(event.payload.params).slice(0, 300)}
+`
+        );
+        markTurnTerminalFailure("canceled_by_reconciliation", lastError);
+        emitObservedAgentEvent(event);
+        return true;
       }
-      process.stderr.write("[worker] codex turn/completed\n");
-      resolvePendingTurnCompletion();
-      return;
+      case "agent.error":
+        flushDeltaBuffer();
+        process.stderr.write(
+          `[worker] runtime error ${JSON.stringify(event.payload.params).slice(0, 300)}
+`
+        );
+        markTurnTerminalFailure("failed", event.payload.error);
+        emitObservedAgentEvent(event);
+        return true;
+      default:
+        return false;
     }
-    if (msg.method === "turn/failed") {
-      flushDeltaBuffer();
-      const lastError = describeTurnTerminalEvent("turn/failed", msg.params ?? null);
-      process.stderr.write(`[worker] codex turn/failed ${JSON.stringify(msg.params ?? {}).slice(0, 300)}
-`);
-      markTurnTerminalFailure("failed", lastError);
-      emitOrchestratorChannelEvent(orchestratorEventName);
+  }
+  function handleServerMessage(msg) {
+    if ("id" in msg && msg.id != null && ("result" in msg || "error" in msg)) {
+      const id = String(msg.id);
+      const pending = pendingRequests.get(id);
+      if (pending) {
+        pendingRequests.delete(id);
+        if ("error" in msg) {
+          pending.reject(new Error(JSON.stringify(msg.error)));
+        } else {
+          pending.resolve(msg.result);
+        }
+      }
       return;
     }
-    if (msg.method === "turn/cancelled") {
-      flushDeltaBuffer();
-      const lastError = describeTurnTerminalEvent("turn/cancelled", msg.params ?? null);
-      process.stderr.write(`[worker] codex turn/cancelled ${JSON.stringify(msg.params ?? {}).slice(0, 300)}
-`);
-      markTurnTerminalFailure("canceled_by_reconciliation", lastError);
-      emitOrchestratorChannelEvent(orchestratorEventName);
-      return;
+    runtimeState.lastEventAt = (/* @__PURE__ */ new Date()).toISOString();
+    const agentEvents = normalizeCodexRuntimeEvents(msg);
+    let handledAgentEvent = false;
+    for (const event of agentEvents) {
+      handledAgentEvent = handleAgentEvent(event) || handledAgentEvent;
     }
-    if (msg.method === "thread/tokenUsage/updated" || msg.method === "total_token_usage" || msg.method === "codex/event/token_count") {
-      const tokenUsage = extractAbsoluteTokenUsage(msg.params);
-      if (tokenUsage) {
-        applyTokenUsageUpdate(msg.method, tokenUsage);
-      }
-      emitOrchestratorChannelEvent(orchestratorEventName);
+    if (handledAgentEvent) {
       return;
     }
     const rateLimits = extractRateLimitPayload(msg.params);
     if (rateLimits && typeof msg.method === "string") {
       applyRateLimitUpdate(msg.method, rateLimits);
     }
-    if (typeof msg.method === "string" && (msg.method === "codex/event/agent_message_content_delta" || msg.method === "codex/event/agent_message_delta" || msg.method === "item/agentMessage/delta")) {
-      const params = msg.params ?? {};
-      const delta = typeof params.delta === "string" ? params.delta : "";
-      const itemId = typeof params.item_id === "string" ? params.item_id : "";
-      if (deltaBuffer?.itemId !== itemId) {
-        flushDeltaBuffer();
-        deltaBuffer = { itemId, text: delta };
-      } else {
-        deltaBuffer.text += delta;
-      }
-      emitOrchestratorChannelEvent(orchestratorEventName);
-      return;
-    }
     if (typeof msg.method === "string") {
       flushDeltaBuffer();
-      emitOrchestratorChannelEvent(orchestratorEventName);
-      process.stderr.write(`[worker] codex \u2192 ${msg.method} ${JSON.stringify(msg.params ?? {}).slice(0, 300)}
-`);
+      emitOrchestratorChannelEvent(msg.method);
+      process.stderr.write(
+        `[worker] codex \u2192 ${msg.method} ${JSON.stringify(msg.params ?? {}).slice(0, 300)}
+`
+      );
     }
   }
   child.stdout.on("data", (chunk) => {
@@ -1318,8 +1421,7 @@ async function runCodexClientProtocol(child, plan, env, options) {
     lineBuffer = lines.pop() ?? "";
     for (const line of lines) {
       const trimmed = line.trim();
-      if (!trimmed)
-        continue;
+      if (!trimmed) continue;
       try {
         const msg = JSON.parse(trimmed);
         handleServerMessage(msg);
@@ -1354,30 +1456,42 @@ async function runCodexClientProtocol(child, plan, env, options) {
         mcp_servers: mcpServers
       }
     };
-    process.stderr.write(`[worker] starting codex thread (mcp_servers: ${Object.keys(mcpServers).join(", ")})
-`);
-    const threadResult = await sendRequestWithTimeout("thread-1", "thread/start", {
-      ...baseThreadParams,
-      ephemeral: false
-    });
+    process.stderr.write(
+      `[worker] starting codex thread (mcp_servers: ${Object.keys(mcpServers).join(", ")})
+`
+    );
+    const threadResult = await sendRequestWithTimeout(
+      "thread-1",
+      "thread/start",
+      {
+        ...baseThreadParams,
+        ephemeral: false
+      }
+    );
     const threadId = threadResult.thread_id ?? threadResult.thread?.id;
     runtimeState.sessionInfo.threadId = threadId ?? null;
     runtimeState.sessionInfo.turnId = null;
     runtimeState.sessionInfo.sessionId = null;
     runtimeState.sessionInfo.exitClassification = null;
     runtimeState.sessionId = null;
-    process.stderr.write(`[worker] codex thread started (id=${String(threadId ?? "unknown")})
-`);
+    process.stderr.write(
+      `[worker] codex thread started (id=${String(threadId ?? "unknown")})
+`
+    );
     if (!threadId) {
-      process.stderr.write("[worker] warning: no threadId returned; cannot start turn\n");
+      process.stderr.write(
+        "[worker] warning: no threadId returned; cannot start turn\n"
+      );
       return;
     }
     let turnCount = 0;
     let requestIdCounter = 0;
     let maxTurnsReached = exhaustedBeforeStart;
     if (exhaustedBeforeStart) {
-      process.stderr.write(`[worker] max_turns (${String(env.SYMPHONY_MAX_TURNS ?? maxTurns)}) does not allow any turns for this worker session \u2014 exiting
-`);
+      process.stderr.write(
+        `[worker] max_turns (${String(env.SYMPHONY_MAX_TURNS ?? maxTurns)}) does not allow any turns for this worker session \u2014 exiting
+`
+      );
     }
     for (let turn = 0; turn < maxTurns; turn++) {
       turnCount = turn + 1;
@@ -1388,18 +1502,24 @@ async function runCodexClientProtocol(child, plan, env, options) {
         continuationGuidance,
         cumulativeTurnCount: turn
       });
-      process.stderr.write(`[worker] starting codex turn ${turnCount}/${maxTurns}${isFirstTurn ? " (initial)" : " (continuation)"}
-`);
+      process.stderr.write(
+        `[worker] starting codex turn ${turnCount}/${maxTurns}${isFirstTurn ? " (initial)" : " (continuation)"}
+`
+      );
       requestIdCounter += 1;
       const turnRequestId = `turn-${requestIdCounter}`;
-      const turnResult = await sendRequestWithTimeout(turnRequestId, "turn/start", {
-        threadId,
-        input: [{ type: "text", text: turnInput }],
-        cwd: plan.cwd,
-        title: composeTurnTitle(issueIdentifier, env.SYMPHONY_ISSUE_TITLE),
-        approvalPolicy,
-        sandboxPolicy: turnSandboxPolicy
-      });
+      const turnResult = await sendRequestWithTimeout(
+        turnRequestId,
+        "turn/start",
+        {
+          threadId,
+          input: [{ type: "text", text: turnInput }],
+          cwd: plan.cwd,
+          title: composeTurnTitle(issueIdentifier, env.SYMPHONY_ISSUE_TITLE),
+          approvalPolicy,
+          sandboxPolicy: turnSandboxPolicy
+        }
+      );
       const turnId = turnResult.turn_id ?? turnResult.turn?.id;
       const sessionId = threadId && turnId ? `${threadId}-${turnId}` : null;
       runtimeState.sessionInfo.turnId = turnId ?? null;
@@ -1413,10 +1533,14 @@ async function runCodexClientProtocol(child, plan, env, options) {
         sessionId,
         tokenUsageBaseline: cloneTokenUsageSnapshot()
       };
-      process.stderr.write(`[worker] codex turn started (id=${String(turnId ?? "unknown")})
-`);
-      process.stderr.write(`[worker] session_id=${String(sessionId ?? "unknown")}
-`);
+      process.stderr.write(
+        `[worker] codex turn started (id=${String(turnId ?? "unknown")})
+`
+      );
+      process.stderr.write(
+        `[worker] session_id=${String(sessionId ?? "unknown")}
+`
+      );
       emitTurnStartedEvent(activeTurnTelemetry);
       await waitForTurnWithTimeout();
       if (userInputRequired) {
@@ -1424,14 +1548,18 @@ async function runCodexClientProtocol(child, plan, env, options) {
         break;
       }
       if (turnTerminalFailurePhase) {
-        process.stderr.write(`[worker] exiting due to ${turnTerminalFailurePhase}
-`);
+        process.stderr.write(
+          `[worker] exiting due to ${turnTerminalFailurePhase}
+`
+        );
         break;
       }
       if (turn + 1 >= maxTurns) {
         maxTurnsReached = true;
-        process.stderr.write(`[worker] max_turns (${maxTurns}) reached for this worker session \u2014 exiting
-`);
+        process.stderr.write(
+          `[worker] max_turns (${maxTurns}) reached for this worker session \u2014 exiting
+`
+        );
         break;
       }
       const trackerState = await refreshTrackerState(env);
@@ -1444,19 +1572,26 @@ async function runCodexClientProtocol(child, plan, env, options) {
           trackerState,
           userInputRequired: false
         });
-        process.stderr.write("[worker] issue no longer actionable \u2014 exiting multi-turn loop\n");
+        process.stderr.write(
+          "[worker] issue no longer actionable \u2014 exiting multi-turn loop\n"
+        );
         break;
       }
       const currentTurnProgressSnapshot = {
         ...captureTurnWorkspaceSnapshot(plan.cwd),
         lastError: runtimeState.run?.lastError ?? null
       };
-      const turnProgress = evaluateTurnProgress(previousTurnProgressSnapshot, currentTurnProgressSnapshot);
+      const turnProgress = evaluateTurnProgress(
+        previousTurnProgressSnapshot,
+        currentTurnProgressSnapshot
+      );
       previousTurnProgressSnapshot = currentTurnProgressSnapshot;
       if (turnProgress.nonProductive) {
         consecutiveNonProductiveTurns += 1;
-        process.stderr.write(`[worker] non-productive turn detected (${consecutiveNonProductiveTurns}/${maxNonProductiveTurns})${turnProgress.reason ? `: ${turnProgress.reason}` : ""}
-`);
+        process.stderr.write(
+          `[worker] non-productive turn detected (${consecutiveNonProductiveTurns}/${maxNonProductiveTurns})${turnProgress.reason ? `: ${turnProgress.reason}` : ""}
+`
+        );
       } else {
         consecutiveNonProductiveTurns = 0;
       }
@@ -1465,13 +1600,17 @@ async function runCodexClientProtocol(child, plan, env, options) {
         if (runtimeState.run) {
           runtimeState.run.lastError = turnProgress.reason ? `convergence_detected: ${turnProgress.reason}` : "convergence_detected: repeated non-productive turn results";
         }
-        process.stderr.write(`[worker] convergence detected after ${consecutiveNonProductiveTurns} non-productive turns \u2014 exiting
-`);
+        process.stderr.write(
+          `[worker] convergence detected after ${consecutiveNonProductiveTurns} non-productive turns \u2014 exiting
+`
+        );
         break;
       }
     }
-    process.stderr.write(`[worker] multi-turn loop complete after ${turnCount} turn(s) \u2014 exiting worker
-`);
+    process.stderr.write(
+      `[worker] multi-turn loop complete after ${turnCount} turn(s) \u2014 exiting worker
+`
+    );
     runtimeState.runPhase = "finishing";
     runtimeState.status = userInputRequired || turnTerminalFailurePhase ? "failed" : "completed";
     runtimeState.runPhase = convergenceDetected ? "failed" : userInputRequired ? "failed" : turnTerminalFailurePhase ?? "succeeded";
@@ -1485,7 +1624,9 @@ async function runCodexClientProtocol(child, plan, env, options) {
     stopOrchestratorHeartbeatTimer();
     emitOrchestratorHeartbeat();
     await persistSessionTokenUsageArtifact(env);
-    await waitForPendingOrchestratorChannelFlush(resolveTerminalOrchestratorChannelFlushTimeoutMs());
+    await waitForPendingOrchestratorChannelFlush(
+      resolveTerminalOrchestratorChannelFlushTimeoutMs()
+    );
     setTimeout(() => {
       process.exit(userInputRequired || turnTerminalFailurePhase ? 1 : 0);
     }, 1500);
@@ -1517,13 +1658,18 @@ async function runCodexClientProtocol(child, plan, env, options) {
       maxTurnsReached: false
     });
     if (activeTurnTelemetry) {
-      emitTurnFailedEvent(activeTurnTelemetry, runtimeState.run?.lastError ?? errMsg);
+      emitTurnFailedEvent(
+        activeTurnTelemetry,
+        runtimeState.run?.lastError ?? errMsg
+      );
       activeTurnTelemetry = null;
     }
     stopOrchestratorHeartbeatTimer();
     emitOrchestratorHeartbeat();
     await persistSessionTokenUsageArtifact(env);
-    await waitForPendingOrchestratorChannelFlush(resolveTerminalOrchestratorChannelFlushTimeoutMs());
+    await waitForPendingOrchestratorChannelFlush(
+      resolveTerminalOrchestratorChannelFlushTimeoutMs()
+    );
     setTimeout(() => {
       process.exit(1);
     }, 1500);
@@ -1533,16 +1679,20 @@ function applyTokenUsageUpdate(source, tokenUsage) {
   runtimeState.tokenUsage.inputTokens = tokenUsage.inputTokens;
   runtimeState.tokenUsage.outputTokens = tokenUsage.outputTokens;
   runtimeState.tokenUsage.totalTokens = tokenUsage.totalTokens;
-  process.stderr.write(`[worker] token_usage source=${source} input=${tokenUsage.inputTokens} output=${tokenUsage.outputTokens} total=${tokenUsage.totalTokens}
-`);
+  process.stderr.write(
+    `[worker] token_usage source=${source} input=${tokenUsage.inputTokens} output=${tokenUsage.outputTokens} total=${tokenUsage.totalTokens}
+`
+  );
 }
-function applyRateLimitUpdate(source, rateLimits) {
+function applyRateLimitUpdate(source, rateLimits, runtimeSource = "codex") {
   runtimeState.rateLimits = {
     ...rateLimits,
-    source: "codex"
+    source: runtimeSource
   };
-  process.stderr.write(`[worker] rate_limits source=${source} payload=${JSON.stringify(runtimeState.rateLimits).slice(0, 300)}
-`);
+  process.stderr.write(
+    `[worker] rate_limits source=${source} payload=${JSON.stringify(runtimeState.rateLimits).slice(0, 300)}
+`
+  );
 }
 function extractRateLimitPayload(value) {
   if (!value || typeof value !== "object") {
@@ -1673,17 +1823,18 @@ async function refreshTrackerState(env) {
   }
   try {
     const response = await fetch(`${orchestratorUrl}/api/v1/state`);
-    if (!response.ok)
-      return "unknown";
+    if (!response.ok) return "unknown";
     const status = await response.json();
-    const isActive = status.activeRuns?.some((run) => run.issueIdentifier === issueIdentifier);
+    const isActive = status.activeRuns?.some(
+      (run) => run.issueIdentifier === issueIdentifier
+    );
     return isActive ? "active" : "non-actionable";
   } catch {
     return "unknown";
   }
 }
 function runToolProcess(toolDef, inputJson) {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve, reject) => {
     const toolEnv = {
       ...process.env,
       ...toolDef.env
@@ -1700,10 +1851,14 @@ function runToolProcess(toolDef, inputJson) {
     toolProc.once("exit", (code) => {
       const output = Buffer.concat(stdout).toString("utf8").trim();
       if (code === 0) {
-        resolve2(output || "{}");
+        resolve(output || "{}");
       } else {
         const errOutput = Buffer.concat(stderr).toString("utf8").trim();
-        reject(new Error(`Tool exited with code ${code ?? "unknown"}: ${errOutput || output}`));
+        reject(
+          new Error(
+            `Tool exited with code ${code ?? "unknown"}: ${errOutput || output}`
+          )
+        );
       }
     });
     toolProc.stdin?.write(inputJson);