@gh-symphony/cli 0.0.19 → 0.0.21

package/dist/worker-entry.js

@@ -1,450 +1,29 @@
 #!/usr/bin/env node
 import {
+  getCodexObservabilityEventName,
+  launchCodexAppServer,
+  loadLauncherEnvironment,
+  normalizeCodexRuntimeEvents,
+  prepareCodexRuntimePlan,
+  resolveLocalRuntimeLaunchConfig
+} from "./chunk-A67CMOYE.js";
+import {
+  DEFAULT_AGENT_INPUT_REQUIRED_REASON,
   classifySessionExit,
+  formatClaudePreflightText,
+  isClaudeRuntimeCommand,
   parseWorkflowMarkdown,
-  readEnvFile
-} from "./chunk-M3IFVLQS.js";
-
-// ../worker/dist/index.js
-import { spawn as spawn2 } from "child_process";
-import { readFile as readFile2 } from "fs/promises";
-import { join as join3 } from "path";
+  resolveClaudeCommandBinary,
+  resolveWorkflowRuntimeCommand,
+  runClaudePreflight
+} from "./chunk-QEONJ5DZ.js";
 
-// ../runtime-codex/dist/runtime.js
+// ../worker/src/index.ts
 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],
-    resumeThreadId: config.resumeThreadId?.trim() || null
-  };
-}
-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,
-    resumeThreadId: env.SYMPHONY_RESUME_THREAD_ID
-  };
-}
-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) {
@@ -474,7 +53,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",
@@ -483,7 +62,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) {
@@ -492,10 +71,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,
@@ -541,7 +124,7 @@ function normalizeError(value) {
   return normalized.length > 0 ? normalized : null;
 }
 
-// ../worker/dist/run-phase.js
+// ../worker/src/run-phase.ts
 var TERMINAL_RUN_PHASES = /* @__PURE__ */ new Set([
   "succeeded",
   "failed",
@@ -556,111 +139,26 @@ function resolveExitRunPhase(currentRunPhase, exit) {
   return exit.code === 0 && !exit.signal ? "succeeded" : "failed";
 }
 
-// ../worker/dist/session-budget.js
-function resolveSessionBudgetState(env) {
-  return {
-    cumulativeTurnCount: parseNonNegativeInteger(env.SYMPHONY_CUMULATIVE_TURN_COUNT),
-    tokenUsageBaseline: {
-      inputTokens: parseNonNegativeInteger(env.SYMPHONY_CUMULATIVE_INPUT_TOKENS),
-      outputTokens: parseNonNegativeInteger(env.SYMPHONY_CUMULATIVE_OUTPUT_TOKENS),
-      totalTokens: parseNonNegativeInteger(env.SYMPHONY_CUMULATIVE_TOTAL_TOKENS)
-    },
-    sessionStartedAt: normalizeTimestamp(env.SYMPHONY_SESSION_STARTED_AT),
-    globalMaxTurns: parsePositiveInteger(env.SYMPHONY_GLOBAL_MAX_TURNS),
-    maxTokens: parsePositiveInteger(env.SYMPHONY_MAX_TOKENS),
-    sessionTimeoutMs: parsePositiveInteger(env.SYMPHONY_SESSION_TIMEOUT_MS)
-  };
-}
-function resolveBudgetExceededReason(budget, currentSessionTurnCount, currentTokenUsage, now) {
-  const totalTurns = budget.cumulativeTurnCount + currentSessionTurnCount;
-  if (budget.globalMaxTurns !== null && totalTurns >= budget.globalMaxTurns) {
-    return "global-turns";
-  }
-  const totalTokens = budget.tokenUsageBaseline.totalTokens + currentTokenUsage.totalTokens;
-  if (budget.maxTokens !== null && totalTokens >= budget.maxTokens) {
-    return "tokens";
-  }
-  if (budget.sessionTimeoutMs !== null && budget.sessionStartedAt !== null && now.getTime() - new Date(budget.sessionStartedAt).getTime() >= budget.sessionTimeoutMs) {
-    return "session-timeout";
-  }
-  return null;
-}
-function parsePositiveInteger(value) {
-  if (!value) {
-    return null;
-  }
-  const parsed = Number(value);
-  if (!Number.isFinite(parsed) || parsed <= 0) {
-    return null;
-  }
-  return Math.floor(parsed);
-}
-function parseNonNegativeInteger(value) {
-  if (!value) {
-    return 0;
-  }
-  const parsed = Number(value);
-  if (!Number.isFinite(parsed) || parsed < 0) {
-    return 0;
-  }
-  return Math.floor(parsed);
-}
-function normalizeTimestamp(value) {
-  if (!value) {
-    return null;
-  }
-  const parsed = Date.parse(value);
-  return Number.isFinite(parsed) ? new Date(parsed).toISOString() : null;
-}
-
-// ../worker/dist/thread-resume.js
+// ../worker/src/thread-resume.ts
 var DEFAULT_CONTINUATION_GUIDANCE = "Continue working on the issue. Review your progress and complete any remaining tasks.";
-function parseNonNegativeInteger2(value) {
+function parseNonNegativeInteger(value) {
   const parsed = typeof value === "number" ? value : Number.parseInt(value ?? "", 10);
   if (!Number.isFinite(parsed) || parsed <= 0) {
     return 0;
   }
   return Math.floor(parsed);
 }
-function resolveRemainingTurns(maxTurns, cumulativeTurnCount) {
-  return Math.max(0, parseNonNegativeInteger2(maxTurns) - parseNonNegativeInteger2(cumulativeTurnCount));
-}
-function buildInitialTurnInput({ renderedPrompt, mode, lastTurnSummary, cumulativeTurnCount = 0, continuationGuidance }) {
-  if (mode === "fresh") {
-    return renderedPrompt;
-  }
-  const renderedContinuationGuidance = buildContinuationTurnInput({
-    continuationGuidance,
-    lastTurnSummary,
-    cumulativeTurnCount
-  });
-  const normalizedSummary = normalizeContinuationVariable(lastTurnSummary) ?? "No previous turn summary was captured.";
-  const normalizedCumulativeTurnCount = Math.max(0, parseNonNegativeInteger2(cumulativeTurnCount));
-  if (mode === "resume") {
-    return [
-      "Resume work on this issue using the existing thread context.",
-      `Previous worker turns completed: ${normalizedCumulativeTurnCount}.`,
-      `Previous session summary: ${normalizedSummary}`,
-      renderedContinuationGuidance
-    ].join("\n");
-  }
-  return [
-    "Resume work on this issue from a previous worker session.",
-    "",
-    "Original issue instructions:",
-    renderedPrompt,
-    "",
-    "Previous session summary:",
-    normalizedSummary,
-    "",
-    renderedContinuationGuidance
-  ].join("\n");
-}
-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, parseNonNegativeInteger2(cumulativeTurnCount)))
+    cumulativeTurnCount: String(
+      Math.max(0, parseNonNegativeInteger(cumulativeTurnCount))
+    )
   });
 }
 function normalizeContinuationVariable(value) {
@@ -669,7 +167,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;
@@ -680,7 +180,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;
@@ -688,26 +190,57 @@ 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/token-usage.js
-import { mkdir as mkdir2, writeFile as writeFile3 } from "fs/promises";
-import { dirname as dirname2, join as join2 } from "path";
+// ../worker/src/turn-limits.ts
+var DEFAULT_SESSION_MAX_TURNS = 20;
+function resolveMaxTurns(value) {
+  const parsed = typeof value === "number" ? value : Number(value);
+  if (!Number.isFinite(parsed)) {
+    return {
+      maxTurns: DEFAULT_SESSION_MAX_TURNS,
+      exhaustedBeforeStart: false
+    };
+  }
+  const normalized = Math.trunc(parsed);
+  if (normalized <= 0) {
+    return {
+      maxTurns: 0,
+      exhaustedBeforeStart: true
+    };
+  }
+  return {
+    maxTurns: normalized,
+    exhaustedBeforeStart: false
+  };
+}
+
+// ../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) {
@@ -715,12 +248,11 @@ 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 sessionBudgetState = resolveSessionBudgetState(launcherEnv);
 var runtimeState = {
   status: launcherEnv.SYMPHONY_RUN_ID ? "starting" : "idle",
   executionPhase: null,
@@ -741,9 +273,9 @@ var runtimeState = {
     lastError: null
   } : null,
   tokenUsage: {
-    inputTokens: sessionBudgetState.tokenUsageBaseline.inputTokens,
-    outputTokens: sessionBudgetState.tokenUsageBaseline.outputTokens,
-    totalTokens: sessionBudgetState.tokenUsageBaseline.totalTokens
+    inputTokens: 0,
+    outputTokens: 0,
+    totalTokens: 0
   },
   lastEventAt: null,
   rateLimits: null,
@@ -755,10 +287,16 @@ 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 shutdownPromise = null;
 var orchestratorChannelDrainPending = false;
@@ -793,7 +331,9 @@ function shutdown(signal) {
     stopOrchestratorHeartbeatTimer();
     emitOrchestratorHeartbeat();
     await persistSessionTokenUsageArtifact(launcherEnv);
-    await waitForPendingOrchestratorChannelFlush(resolveTerminalOrchestratorChannelFlushTimeoutMs());
+    await waitForPendingOrchestratorChannelFlush(
+      resolveTerminalOrchestratorChannelFlushTimeoutMs()
+    );
     console.log(`Worker stopped on ${signal}`);
     process.exit(0);
   })();
@@ -826,13 +366,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) {
@@ -847,14 +387,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) {
@@ -932,13 +475,22 @@ 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() {
-  return resolveTurnTokenUsageDelta(sessionBudgetState.tokenUsageBaseline);
+  return cloneTokenUsageSnapshot();
 }
 async function persistSessionTokenUsageArtifact(env) {
   await persistTokenUsageArtifact(env, resolveSessionTokenUsageDelta());
@@ -971,7 +523,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,
@@ -992,7 +547,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,
@@ -1005,16 +563,42 @@ 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
+    );
+    if (isClaudeRuntimeCommand(workflow.codex.command)) {
+      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;
+      }
+      await exitWorkerStartupFailure(
+        "Claude runtime worker launch is not yet implemented in this branch."
+      );
+      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;
+    config.agentCommand = resolveWorkflowRuntimeCommand(workflow);
     runtimeState.runPhase = "launching_agent";
     const plan = await prepareCodexRuntimePlan(config);
     childProcess = launchCodexAppServer(plan);
@@ -1026,24 +610,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";
@@ -1061,27 +648,45 @@ async function startAssignedRun() {
     await persistSessionTokenUsageArtifact(launcherEnv);
   }
 }
