@gh-symphony/cli 0.0.21 → 0.0.22

package/dist/{chunk-QEONJ5DZ.js → chunk-EEQQWTXS.js}

@@ -583,6 +583,73 @@ function matchOptionalSection(markdown, heading) {
   return match?.[1]?.trim() ?? null;
 }
 
+// ../core/src/workflow/loader.ts
+import { createHash } from "crypto";
+import { access, readFile, stat } from "fs/promises";
+import { constants } from "fs";
+var WorkflowConfigStore = class {
+  cache = /* @__PURE__ */ new Map();
+  async load(workflowPath, env = process.env) {
+    await access(workflowPath, constants.R_OK);
+    const fileStat = await stat(workflowPath);
+    const cached = this.cache.get(workflowPath);
+    const markdown = await readFile(workflowPath, "utf8");
+    const fingerprint = `${fileStat.mtimeMs}:${fileStat.size}:${createHash("sha256").update(markdown).digest("hex")}`;
+    if (cached && cached.fingerprint === fingerprint) {
+      return toWorkflowResolution(workflowPath, cached.workflow, {
+        isValid: true,
+        usedLastKnownGood: false,
+        validationError: null
+      });
+    }
+    try {
+      const workflow = parseWorkflowMarkdown(markdown, env);
+      this.cache.set(workflowPath, {
+        fingerprint,
+        workflow,
+        loadedAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      return toWorkflowResolution(workflowPath, workflow, {
+        isValid: true,
+        usedLastKnownGood: false,
+        validationError: null
+      });
+    } catch (error) {
+      if (cached) {
+        return toWorkflowResolution(workflowPath, cached.workflow, {
+          isValid: false,
+          usedLastKnownGood: true,
+          validationError: error instanceof Error ? error.message : "Invalid workflow definition."
+        });
+      }
+      throw error;
+    }
+  }
+};
+function createDefaultWorkflowResolution() {
+  return createInvalidWorkflowResolution(null, "missing_workflow_file");
+}
+function createInvalidWorkflowResolution(workflowPath, validationError) {
+  return toWorkflowResolution(workflowPath, DEFAULT_WORKFLOW_DEFINITION, {
+    isValid: false,
+    usedLastKnownGood: false,
+    validationError
+  });
+}
+function toWorkflowResolution(workflowPath, workflow, metadata) {
+  return {
+    workflowPath,
+    workflow,
+    lifecycle: workflow.lifecycle,
+    promptTemplate: workflow.promptTemplate,
+    agentCommand: workflow.agentCommand,
+    hookPath: workflow.hookPath ?? "",
+    isValid: metadata.isValid,
+    usedLastKnownGood: metadata.usedLastKnownGood,
+    validationError: metadata.validationError
+  };
+}
+
 // ../core/src/workflow/render.ts
 import {
   Liquid,
@@ -806,73 +873,6 @@ function isOrchestratorChannelEvent(value) {
   return false;
 }
 
-// ../core/src/workflow/loader.ts
-import { createHash } from "crypto";
-import { access, readFile, stat } from "fs/promises";
-import { constants } from "fs";
-var WorkflowConfigStore = class {
-  cache = /* @__PURE__ */ new Map();
-  async load(workflowPath, env = process.env) {
-    await access(workflowPath, constants.R_OK);
-    const fileStat = await stat(workflowPath);
-    const fingerprint = `${fileStat.mtimeMs}:${fileStat.size}`;
-    const cached = this.cache.get(workflowPath);
-    if (cached && cached.fingerprint === fingerprint) {
-      return toWorkflowResolution(workflowPath, cached.workflow, {
-        isValid: true,
-        usedLastKnownGood: false,
-        validationError: null
-      });
-    }
-    const markdown = await readFile(workflowPath, "utf8");
-    try {
-      const workflow = parseWorkflowMarkdown(markdown, env);
-      this.cache.set(workflowPath, {
-        fingerprint,
-        workflow,
-        loadedAt: (/* @__PURE__ */ new Date()).toISOString()
-      });
-      return toWorkflowResolution(workflowPath, workflow, {
-        isValid: true,
-        usedLastKnownGood: false,
-        validationError: null
-      });
-    } catch (error) {
-      if (cached) {
-        return toWorkflowResolution(workflowPath, cached.workflow, {
-          isValid: false,
-          usedLastKnownGood: true,
-          validationError: error instanceof Error ? error.message : "Invalid workflow definition."
-        });
-      }
-      throw error;
-    }
-  }
-};
-function createDefaultWorkflowResolution() {
-  return createInvalidWorkflowResolution(null, "missing_workflow_file");
-}
-function createInvalidWorkflowResolution(workflowPath, validationError) {
-  return toWorkflowResolution(workflowPath, DEFAULT_WORKFLOW_DEFINITION, {
-    isValid: false,
-    usedLastKnownGood: false,
-    validationError
-  });
-}
-function toWorkflowResolution(workflowPath, workflow, metadata) {
-  return {
-    workflowPath,
-    workflow,
-    lifecycle: workflow.lifecycle,
-    promptTemplate: workflow.promptTemplate,
-    agentCommand: workflow.agentCommand,
-    hookPath: workflow.hookPath ?? "",
-    isValid: metadata.isValid,
-    usedLastKnownGood: metadata.usedLastKnownGood,
-    validationError: metadata.validationError
-  };
-}
-
 // ../core/src/workflow/exit-classification.ts
 function classifySessionExit(params) {
   if (params.userInputRequired) {
@@ -917,9 +917,22 @@ var CODEX_ENV_KEYS = [
   "OPENAI_ORG_ID",
   "OPENAI_PROJECT"
 ];
+var AgentRuntimeCredentialError = class extends Error {
+};
 function extractEnvForCodex(env) {
   return pickRuntimeEnv(env, CODEX_ENV_KEYS);
 }
+function extractEnvForClaude(env, envKey = "ANTHROPIC_API_KEY") {
+  const apiKey = env[envKey];
+  if (!apiKey) {
+    throw new AgentRuntimeCredentialError(
+      `${envKey} is required in the credential broker response.`
+    );
+  }
+  return {
+    [envKey]: apiKey
+  };
+}
 function toAgentCredentialCacheEntry(brokerResponse, now = /* @__PURE__ */ new Date()) {
   return {
     env: brokerResponse.env,
@@ -1024,37 +1037,49 @@ import { resolve } from "path";
 // ../core/src/workspace/identity.ts
 import { resolve as resolve2, join } from "path";
 import { createHash as createHash2 } from "crypto";
-function deriveIssueWorkspaceKey(identity, issueIdentifier) {
-  if (issueIdentifier) {
-    return deriveIssueWorkspaceKeyFromIdentifier(issueIdentifier);
-  }
-  return deriveLegacyIssueWorkspaceKey(identity);
-}
-function deriveIssueWorkspaceKeyFromIdentifier(issueIdentifier) {
-  const sanitized = issueIdentifier.replace(/[^A-Za-z0-9._-]+/g, "_").replace(/^_+|_+$/g, "");
+var RESERVED_WORKSPACE_KEYS = /* @__PURE__ */ new Set([
+  "cache",
+  "issues.json",
+  "project.json",
+  "runs",
+  "status.json"
+]);
+function deriveWorkspaceKey(identifier) {
+  const sanitized = identifier.replace(/[^A-Za-z0-9._-]+/g, "_").replace(/^_+|_+$/g, "");
   if (!sanitized || /^[.]+$/.test(sanitized)) {
     return "issue";
   }
   return sanitized;
 }
-function deriveLegacyIssueWorkspaceKey(identity) {
-  const input = [
-    identity.projectId,
-    identity.adapter,
-    identity.issueSubjectId
-  ].join(":");
+var deriveIssueWorkspaceKeyFromIdentifier = deriveWorkspaceKey;
+function deriveIssueWorkspaceKey(identityOrIdentifier, issueIdentifier) {
+  if (typeof identityOrIdentifier === "string") {
+    return deriveWorkspaceKey(identityOrIdentifier);
+  }
+  return deriveWorkspaceKey(
+    issueIdentifier ?? identityOrIdentifier.issueSubjectId
+  );
+}
+function deriveLegacyIssueWorkspaceKey(identity, projectId) {
+  const input = [projectId, identity.adapter, identity.issueSubjectId].filter((part) => typeof part === "string").join(":");
   return createHash2("sha256").update(input).digest("hex").slice(0, 16);
 }
-function resolveIssueWorkspaceDirectory(projectDirectory, workspaceKey) {
-  const normalizedProjectDirectory = resolve2(projectDirectory);
-  const candidate = resolve2(normalizedProjectDirectory, "issues", workspaceKey);
-  if (!candidate.startsWith(`${normalizedProjectDirectory}/`)) {
+function resolveIssueWorkspaceDirectory(runtimeRoot, workspaceKey) {
+  const normalizedRuntimeRoot = resolve2(runtimeRoot);
+  const candidate = resolve2(normalizedRuntimeRoot, workspaceKey);
+  if (!candidate.startsWith(`${normalizedRuntimeRoot}/`)) {
     throw new Error(
-      "Issue workspace path escapes the configured project directory."
+      "Issue workspace path escapes the configured runtime root."
     );
   }
+  if (isReservedWorkspaceKey(workspaceKey)) {
+    throw new Error("Issue workspace key is reserved by the runtime layout.");
+  }
   return candidate;
 }
+function isReservedWorkspaceKey(workspaceKey) {
+  return workspaceKey.startsWith(".") || RESERVED_WORKSPACE_KEYS.has(workspaceKey);
+}
 
 // ../core/src/workspace/hooks.ts
 import { spawn } from "child_process";
@@ -1206,11 +1231,11 @@ function buildProjectSnapshot(input) {
     allRuns ?? activeRuns
   );
   return {
-    projectId: project.projectId,
-    slug: project.slug,
+    repository: project.repository,
     tracker: {
       adapter: project.tracker.adapter,
-      bindingId: project.tracker.bindingId
+      bindingId: project.tracker.bindingId,
+      settings: project.tracker.settings
     },
     lastTickAt,
     health: lastError ? "degraded" : activeRuns.length > 0 ? "running" : "idle",
@@ -1405,9 +1430,9 @@ function parseRunEventLine(line) {
 }
 
 // ../core/src/observability/status-assembler.ts
-function isMatchingIssueRun(run, projectId, issueId, issueIdentifier) {
+function isMatchingIssueRun(run, issueId, issueIdentifier) {
   return Boolean(
-    run && run.projectId === projectId && (run.issueId === issueId || run.issueIdentifier === issueIdentifier)
+    run && (run.issueId === issueId || run.issueIdentifier === issueIdentifier)
   );
 }
 function mapIssueOrchestrationStateToStatus(state) {
@@ -1717,6 +1742,77 @@ import { randomUUID } from "crypto";
 import { rm } from "fs/promises";
 import { join as join5 } from "path";
 
+// ../runtime-claude/src/argv.ts
+var DEFAULT_CLAUDE_PRINT_ARGS = [
+  "-p",
+  "--output-format",
+  "stream-json",
+  "--input-format",
+  "stream-json",
+  "--include-partial-messages",
+  // Claude stream-json output requires verbose mode when partial message
+  // events are included; keep this even when callers provide custom args.
+  "--verbose",
+  "--permission-mode",
+  "bypassPermissions"
+];
+function buildClaudePrintArgv(options = {}) {
+  const args = options.baseArgs ? withRequiredClaudePrintArgs(options.baseArgs) : [...DEFAULT_CLAUDE_PRINT_ARGS];
+  const { session, isolation, extraArgs } = options;
+  if (session?.mode === "start") {
+    ensureFlagValue(args, "--session-id", session.sessionId);
+  }
+  if (session?.mode === "resume") {
+    ensureFlagValue(args, "--resume", session.sessionId);
+    if (session.forkSession) {
+      ensureFlag(args, "--fork-session");
+    }
+  }
+  if (isolation?.bare) {
+    ensureFlag(args, "--bare");
+  }
+  if (isolation?.strictMcpConfig) {
+    ensureFlag(args, "--strict-mcp-config");
+    if (isolation.mcpConfigPath) {
+      ensureFlagValue(args, "--mcp-config", isolation.mcpConfigPath);
+    }
+  }
+  if (extraArgs?.length) {
+    args.push(...extraArgs);
+  }
+  return args;
+}
+function withRequiredClaudePrintArgs(baseArgs) {
+  const args = [...baseArgs];
+  ensureFlag(args, "-p");
+  ensureFlagValue(args, "--output-format", "stream-json");
+  ensureFlagValue(args, "--input-format", "stream-json");
+  ensureFlag(args, "--include-partial-messages");
+  ensureFlag(args, "--verbose");
+  ensureFlagValue(args, "--permission-mode", "bypassPermissions");
+  return args;
+}
+function ensureFlag(args, flag) {
+  if (!args.includes(flag)) {
+    args.push(flag);
+  }
+}
+function ensureFlagValue(args, flag, value) {
+  const index = args.indexOf(flag);
+  if (index === -1) {
+    args.push(flag, value);
+    return;
+  }
+  const existingValue = args[index + 1];
+  if (existingValue?.startsWith("-")) {
+    args.splice(index + 1, 0, value);
+    return;
+  }
+  if (existingValue !== value) {
+    args.splice(index + 1, existingValue === void 0 ? 0 : 1, value);
+  }
+}
+
 // ../runtime-claude/src/mcp-compose.ts
 import { mkdir, readFile as readFile6, writeFile as writeFile3 } from "fs/promises";
 import { basename, dirname, join as join3, resolve as resolve4 } from "path";
@@ -2006,13 +2102,1111 @@ function createGitHubGraphQLMcpServerEntry(options = {}) {
   };
 }
 
+// ../runtime-claude/src/mcp-compose.ts
+async function composeClaudeMcpConfig(workspaceRoot, strictMode, symphonyTokenEnv = {}) {
+  const workspaceMcpPath = join3(workspaceRoot, ".mcp.json");
+  const finalPath = strictMode ? resolveStrictMcpConfigPath(workspaceRoot, symphonyTokenEnv) : workspaceMcpPath;
+  const baseConfig = await readBaseMcpConfig(workspaceMcpPath);
+  const mergedConfig = mergeGitHubGraphQLMcpServer(baseConfig, symphonyTokenEnv);
+  await mkdir(dirname(finalPath), { recursive: true });
+  await writeFile3(finalPath, JSON.stringify(mergedConfig, null, 2) + "\n", "utf8");
+  return {
+    finalPath,
+    extraArgv: strictMode ? ["--strict-mcp-config", "--mcp-config", finalPath] : [],
+    ...strictMode ? { cleanupPath: finalPath } : {}
+  };
+}
+async function readBaseMcpConfig(workspaceMcpPath) {
+  try {
+    const raw = await readFile6(workspaceMcpPath, "utf8");
+    const parsed = JSON.parse(raw);
+    return isRecord3(parsed) ? parsed : { mcpServers: {} };
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") {
+      return { mcpServers: {} };
+    }
+    throw error;
+  }
+}
+function mergeGitHubGraphQLMcpServer(baseConfig, env) {
+  const mcpServers = isRecord3(baseConfig.mcpServers) ? baseConfig.mcpServers : {};
+  return {
+    ...baseConfig,
+    mcpServers: {
+      ...mcpServers,
+      github_graphql: createGitHubGraphQLMcpServerEntry({
+        githubToken: env.GITHUB_GRAPHQL_TOKEN,
+        githubGraphqlApiUrl: env.GITHUB_GRAPHQL_API_URL,
+        githubTokenBrokerUrl: env.GITHUB_TOKEN_BROKER_URL,
+        githubTokenBrokerSecret: env.GITHUB_TOKEN_BROKER_SECRET,
+        githubTokenCachePath: env.GITHUB_TOKEN_CACHE_PATH,
+        githubProjectId: env.GITHUB_PROJECT_ID
+      })
+    }
+  };
+}
+function resolveStrictMcpConfigPath(workspaceRoot, env) {
+  const normalizedWorkspaceRoot = resolve4(workspaceRoot);
+  const runtimeDir = env.WORKSPACE_RUNTIME_DIR ?? join3(normalizedWorkspaceRoot, ".runtime", basename(normalizedWorkspaceRoot));
+  return join3(runtimeDir, "mcp.json");
+}
+function isRecord3(value) {
+  return value != null && typeof value === "object" && !Array.isArray(value);
+}
+function isNodeError(error) {
+  return error instanceof Error && "code" in error;
+}
+
 // ../runtime-claude/src/spawn.ts
 import { spawn as spawn2 } from "child_process";
 import { finished } from "stream/promises";
 
+// ../runtime-claude/src/internal.ts
+function asRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function getString(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (typeof value === "number") {
+    return String(value);
+  }
+  return void 0;
+}
+
+// ../runtime-claude/src/events.ts
+var CLAUDE_OBSERVABILITY_PREFIX = "claude-print/";
+function parseClaudePrintNdjsonLine(line) {
+  const trimmedLine = line.trim();
+  if (!trimmedLine) {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(trimmedLine);
+    if (!asRecord(parsed)) {
+      return {
+        line: trimmedLine,
+        parseError: "Claude stream-json line is not a JSON object."
+      };
+    }
+    return {
+      line: trimmedLine,
+      message: parsed
+    };
+  } catch (error) {
+    return {
+      line: trimmedLine,
+      parseError: error instanceof Error ? error.message : "Unknown JSON parse error."
+    };
+  }
+}
+var ClaudePrintEventMapper = class {
+  constructor(options = {}) {
+    this.options = options;
+  }
+  hasStartedTurn = false;
+  latestResultEvent = null;
+  // Claude -p stream-json does not define an ordered collection of error
+  // records for one turn; keep the terminal/latest error for exit classification.
+  latestErrorEvent = null;
+  sawRateLimit = false;
+  mapLine(line) {
+    const record = parseClaudePrintNdjsonLine(line);
+    if (!record?.message) {
+      return [];
+    }
+    return this.mapMessage(record.message);
+  }
+  mapMessage(message) {
+    const type = getEventType(message);
+    const events = [];
+    if (type === "message_start") {
+      events.push(this.buildTurnStartedEvent(message, type));
+      this.hasStartedTurn = true;
+      return events;
+    }
+    if (type === "content_block_start" || type === "tool_use") {
+      if (!this.hasStartedTurn) {
+        events.push(this.buildTurnStartedEvent(message, type));
+        this.hasStartedTurn = true;
+      }
+      const toolUseEvent = mapToolUseEvent(message, this.options);
+      if (toolUseEvent) {
+        events.push(toolUseEvent);
+      }
+    }
+    if (type === "content_block_delta") {
+      if (!this.hasStartedTurn) {
+        events.push(this.buildTurnStartedEvent(message, type));
+        this.hasStartedTurn = true;
+      }
+      events.push({
+        name: "agent.messageDelta",
+        payload: {
+          observabilityEvent: observabilityEventName(type),
+          params: message,
+          delta: extractDeltaText(message),
+          itemId: extractItemId(message)
+        }
+      });
+    }
+    if (type === "result") {
+      this.latestResultEvent = message;
+      const rateLimit = extractRateLimit(message);
+      if (rateLimit) {
+        this.sawRateLimit = true;
+        events.push({
+          name: "agent.rateLimit",
+          payload: {
+            observabilityEvent: observabilityEventName(type),
+            params: {
+              source: "claude",
+              rate_limit: rateLimit,
+              usage: asRecord(message.usage),
+              result: message
+            }
+          }
+        });
+      }
+      if (isClaudeResultError(message)) {
+        events.push(buildClaudeErrorEvent(message, type));
+      } else {
+        events.push({
+          name: "agent.turnCompleted",
+          payload: {
+            observabilityEvent: observabilityEventName(type),
+            params: message,
+            inputRequired: false
+          }
+        });
+      }
+    }
+    if (type === "error") {
+      this.latestErrorEvent = message;
+      events.push(buildClaudeErrorEvent(message, type));
+    }
+    return events;
+  }
+  snapshot() {
+    return {
+      hasStartedTurn: this.hasStartedTurn,
+      latestResultEvent: this.latestResultEvent,
+      latestErrorEvent: this.latestErrorEvent,
+      sawRateLimit: this.sawRateLimit
+    };
+  }
+  buildTurnStartedEvent(message, type) {
+    return {
+      name: "agent.turnStarted",
+      payload: {
+        observabilityEvent: observabilityEventName(type),
+        params: message
+      }
+    };
+  }
+};
+function isClaudeResultError(message) {
+  const subtype = getString(message.subtype);
+  const stopReason = getString(message.stop_reason);
+  return message.is_error === true || subtype !== void 0 && subtype.startsWith("error") || stopReason !== void 0 && stopReason.startsWith("error");
+}
+function extractRateLimit(message) {
+  const usage = asRecord(message.usage);
+  const rateLimit = usage ? asRecord(usage.rate_limit) : null;
+  if (rateLimit) {
+    return rateLimit;
+  }
+  return asRecord(message.rate_limit);
+}
+function getClaudeResultStatus(message) {
+  if (!message) {
+    return void 0;
+  }
+  return getString(message.subtype) ?? getString(message.stop_reason);
+}
+function mapToolUseEvent(message, options) {
+  const type = getEventType(message);
+  const contentBlock = asRecord(message.content_block);
+  const toolUse = type === "tool_use" ? message : contentBlock && getString(contentBlock.type) === "tool_use" ? contentBlock : null;
+  if (!toolUse) {
+    return null;
+  }
+  const input = toolUse.input !== void 0 ? toolUse.input : toolUse.arguments;
+  return {
+    name: "agent.toolCallRequested",
+    payload: {
+      observabilityEvent: observabilityEventName(type),
+      params: message,
+      callId: getString(toolUse.id) ?? "",
+      toolName: getString(toolUse.name) ?? "",
+      threadId: options.threadId ?? getString(message.thread_id),
+      turnId: options.turnId ?? getString(message.turn_id),
+      arguments: input
+    }
+  };
+}
+function buildClaudeErrorEvent(message, type) {
+  return {
+    name: "agent.error",
+    payload: {
+      observabilityEvent: observabilityEventName(type),
+      params: message,
+      error: describeClaudeError(message)
+    }
+  };
+}
+function describeClaudeError(message) {
+  const error = asRecord(message.error);
+  return getString(error?.message) ?? getString(error?.type) ?? getString(message.message) ?? getString(message.subtype) ?? getString(message.stop_reason) ?? JSON.stringify(message);
+}
+function extractDeltaText(message) {
+  const delta = asRecord(message.delta);
+  return getString(delta?.text) ?? getString(delta?.partial_json) ?? getString(message.text) ?? "";
+}
+function extractItemId(message) {
+  return getString(message.item_id) ?? getString(message.content_block_id) ?? getString(message.index) ?? "";
+}
+function getEventType(message) {
+  return getString(message.type) ?? "";
+}
+function observabilityEventName(type) {
+  return `${CLAUDE_OBSERVABILITY_PREFIX}${type || "unknown"}`;
+}
+
+// ../runtime-claude/src/exit-classifier.ts
+var TRANSIENT_ERROR_PATTERNS = [
+  /rate.?limit/i,
+  /\b429\b/,
+  /timeout/i,
+  /timed?.?out/i,
+  /temporar/i,
+  /overload/i,
+  /unavailable/i,
+  /ECONNRESET/,
+  /ETIMEDOUT/,
+  /EAI_AGAIN/
+];
+function classifyClaudeTurnExit(input) {
+  const resultStatus = getClaudeResultStatus(input.resultEvent);
+  if (input.exitCode === 0 && input.resultEvent && !isClaudeResultError(input.resultEvent)) {
+    return {
+      kind: "success",
+      transient: false,
+      reason: "result_success",
+      resultStatus
+    };
+  }
+  if (input.exitCode === 0 && !input.resultEvent) {
+    return {
+      kind: "app-error",
+      transient: false,
+      reason: "missing_result",
+      resultStatus
+    };
+  }
+  if (input.exitCode === 0 && input.resultEvent && isClaudeResultError(input.resultEvent)) {
+    return {
+      kind: "app-error",
+      transient: isTransientClaudeFailure(input),
+      reason: resultStatus ?? "result_error",
+      resultStatus
+    };
+  }
+  return {
+    kind: "process-error",
+    transient: isTransientClaudeFailure(input),
+    reason: describeProcessFailure(input),
+    resultStatus
+  };
+}
+function isTransientClaudeFailure(input) {
+  if (input.sawRateLimit || input.resultEvent && (extractRateLimit(input.resultEvent) !== null || getClaudeResultStatus(input.resultEvent) === "error_rate_limit")) {
+    return true;
+  }
+  if (input.signal === "SIGTERM") {
+    return true;
+  }
+  const text = [
+    input.spawnErrorMessage,
+    extractFailureMessage(input.errorEvent),
+    extractFailureMessage(input.resultEvent)
+  ].join("\n");
+  return TRANSIENT_ERROR_PATTERNS.some((pattern) => pattern.test(text));
+}
+function describeProcessFailure(input) {
+  if (input.signal) {
+    return `signal_${input.signal}`;
+  }
+  if (input.spawnErrorMessage) {
+    return input.spawnErrorMessage;
+  }
+  if (typeof input.exitCode === "number") {
+    return `exit_${input.exitCode}`;
+  }
+  return "process_error";
+}
+function extractFailureMessage(event) {
+  if (!event) {
+    return "";
+  }
+  const error = asRecord(event.error);
+  return [
+    getString(error?.message),
+    getString(error?.type),
+    getString(event.message)
+  ].filter((value) => value !== void 0).join("\n");
+}
+
+// ../runtime-claude/src/spawn.ts
+async function spawnClaudeTurn(input, dependencies = {}) {
+  const command = input.command ?? "claude";
+  const child = (dependencies.spawnImpl ?? spawn2)(command, input.args, {
+    cwd: input.cwd,
+    env: input.env,
+    stdio: "pipe"
+  });
+  dependencies.onSpawned?.(child);
+  const records = [];
+  const eventMapper = new ClaudePrintEventMapper();
+  let emittedErrorEvent = false;
+  const emitEvent = (event) => {
+    if (event.name === "agent.error") {
+      emittedErrorEvent = true;
+    }
+    dependencies.onEvent?.(event);
+  };
+  const stdoutDone = collectNdjsonStream(
+    child.stdout,
+    "stdout",
+    records,
+    eventMapper,
+    emitEvent
+  );
+  const stderrDone = collectNdjsonStream(
+    child.stderr,
+    "stderr",
+    records,
+    null,
+    null
+  );
+  const exitDone = waitForChildExit(child, records);
+  const stdinMessages = Array.isArray(input.stdinMessages) ? input.stdinMessages : [input.stdinMessages];
+  for (const message of stdinMessages) {
+    const didWrite = await writeToStdin(
+      child.stdin,
+      `${JSON.stringify(message)}
+`
+    );
+    if (!didWrite) {
+      break;
+    }
+  }
+  if (child.stdin && !child.stdin.destroyed && !child.stdin.writableEnded && !child.stdin.writableFinished) {
+    child.stdin.end();
+  }
+  const outcome = await exitDone;
+  await Promise.all([stdoutDone, stderrDone]);
+  const mapperState = eventMapper.snapshot();
+  const classification = classifyClaudeTurnExit({
+    exitCode: outcome.exitCode,
+    signal: outcome.signal,
+    resultEvent: mapperState.latestResultEvent,
+    errorEvent: mapperState.latestErrorEvent,
+    sawRateLimit: mapperState.sawRateLimit,
+    spawnErrorMessage: "errorMessage" in outcome ? outcome.errorMessage : void 0
+  });
+  if ((classification.kind === "app-error" || classification.kind === "process-error") && !emittedErrorEvent) {
+    emitEvent({
+      name: "agent.error",
+      payload: {
+        observabilityEvent: classification.kind === "app-error" ? "claude-print/app-error" : "claude-print/process-exit",
+        params: {
+          exitCode: outcome.exitCode,
+          signal: outcome.signal,
+          classification,
+          errorMessage: "errorMessage" in outcome ? outcome.errorMessage : void 0
+        },
+        error: classification.reason
+      }
+    });
+  }
+  return {
+    command,
+    args: [...input.args],
+    cwd: input.cwd,
+    records,
+    exitCode: outcome.exitCode,
+    signal: outcome.signal,
+    result: classification.kind,
+    classification,
+    errorMessage: "errorMessage" in outcome ? outcome.errorMessage : void 0
+  };
+}
+async function collectNdjsonStream(stream, channel, records, eventMapper, onEvent) {
+  if (!stream) {
+    return;
+  }
+  let buffer = "";
+  stream.setEncoding("utf8");
+  stream.on("data", (chunk) => {
+    buffer += chunk;
+    while (true) {
+      const newlineIndex = buffer.indexOf("\n");
+      if (newlineIndex === -1) {
+        break;
+      }
+      const line = buffer.slice(0, newlineIndex).trim();
+      buffer = buffer.slice(newlineIndex + 1);
+      if (line.length === 0) {
+        continue;
+      }
+      records.push(parseClaudeRecord(channel, line, eventMapper, onEvent));
+    }
+  });
+  try {
+    await finished(stream);
+  } catch (error) {
+    records.push({
+      stream: channel,
+      line: "",
+      parseError: error instanceof Error ? error.message : "Unknown stream error."
+    });
+  }
+  const trailingLine = buffer.trim();
+  if (trailingLine.length > 0) {
+    records.push(
+      parseClaudeRecord(channel, trailingLine, eventMapper, onEvent)
+    );
+  }
+}
+function parseClaudeRecord(stream, line, eventMapper, onEvent) {
+  const record = parseClaudePrintNdjsonLine(line);
+  if (record.message) {
+    if (!eventMapper) {
+      return {
+        stream,
+        line: record.line,
+        message: record.message
+      };
+    }
+    for (const event of eventMapper.mapMessage(record.message)) {
+      onEvent?.(event);
+    }
+    return {
+      stream,
+      line: record.line,
+      message: record.message
+    };
+  }
+  return {
+    stream,
+    line: record.line,
+    parseError: record.parseError
+  };
+}
+async function writeToStdin(stream, line) {
+  if (!stream || stream.destroyed || stream.writableEnded) {
+    return false;
+  }
+  if (stream.write(line)) {
+    return true;
+  }
+  return waitForDrainOrClosure(stream);
+}
+function waitForDrainOrClosure(stream) {
+  return new Promise((resolve5) => {
+    const cleanup = () => {
+      stream.removeListener("drain", handleDrain);
+      stream.removeListener("close", handleClose);
+      stream.removeListener("finish", handleFinish);
+      stream.removeListener("error", handleError);
+    };
+    const handleDrain = () => {
+      cleanup();
+      resolve5(true);
+    };
+    const handleClose = () => {
+      cleanup();
+      resolve5(false);
+    };
+    const handleFinish = () => {
+      cleanup();
+      resolve5(false);
+    };
+    const handleError = () => {
+      cleanup();
+      resolve5(false);
+    };
+    stream.once("drain", handleDrain);
+    stream.once("close", handleClose);
+    stream.once("finish", handleFinish);
+    stream.once("error", handleError);
+  });
+}
+function waitForChildExit(child, records) {
+  return new Promise((resolve5) => {
+    const handleClose = (exitCode, signal) => {
+      cleanup();
+      resolve5({ exitCode, signal });
+    };
+    const handleError = (error) => {
+      cleanup();
+      records.push({
+        stream: "stderr",
+        line: "",
+        parseError: error.message
+      });
+      resolve5({
+        exitCode: null,
+        signal: null,
+        errorMessage: error.message
+      });
+    };
+    const cleanup = () => {
+      child.removeListener("close", handleClose);
+      child.removeListener("error", handleError);
+    };
+    child.on("close", handleClose);
+    child.on("error", handleError);
+  });
+}
+
 // ../runtime-claude/src/session-store.ts
 import { mkdir as mkdir2, readFile as readFile7, rename, writeFile as writeFile4 } from "fs/promises";
 import { dirname as dirname2, join as join4 } from "path";
+var CLAUDE_SESSION_PROTOCOL = "claude-print";
+var CLAUDE_SESSION_FILENAME = "claude-session.json";
+var ClaudeSessionStore = class {
+  constructor(options) {
+    this.options = options;
+  }
+  sessionFilePath(options) {
+    return join4(
+      options.runDirectory ?? this.runDirectory(options.runId),
+      CLAUDE_SESSION_FILENAME
+    );
+  }
+  async load(options) {
+    let raw;
+    try {
+      raw = await readFile7(this.sessionFilePath(options), "utf8");
+    } catch (error) {
+      if (isFileNotFoundError(error)) {
+        return null;
+      }
+      throw error;
+    }
+    return parseClaudeSessionFile(JSON.parse(raw));
+  }
+  async save(options) {
+    const session = {
+      protocol: CLAUDE_SESSION_PROTOCOL,
+      sessionId: options.sessionId,
+      createdAt: options.createdAt,
+      protocolState: options.protocolState ?? {}
+    };
+    if (options.parentRunId) {
+      session.parentRunId = options.parentRunId;
+    }
+    const path = this.sessionFilePath(options);
+    await mkdir2(dirname2(path), { recursive: true });
+    await writeFile4(`${path}.tmp`, `${JSON.stringify(session, null, 2)}
+`, "utf8");
+    await rename(`${path}.tmp`, path);
+    return session;
+  }
+  runDirectory(runId) {
+    return join4(this.options.runtimeRoot, "runs", runId);
+  }
+};
+function parseClaudeSessionFile(value) {
+  if (!isRecord4(value)) {
+    throw new Error("Claude session file must be a JSON object.");
+  }
+  if (value.protocol !== CLAUDE_SESSION_PROTOCOL) {
+    throw new Error(
+      `Claude session file protocol must be ${CLAUDE_SESSION_PROTOCOL}.`
+    );
+  }
+  if (typeof value.sessionId !== "string" || value.sessionId.length === 0) {
+    throw new Error("Claude session file sessionId must be a non-empty string.");
+  }
+  if (typeof value.createdAt !== "string" || value.createdAt.length === 0) {
+    throw new Error("Claude session file createdAt must be a non-empty string.");
+  }
+  if ("parentRunId" in value && value.parentRunId !== void 0 && typeof value.parentRunId !== "string") {
+    throw new Error("Claude session file parentRunId must be a string.");
+  }
+  if ("protocolState" in value && value.protocolState !== void 0 && !isRecord4(value.protocolState)) {
+    throw new Error("Claude session file protocolState must be an object.");
+  }
+  return {
+    protocol: CLAUDE_SESSION_PROTOCOL,
+    sessionId: value.sessionId,
+    createdAt: value.createdAt,
+    parentRunId: typeof value.parentRunId === "string" ? value.parentRunId : void 0,
+    protocolState: isRecord4(value.protocolState) ? value.protocolState : {}
+  };
+}
+function isRecord4(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function isFileNotFoundError(error) {
+  return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+
+// ../runtime-claude/src/adapter.ts
+var ClaudePrintRuntimeAdapter = class {
+  constructor(config, dependencies = {}) {
+    this.config = config;
+    this.dependencies = dependencies;
+    this.sessionStore = new ClaudeSessionStore({
+      runtimeRoot: config.runtimeRoot ?? join5(config.workingDirectory, ".runtime", "orchestrator")
+    });
+  }
+  activeChild = null;
+  preparedMcpConfig = null;
+  preparedSession = null;
+  eventHandlers = /* @__PURE__ */ new Set();
+  pendingEvents = [];
+  sessionStore;
+  async prepare(context) {
+    await this.cleanupPreparedMcpConfig();
+    this.pendingEvents.length = 0;
+    this.preparedSession = await this.prepareSession(context);
+    this.preparedMcpConfig = await composeClaudeMcpConfig(
+      this.config.workingDirectory,
+      this.config.isolation?.strictMcpConfig === true,
+      buildClaudeMcpTokenEnvironment({
+        inheritProcessEnv: this.config.inheritProcessEnv === true,
+        configEnv: this.config.env,
+        runtimeDirectory: this.config.runtimeDirectory
+      })
+    );
+  }
+  async spawnTurn(input) {
+    if (this.activeChild) {
+      throw new Error(
+        "TODO(#8): Claude print runtime adapter supports only one in-flight turn."
+      );
+    }
+    const session = input.session ?? this.preparedSession?.session;
+    const argv = buildClaudePrintArgv(this.buildArgvOptions(input, session));
+    try {
+      const result = await this.spawnWithArgv(input, argv);
+      if (this.shouldInvalidatePreparedResume(session, result)) {
+        return await this.retryWithFreshSession(input, result);
+      }
+      await this.persistStartedSessionId(result);
+      await this.persistForkedSessionId(result);
+      return result;
+    } finally {
+      this.activeChild = null;
+    }
+  }
+  onEvent(handler) {
+    this.eventHandlers.add(handler);
+    for (const event of this.pendingEvents) {
+      handler(event);
+    }
+    return () => {
+      this.eventHandlers.delete(handler);
+    };
+  }
+  resolveCredentials(brokerResponse) {
+    return extractEnvForClaude(brokerResponse.env, this.config.authEnvKey);
+  }
+  async shutdown() {
+    this.stopActiveChild();
+    await this.cleanupPreparedMcpConfig();
+  }
+  async cancel(_reason) {
+    this.stopActiveChild();
+    await this.cleanupPreparedMcpConfig();
+  }
+  buildArgvOptions(input, session) {
+    const isolation = {
+      ...this.config.isolation,
+      ...input.isolation
+    };
+    const configuredExtraArgs = input.extraArgs ?? this.config.extraArgs ?? [];
+    if (this.preparedMcpConfig) {
+      return {
+        baseArgs: this.config.args,
+        session,
+        // prepare() owns MCP argv injection through extraArgv; suppress the
+        // isolation flag here so buildClaudePrintArgv does not add it twice.
+        // Any input mcpConfigPath is intentionally ignored while a prepared
+        // composition result is active.
+        isolation: {
+          ...isolation,
+          strictMcpConfig: false,
+          mcpConfigPath: void 0
+        },
+        extraArgs: [
+          ...this.preparedMcpConfig.extraArgv,
+          ...configuredExtraArgs
+        ]
+      };
+    }
+    if (isolation.strictMcpConfig && !isolation.mcpConfigPath) {
+      throw new Error(
+        "Claude strict MCP config requires prepare() or an explicit mcpConfigPath."
+      );
+    }
+    return {
+      baseArgs: this.config.args,
+      session,
+      isolation,
+      extraArgs: configuredExtraArgs
+    };
+  }
+  async prepareSession(context) {
+    const currentOptions = {
+      runId: context.runId,
+      runDirectory: context.runDirectory
+    };
+    const parentRunId = context.previousRunId;
+    try {
+      const current = await this.sessionStore.load(currentOptions);
+      if (current) {
+        return {
+          runId: context.runId,
+          runDirectory: context.runDirectory,
+          sessionFile: current,
+          session: {
+            mode: "resume",
+            sessionId: current.sessionId
+          }
+        };
+      }
+    } catch (error) {
+      return await this.createFreshSession(context, {
+        reason: `session file could not be read or parsed: ${formatErrorMessage(error)}`,
+        invalidatedSessionId: "unknown",
+        parentRunId
+      });
+    }
+    if (context.previousRunId) {
+      try {
+        const previous = await this.sessionStore.load({
+          runId: context.previousRunId,
+          runDirectory: context.previousRunDirectory
+        });
+        if (previous) {
+          const sessionFile = await this.sessionStore.save({
+            ...currentOptions,
+            sessionId: previous.sessionId,
+            createdAt: this.nowIso(),
+            parentRunId: context.previousRunId
+          });
+          return {
+            runId: context.runId,
+            runDirectory: context.runDirectory,
+            sessionFile,
+            session: {
+              mode: "resume",
+              sessionId: previous.sessionId,
+              forkSession: true
+            }
+          };
+        }
+      } catch (error) {
+        return await this.createFreshSession(context, {
+          reason: `parent session file could not be read or parsed: ${formatErrorMessage(error)}`,
+          invalidatedSessionId: "unknown",
+          parentRunId
+        });
+      }
+    }
+    return await this.createFreshSession(context, { parentRunId });
+  }
+  async createFreshSession(context, options = {}) {
+    const replacementSessionId = this.createSessionId();
+    const sessionFile = await this.sessionStore.save({
+      runId: context.runId,
+      runDirectory: context.runDirectory,
+      sessionId: replacementSessionId,
+      createdAt: this.nowIso(),
+      parentRunId: options.parentRunId
+    });
+    if (options.reason) {
+      this.emitSessionInvalidated({
+        runId: context.runId,
+        sessionId: options.invalidatedSessionId ?? "unknown",
+        replacementSessionId,
+        reason: options.reason
+      });
+    }
+    return {
+      runId: context.runId,
+      runDirectory: context.runDirectory,
+      sessionFile,
+      session: {
+        mode: "start",
+        sessionId: replacementSessionId
+      }
+    };
+  }
+  async retryWithFreshSession(input, failedResult) {
+    if (!this.preparedSession) {
+      return failedResult;
+    }
+    const invalidatedSessionId = this.preparedSession.session.sessionId;
+    const replacementSessionId = this.createSessionId();
+    const parentRunId = this.preparedSession.sessionFile.parentRunId;
+    const sessionFile = await this.sessionStore.save({
+      runId: this.preparedSession.runId,
+      runDirectory: this.preparedSession.runDirectory,
+      sessionId: replacementSessionId,
+      createdAt: this.nowIso(),
+      parentRunId
+    });
+    this.preparedSession = {
+      ...this.preparedSession,
+      sessionFile,
+      session: {
+        mode: "start",
+        sessionId: replacementSessionId
+      }
+    };
+    this.emitSessionInvalidated({
+      runId: this.preparedSession.runId,
+      sessionId: invalidatedSessionId,
+      replacementSessionId,
+      reason: "claude resume session was rejected with a 4xx response"
+    });
+    const retryArgv = buildClaudePrintArgv(
+      this.buildArgvOptions(input, this.preparedSession.session)
+    );
+    const retryResult = await this.spawnWithArgv(input, retryArgv);
+    await this.persistStartedSessionId(retryResult);
+    return retryResult;
+  }
+  async spawnWithArgv(input, argv) {
+    return await spawnClaudeTurn(
+      {
+        command: input.command ?? this.config.command,
+        args: argv,
+        cwd: input.cwd ?? this.config.workingDirectory,
+        env: buildClaudeSpawnEnv({
+          inheritProcessEnv: this.config.inheritProcessEnv === true,
+          configEnv: this.config.env,
+          inputEnv: input.env
+        }),
+        stdinMessages: input.messages
+      },
+      {
+        ...this.dependencies,
+        onSpawned: (child) => {
+          this.activeChild = child;
+          this.dependencies.onSpawned?.(child);
+        },
+        onEvent: (event) => {
+          this.emitEvent(event);
+          try {
+            this.dependencies.onEvent?.(event);
+          } catch {
+          }
+        }
+      }
+    );
+  }
+  async persistForkedSessionId(result) {
+    if (this.preparedSession?.session.mode !== "resume" || !this.preparedSession.session.forkSession) {
+      return;
+    }
+    const forkedSessionId = findSessionIdInResult(result);
+    const sessionId = forkedSessionId ?? this.preparedSession.session.sessionId;
+    this.preparedSession = {
+      ...this.preparedSession,
+      sessionFile: await this.sessionStore.save({
+        runId: this.preparedSession.runId,
+        runDirectory: this.preparedSession.runDirectory,
+        sessionId,
+        createdAt: this.preparedSession.sessionFile.createdAt,
+        parentRunId: this.preparedSession.sessionFile.parentRunId,
+        protocolState: this.preparedSession.sessionFile.protocolState
+      }),
+      session: {
+        mode: "resume",
+        sessionId
+      }
+    };
+  }
+  async persistStartedSessionId(result) {
+    if (this.preparedSession?.session.mode !== "start") {
+      return;
+    }
+    if (result.result !== "success") {
+      return;
+    }
+    const sessionId = findSessionIdInResult(result) ?? this.preparedSession.session.sessionId;
+    this.preparedSession = {
+      ...this.preparedSession,
+      sessionFile: await this.sessionStore.save({
+        runId: this.preparedSession.runId,
+        runDirectory: this.preparedSession.runDirectory,
+        sessionId,
+        createdAt: this.preparedSession.sessionFile.createdAt,
+        parentRunId: this.preparedSession.sessionFile.parentRunId,
+        protocolState: this.preparedSession.sessionFile.protocolState
+      }),
+      session: {
+        mode: "resume",
+        sessionId
+      }
+    };
+  }
+  shouldInvalidatePreparedResume(session, result) {
+    return session === this.preparedSession?.session && session?.mode === "resume" && isResumeRejectedWith4xx(result);
+  }
+  emitSessionInvalidated(payload) {
+    const event = {
+      name: "agent.sessionInvalidated",
+      payload: {
+        params: {},
+        ...payload,
+        observabilityEvent: "session_invalidated"
+      }
+    };
+    if (this.eventHandlers.size === 0) {
+      this.pendingEvents.push(event);
+    } else {
+      for (const handler of this.eventHandlers) {
+        handler(event);
+      }
+    }
+  }
+  createSessionId() {
+    return this.dependencies.createSessionId?.() ?? randomUUID();
+  }
+  nowIso() {
+    return (this.dependencies.now?.() ?? /* @__PURE__ */ new Date()).toISOString();
+  }
+  stopActiveChild() {
+    if (!this.activeChild || this.activeChild.killed) {
+      this.activeChild = null;
+      return;
+    }
+    this.activeChild.kill("SIGTERM");
+    this.activeChild = null;
+  }
+  async cleanupPreparedMcpConfig() {
+    const cleanupPath = this.preparedMcpConfig?.cleanupPath;
+    this.preparedMcpConfig = null;
+    if (!cleanupPath) {
+      return;
+    }
+    await rm(cleanupPath, { force: true });
+  }
+  emitEvent(event) {
+    for (const handler of this.eventHandlers) {
+      try {
+        handler(event);
+      } catch {
+      }
+    }
+  }
+};
+function createClaudePrintRuntimeAdapter(config, dependencies = {}) {
+  return new ClaudePrintRuntimeAdapter(config, dependencies);
+}
+var DEFAULT_INHERITED_ENV_KEYS = [
+  "HOME",
+  "LANG",
+  "PATH",
+  "SHELL",
+  "SYSTEMROOT",
+  "TEMP",
+  "TERM",
+  "TMP",
+  "TMPDIR",
+  "USER",
+  "USERPROFILE"
+];
+function buildClaudeSpawnEnv(options) {
+  if (options.inheritProcessEnv) {
+    return {
+      ...process.env,
+      ...options.configEnv,
+      ...options.inputEnv
+    };
+  }
+  const env = {};
+  for (const key of DEFAULT_INHERITED_ENV_KEYS) {
+    const value = process.env[key];
+    if (value !== void 0) {
+      env[key] = value;
+    }
+  }
+  Object.assign(env, options.configEnv, options.inputEnv);
+  return env;
+}
+function findSessionIdInResult(result) {
+  for (const record of result.records) {
+    const sessionId = findSessionId(record.message);
+    if (sessionId) {
+      return sessionId;
+    }
+  }
+  return null;
+}
+function findSessionId(value, depth = 0) {
+  if (depth > 5) {
+    return null;
+  }
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return null;
+  }
+  const record = value;
+  if (typeof record.sessionId === "string") {
+    return record.sessionId;
+  }
+  if (typeof record.session_id === "string") {
+    return record.session_id;
+  }
+  for (const nested of Object.values(record)) {
+    const sessionId = findSessionId(nested, depth + 1);
+    if (sessionId) {
+      return sessionId;
+    }
+  }
+  return null;
+}
+function isResumeRejectedWith4xx(result) {
+  if (result.result !== "process-error") {
+    return false;
+  }
+  return result.records.some((record) => {
+    const text = record.line.toLowerCase();
+    return text.includes("resume") && /\b4\d\d\b/.test(text);
+  });
+}
+function formatErrorMessage(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+function buildClaudeMcpTokenEnvironment(options) {
+  const source = options.inheritProcessEnv ? {
+    ...process.env,
+    ...options.configEnv
+  } : {
+    ...options.configEnv
+  };
+  return {
+    GITHUB_GRAPHQL_TOKEN: source.GITHUB_GRAPHQL_TOKEN,
+    GITHUB_GRAPHQL_API_URL: source.GITHUB_GRAPHQL_API_URL,
+    GITHUB_TOKEN_BROKER_URL: source.GITHUB_TOKEN_BROKER_URL,
+    GITHUB_TOKEN_BROKER_SECRET: source.GITHUB_TOKEN_BROKER_SECRET,
+    GITHUB_TOKEN_CACHE_PATH: source.GITHUB_TOKEN_CACHE_PATH,
+    GITHUB_PROJECT_ID: source.GITHUB_PROJECT_ID,
+    WORKSPACE_RUNTIME_DIR: options.runtimeDirectory ?? source.WORKSPACE_RUNTIME_DIR
+  };
+}
 
 export {
   isOrchestratorChannelEvent,
@@ -2032,14 +3226,15 @@ export {
   classifySessionExit,
   scheduleRetryAt,
   extractEnvForCodex,
+  extractEnvForClaude,
   shouldReuseAgentCredentialCache,
   readAgentCredentialCache,
   writeAgentCredentialCache,
   DEFAULT_AGENT_INPUT_REQUIRED_REASON,
   buildAgentInputRequiredReason,
   readEnvFile,
-  deriveIssueWorkspaceKey,
   deriveIssueWorkspaceKeyFromIdentifier,
+  deriveIssueWorkspaceKey,
   deriveLegacyIssueWorkspaceKey,
   resolveIssueWorkspaceDirectory,
   buildHookEnv,
@@ -2053,6 +3248,7 @@ export {
   mapIssueOrchestrationStateToStatus,
   resolveGitHubGraphQLToken,
   createGitHubGraphQLMcpServerEntry,
+  createClaudePrintRuntimeAdapter,
   runClaudePreflight,
   formatClaudePreflightText,
   isClaudeRuntimeCommand,