@gh-symphony/cli 0.0.15 → 0.0.17

package/dist/worker-entry.js

@@ -0,0 +1,1828 @@
+#!/usr/bin/env node
+import {
+  classifySessionExit,
+  parseWorkflowMarkdown,
+  readEnvFile
+} from "./chunk-TF3QNWNC.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";
+
+// ../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],
+    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();
+}
+
+// ../worker/dist/execution-phase.js
+function resolveInitialExecutionPhase(input) {
+  const { issueState, blockerCheckStates, activeStates } = input;
+  if (!issueState) {
+    return null;
+  }
+  if (blockerCheckStates.includes(issueState)) {
+    return "planning";
+  }
+  if (activeStates.includes(issueState)) {
+    return "implementation";
+  }
+  return null;
+}
+function resolvePausedExecutionPhase(currentPhase) {
+  if (currentPhase === "planning") {
+    return "human-review";
+  }
+  if (currentPhase === "implementation") {
+    return "awaiting-merge";
+  }
+  return null;
+}
+function resolveFinalExecutionPhase(input) {
+  if (input.userInputRequired || input.trackerState !== "non-actionable") {
+    return input.currentPhase;
+  }
+  return resolvePausedExecutionPhase(input.currentPhase) ?? input.currentPhase;
+}
+
+// ../worker/dist/codex-policy.js
+function resolveCodexPolicySettings(env) {
+  return {
+    approvalPolicy: env.SYMPHONY_APPROVAL_POLICY || "never",
+    threadSandbox: env.SYMPHONY_THREAD_SANDBOX || "danger-full-access",
+    turnSandboxPolicy: env.SYMPHONY_TURN_SANDBOX_POLICY ? { type: env.SYMPHONY_TURN_SANDBOX_POLICY } : void 0
+  };
+}
+
+// ../worker/dist/convergence-detection.js
+import { spawnSync } from "child_process";
+var DEFAULT_MAX_NONPRODUCTIVE_TURNS = 3;
+function resolveMaxNonProductiveTurns(env) {
+  const rawValue = env.SYMPHONY_MAX_NONPRODUCTIVE_TURNS;
+  const parsed = Number(rawValue);
+  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"
+  });
+  if (result.status !== 0) {
+    return {
+      fingerprint: null,
+      changedFiles: []
+    };
+  }
+  const changedFiles = result.stdout.split(/\r?\n/).map((line) => line.trimEnd()).filter(Boolean).sort();
+  return {
+    fingerprint: changedFiles.join("\n"),
+    changedFiles
+  };
+}
+function evaluateTurnProgress(previous, current) {
+  const normalizedPreviousError = normalizeError(previous.lastError);
+  const normalizedCurrentError = normalizeError(current.lastError);
+  const repeatedError = normalizedPreviousError !== null && normalizedCurrentError !== null && normalizedPreviousError === normalizedCurrentError;
+  if (repeatedError) {
+    return {
+      nonProductive: true,
+      repeatedPattern: true,
+      reason: `repeated error: ${normalizedCurrentError}`
+    };
+  }
+  const unchangedWorkspace = previous.fingerprint !== null && current.fingerprint !== null && previous.fingerprint === current.fingerprint;
+  if (unchangedWorkspace) {
+    return {
+      nonProductive: true,
+      repeatedPattern: true,
+      reason: current.changedFiles.length > 0 ? `workspace diff unchanged (${current.changedFiles.length} tracked change${current.changedFiles.length === 1 ? "" : "s"})` : "workspace unchanged"
+    };
+  }
+  return {
+    nonProductive: false,
+    repeatedPattern: false,
+    reason: null
+  };
+}
+function normalizeError(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const normalized = value.trim();
+  return normalized.length > 0 ? normalized : null;
+}
+
+// ../worker/dist/run-phase.js
+var TERMINAL_RUN_PHASES = /* @__PURE__ */ new Set([
+  "succeeded",
+  "failed",
+  "timed_out",
+  "stalled",
+  "canceled_by_reconciliation"
+]);
+function resolveExitRunPhase(currentRunPhase, exit) {
+  if (currentRunPhase && TERMINAL_RUN_PHASES.has(currentRunPhase)) {
+    return currentRunPhase;
+  }
+  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
+var DEFAULT_CONTINUATION_GUIDANCE = "Continue working on the issue. Review your progress and complete any remaining tasks.";
+function parseNonNegativeInteger2(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 }) {
+  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)))
+  });
+}
+function normalizeContinuationVariable(value) {
+  const normalized = value?.trim();
+  return normalized ? normalized : null;
+}
+function renderContinuationGuidance(template, variables) {
+  return template.replace(/\{\{\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*\}\}/g, (match, key) => variables[key] ?? match);
+}
+
+// ../worker/dist/token-usage.js
+import { mkdir as mkdir2, writeFile as writeFile3 } from "fs/promises";
+import { dirname as dirname2, join as join2 } 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");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`[worker] failed to persist token usage artifact: ${message}
+`);
+  }
+}
+function resolveTokenUsageArtifactPath(env) {
+  const workspaceRuntimeDir = env.WORKSPACE_RUNTIME_DIR;
+  if (!workspaceRuntimeDir) {
+    return null;
+  }
+  return join2(workspaceRuntimeDir, "token-usage.json");
+}
+
+// ../worker/dist/index.js
+var launcherEnv = loadLauncherEnvironment(process.env);
+var sessionBudgetState = resolveSessionBudgetState(launcherEnv);
+var runtimeState = {
+  status: launcherEnv.SYMPHONY_RUN_ID ? "starting" : "idle",
+  executionPhase: null,
+  runPhase: launcherEnv.SYMPHONY_RUN_ID ? "preparing_workspace" : null,
+  sessionId: null,
+  run: launcherEnv.SYMPHONY_RUN_ID ? {
+    runId: launcherEnv.SYMPHONY_RUN_ID,
+    issueId: launcherEnv.SYMPHONY_ISSUE_ID ?? null,
+    issueIdentifier: launcherEnv.SYMPHONY_ISSUE_IDENTIFIER ?? null,
+    state: launcherEnv.SYMPHONY_ISSUE_STATE ?? null,
+    processId: null,
+    repository: {
+      owner: launcherEnv.TARGET_REPOSITORY_OWNER ?? null,
+      name: launcherEnv.TARGET_REPOSITORY_NAME ?? null,
+      cloneUrl: launcherEnv.TARGET_REPOSITORY_CLONE_URL ?? null,
+      url: launcherEnv.TARGET_REPOSITORY_URL ?? null
+    },
+    lastError: null
+  } : null,
+  tokenUsage: {
+    inputTokens: sessionBudgetState.tokenUsageBaseline.inputTokens,
+    outputTokens: sessionBudgetState.tokenUsageBaseline.outputTokens,
+    totalTokens: sessionBudgetState.tokenUsageBaseline.totalTokens
+  },
+  lastEventAt: null,
+  rateLimits: null,
+  sessionInfo: {
+    threadId: null,
+    turnId: null,
+    turnCount: 0,
+    sessionId: null,
+    exitClassification: null
+  }
+};
+console.log(JSON.stringify({
+  package: "@gh-symphony/worker",
+  runtime: "self-hosted-sample"
+}, null, 2));
+var childProcess = null;
+var shutdownPromise = null;
+var orchestratorChannelDrainPending = false;
+var pendingOrchestratorChannelPayloads = [];
+var orchestratorHeartbeatTimer = null;
+var MAX_PENDING_ORCHESTRATOR_CHANNEL_PAYLOADS = 16;
+var ORCHESTRATOR_CHANNEL_FLUSH_TIMEOUT_MS = 250;
+var ORCHESTRATOR_CHANNEL_HEARTBEAT_INTERVAL_MS = 1e4;
+function composeTurnTitle(issueIdentifierValue, issueTitleValue) {
+  const issueIdentifier = issueIdentifierValue?.trim() ?? "";
+  const issueTitle = issueTitleValue?.trim() ?? "";
+  if (issueIdentifier && issueTitle) {
+    return `${issueIdentifier}: ${issueTitle}`;
+  }
+  return issueIdentifier || issueTitle || "Untitled issue";
+}
+if (launcherEnv.SYMPHONY_RUN_ID && launcherEnv.WORKING_DIRECTORY) {
+  startOrchestratorHeartbeatTimer();
+  void startAssignedRun();
+}
+function shutdown(signal) {
+  if (shutdownPromise) {
+    return;
+  }
+  shutdownPromise = (async () => {
+    if (childProcess?.pid) {
+      try {
+        process.kill(childProcess.pid, "SIGTERM");
+      } catch {
+      }
+    }
+    stopOrchestratorHeartbeatTimer();
+    emitOrchestratorHeartbeat();
+    await persistTokenUsageArtifact(launcherEnv, runtimeState.tokenUsage);
+    await waitForPendingOrchestratorChannelFlush(resolveTerminalOrchestratorChannelFlushTimeoutMs());
+    console.log(`Worker stopped on ${signal}`);
+    process.exit(0);
+  })();
+}
+process.on("SIGINT", () => shutdown("SIGINT"));
+process.on("SIGTERM", () => shutdown("SIGTERM"));
+function enqueuePendingOrchestratorChannelPayload(payload) {
+  if (pendingOrchestratorChannelPayloads.length >= MAX_PENDING_ORCHESTRATOR_CHANNEL_PAYLOADS) {
+    pendingOrchestratorChannelPayloads.shift();
+  }
+  pendingOrchestratorChannelPayloads.push(payload);
+}
+function flushPendingOrchestratorChannelEvent() {
+  while (pendingOrchestratorChannelPayloads.length > 0) {
+    const payload = pendingOrchestratorChannelPayloads.shift();
+    if (!payload) {
+      continue;
+    }
+    const wrote = process.stderr.write(payload);
+    if (wrote) {
+      continue;
+    }
+    orchestratorChannelDrainPending = true;
+    process.stderr.once("drain", flushPendingOrchestratorChannelEvent);
+    return;
+  }
+  orchestratorChannelDrainPending = false;
+}
+function waitForPendingOrchestratorChannelFlush(timeoutMs = ORCHESTRATOR_CHANNEL_FLUSH_TIMEOUT_MS) {
+  if (!orchestratorChannelDrainPending && pendingOrchestratorChannelPayloads.length === 0) {
+    return Promise.resolve();
+  }
+  return new Promise((resolve2) => {
+    let settled = false;
+    let timeout = setTimeout(() => {
+      settled = true;
+      process.stderr.removeListener("drain", handleDrain);
+      timeout = null;
+      resolve2();
+    }, timeoutMs);
+    const handleDrain = () => {
+      if (orchestratorChannelDrainPending || pendingOrchestratorChannelPayloads.length > 0) {
+        return;
+      }
+      if (settled) {
+        return;
+      }
+      settled = true;
+      if (timeout) {
+        clearTimeout(timeout);
+        timeout = null;
+      }
+      process.stderr.removeListener("drain", handleDrain);
+      resolve2();
+    };
+    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);
+}
+function writeOrQueueOrchestratorChannelPayload(serializedPayload) {
+  if (orchestratorChannelDrainPending) {
+    enqueuePendingOrchestratorChannelPayload(serializedPayload);
+    return;
+  }
+  const wrote = process.stderr.write(serializedPayload);
+  if (!wrote) {
+    orchestratorChannelDrainPending = true;
+    process.stderr.once("drain", flushPendingOrchestratorChannelEvent);
+  }
+}
+function emitOrchestratorHeartbeat() {
+  const issueId = runtimeState.run?.issueId;
+  if (!issueId) {
+    return;
+  }
+  const payload = {
+    type: "heartbeat",
+    issueId,
+    lastEventAt: runtimeState.lastEventAt,
+    tokenUsage: { ...runtimeState.tokenUsage },
+    rateLimits: runtimeState.rateLimits ? { ...runtimeState.rateLimits } : null,
+    sessionInfo: { ...runtimeState.sessionInfo },
+    executionPhase: runtimeState.executionPhase,
+    runPhase: runtimeState.runPhase,
+    lastError: runtimeState.run?.lastError ?? null
+  };
+  writeOrQueueOrchestratorChannelPayload(`${JSON.stringify(payload)}
+`);
+}
+function startOrchestratorHeartbeatTimer() {
+  if (orchestratorHeartbeatTimer) {
+    return;
+  }
+  orchestratorHeartbeatTimer = setInterval(() => {
+    emitOrchestratorHeartbeat();
+  }, ORCHESTRATOR_CHANNEL_HEARTBEAT_INTERVAL_MS);
+  orchestratorHeartbeatTimer.unref?.();
+}
+function stopOrchestratorHeartbeatTimer() {
+  if (!orchestratorHeartbeatTimer) {
+    return;
+  }
+  clearInterval(orchestratorHeartbeatTimer);
+  orchestratorHeartbeatTimer = null;
+}
+function emitOrchestratorChannelEvent(event) {
+  const issueId = runtimeState.run?.issueId;
+  const lastEventAt = runtimeState.lastEventAt;
+  if (!issueId || !lastEventAt) {
+    return;
+  }
+  const payload = {
+    type: "codex_update",
+    issueId,
+    lastEventAt,
+    tokenUsage: { ...runtimeState.tokenUsage },
+    sessionInfo: { ...runtimeState.sessionInfo },
+    executionPhase: runtimeState.executionPhase,
+    runPhase: runtimeState.runPhase,
+    lastError: runtimeState.run?.lastError ?? null
+  };
+  if (runtimeState.rateLimits) {
+    payload.rateLimits = { ...runtimeState.rateLimits };
+  }
+  if (event) {
+    payload.event = event;
+  }
+  writeOrQueueOrchestratorChannelPayload(`${JSON.stringify(payload)}
+`);
+}
+function cloneTokenUsageSnapshot() {
+  return { ...runtimeState.tokenUsage };
+}
+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)
+  };
+}
+function emitTurnStartedEvent(turn) {
+  const issueId = runtimeState.run?.issueId;
+  if (!issueId) {
+    return;
+  }
+  const payload = {
+    type: "turn_started",
+    issueId,
+    startedAt: turn.startedAt,
+    threadId: turn.threadId,
+    turnId: turn.turnId,
+    turnCount: turn.turnCount,
+    sessionId: turn.sessionId
+  };
+  writeOrQueueOrchestratorChannelPayload(`${JSON.stringify(payload)}
+`);
+}
+function emitTurnCompletedEvent(turn) {
+  const issueId = runtimeState.run?.issueId;
+  if (!issueId) {
+    return;
+  }
+  const completedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const payload = {
+    type: "turn_completed",
+    issueId,
+    startedAt: turn.startedAt,
+    completedAt,
+    durationMs: Math.max(0, new Date(completedAt).getTime() - new Date(turn.startedAt).getTime()),
+    threadId: turn.threadId,
+    turnId: turn.turnId,
+    turnCount: turn.turnCount,
+    sessionId: turn.sessionId,
+    tokenUsage: resolveTurnTokenUsageDelta(turn.tokenUsageBaseline)
+  };
+  writeOrQueueOrchestratorChannelPayload(`${JSON.stringify(payload)}
+`);
+}
+function emitTurnFailedEvent(turn, error) {
+  const issueId = runtimeState.run?.issueId;
+  if (!issueId) {
+    return;
+  }
+  const failedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const payload = {
+    type: "turn_failed",
+    issueId,
+    startedAt: turn.startedAt,
+    failedAt,
+    durationMs: Math.max(0, new Date(failedAt).getTime() - new Date(turn.startedAt).getTime()),
+    threadId: turn.threadId,
+    turnId: turn.turnId,
+    turnCount: turn.turnCount,
+    sessionId: turn.sessionId,
+    tokenUsage: resolveTurnTokenUsageDelta(turn.tokenUsageBaseline),
+    error
+  };
+  writeOrQueueOrchestratorChannelPayload(`${JSON.stringify(payload)}
+`);
+}
+async function startAssignedRun() {
+  try {
+    const workflowPath = launcherEnv.SYMPHONY_WORKFLOW_PATH || join3(launcherEnv.WORKING_DIRECTORY, "WORKFLOW.md");
+    runtimeState.runPhase = "building_prompt";
+    const workflow = parseWorkflowMarkdown(await readFile2(workflowPath, "utf8"), launcherEnv);
+    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";
+    const plan = await prepareCodexRuntimePlan(config);
+    childProcess = launchCodexAppServer(plan);
+    runtimeState.status = "running";
+    runtimeState.runPhase = "initializing_session";
+    if (runtimeState.run) {
+      runtimeState.run.processId = childProcess.pid ?? null;
+    }
+    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) {
+        if (!preservesTerminalPhase) {
+          runtimeState.run.lastError = code === 0 && !signal ? null : `codex app-server exited with ${signal ?? code ?? "unknown"}`;
+        }
+      }
+      void persistTokenUsageArtifact(launcherEnv, runtimeState.tokenUsage);
+    });
+    childProcess.once("error", (error) => {
+      runtimeState.status = "failed";
+      runtimeState.runPhase = "failed";
+      if (runtimeState.run) {
+        runtimeState.run.lastError = error.message;
+      }
+      void persistTokenUsageArtifact(launcherEnv, runtimeState.tokenUsage);
+    });
+  } catch (error) {
+    runtimeState.status = "failed";
+    runtimeState.runPhase = "failed";
+    if (runtimeState.run) {
+      runtimeState.run.lastError = error instanceof Error ? error.message : "Unknown worker startup error";
+    }
+    await persistTokenUsageArtifact(launcherEnv, runtimeState.tokenUsage);
+  }
+}
+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");
+    return;
+  }
+  if (!child.stdin || !child.stdout) {
+    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 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
+  };
+  child.stderr?.pipe(process.stderr);
+  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)}
+`);
+    deltaBuffer = null;
+  }
+  const pendingRequests = /* @__PURE__ */ new Map();
+  let turnCompletedResolve = null;
+  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();
+      turnCompletedResolve = null;
+    }
+  }
+  function describeTurnTerminalEvent(event, params) {
+    const fallback = event === "turn/failed" ? "turn_failed: codex reported turn failure" : "turn_cancelled: codex reported turn cancellation";
+    if (!params || typeof params !== "object") {
+      return fallback;
+    }
+    const record = params;
+    const directReasonKeys = ["message", "reason", "error"];
+    for (const key of directReasonKeys) {
+      const value = record[key];
+      if (typeof value === "string" && value.trim()) {
+        return `${event.replace("/", "_")}: ${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}`;
+        }
+      }
+    }
+    const serialized = JSON.stringify(params).slice(0, 300);
+    return serialized && serialized !== "{}" ? `${event.replace("/", "_")}: ${serialized}` : fallback;
+  }
+  function markTurnTerminalFailure(runPhase, lastError) {
+    runtimeState.status = "failed";
+    runtimeState.runPhase = runPhase;
+    if (runtimeState.run) {
+      runtimeState.run.lastError = lastError;
+    }
+    turnTerminalFailurePhase = runPhase;
+    resolvePendingTurnCompletion();
+    if (activeTurnTelemetry) {
+      emitTurnFailedEvent(activeTurnTelemetry, lastError);
+      activeTurnTelemetry = null;
+    }
+  }
+  function sendMessage(msg) {
+    const line = JSON.stringify(msg) + "\n";
+    child.stdin?.write(line);
+  }
+  function sendRequest(id, method, params) {
+    return new Promise((resolve2, reject) => {
+      pendingRequests.set(id, { resolve: resolve2, reject });
+      sendMessage({ jsonrpc: "2.0", id, method, params });
+    });
+  }
+  function sendRequestWithTimeout(id, method, params) {
+    return new Promise((resolve2, reject) => {
+      const timer = setTimeout(() => {
+        pendingRequests.delete(id);
+        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);
+      });
+    });
+  }
+  function waitForTurnCompletion() {
+    return new Promise((resolve2) => {
+      turnCompletedResolve = resolve2;
+    });
+  }
+  function waitForTurnWithTimeout() {
+    return new Promise((resolve2, reject) => {
+      const timer = setTimeout(() => {
+        process.stderr.write(`[worker] turn_timeout: turn exceeded ${turnTimeoutMs}ms \u2014 killing codex process
+`);
+        if (child.pid) {
+          try {
+            process.kill(child.pid, "SIGTERM");
+          } catch {
+          }
+        }
+        reject(new Error("turn_timeout: turn exceeded time limit"));
+      }, turnTimeoutMs);
+      waitForTurnCompletion().then(() => {
+        clearTimeout(timer);
+        resolve2();
+      }, (error) => {
+        clearTimeout(timer);
+        reject(error);
+      });
+    });
+  }
+  async function dispatchDynamicToolCall(callId, toolName, threadId, turnId, args) {
+    const toolDef = plan.tools.find((t) => t.name === toolName);
+    if (!toolDef) {
+      process.stderr.write(`[worker] unknown dynamic tool: ${toolName}; sending error response
+`);
+      sendMessage({
+        jsonrpc: "2.0",
+        method: "dynamic_tool_call_response",
+        params: {
+          callId,
+          threadId,
+          turnId,
+          contentItems: [
+            {
+              type: "input_text",
+              text: `Tool "${toolName}" is not registered.`
+            }
+          ],
+          isError: true
+        }
+      });
+      return;
+    }
+    const inputJson = JSON.stringify(args ?? {});
+    process.stderr.write(`[worker] executing dynamic tool "${toolName}" (callId=${callId})
+`);
+    try {
+      const output = await runToolProcess(toolDef, inputJson);
+      sendMessage({
+        jsonrpc: "2.0",
+        method: "dynamic_tool_call_response",
+        params: {
+          callId,
+          threadId,
+          turnId,
+          contentItems: [{ type: "input_text", text: output }],
+          isError: false
+        }
+      });
+    } catch (err) {
+      const errMsg = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`[worker] tool "${toolName}" failed: ${errMsg}
+`);
+      sendMessage({
+        jsonrpc: "2.0",
+        method: "dynamic_tool_call_response",
+        params: {
+          callId,
+          threadId,
+          turnId,
+          contentItems: [{ type: "input_text", text: errMsg }],
+          isError: true
+        }
+      });
+    }
+  }
+  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;
+    }
+    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;
+    }
+    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;
+      }
+      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);
+      }
+      const rateLimits2 = extractRateLimitPayload(turnParams);
+      if (rateLimits2) {
+        applyRateLimitUpdate("turn/completed", rateLimits2);
+      }
+      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";
+        }
+        if (child.pid) {
+          try {
+            process.kill(child.pid, "SIGTERM");
+          } catch {
+          }
+        }
+        if (activeTurnTelemetry) {
+          emitTurnFailedEvent(activeTurnTelemetry, runtimeState.run?.lastError ?? null);
+          activeTurnTelemetry = null;
+        }
+        resolvePendingTurnCompletion();
+        emitOrchestratorChannelEvent(orchestratorEventName);
+        return;
+      }
+      emitOrchestratorChannelEvent(orchestratorEventName);
+      if (activeTurnTelemetry) {
+        emitTurnCompletedEvent(activeTurnTelemetry);
+        activeTurnTelemetry = null;
+      }
+      process.stderr.write("[worker] codex turn/completed\n");
+      resolvePendingTurnCompletion();
+      return;
+    }
+    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);
+      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;
+    }
+    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);
+      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)}
+`);
+    }
+  }
+  child.stdout.on("data", (chunk) => {
+    lineBuffer += chunk.toString("utf8");
+    const lines = lineBuffer.split("\n");
+    lineBuffer = lines.pop() ?? "";
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed)
+        continue;
+      try {
+        const msg = JSON.parse(trimmed);
+        handleServerMessage(msg);
+      } catch {
+        process.stderr.write(`[worker] codex stdout (non-JSON): ${trimmed}
+`);
+      }
+    }
+  });
+  try {
+    process.stderr.write("[worker] sending codex initialize\n");
+    await sendRequestWithTimeout("init-1", "initialize", {
+      clientInfo: { name: "github-symphony", version: "0.1.0" },
+      capabilities: {}
+    });
+    process.stderr.write("[worker] codex initialized\n");
+    sendMessage({ jsonrpc: "2.0", method: "initialized", params: {} });
+    const mcpServers = {};
+    for (const t of plan.tools) {
+      mcpServers[t.name] = {
+        command: t.command,
+        args: t.args,
+        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 persistTokenUsageArtifact(env, runtimeState.tokenUsage);
+      await waitForPendingOrchestratorChannelFlush(resolveTerminalOrchestratorChannelFlushTimeoutMs());
+      setTimeout(() => {
+        process.exit(0);
+      }, 1500);
+      return;
+    }
+    const baseThreadParams = {
+      cwd: plan.cwd,
+      developerInstructions: renderedPrompt,
+      approvalPolicy,
+      sandbox: threadSandbox,
+      config: {
+        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", {
+        ...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")})
+`);
+    if (!threadId) {
+      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;
+      }
+      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({
+        continuationGuidance,
+        lastTurnSummary,
+        cumulativeTurnCount: globalTurnCount - 1
+      });
+      process.stderr.write(`[worker] starting codex turn ${globalTurnCount}/${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 turnId = turnResult.turn_id ?? turnResult.turn?.id;
+      const sessionId = threadId && turnId ? `${threadId}-${turnId}` : null;
+      runtimeState.sessionInfo.turnId = turnId ?? null;
+      runtimeState.sessionInfo.sessionId = sessionId;
+      runtimeState.sessionId = sessionId;
+      activeTurnTelemetry = {
+        startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        threadId: threadId ?? null,
+        turnId: turnId ?? null,
+        turnCount,
+        sessionId,
+        tokenUsageBaseline: cloneTokenUsageSnapshot()
+      };
+      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) {
+        process.stderr.write("[worker] exiting due to user_input_required\n");
+        break;
+      }
+      if (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) {
+        maxTurnsReached = true;
+        process.stderr.write(`[worker] max_turns (${maxTurns}) reached across sessions \u2014 exiting
+`);
+        break;
+      }
+      const trackerState = await refreshTrackerState(env);
+      process.stderr.write(`[worker] tracker state refresh: ${trackerState}
+`);
+      if (trackerState === "non-actionable") {
+        runtimeState.runPhase = "finishing";
+        runtimeState.executionPhase = resolveFinalExecutionPhase({
+          currentPhase: runtimeState.executionPhase,
+          trackerState,
+          userInputRequired: false
+        });
+        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);
+      previousTurnProgressSnapshot = currentTurnProgressSnapshot;
+      if (turnProgress.nonProductive) {
+        consecutiveNonProductiveTurns += 1;
+        process.stderr.write(`[worker] non-productive turn detected (${consecutiveNonProductiveTurns}/${maxNonProductiveTurns})${turnProgress.reason ? `: ${turnProgress.reason}` : ""}
+`);
+      } else {
+        consecutiveNonProductiveTurns = 0;
+      }
+      if (consecutiveNonProductiveTurns >= maxNonProductiveTurns) {
+        convergenceDetected = true;
+        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
+`);
+        break;
+      }
+    }
+    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,
+      convergenceDetected,
+      maxTurnsReached
+    });
+    stopOrchestratorHeartbeatTimer();
+    emitOrchestratorHeartbeat();
+    await persistTokenUsageArtifact(env, runtimeState.tokenUsage);
+    await waitForPendingOrchestratorChannelFlush(resolveTerminalOrchestratorChannelFlushTimeoutMs());
+    setTimeout(() => {
+      process.exit(userInputRequired || turnTerminalFailurePhase ? 1 : 0);
+    }, 1500);
+  } catch (err) {
+    const errMsg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`[worker] codex client protocol error: ${errMsg}
+`);
+    runtimeState.status = "failed";
+    runtimeState.runPhase = "failed";
+    if (runtimeState.run) {
+      runtimeState.run.lastError = `Codex client protocol error: ${errMsg}`;
+    }
+    if (errMsg.startsWith("response_timeout:")) {
+      runtimeState.runPhase = "stalled";
+      if (runtimeState.run) {
+        runtimeState.run.lastError = errMsg;
+      }
+    } else if (errMsg.startsWith("turn_timeout:")) {
+      runtimeState.runPhase = "timed_out";
+      if (runtimeState.run) {
+        runtimeState.run.lastError = errMsg;
+      }
+    }
+    runtimeState.sessionInfo.exitClassification = classifySessionExit({
+      runPhase: runtimeState.runPhase,
+      userInputRequired: false,
+      budgetExceeded: false,
+      convergenceDetected: false,
+      maxTurnsReached: false
+    });
+    if (activeTurnTelemetry) {
+      emitTurnFailedEvent(activeTurnTelemetry, runtimeState.run?.lastError ?? errMsg);
+      activeTurnTelemetry = null;
+    }
+    stopOrchestratorHeartbeatTimer();
+    emitOrchestratorHeartbeat();
+    await persistTokenUsageArtifact(env, runtimeState.tokenUsage);
+    await waitForPendingOrchestratorChannelFlush(resolveTerminalOrchestratorChannelFlushTimeoutMs());
+    setTimeout(() => {
+      process.exit(1);
+    }, 1500);
+  }
+}
+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}
+`);
+}
+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)}
+`);
+}
+function extractRateLimitPayload(value) {
+  if (!value || typeof value !== "object") {
+    return null;
+  }
+  const direct = parseRateLimitRecord(value);
+  if (direct) {
+    return direct;
+  }
+  const record = value;
+  const preferredKeys = [
+    "rate_limits",
+    "rateLimits",
+    "rate_limit",
+    "rateLimit",
+    "info",
+    "msg",
+    "event",
+    "data",
+    "result",
+    "payload"
+  ];
+  for (const key of preferredKeys) {
+    if (key in record) {
+      const nested = extractRateLimitPayload(record[key]);
+      if (nested) {
+        return nested;
+      }
+    }
+  }
+  for (const nestedValue of Object.values(record)) {
+    const nested = extractRateLimitPayload(nestedValue);
+    if (nested) {
+      return nested;
+    }
+  }
+  return null;
+}
+function parseRateLimitRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return null;
+  }
+  const record = value;
+  const keys = Object.keys(record);
+  const directKeys = /* @__PURE__ */ new Set([
+    "limit",
+    "remaining",
+    "used",
+    "reset",
+    "resetAt",
+    "resets_at",
+    "reset_at",
+    "window_minutes",
+    "resource",
+    "retry_after"
+  ]);
+  if (!keys.some((key) => directKeys.has(key))) {
+    return null;
+  }
+  return { ...record };
+}
+function extractAbsoluteTokenUsage(value) {
+  const direct = parseTokenUsageSnapshot(value);
+  if (direct) {
+    return direct;
+  }
+  if (!value || typeof value !== "object") {
+    return null;
+  }
+  const record = value;
+  const preferredKeys = [
+    "total_token_usage",
+    "token_usage",
+    "info",
+    "msg",
+    "event",
+    "data",
+    "result",
+    "payload"
+  ];
+  for (const key of preferredKeys) {
+    if (key in record) {
+      const nested = extractAbsoluteTokenUsage(record[key]);
+      if (nested) {
+        return nested;
+      }
+    }
+  }
+  for (const [key, nestedValue] of Object.entries(record)) {
+    if (key === "last_token_usage") {
+      continue;
+    }
+    const nested = extractAbsoluteTokenUsage(nestedValue);
+    if (nested) {
+      return nested;
+    }
+  }
+  return null;
+}
+function parseTokenUsageSnapshot(value) {
+  if (!value || typeof value !== "object") {
+    return null;
+  }
+  const record = value;
+  const inputTokens = typeof record.input_tokens === "number" ? record.input_tokens : typeof record.inputTokens === "number" ? record.inputTokens : null;
+  const outputTokens = typeof record.output_tokens === "number" ? record.output_tokens : typeof record.outputTokens === "number" ? record.outputTokens : null;
+  const explicitTotalTokens = typeof record.total_tokens === "number" ? record.total_tokens : typeof record.totalTokens === "number" ? record.totalTokens : null;
+  if (inputTokens === null && outputTokens === null && explicitTotalTokens === null) {
+    return null;
+  }
+  const normalizedInputTokens = inputTokens ?? 0;
+  const normalizedOutputTokens = outputTokens ?? 0;
+  const normalizedTotalTokens = explicitTotalTokens ?? normalizedInputTokens + normalizedOutputTokens;
+  if (normalizedInputTokens <= 0 && normalizedOutputTokens <= 0 && normalizedTotalTokens <= 0) {
+    return null;
+  }
+  return {
+    inputTokens: normalizedInputTokens,
+    outputTokens: normalizedOutputTokens,
+    totalTokens: normalizedTotalTokens || normalizedInputTokens + normalizedOutputTokens
+  };
+}
+async function refreshTrackerState(env) {
+  const orchestratorUrl = env.SYMPHONY_ORCHESTRATOR_URL;
+  const issueIdentifier = env.SYMPHONY_ISSUE_IDENTIFIER;
+  if (!orchestratorUrl) {
+    return "unknown";
+  }
+  try {
+    const response = await fetch(`${orchestratorUrl}/api/v1/state`);
+    if (!response.ok)
+      return "unknown";
+    const status = await response.json();
+    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) => {
+    const toolEnv = {
+      ...process.env,
+      ...toolDef.env
+    };
+    const toolProc = spawn2(toolDef.command, toolDef.args, {
+      env: toolEnv,
+      stdio: "pipe"
+    });
+    const stdout = [];
+    const stderr = [];
+    toolProc.stdout?.on("data", (chunk) => stdout.push(chunk));
+    toolProc.stderr?.on("data", (chunk) => stderr.push(chunk));
+    toolProc.once("error", (err) => reject(err));
+    toolProc.once("exit", (code) => {
+      const output = Buffer.concat(stdout).toString("utf8").trim();
+      if (code === 0) {
+        resolve2(output || "{}");
+      } else {
+        const errOutput = Buffer.concat(stderr).toString("utf8").trim();
+        reject(new Error(`Tool exited with code ${code ?? "unknown"}: ${errOutput || output}`));
+      }
+    });
+    toolProc.stdin?.write(inputJson);
+    toolProc.stdin?.end();
+  });
+}