+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 = Number(env.SYMPHONY_MAX_TURNS) || 20;
-  const cumulativeTurnCount = parseNonNegativeInteger2(env.SYMPHONY_CUMULATIVE_TURN_COUNT);
-  const remainingTurns = resolveRemainingTurns(maxTurns, cumulativeTurnCount);
+  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);
   const issueIdentifier = env.SYMPHONY_ISSUE_IDENTIFIER ?? "";
-  const lastTurnSummary = env.SYMPHONY_LAST_TURN_SUMMARY ?? null;
   const continuationGuidance = env.SYMPHONY_CONTINUATION_GUIDANCE ?? options.continuationGuidance;
   const { approvalPolicy, threadSandbox, turnSandboxPolicy } = resolveCodexPolicySettings(env);
-  const budgetState = resolveSessionBudgetState(env);
   let previousTurnProgressSnapshot = {
     ...captureTurnWorkspaceSnapshot(plan.cwd),
     lastError: runtimeState.run?.lastError ?? null
@@ -1090,10 +695,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();
@@ -1101,16 +707,8 @@ async function runCodexClientProtocol(child, plan, env, options) {
   let userInputRequired = false;
   let turnTerminalFailurePhase = null;
   let activeTurnTelemetry = null;
-  let budgetExceededReason = null;
   let consecutiveNonProductiveTurns = 0;
   let convergenceDetected = false;
-  function checkSessionBudgets(currentSessionTurnCount) {
-    return resolveBudgetExceededReason(budgetState, currentSessionTurnCount, {
-      inputTokens: runtimeState.tokenUsage.inputTokens - budgetState.tokenUsageBaseline.inputTokens,
-      outputTokens: runtimeState.tokenUsage.outputTokens - budgetState.tokenUsageBaseline.outputTokens,
-      totalTokens: runtimeState.tokenUsage.totalTokens - budgetState.tokenUsageBaseline.totalTokens
-    }, /* @__PURE__ */ new Date());
-  }
   function resolvePendingTurnCompletion() {
     if (turnCompletedResolve) {
       turnCompletedResolve();
@@ -1118,7 +716,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;
     }
@@ -1127,18 +726,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";
@@ -1158,36 +757,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");
@@ -1196,20 +804,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",
@@ -1229,8 +844,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({
@@ -1261,138 +878,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) => {
@@ -1401,8 +1065,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);
@@ -1428,27 +1091,6 @@ async function runCodexClientProtocol(child, plan, env, options) {
         env: t.env
       };
     }
-    if (remainingTurns <= 0) {
-      process.stderr.write(`[worker] max_turns already exhausted by previous sessions (${cumulativeTurnCount}/${maxTurns})
-`);
-      runtimeState.status = "completed";
-      runtimeState.runPhase = "succeeded";
-      runtimeState.sessionInfo.exitClassification = classifySessionExit({
-        runPhase: runtimeState.runPhase,
-        userInputRequired: false,
-        budgetExceeded: false,
-        convergenceDetected: false,
-        maxTurnsReached: true
-      });
-      stopOrchestratorHeartbeatTimer();
-      emitOrchestratorHeartbeat();
-      await persistSessionTokenUsageArtifact(env);
-      await waitForPendingOrchestratorChannelFlush(resolveTerminalOrchestratorChannelFlushTimeoutMs());
-      setTimeout(() => {
-        process.exit(0);
-      }, 1500);
-      return;
-    }
     const baseThreadParams = {
       cwd: plan.cwd,
       developerInstructions: renderedPrompt,
@@ -1458,86 +1100,70 @@ async function runCodexClientProtocol(child, plan, env, options) {
         mcp_servers: mcpServers
       }
     };
-    const resumeThreadId = plan.resumeThreadId;
-    let threadBootstrapMode = "fresh";
-    process.stderr.write(`[worker] starting codex thread (mcp_servers: ${Object.keys(mcpServers).join(", ")})
-`);
-    let threadResult;
-    if (resumeThreadId) {
-      process.stderr.write(`[worker] attempting thread/resume for ${resumeThreadId}
-`);
-      try {
-        threadResult = await sendRequestWithTimeout("thread-resume-1", "thread/resume", {
-          ...baseThreadParams,
-          threadId: resumeThreadId
-        });
-        threadBootstrapMode = "resume";
-      } catch (error) {
-        const message = error instanceof Error ? error.message : String(error ?? "unknown");
-        threadBootstrapMode = "soft-resume";
-        process.stderr.write(`[worker] thread/resume failed for ${resumeThreadId}: ${message}; falling back to thread/start
-`);
-        threadResult = await sendRequestWithTimeout("thread-1", "thread/start", {
-          ...baseThreadParams,
-          ephemeral: false
-        });
-      }
-    } else {
-      threadResult = await sendRequestWithTimeout("thread-1", "thread/start", {
+    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 = false;
-    for (let turn = 0; turn < remainingTurns; turn++) {
-      budgetExceededReason = checkSessionBudgets(turn);
-      if (budgetExceededReason) {
-        process.stderr.write(`[worker] session budget exceeded (${budgetExceededReason}) \u2014 exiting
-`);
-        break;
-      }
+    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
+`
+      );
+    }
+    for (let turn = 0; turn < maxTurns; turn++) {
       turnCount = turn + 1;
-      const globalTurnCount = cumulativeTurnCount + turnCount;
       runtimeState.sessionInfo.turnCount = turnCount;
       runtimeState.runPhase = "streaming_turn";
       const isFirstTurn = turn === 0;
-      const turnInput = isFirstTurn ? buildInitialTurnInput({
-        renderedPrompt,
-        mode: threadBootstrapMode,
-        lastTurnSummary,
-        cumulativeTurnCount,
-        continuationGuidance
-      }) : buildContinuationTurnInput({
+      const turnInput = isFirstTurn ? renderedPrompt : buildContinuationTurnInput({
         continuationGuidance,
-        lastTurnSummary,
-        cumulativeTurnCount: globalTurnCount - 1
+        cumulativeTurnCount: turn
       });
-      process.stderr.write(`[worker] starting codex turn ${globalTurnCount}/${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;
@@ -1551,10 +1177,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) {
@@ -1562,20 +1192,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;
       }
-      budgetExceededReason = checkSessionBudgets(turnCount);
-      if (budgetExceededReason) {
-        process.stderr.write(`[worker] session budget exceeded (${budgetExceededReason}) \u2014 exiting
-`);
-        break;
-      }
-      if (turn + 1 >= remainingTurns) {
+      if (turn + 1 >= maxTurns) {
         maxTurnsReached = true;
-        process.stderr.write(`[worker] max_turns (${maxTurns}) reached across sessions \u2014 exiting
-`);
+        process.stderr.write(
+          `[worker] max_turns (${maxTurns}) reached for this worker session \u2014 exiting
+`
+        );
         break;
       }
       const trackerState = await refreshTrackerState(env);
@@ -1588,19 +1216,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;
       }
@@ -1609,27 +1244,33 @@ 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";
     runtimeState.sessionInfo.exitClassification = classifySessionExit({
       runPhase: runtimeState.runPhase,
       userInputRequired,
-      budgetExceeded: budgetExceededReason !== null,
+      budgetExceeded: false,
       convergenceDetected,
       maxTurnsReached
     });
     stopOrchestratorHeartbeatTimer();
     emitOrchestratorHeartbeat();
     await persistSessionTokenUsageArtifact(env);
-    await waitForPendingOrchestratorChannelFlush(resolveTerminalOrchestratorChannelFlushTimeoutMs());
+    await waitForPendingOrchestratorChannelFlush(
+      resolveTerminalOrchestratorChannelFlushTimeoutMs()
+    );
     setTimeout(() => {
       process.exit(userInputRequired || turnTerminalFailurePhase ? 1 : 0);
     }, 1500);
@@ -1661,13 +1302,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);
@@ -1677,16 +1323,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) {
   runtimeState.rateLimits = {
     ...rateLimits,
     source: "codex"
   };
-  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") {
@@ -1817,22 +1467,23 @@ 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
     };
-    const toolProc = spawn2(toolDef.command, toolDef.args, {
+    const toolProc = spawn(toolDef.command, toolDef.args, {
       env: toolEnv,
       stdio: "pipe"
     });
@@ -1844,10 +1495,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);