@gh-symphony/cli 0.0.20 → 0.0.22

package/dist/chunk-EEQQWTXS.js

@@ -0,0 +1,3257 @@
+#!/usr/bin/env node
+
+// ../core/src/workflow/lifecycle.ts
+var DEFAULT_WORKFLOW_LIFECYCLE = {
+  stateFieldName: "Status",
+  activeStates: ["Todo", "In Progress"],
+  terminalStates: ["Done"],
+  blockerCheckStates: ["Todo"]
+};
+function isStateActive(state, lifecycle) {
+  return matchesWorkflowState(state, lifecycle.activeStates);
+}
+function isStateTerminal(state, lifecycle) {
+  return matchesWorkflowState(state, lifecycle.terminalStates);
+}
+function matchesWorkflowState(state, candidates) {
+  const normalizedState = normalizeWorkflowState(state);
+  return candidates.some((candidate) => normalizeWorkflowState(candidate) === normalizedState);
+}
+function normalizeWorkflowState(state) {
+  return state.trim().toLowerCase();
+}
+
+// ../core/src/workflow/config.ts
+var DEFAULT_CODEX_COMMAND = "codex app-server";
+var DEFAULT_CLAUDE_COMMAND = "claude";
+var DEFAULT_AGENT_COMMAND = DEFAULT_CODEX_COMMAND;
+var DEFAULT_HOOK_TIMEOUT_MS = 6e4;
+var DEFAULT_POLL_INTERVAL_MS = 3e4;
+var DEFAULT_MAX_RETRY_BACKOFF_MS = 3e5;
+var DEFAULT_MAX_DELAY_MS = DEFAULT_MAX_RETRY_BACKOFF_MS;
+var DEFAULT_BASE_DELAY_MS = 1e4;
+var DEFAULT_MAX_TURNS = 20;
+var DEFAULT_MAX_FAILURE_RETRIES = 10;
+var DEFAULT_READ_TIMEOUT_MS = 5e3;
+var DEFAULT_TURN_TIMEOUT_MS = 36e5;
+var DEFAULT_STALL_TIMEOUT_MS = 3e5;
+var DEFAULT_MAX_CONCURRENT_AGENTS = 10;
+var DEFAULT_WORKFLOW_HOOKS = {
+  afterCreate: null,
+  beforeRun: null,
+  afterRun: null,
+  beforeRemove: null,
+  timeoutMs: DEFAULT_HOOK_TIMEOUT_MS
+};
+var DEFAULT_WORKFLOW_TRACKER = {
+  kind: null,
+  endpoint: null,
+  apiKey: null,
+  projectSlug: null,
+  activeStates: DEFAULT_WORKFLOW_LIFECYCLE.activeStates,
+  terminalStates: DEFAULT_WORKFLOW_LIFECYCLE.terminalStates,
+  projectId: null,
+  stateFieldName: DEFAULT_WORKFLOW_LIFECYCLE.stateFieldName,
+  priorityFieldName: null,
+  blockerCheckStates: DEFAULT_WORKFLOW_LIFECYCLE.blockerCheckStates
+};
+var DEFAULT_WORKFLOW_WORKSPACE = {
+  root: null
+};
+var DEFAULT_WORKFLOW_AGENT = {
+  maxConcurrentAgents: DEFAULT_MAX_CONCURRENT_AGENTS,
+  maxRetryBackoffMs: DEFAULT_MAX_RETRY_BACKOFF_MS,
+  maxConcurrentAgentsByState: {},
+  maxFailureRetries: DEFAULT_MAX_FAILURE_RETRIES,
+  maxTurns: DEFAULT_MAX_TURNS,
+  retryBaseDelayMs: DEFAULT_BASE_DELAY_MS
+};
+var DEFAULT_WORKFLOW_CODEX = {
+  command: DEFAULT_CODEX_COMMAND,
+  approvalPolicy: null,
+  threadSandbox: null,
+  turnSandboxPolicy: null,
+  turnTimeoutMs: DEFAULT_TURN_TIMEOUT_MS,
+  readTimeoutMs: DEFAULT_READ_TIMEOUT_MS,
+  stallTimeoutMs: DEFAULT_STALL_TIMEOUT_MS
+};
+var DEFAULT_WORKFLOW_DEFINITION = {
+  promptTemplate: "",
+  continuationGuidance: null,
+  tracker: DEFAULT_WORKFLOW_TRACKER,
+  polling: {
+    intervalMs: DEFAULT_POLL_INTERVAL_MS
+  },
+  workspace: DEFAULT_WORKFLOW_WORKSPACE,
+  hooks: DEFAULT_WORKFLOW_HOOKS,
+  agent: DEFAULT_WORKFLOW_AGENT,
+  runtime: null,
+  codex: DEFAULT_WORKFLOW_CODEX,
+  lifecycle: DEFAULT_WORKFLOW_LIFECYCLE,
+  format: "default",
+  githubProjectId: null,
+  agentCommand: DEFAULT_CODEX_COMMAND,
+  hookPath: null,
+  maxConcurrentByState: {}
+};
+function resolveWorkflowRuntimeCommand(workflow) {
+  if (!workflow.runtime) {
+    return workflow.codex.command;
+  }
+  if (workflow.runtime.args.length === 0) {
+    return workflow.runtime.command;
+  }
+  return [workflow.runtime.command, ...workflow.runtime.args].join(" ");
+}
+function resolveWorkflowRuntimeTimeouts(workflow) {
+  return workflow.runtime?.timeouts ?? workflow.codex;
+}
+
+// ../core/src/workflow/parser.ts
+function parseWorkflowMarkdown(markdown, env = process.env, options = {}) {
+  const compatibilityMode = options.compatibilityMode ?? "strict";
+  const frontMatterMatch = markdown.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+  if (!frontMatterMatch) {
+    if (compatibilityMode === "legacy") {
+      return parseLegacyWorkflowMarkdown(markdown);
+    }
+    throw new Error("WORKFLOW.md must use YAML front matter.");
+  }
+  const [, rawFrontMatter, rawPromptTemplate = ""] = frontMatterMatch;
+  const frontMatter = parseFrontMatter(rawFrontMatter);
+  const promptTemplate = rawPromptTemplate.trim();
+  const tracker = readRequiredObject(frontMatter, "tracker");
+  const polling = readObject(frontMatter, "polling");
+  const workspace = readObject(frontMatter, "workspace");
+  const hooks = readObject(frontMatter, "hooks");
+  const agent = readObject(frontMatter, "agent");
+  const runtimeNode = readOptionalRuntimeObject(frontMatter);
+  const hasRuntime = runtimeNode !== null;
+  const codex = hasRuntime ? readObject(frontMatter, "codex") : readRequiredObject(frontMatter, "codex");
+  const trackerKind = readRequiredString(tracker, "kind", env);
+  const activeStates = readStringList(tracker, "active_states") ?? DEFAULT_WORKFLOW_TRACKER.activeStates;
+  const terminalStates = readStringList(tracker, "terminal_states") ?? DEFAULT_WORKFLOW_TRACKER.terminalStates;
+  const blockerCheckStates = readStringList(tracker, "blocker_check_states") ?? DEFAULT_WORKFLOW_TRACKER.blockerCheckStates;
+  const maxConcurrentAgentsByState = readNumberMap(
+    agent,
+    "max_concurrent_agents_by_state"
+  );
+  const runtime = hasRuntime ? parseRuntimeConfig(runtimeNode, env) : null;
+  const codexConfig = {
+    command: readOptionalString(codex, "command", env) ?? DEFAULT_AGENT_COMMAND,
+    approvalPolicy: readOptionalString(codex, "approval_policy", env),
+    threadSandbox: readOptionalString(codex, "thread_sandbox", env),
+    turnSandboxPolicy: readOptionalString(codex, "turn_sandbox_policy", env),
+    turnTimeoutMs: readOptionalIntegerLike(codex, "turn_timeout_ms") ?? DEFAULT_TURN_TIMEOUT_MS,
+    readTimeoutMs: readOptionalIntegerLike(codex, "read_timeout_ms") ?? DEFAULT_READ_TIMEOUT_MS,
+    stallTimeoutMs: readOptionalIntegerLike(codex, "stall_timeout_ms") ?? DEFAULT_STALL_TIMEOUT_MS
+  };
+  const agentCommand = resolveWorkflowRuntimeCommand({
+    runtime,
+    codex: codexConfig
+  });
+  const parsed = {
+    promptTemplate,
+    continuationGuidance: readOptionalWorkflowString(
+      frontMatter,
+      "continuationGuidance",
+      "continuation_guidance",
+      env
+    ),
+    tracker: {
+      kind: trackerKind,
+      endpoint: readOptionalString(tracker, "endpoint", env),
+      apiKey: readOptionalString(tracker, "api_key", env),
+      projectSlug: readOptionalString(tracker, "project_slug", env),
+      activeStates,
+      terminalStates,
+      projectId: readOptionalString(tracker, "project_id", env),
+      stateFieldName: readOptionalString(tracker, "state_field", env) ?? DEFAULT_WORKFLOW_TRACKER.stateFieldName,
+      priorityFieldName: readOptionalString(tracker, "priority_field", env),
+      blockerCheckStates
+    },
+    polling: {
+      intervalMs: readOptionalIntegerLike(polling, "interval_ms") ?? DEFAULT_POLL_INTERVAL_MS
+    },
+    workspace: {
+      root: readOptionalString(workspace, "root", env)
+    },
+    hooks: {
+      afterCreate: readOptionalString(hooks, "after_create", env),
+      beforeRun: readOptionalString(hooks, "before_run", env),
+      afterRun: readOptionalString(hooks, "after_run", env),
+      beforeRemove: readOptionalString(hooks, "before_remove", env),
+      timeoutMs: readOptionalIntegerLike(hooks, "timeout_ms") ?? DEFAULT_HOOK_TIMEOUT_MS
+    },
+    agent: {
+      maxConcurrentAgents: readOptionalIntegerLike(agent, "max_concurrent_agents") ?? DEFAULT_MAX_CONCURRENT_AGENTS,
+      maxRetryBackoffMs: readOptionalIntegerLike(agent, "max_retry_backoff_ms") ?? DEFAULT_MAX_RETRY_BACKOFF_MS,
+      maxConcurrentAgentsByState,
+      maxFailureRetries: readOptionalIntegerLike(agent, "max_failure_retries") ?? DEFAULT_MAX_FAILURE_RETRIES,
+      maxTurns: readOptionalIntegerLike(agent, "max_turns") ?? DEFAULT_MAX_TURNS,
+      retryBaseDelayMs: readOptionalIntegerLike(agent, "retry_base_delay_ms") ?? DEFAULT_BASE_DELAY_MS
+    },
+    runtime,
+    codex: codexConfig,
+    lifecycle: {
+      stateFieldName: readOptionalString(tracker, "state_field", env) ?? DEFAULT_WORKFLOW_TRACKER.stateFieldName,
+      activeStates,
+      terminalStates,
+      blockerCheckStates
+    },
+    format: "front-matter",
+    githubProjectId: readOptionalString(tracker, "project_id", env),
+    agentCommand,
+    hookPath: readOptionalString(hooks, "after_create", env),
+    maxConcurrentByState: maxConcurrentAgentsByState
+  };
+  return parsed;
+}
+function parseLegacyWorkflowMarkdown(markdown) {
+  const promptGuidelines = matchOptionalSection(markdown, "Prompt Guidelines") ?? "";
+  return {
+    ...DEFAULT_WORKFLOW_DEFINITION,
+    promptTemplate: promptGuidelines,
+    format: "legacy-sectioned"
+  };
+}
+function parseFrontMatter(frontMatter) {
+  const lines = frontMatter.replace(/\r\n/g, "\n").split("\n");
+  const [value] = parseBlock(lines, 0, 0);
+  if (!value || Array.isArray(value) || typeof value !== "object") {
+    throw new Error("Workflow front matter must be a YAML object.");
+  }
+  return value;
+}
+function parseBlock(lines, startIndex, indent) {
+  let index = startIndex;
+  let collectionType = null;
+  const arrayValues = [];
+  const objectValues = {};
+  while (index < lines.length) {
+    const line = lines[index] ?? "";
+    if (!line.trim()) {
+      index += 1;
+      continue;
+    }
+    const lineIndent = countIndent(line);
+    if (lineIndent < indent) {
+      break;
+    }
+    if (lineIndent > indent) {
+      throw new Error(
+        `Invalid workflow front matter indentation near "${line.trim()}".`
+      );
+    }
+    const trimmed = line.trim();
+    if (trimmed.startsWith("- ")) {
+      if (collectionType === "object") {
+        throw new Error(
+          "Cannot mix array and object values in workflow front matter."
+        );
+      }
+      collectionType = "array";
+      const itemText = trimmed.slice(2).trim();
+      if (itemText === "|" || itemText === "|-") {
+        const [multiline, nextIndex3] = parseMultilineScalar(
+          lines,
+          index + 1,
+          indent + 2
+        );
+        arrayValues.push(multiline);
+        index = nextIndex3;
+        continue;
+      }
+      if (itemText) {
+        arrayValues.push(parseScalar(itemText));
+        index += 1;
+        continue;
+      }
+      const [child2, nextIndex2] = parseBlock(lines, index + 1, indent + 2);
+      arrayValues.push(child2);
+      index = nextIndex2;
+      continue;
+    }
+    if (collectionType === "array") {
+      throw new Error(
+        "Cannot mix object and array values in workflow front matter."
+      );
+    }
+    collectionType = "object";
+    const separatorIndex = trimmed.indexOf(":");
+    if (separatorIndex < 0) {
+      throw new Error(`Invalid workflow front matter line "${trimmed}".`);
+    }
+    const key = trimmed.slice(0, separatorIndex).trim();
+    const remainder = trimmed.slice(separatorIndex + 1).trim();
+    if (remainder === "|" || remainder === "|-") {
+      const [multiline, nextIndex2] = parseMultilineScalar(
+        lines,
+        index + 1,
+        indent + 2
+      );
+      objectValues[key] = multiline;
+      index = nextIndex2;
+      continue;
+    }
+    if (remainder) {
+      objectValues[key] = parseScalar(remainder);
+      index += 1;
+      continue;
+    }
+    const [child, nextIndex] = parseBlock(lines, index + 1, indent + 2);
+    objectValues[key] = child;
+    index = nextIndex;
+  }
+  return [collectionType === "array" ? arrayValues : objectValues, index];
+}
+function parseMultilineScalar(lines, startIndex, indent) {
+  let index = startIndex;
+  const collected = [];
+  while (index < lines.length) {
+    const line = lines[index] ?? "";
+    if (!line.trim()) {
+      collected.push("");
+      index += 1;
+      continue;
+    }
+    const lineIndent = countIndent(line);
+    if (lineIndent < indent) {
+      break;
+    }
+    collected.push(line.slice(indent));
+    index += 1;
+  }
+  return [collected.join("\n").trimEnd(), index];
+}
+function countIndent(line) {
+  return line.match(/^ */)?.[0].length ?? 0;
+}
+function parseScalar(value) {
+  if (value === "null") return null;
+  if (value === "true") return true;
+  if (value === "false") return false;
+  if (value.startsWith("[") && value.endsWith("]")) {
+    return parseInlineArray(value);
+  }
+  if (/^-?\d+$/.test(value)) return Number.parseInt(value, 10);
+  if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+    return value.slice(1, -1);
+  }
+  return value;
+}
+function parseInlineArray(value) {
+  const inner = value.slice(1, -1).trim();
+  if (!inner) {
+    return [];
+  }
+  return splitInlineArrayEntries(inner).map((entry) => parseScalar(entry));
+}
+function splitInlineArrayEntries(inner) {
+  const entries = [];
+  let current = "";
+  let quote = null;
+  for (const char of inner) {
+    if (quote) {
+      current += char;
+      if (char === quote) {
+        quote = null;
+      }
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      quote = char;
+      current += char;
+      continue;
+    }
+    if (char === ",") {
+      pushInlineArrayEntry(entries, current, "middle");
+      current = "";
+      continue;
+    }
+    current += char;
+  }
+  if (quote) {
+    throw new Error("Workflow front matter inline array has an unterminated string.");
+  }
+  pushInlineArrayEntry(entries, current, "end");
+  return entries;
+}
+function pushInlineArrayEntry(entries, entry, position) {
+  const trimmed = entry.trim();
+  if (!trimmed) {
+    const reason = position === "end" ? "has a trailing comma" : "contains an empty item";
+    throw new Error(`Workflow front matter inline array ${reason}.`);
+  }
+  entries.push(trimmed);
+}
+function parseRuntimeConfig(runtime, env) {
+  const kind = readRuntimeKind(runtime, env);
+  const isolation = readObject(runtime, "isolation", "runtime.isolation");
+  const auth = readObject(runtime, "auth", "runtime.auth");
+  const timeouts = readObject(runtime, "timeouts", "runtime.timeouts");
+  const configuredCommand = readOptionalString(runtime, "command", env);
+  const command = configuredCommand ?? defaultRuntimeCommand(kind);
+  if (!command) {
+    throw new Error(
+      'Workflow front matter field "runtime.command" is required for runtime.kind "custom".'
+    );
+  }
+  return {
+    kind,
+    command,
+    args: readRuntimeArgs(runtime),
+    isolation: {
+      bare: readOptionalBoolean(isolation, "bare", "runtime.isolation.bare") ?? false,
+      strictMcpConfig: readOptionalBoolean(
+        isolation,
+        "strict_mcp_config",
+        "runtime.isolation.strict_mcp_config"
+      ) ?? false
+    },
+    auth: {
+      env: readOptionalString(auth, "env", env)
+    },
+    timeouts: {
+      turnTimeoutMs: readOptionalIntegerLike(timeouts, "turn_timeout_ms") ?? DEFAULT_TURN_TIMEOUT_MS,
+      readTimeoutMs: readOptionalIntegerLike(timeouts, "read_timeout_ms") ?? DEFAULT_READ_TIMEOUT_MS,
+      stallTimeoutMs: readOptionalIntegerLike(timeouts, "stall_timeout_ms") ?? DEFAULT_STALL_TIMEOUT_MS
+    }
+  };
+}
+function readRuntimeKind(runtime, env) {
+  const kind = readRequiredString(runtime, "kind", env);
+  if (kind === "codex-app-server" || kind === "claude-print" || kind === "custom") {
+    return kind;
+  }
+  throw new Error(
+    `Unsupported workflow runtime kind "${kind}". Supported values: codex-app-server, claude-print, custom.`
+  );
+}
+function defaultRuntimeCommand(kind) {
+  if (kind === "claude-print") {
+    return DEFAULT_CLAUDE_COMMAND;
+  }
+  if (kind === "codex-app-server") {
+    return DEFAULT_AGENT_COMMAND;
+  }
+  return null;
+}
+function readObject(input, key, path = key) {
+  const value = input[key];
+  if (value === void 0 || value === null) {
+    return {};
+  }
+  if (typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`Workflow front matter field "${path}" must be an object.`);
+  }
+  return value;
+}
+function readOptionalRuntimeObject(input) {
+  if (input.runtime === void 0 || input.runtime === null) {
+    return null;
+  }
+  return readObject(input, "runtime");
+}
+function readRequiredObject(input, key) {
+  if (!(key in input)) {
+    throw new Error(`Workflow front matter field "${key}" is required.`);
+  }
+  return readObject(input, key);
+}
+function readOptionalString(input, key, env) {
+  const value = input[key];
+  if (value === void 0 || value === null) {
+    return null;
+  }
+  if (typeof value !== "string") {
+    throw new Error(`Workflow front matter field "${key}" must be a string.`);
+  }
+  return resolveEnvironmentValue(value, env);
+}
+function readOptionalWorkflowString(input, primaryKey, fallbackKey, env) {
+  return readOptionalString(input, primaryKey, env) ?? readOptionalString(input, fallbackKey, env);
+}
+function readRequiredString(input, key, env) {
+  const value = readOptionalString(input, key, env);
+  if (!value) {
+    throw new Error(`Workflow front matter field "${key}" is required.`);
+  }
+  return value;
+}
+function readStringList(input, key) {
+  const value = input[key];
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  if (typeof value === "string") {
+    return value.split(",").map((entry) => entry.trim()).filter(Boolean);
+  }
+  if (!Array.isArray(value) || value.some((entry) => typeof entry !== "string")) {
+    throw new Error(
+      `Workflow front matter field "${key}" must be an array of strings or comma-separated string.`
+    );
+  }
+  return value;
+}
+function readRuntimeArgs(input) {
+  const value = input.args;
+  if (value === void 0 || value === null) {
+    return [];
+  }
+  if (!Array.isArray(value) || value.some((entry) => typeof entry !== "string")) {
+    throw new Error(
+      'Workflow front matter field "runtime.args" must be an array of strings.'
+    );
+  }
+  return value;
+}
+function readOptionalBoolean(input, key, path = key) {
+  const value = input[key];
+  if (value === void 0 || value === null) {
+    return null;
+  }
+  if (typeof value !== "boolean") {
+    throw new Error(`Workflow front matter field "${path}" must be a boolean.`);
+  }
+  return value;
+}
+function readOptionalIntegerLike(input, key) {
+  const value = input[key];
+  if (value === void 0 || value === null) {
+    return null;
+  }
+  if (typeof value === "number") {
+    return value;
+  }
+  if (typeof value === "string" && /^-?\d+$/.test(value)) {
+    return Number.parseInt(value, 10);
+  }
+  throw new Error(`Workflow front matter field "${key}" must be an integer.`);
+}
+function readNumberMap(input, key) {
+  const value = input[key];
+  if (value === void 0 || value === null) {
+    return {};
+  }
+  if (typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`Workflow front matter field "${key}" must be an object.`);
+  }
+  const result = {};
+  for (const [entryKey, entryValue] of Object.entries(value)) {
+    if (typeof entryValue === "number") {
+      result[entryKey] = entryValue;
+      continue;
+    }
+    if (typeof entryValue === "string" && /^\d+$/.test(entryValue)) {
+      result[entryKey] = Number.parseInt(entryValue, 10);
+      continue;
+    }
+    throw new Error(
+      `Workflow front matter field "${key}.${entryKey}" must be an integer.`
+    );
+  }
+  return result;
+}
+function resolveEnvironmentValue(value, env) {
+  const envTokenMatch = value.match(/^(?:env:)?([A-Z0-9_]+)$/);
+  if (value.startsWith("env:") && envTokenMatch) {
+    const resolved = env[envTokenMatch[1]];
+    if (!resolved) {
+      throw new Error(
+        `Workflow front matter requires environment variable ${envTokenMatch[1]}.`
+      );
+    }
+    return resolved;
+  }
+  return value.replace(/\$\{([A-Z0-9_]+)\}/g, (_, name) => {
+    const resolved = env[name];
+    if (!resolved) {
+      throw new Error(
+        `Workflow front matter requires environment variable ${name}.`
+      );
+    }
+    return resolved;
+  });
+}
+function matchOptionalSection(markdown, heading) {
+  const escapedHeading = heading.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const pattern = new RegExp(
+    `## ${escapedHeading}\\n\\n([\\s\\S]*?)(?=\\n## |$)`
+  );
+  const match = markdown.match(pattern);
+  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,
+  ParseError,
+  RenderError,
+  TokenizationError,
+  UndefinedVariableError
+} from "liquidjs";
+function buildPromptVariables(issue, options) {
+  return {
+    issue: {
+      id: issue.id,
+      identifier: issue.identifier,
+      number: issue.number,
+      title: issue.title,
+      description: issue.description,
+      priority: issue.priority,
+      url: issue.url,
+      state: issue.state,
+      labels: issue.labels,
+      blocked_by: issue.blockedBy,
+      branch_name: issue.branchName,
+      created_at: issue.createdAt,
+      updated_at: issue.updatedAt,
+      repository: `${issue.repository.owner}/${issue.repository.name}`
+    },
+    attempt: options.attempt
+  };
+}
+var STRICT_LIQUID_ENGINE = new Liquid({
+  strictVariables: true,
+  strictFilters: true,
+  ownPropertyOnly: true
+});
+function renderPrompt(template, variables, options = {}) {
+  const strict = options.strict ?? true;
+  if (!strict) {
+    return renderLegacyPrompt(template, variables);
+  }
+  try {
+    return STRICT_LIQUID_ENGINE.parseAndRenderSync(template, variables);
+  } catch (error) {
+    throw normalizeTemplateError(error);
+  }
+}
+function normalizeTemplateError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  if (error instanceof UndefinedVariableError || error instanceof RenderError || error instanceof ParseError && message.startsWith("undefined filter:")) {
+    return new Error(`template_render_error: ${message}`, { cause: error });
+  }
+  if (error instanceof ParseError || error instanceof TokenizationError) {
+    return new Error(`template_parse_error: ${message}`, { cause: error });
+  }
+  return new Error(`template_render_error: ${message}`, { cause: error });
+}
+function flattenVariables(obj, prefix = "") {
+  const result = /* @__PURE__ */ new Map();
+  for (const [key, value] of Object.entries(obj)) {
+    const fullKey = prefix ? `${prefix}.${key}` : key;
+    if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+      for (const [nestedKey, nestedValue] of flattenVariables(
+        value,
+        fullKey
+      )) {
+        result.set(nestedKey, nestedValue);
+      }
+    } else {
+      result.set(fullKey, value);
+    }
+  }
+  return result;
+}
+function renderLegacyPrompt(template, variables) {
+  const flatVars = flattenVariables(variables);
+  return template.replace(
+    /\{\{([a-zA-Z_][a-zA-Z0-9_.]*)\}\}/g,
+    (match, key) => {
+      const value = flatVars.get(key);
+      if (value === void 0) {
+        return match;
+      }
+      if (value === null) {
+        return "";
+      }
+      return String(value);
+    }
+  );
+}
+
+// ../core/src/contracts/status-surface.ts
+var WORKFLOW_EXECUTION_PHASES = [
+  "planning",
+  "human-review",
+  "implementation",
+  "awaiting-merge",
+  "completed"
+];
+function isWorkflowExecutionPhase(value) {
+  return typeof value === "string" && WORKFLOW_EXECUTION_PHASES.includes(value);
+}
+var SESSION_EXIT_CLASSIFICATIONS = [
+  "completed",
+  "budget-exceeded",
+  "convergence-detected",
+  "max-turns-reached",
+  "user-input-required",
+  "timeout",
+  "error"
+];
+function isSessionExitClassification(value) {
+  return typeof value === "string" && SESSION_EXIT_CLASSIFICATIONS.includes(value);
+}
+
+// ../core/src/contracts/run-attempt-phase.ts
+var RUN_ATTEMPT_PHASES = [
+  "preparing_workspace",
+  "building_prompt",
+  "launching_agent",
+  "initializing_session",
+  "streaming_turn",
+  "finishing",
+  "succeeded",
+  "failed",
+  "timed_out",
+  "stalled",
+  "canceled_by_reconciliation"
+];
+function isRunAttemptPhase(value) {
+  return typeof value === "string" && RUN_ATTEMPT_PHASES.includes(value);
+}
+
+// ../core/src/contracts/orchestrator-channel.ts
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function isTokenUsage(value) {
+  if (!isRecord(value)) {
+    return false;
+  }
+  return typeof value.inputTokens === "number" && typeof value.outputTokens === "number" && typeof value.totalTokens === "number";
+}
+function isSessionInfo(value) {
+  if (!isRecord(value)) {
+    return false;
+  }
+  return (typeof value.threadId === "string" || value.threadId === null) && (typeof value.turnId === "string" || value.turnId === null) && typeof value.turnCount === "number" && (typeof value.sessionId === "string" || value.sessionId === null) && (!("exitClassification" in value) || value.exitClassification === void 0 || value.exitClassification === null || isSessionExitClassification(value.exitClassification));
+}
+function isNullableString(value) {
+  return typeof value === "string" || value === null;
+}
+function isTurnEventBase(value) {
+  return typeof value.startedAt === "string" && isNullableString(value.threadId) && isNullableString(value.turnId) && typeof value.turnCount === "number" && isNullableString(value.sessionId);
+}
+function isOrchestratorChannelEvent(value) {
+  if (!isRecord(value)) {
+    return false;
+  }
+  if (typeof value.issueId !== "string") {
+    return false;
+  }
+  if (value.type === "codex_update") {
+    if (typeof value.lastEventAt !== "string") {
+      return false;
+    }
+    if ("event" in value && value.event !== void 0 && typeof value.event !== "string") {
+      return false;
+    }
+    if ("tokenUsage" in value && value.tokenUsage !== void 0 && !isTokenUsage(value.tokenUsage)) {
+      return false;
+    }
+    if ("rateLimits" in value && value.rateLimits !== void 0 && !isRecord(value.rateLimits)) {
+      return false;
+    }
+    if ("sessionInfo" in value && value.sessionInfo !== void 0 && !isSessionInfo(value.sessionInfo)) {
+      return false;
+    }
+    if ("executionPhase" in value && value.executionPhase !== void 0 && value.executionPhase !== null && !isWorkflowExecutionPhase(value.executionPhase)) {
+      return false;
+    }
+    if ("runPhase" in value && value.runPhase !== void 0 && value.runPhase !== null && !isRunAttemptPhase(value.runPhase)) {
+      return false;
+    }
+    if ("lastError" in value && value.lastError !== void 0 && value.lastError !== null && typeof value.lastError !== "string") {
+      return false;
+    }
+    return true;
+  }
+  if (value.type === "heartbeat") {
+    if (value.lastEventAt !== null && typeof value.lastEventAt !== "string") {
+      return false;
+    }
+    if (!isTokenUsage(value.tokenUsage)) {
+      return false;
+    }
+    if (value.rateLimits !== null && !isRecord(value.rateLimits)) {
+      return false;
+    }
+    if (value.sessionInfo !== null && !isSessionInfo(value.sessionInfo)) {
+      return false;
+    }
+    if (value.executionPhase !== null && !isWorkflowExecutionPhase(value.executionPhase)) {
+      return false;
+    }
+    if (value.runPhase !== null && !isRunAttemptPhase(value.runPhase)) {
+      return false;
+    }
+    if (value.lastError !== null && typeof value.lastError !== "string") {
+      return false;
+    }
+    return true;
+  }
+  if (value.type === "turn_started") {
+    return isTurnEventBase(value);
+  }
+  if (value.type === "turn_completed") {
+    return isTurnEventBase(value) && typeof value.completedAt === "string" && typeof value.durationMs === "number" && isTokenUsage(value.tokenUsage);
+  }
+  if (value.type === "turn_failed") {
+    return isTurnEventBase(value) && typeof value.failedAt === "string" && typeof value.durationMs === "number" && isTokenUsage(value.tokenUsage) && isNullableString(value.error);
+  }
+  return false;
+}
+
+// ../core/src/workflow/exit-classification.ts
+function classifySessionExit(params) {
+  if (params.userInputRequired) {
+    return "user-input-required";
+  }
+  if (params.budgetExceeded) {
+    return "budget-exceeded";
+  }
+  if (params.convergenceDetected) {
+    return "convergence-detected";
+  }
+  if (params.runPhase === "timed_out" || params.runPhase === "stalled") {
+    return "timeout";
+  }
+  if (params.maxTurnsReached) {
+    return "max-turns-reached";
+  }
+  if (params.runPhase === "succeeded") {
+    return "completed";
+  }
+  return "error";
+}
+
+// ../core/src/orchestration/retry-policy.ts
+function calculateRetryDelay(attempt, options = {}) {
+  const baseDelayMs = options.baseDelayMs ?? DEFAULT_BASE_DELAY_MS;
+  const maxDelayMs = options.maxDelayMs ?? DEFAULT_MAX_DELAY_MS;
+  const normalizedAttempt = Math.max(1, attempt);
+  const delay = baseDelayMs * 2 ** (normalizedAttempt - 1);
+  return Math.min(delay, maxDelayMs);
+}
+function scheduleRetryAt(now, attempt, options = {}) {
+  return new Date(now.getTime() + calculateRetryDelay(attempt, options));
+}
+
+// ../core/src/runtime/credentials.ts
+import { readFile as readFile2, writeFile } from "fs/promises";
+var TOKEN_REUSE_WINDOW_MS = 60 * 1e3;
+var CODEX_ENV_KEYS = [
+  "OPENAI_API_KEY",
+  "OPENAI_BASE_URL",
+  "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,
+    expires_at: brokerResponse.expires_at,
+    cachedAt: now.toISOString()
+  };
+}
+function shouldReuseAgentCredentialCache(entry, now = /* @__PURE__ */ new Date()) {
+  if (Object.keys(entry.env).length === 0) {
+    return false;
+  }
+  if (!entry.expires_at) {
+    return true;
+  }
+  const expiresAt = Date.parse(entry.expires_at);
+  if (Number.isNaN(expiresAt)) {
+    return false;
+  }
+  return expiresAt - now.getTime() > TOKEN_REUSE_WINDOW_MS;
+}
+async function readAgentCredentialCache(path, readFileImpl = readFile2) {
+  try {
+    return normalizeAgentCredentialCacheEntry(
+      JSON.parse(await readFileImpl(path, "utf8"))
+    );
+  } catch {
+    return null;
+  }
+}
+async function writeAgentCredentialCache(path, brokerResponse, writeFileImpl = writeFile, now = /* @__PURE__ */ new Date()) {
+  const entry = toAgentCredentialCacheEntry(brokerResponse, now);
+  await writeFileImpl(path, JSON.stringify(entry), "utf8");
+  return entry;
+}
+function pickRuntimeEnv(env, keys) {
+  const resolved = {};
+  for (const key of keys) {
+    const value = env[key];
+    if (value) {
+      resolved[key] = value;
+    }
+  }
+  return resolved;
+}
+function normalizeAgentCredentialCacheEntry(payload) {
+  if (!isRecord2(payload)) {
+    return null;
+  }
+  if (!isRecord2(payload.env)) {
+    return null;
+  }
+  const env = Object.fromEntries(
+    Object.entries(payload.env).filter(
+      (entry) => typeof entry[1] === "string"
+    )
+  );
+  if (Object.keys(env).length === 0) {
+    return null;
+  }
+  return {
+    env,
+    expires_at: typeof payload.expires_at === "string" ? payload.expires_at : void 0,
+    cachedAt: typeof payload.cachedAt === "string" ? payload.cachedAt : (/* @__PURE__ */ new Date(0)).toISOString()
+  };
+}
+function isRecord2(value) {
+  return value !== null && typeof value === "object";
+}
+
+// ../core/src/runtime/events.ts
+var DEFAULT_AGENT_INPUT_REQUIRED_REASON = "turn_input_required: agent requires user input";
+function buildAgentInputRequiredReason(prompt) {
+  if (typeof prompt === "string") {
+    const trimmedPrompt = prompt.trim();
+    if (trimmedPrompt) {
+      return `turn_input_required: ${trimmedPrompt}`;
+    }
+  }
+  return DEFAULT_AGENT_INPUT_REQUIRED_REASON;
+}
+
+// ../core/src/workspace/env-file.ts
+import { existsSync, readFileSync } from "fs";
+function readEnvFile(path) {
+  if (!existsSync(path)) {
+    return {};
+  }
+  return readFileSync(path, "utf8").split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#") && line.includes("=")).reduce((result, line) => {
+    const separatorIndex = line.indexOf("=");
+    const key = line.slice(0, separatorIndex).trim();
+    const value = line.slice(separatorIndex + 1).trim();
+    if (key) {
+      result[key] = value;
+    }
+    return result;
+  }, {});
+}
+
+// ../core/src/workspace/safety.ts
+import { resolve } from "path";
+
+// ../core/src/workspace/identity.ts
+import { resolve as resolve2, join } from "path";
+import { createHash as createHash2 } from "crypto";
+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;
+}
+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(runtimeRoot, workspaceKey) {
+  const normalizedRuntimeRoot = resolve2(runtimeRoot);
+  const candidate = resolve2(normalizedRuntimeRoot, workspaceKey);
+  if (!candidate.startsWith(`${normalizedRuntimeRoot}/`)) {
+    throw new Error(
+      "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";
+var DEFAULT_HOOK_TIMEOUT_MS2 = 6e4;
+async function executeHook(options) {
+  const { kind, command, cwd, env, timeoutMs } = options;
+  const start = Date.now();
+  const normalizedCommand = normalizeHookCommand(command);
+  return new Promise((resolveResult) => {
+    let timedOut = false;
+    let timer = null;
+    const child = spawn("bash", ["-lc", normalizedCommand], {
+      cwd,
+      env: { ...process.env, ...env },
+      stdio: "pipe"
+    });
+    const stderrChunks = [];
+    child.stderr?.on("data", (chunk) => {
+      stderrChunks.push(chunk);
+    });
+    if (timeoutMs > 0) {
+      timer = setTimeout(() => {
+        timedOut = true;
+        child.kill("SIGTERM");
+        setTimeout(() => {
+          try {
+            child.kill("SIGKILL");
+          } catch {
+          }
+        }, 5e3);
+      }, timeoutMs);
+    }
+    child.on("close", (code) => {
+      if (timer) {
+        clearTimeout(timer);
+      }
+      const durationMs = Date.now() - start;
+      const stderr = Buffer.concat(stderrChunks).toString("utf8").trim();
+      if (timedOut) {
+        resolveResult({
+          kind,
+          outcome: "timeout",
+          exitCode: code,
+          durationMs,
+          error: `Hook "${kind}" timed out after ${timeoutMs}ms`
+        });
+        return;
+      }
+      if (code !== 0) {
+        resolveResult({
+          kind,
+          outcome: "failure",
+          exitCode: code,
+          durationMs,
+          error: stderr || `Hook "${kind}" exited with code ${code}`
+        });
+        return;
+      }
+      resolveResult({
+        kind,
+        outcome: "success",
+        exitCode: 0,
+        durationMs,
+        error: null
+      });
+    });
+    child.on("error", (err) => {
+      if (timer) {
+        clearTimeout(timer);
+      }
+      resolveResult({
+        kind,
+        outcome: "failure",
+        exitCode: null,
+        durationMs: Date.now() - start,
+        error: err.message
+      });
+    });
+  });
+}
+function buildHookEnv(context) {
+  const env = {
+    SYMPHONY_PROJECT_ID: context.projectId,
+    SYMPHONY_ISSUE_WORKSPACE_KEY: context.workspaceKey,
+    SYMPHONY_ISSUE_SUBJECT_ID: context.issueSubjectId,
+    SYMPHONY_ISSUE_IDENTIFIER: context.issueIdentifier,
+    SYMPHONY_WORKSPACE_PATH: context.workspacePath,
+    SYMPHONY_REPOSITORY_PATH: context.repositoryPath
+  };
+  if (context.runId) {
+    env.SYMPHONY_RUN_ID = context.runId;
+  }
+  if (context.state) {
+    env.SYMPHONY_ISSUE_STATE = context.state;
+  }
+  return env;
+}
+function resolveHookCommand(hooks, kind) {
+  switch (kind) {
+    case "after_create":
+      return hooks.afterCreate;
+    case "before_run":
+      return hooks.beforeRun;
+    case "after_run":
+      return hooks.afterRun;
+    case "before_remove":
+      return hooks.beforeRemove;
+  }
+}
+async function executeWorkspaceHook(options) {
+  const hookCommand = resolveHookCommand(options.hooks, options.kind);
+  if (!hookCommand) {
+    return {
+      kind: options.kind,
+      outcome: "skipped",
+      exitCode: null,
+      durationMs: 0,
+      error: null
+    };
+  }
+  return executeHook({
+    kind: options.kind,
+    command: hookCommand,
+    cwd: options.repositoryPath,
+    env: options.env,
+    timeoutMs: options.timeoutMs ?? DEFAULT_HOOK_TIMEOUT_MS2
+  });
+}
+function normalizeHookCommand(command) {
+  const trimmed = command.trim();
+  if (trimmed.includes("/") && !trimmed.startsWith("/") && !trimmed.startsWith("./") && !trimmed.startsWith("../") && !/\s/.test(trimmed)) {
+    return `bash ./${trimmed}`;
+  }
+  return command;
+}
+
+// ../core/src/observability/snapshot-builder.ts
+function buildProjectSnapshot(input) {
+  const {
+    project,
+    activeRuns,
+    allRuns,
+    summary,
+    lastTickAt,
+    lastError,
+    rateLimits
+  } = input;
+  const cumulativeTokenUsageByIssue = aggregateTokenUsageByIssue(
+    allRuns ?? activeRuns
+  );
+  return {
+    repository: project.repository,
+    tracker: {
+      adapter: project.tracker.adapter,
+      bindingId: project.tracker.bindingId,
+      settings: project.tracker.settings
+    },
+    lastTickAt,
+    health: lastError ? "degraded" : activeRuns.length > 0 ? "running" : "idle",
+    summary: {
+      dispatched: summary.dispatched,
+      suppressed: summary.suppressed,
+      recovered: summary.recovered,
+      activeRuns: activeRuns.length
+    },
+    activeRuns: activeRuns.map((run) => ({
+      runId: run.runId,
+      issueIdentifier: run.issueIdentifier,
+      issueState: run.issueState,
+      status: run.status,
+      retryKind: run.retryKind,
+      port: run.port,
+      runtimeSession: run.runtimeSession ?? null,
+      // New fields from live worker data
+      processId: run.processId ?? null,
+      turnCount: run.turnCount,
+      startedAt: run.startedAt ?? null,
+      lastEvent: run.lastEvent ?? null,
+      lastEventAt: run.lastEventAt ?? null,
+      executionPhase: run.executionPhase ?? null,
+      runPhase: run.runPhase ?? null,
+      tokenUsage: attachCumulativeTokenUsage(
+        run.tokenUsage,
+        cumulativeTokenUsageByIssue.get(run.issueId)
+      )
+    })),
+    retryQueue: activeRuns.filter((run) => run.status === "retrying" && run.retryKind).map((run) => ({
+      runId: run.runId,
+      issueIdentifier: run.issueIdentifier,
+      retryKind: run.retryKind ?? "failure",
+      nextRetryAt: run.nextRetryAt
+    })),
+    lastError,
+    codexTotals: aggregateTokenUsage(allRuns ?? activeRuns, lastTickAt),
+    rateLimits: rateLimits ?? null
+  };
+}
+function aggregateTokenUsageByIssue(runs) {
+  const totals = /* @__PURE__ */ new Map();
+  for (const run of runs) {
+    if (!run.tokenUsage) {
+      continue;
+    }
+    const current = totals.get(run.issueId) ?? {
+      inputTokens: 0,
+      outputTokens: 0,
+      totalTokens: 0
+    };
+    current.inputTokens += run.tokenUsage.inputTokens;
+    current.outputTokens += run.tokenUsage.outputTokens;
+    current.totalTokens += run.tokenUsage.totalTokens;
+    totals.set(run.issueId, current);
+  }
+  return totals;
+}
+function attachCumulativeTokenUsage(tokenUsage, cumulative) {
+  if (!tokenUsage) {
+    return void 0;
+  }
+  return {
+    ...tokenUsage,
+    cumulativeInputTokens: cumulative?.inputTokens ?? tokenUsage.inputTokens,
+    cumulativeOutputTokens: cumulative?.outputTokens ?? tokenUsage.outputTokens,
+    cumulativeTotalTokens: cumulative?.totalTokens ?? tokenUsage.totalTokens
+  };
+}
+function aggregateTokenUsage(runs, lastTickAt) {
+  let inputTokens = 0;
+  let outputTokens = 0;
+  let totalTokens = 0;
+  let earliestStart = null;
+  let latestEnd = null;
+  for (const run of runs) {
+    if (run.tokenUsage) {
+      inputTokens += run.tokenUsage.inputTokens;
+      outputTokens += run.tokenUsage.outputTokens;
+      totalTokens += run.tokenUsage.totalTokens;
+    }
+    if (run.startedAt) {
+      const start = new Date(run.startedAt).getTime();
+      if (earliestStart === null || start < earliestStart) {
+        earliestStart = start;
+      }
+    }
+    const end = run.completedAt ? new Date(run.completedAt).getTime() : new Date(lastTickAt).getTime();
+    if (latestEnd === null || end > latestEnd) {
+      latestEnd = end;
+    }
+  }
+  const secondsRunning = earliestStart !== null && latestEnd !== null ? Math.max(0, Math.round((latestEnd - earliestStart) / 1e3)) : 0;
+  return { inputTokens, outputTokens, totalTokens, secondsRunning };
+}
+
+// ../core/src/observability/fs-reader.ts
+import { readFile as readFile3, readdir } from "fs/promises";
+async function readJsonFile(path) {
+  try {
+    const raw = await readFile3(path, "utf8");
+    return JSON.parse(raw);
+  } catch (error) {
+    if (isFileMissing(error)) {
+      return null;
+    }
+    throw error;
+  }
+}
+async function safeReadDir(path) {
+  try {
+    return await readdir(path);
+  } catch (error) {
+    if (isFileMissing(error)) {
+      return [];
+    }
+    throw error;
+  }
+}
+function isFileMissing(error) {
+  return Boolean(
+    error && typeof error === "object" && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR")
+  );
+}
+
+// ../core/src/observability/event-formatter.ts
+function formatEventMessage(event) {
+  switch (event.event) {
+    case "run-dispatched":
+      return event.issueState ? `Dispatched from ${event.issueState}` : "Dispatched";
+    case "run-recovered":
+      return "Recovered existing run";
+    case "run-retried":
+      return `Retry ${event.attempt} scheduled (${event.retryKind})`;
+    case "run-failed":
+      return event.lastError;
+    case "run-suppressed":
+      return event.reason;
+    case "hook-executed":
+      return `${event.hook}: ${event.outcome}`;
+    case "hook-failed":
+      return event.error;
+    case "workspace-cleanup":
+      return event.error ? `${event.outcome}: ${event.error}` : event.outcome;
+    case "worker-error":
+      return event.error;
+    case "turn_started":
+      return `Turn ${event.turnCount} started`;
+    case "turn_completed":
+      return `Turn ${event.turnCount} completed in ${event.durationMs}ms`;
+    case "turn_failed":
+      return event.error ?? `Turn ${event.turnCount} failed`;
+    case "session_invalidated":
+      return event.reason;
+    default:
+      return null;
+  }
+}
+function parseRecentEvents(raw, limit, options) {
+  const lines = raw.split("\n");
+  if (options.allowPartialFirstLine) {
+    lines.shift();
+  }
+  const events = [];
+  for (let index = lines.length - 1; index >= 0; index -= 1) {
+    const line = lines[index]?.trim();
+    if (!line) {
+      continue;
+    }
+    const event = parseRunEventLine(line);
+    if (!event) {
+      continue;
+    }
+    events.push({
+      at: event.at,
+      event: event.event,
+      message: formatEventMessage(event)
+    });
+    if (events.length === limit) {
+      break;
+    }
+  }
+  return events.reverse();
+}
+function parseRunEventLine(line) {
+  try {
+    return JSON.parse(line);
+  } catch {
+    return null;
+  }
+}
+
+// ../core/src/observability/status-assembler.ts
+function isMatchingIssueRun(run, issueId, issueIdentifier) {
+  return Boolean(
+    run && (run.issueId === issueId || run.issueIdentifier === issueIdentifier)
+  );
+}
+function mapIssueOrchestrationStateToStatus(state) {
+  switch (state) {
+    case "claimed":
+      return "starting";
+    case "running":
+      return "running";
+    case "retry_queued":
+      return "retrying";
+    case "released":
+      return "released";
+    case "unclaimed":
+      return "pending";
+    default:
+      return state;
+  }
+}
+
+// ../runtime-claude/src/preflight.ts
+import { execFileSync } from "child_process";
+import { constants as constants2 } from "fs";
+import { access as access2, readFile as readFile4 } from "fs/promises";
+import { isAbsolute, join as join2, resolve as resolve3 } from "path";
+var DEFAULT_DEPENDENCIES = {
+  execFileSync,
+  readFile: readFile4,
+  access: access2,
+  fetchImpl: fetch,
+  platform: process.platform
+};
+var CREDENTIAL_BROKER_TIMEOUT_MS = 5e3;
+async function runClaudePreflight(options, dependencies = {}) {
+  const deps = { ...DEFAULT_DEPENDENCIES, ...dependencies };
+  const env = options.env ?? process.env;
+  const command = resolveRuntimeCommandBinary(options.command) ?? "claude";
+  const checks = [];
+  checks.push(checkClaudeBinary(command, options.cwd, deps));
+  checks.push(await checkAnthropicApiKey(env, options, deps));
+  checks.push(await checkWorkspaceMcpConfig(options.cwd, deps));
+  if (options.includeGhAuth) {
+    checks.push(checkGhAuthentication(options.cwd, deps));
+  }
+  return {
+    ok: checks.every((check) => check.status !== "fail"),
+    checks
+  };
+}
+function formatClaudePreflightText(report) {
+  const lines = ["Claude runtime preflight"];
+  for (const check of report.checks) {
+    const label = check.status === "pass" ? "PASS" : check.status === "warn" ? "WARN" : "FAIL";
+    lines.push(`${label} ${check.title}`);
+    lines.push(`  ${check.summary}`);
+    if (check.remediation) {
+      lines.push(`  Fix: ${check.remediation}`);
+    }
+  }
+  return lines.join("\n");
+}
+function pass(id, title, summary, details) {
+  return { id, title, status: "pass", summary, details };
+}
+function warn(id, title, summary, remediation, details) {
+  return { id, title, status: "warn", summary, remediation, details };
+}
+function fail(id, title, summary, remediation, details) {
+  return { id, title, status: "fail", summary, remediation, details };
+}
+function checkClaudeBinary(command, cwd, deps) {
+  const executable = resolveExecutableCommand(command, cwd);
+  try {
+    const locatedPath = locateClaudeBinary(executable, cwd, deps);
+    const version = deps.execFileSync(executable, ["--version"], {
+      encoding: "utf8",
+      cwd,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).toString().trim();
+    return pass(
+      "claude_binary",
+      "Claude CLI binary",
+      version ? `${executable} is available: ${version}.` : `${executable} is available, but --version returned an empty response.`,
+      { command: executable, path: locatedPath, version }
+    );
+  } catch (error) {
+    return fail(
+      "claude_binary",
+      "Claude CLI binary",
+      `${executable} could not be found or executed from PATH.`,
+      `Install Claude Code and ensure '${executable}' is on PATH, then re-run the command.`,
+      {
+        command: executable,
+        error: error instanceof Error ? error.message : String(error)
+      }
+    );
+  }
+}
+function resolveExecutableCommand(command, cwd) {
+  if ((command.includes("/") || command.includes("\\")) && !isAbsolute(command)) {
+    return resolve3(cwd, command);
+  }
+  return command;
+}
+function locateClaudeBinary(command, cwd, deps) {
+  if (command.includes("/") || command.includes("\\")) {
+    return command;
+  }
+  try {
+    const locator = deps.platform === "win32" ? "where" : "which";
+    return deps.execFileSync(locator, [command], {
+      encoding: "utf8",
+      cwd,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).toString().split(/\r?\n/).find((line) => line.trim())?.trim() ?? null;
+  } catch {
+    return null;
+  }
+}
+function checkGhAuthentication(cwd, deps) {
+  try {
+    deps.execFileSync("gh", ["auth", "status"], {
+      encoding: "utf8",
+      cwd,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return pass(
+      "gh_authentication",
+      "GitHub CLI authentication",
+      "gh auth status succeeded."
+    );
+  } catch (error) {
+    return fail(
+      "gh_authentication",
+      "GitHub CLI authentication",
+      "gh auth status failed or no GitHub login is configured.",
+      "Run 'gh auth login --scopes repo,read:org,project' and re-run the command.",
+      { error: error instanceof Error ? error.message : String(error) }
+    );
+  }
+}
+async function checkAnthropicApiKey(env, options, deps) {
+  if (env.ANTHROPIC_API_KEY?.trim()) {
+    return pass(
+      "anthropic_api_key",
+      "Anthropic API key",
+      "ANTHROPIC_API_KEY is configured in the environment.",
+      { source: "env" }
+    );
+  }
+  const brokerUrl = env.AGENT_CREDENTIAL_BROKER_URL?.trim();
+  const brokerSecret = env.AGENT_CREDENTIAL_BROKER_SECRET?.trim();
+  if (!brokerUrl || !brokerSecret) {
+    return fail(
+      "anthropic_api_key",
+      "Anthropic API key",
+      "Neither ANTHROPIC_API_KEY nor an agent credential broker is configured.",
+      "Set ANTHROPIC_API_KEY or configure AGENT_CREDENTIAL_BROKER_URL and AGENT_CREDENTIAL_BROKER_SECRET.",
+      { source: "missing" }
+    );
+  }
+  if (options.probeCredentialBroker === false) {
+    return pass(
+      "anthropic_api_key",
+      "Anthropic API key",
+      "Agent credential broker configuration is present.",
+      { source: "broker", brokerUrl }
+    );
+  }
+  try {
+    const response = await deps.fetchImpl(brokerUrl, {
+      method: "POST",
+      headers: {
+        accept: "application/json",
+        authorization: `Bearer ${brokerSecret}`
+      },
+      signal: AbortSignal.timeout(CREDENTIAL_BROKER_TIMEOUT_MS)
+    });
+    const payload = await response.json();
+    if (response.ok && payload.env?.ANTHROPIC_API_KEY?.trim()) {
+      return pass(
+        "anthropic_api_key",
+        "Anthropic API key",
+        "Agent credential broker is reachable and returned ANTHROPIC_API_KEY.",
+        { source: "broker", brokerUrl }
+      );
+    }
+    return fail(
+      "anthropic_api_key",
+      "Anthropic API key",
+      payload.error ? `Agent credential broker did not return ANTHROPIC_API_KEY: ${payload.error}.` : "Agent credential broker did not return ANTHROPIC_API_KEY.",
+      "Set ANTHROPIC_API_KEY or configure the credential broker to return ANTHROPIC_API_KEY.",
+      { source: "broker", brokerUrl, status: response.status }
+    );
+  } catch (error) {
+    return fail(
+      "anthropic_api_key",
+      "Anthropic API key",
+      "Agent credential broker could not be reached.",
+      "Set ANTHROPIC_API_KEY or fix AGENT_CREDENTIAL_BROKER_URL and AGENT_CREDENTIAL_BROKER_SECRET.",
+      {
+        source: "broker",
+        brokerUrl,
+        error: error instanceof Error ? error.message : String(error)
+      }
+    );
+  }
+}
+async function checkWorkspaceMcpConfig(cwd, deps) {
+  const path = join2(cwd, ".mcp.json");
+  try {
+    await deps.access(path, constants2.R_OK);
+  } catch (error) {
+    const err = error;
+    if (err.code === "ENOENT") {
+      return warn(
+        "claude_mcp_config",
+        "Workspace .mcp.json",
+        ".mcp.json was not found in the workspace root. Claude can still run without a workspace MCP config.",
+        void 0,
+        { path, reason: "missing" }
+      );
+    }
+    return warn(
+      "claude_mcp_config",
+      "Workspace .mcp.json",
+      `.mcp.json exists but is not readable: ${err.message}.`,
+      "Fix .mcp.json file permissions if this workspace needs Claude MCP servers.",
+      { path, reason: "unreadable", error: err.message }
+    );
+  }
+  try {
+    const content = await deps.readFile(path, "utf8");
+    JSON.parse(content);
+    return pass(
+      "claude_mcp_config",
+      "Workspace .mcp.json",
+      ".mcp.json is readable and contains valid JSON.",
+      { path }
+    );
+  } catch (error) {
+    return fail(
+      "claude_mcp_config",
+      "Workspace .mcp.json",
+      `.mcp.json could not be parsed as JSON: ${error instanceof Error ? error.message : String(error)}.`,
+      "Fix or remove the workspace root .mcp.json file, then re-run the command.",
+      { path, reason: "invalid_json" }
+    );
+  }
+}
+function isClaudeRuntimeCommand(command) {
+  return resolveClaudeCommandBinary(command) != null;
+}
+function resolveClaudeCommandBinary(command) {
+  const binary = resolveRuntimeCommandBinary(command);
+  return binary != null && isClaudeBinaryName(binary) ? binary : null;
+}
+function resolveRuntimeCommandBinary(command) {
+  const normalized = (command ?? "").trim();
+  if (!normalized) {
+    return null;
+  }
+  const tokens = tokenizeRuntimeCommand(normalized);
+  if (tokens.length === 0) {
+    return null;
+  }
+  const first = stripClaudeCommandQuotes(tokens[0]);
+  if ((first === "bash" || first === "sh" || first === "zsh" || first === "fish") && tokens.length >= 3) {
+    const flagIndex = tokens.findIndex((token) => {
+      const value = stripClaudeCommandQuotes(token);
+      return value === "-c" || value === "-lc";
+    });
+    if (flagIndex >= 0 && flagIndex + 1 < tokens.length) {
+      const shellCommand = stripClaudeCommandQuotes(tokens[flagIndex + 1]);
+      return resolveShellCommandClaudeBinary(shellCommand) ?? resolveRuntimeCommandBinary(shellCommand);
+    }
+  }
+  return first;
+}
+function stripClaudeCommandQuotes(value) {
+  return value.replace(/^['"]|['"]$/g, "");
+}
+function tokenizeRuntimeCommand(command) {
+  return command.match(/"[^"]*"|'[^']*'|\S+/g) ?? [];
+}
+function resolveShellCommandClaudeBinary(command) {
+  for (const segment of command.split(/&&|\|\||[;\n]/g)) {
+    const tokens = tokenizeRuntimeCommand(segment);
+    for (const token of tokens) {
+      const value = stripClaudeCommandQuotes(token);
+      if (value.includes("=") && !value.startsWith("/") && !value.startsWith("./")) {
+        continue;
+      }
+      if (isClaudeBinaryName(value)) {
+        return value;
+      }
+    }
+  }
+  return null;
+}
+function isClaudeBinaryName(command) {
+  const normalized = (command.split(/[\\/]/).pop() ?? command).toLowerCase().replace(/\.(exe|cmd|bat)$/i, "");
+  return normalized === "claude" || normalized === "claude-code";
+}
+
+// ../runtime-claude/src/adapter.ts
+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";
+
+// ../tool-github-graphql/src/tool.ts
+import { readFile as readFile5, writeFile as writeFile2 } from "fs/promises";
+var DEFAULT_GITHUB_GRAPHQL_API_URL = "https://api.github.com/graphql";
+var TOKEN_REUSE_WINDOW_MS2 = 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_URL,
+    {
+      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 ?? readFile5;
+  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_MS2) {
+    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 main() {
+  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) {
+  main().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;
+  }
+}
+
+// ../tool-github-graphql/src/mcp-server.ts
+import { fileURLToPath } from "url";
+var TOOL_SCHEMA = {
+  name: "github_graphql",
+  description: "Execute GitHub GraphQL queries for the active workspace so the agent can mutate project and issue state directly.",
+  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
+  }
+};
+var lineBuffer = "";
+function resolveGitHubGraphQLMcpServerEntryPoint() {
+  return fileURLToPath(new URL("./mcp-server.js", import.meta.url));
+}
+function sendResponse(id, result) {
+  const msg = JSON.stringify({ jsonrpc: "2.0", id, result });
+  process.stdout.write(msg + "\n");
+}
+function sendError(id, code, message) {
+  const msg = JSON.stringify({
+    jsonrpc: "2.0",
+    id,
+    error: { code, message }
+  });
+  process.stdout.write(msg + "\n");
+}
+async function handleRequest(msg) {
+  const id = msg.id ?? null;
+  switch (msg.method) {
+    case "initialize": {
+      sendResponse(id, {
+        protocolVersion: "2024-11-05",
+        capabilities: { tools: {} },
+        serverInfo: {
+          name: "github-symphony-graphql",
+          version: "0.1.0"
+        }
+      });
+      process.stdout.write(
+        JSON.stringify({
+          jsonrpc: "2.0",
+          method: "notifications/initialized"
+        }) + "\n"
+      );
+      break;
+    }
+    case "tools/list": {
+      sendResponse(id, { tools: [TOOL_SCHEMA] });
+      break;
+    }
+    case "tools/call": {
+      const params = msg.params;
+      if (params.name !== "github_graphql") {
+        sendError(id, -32602, `Unknown tool: ${params.name}`);
+        return;
+      }
+      const args = params.arguments ?? {};
+      const invocation = {
+        query: args.query,
+        variables: args.variables,
+        operationName: args.operationName
+      };
+      try {
+        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
+        });
+        sendResponse(id, {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result, null, 2)
+            }
+          ]
+        });
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        sendResponse(id, {
+          content: [{ type: "text", text: message }],
+          isError: true
+        });
+      }
+      break;
+    }
+    case "notifications/initialized":
+    case "ping": {
+      if (id !== null && id !== void 0) {
+        sendResponse(id, {});
+      }
+      break;
+    }
+    default: {
+      if (id !== null && id !== void 0) {
+        sendError(id, -32601, `Method not found: ${msg.method}`);
+      }
+    }
+  }
+}
+async function main2() {
+  process.stdin.setEncoding("utf8");
+  process.stdin.on("data", (chunk) => {
+    lineBuffer += chunk;
+    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);
+        void handleRequest(msg);
+      } catch (err) {
+        process.stderr.write(
+          `[github-graphql-mcp] parse error: ${err instanceof Error ? err.message : String(err)}
+`
+        );
+      }
+    }
+  });
+  process.stdin.on("end", () => {
+    process.exit(0);
+  });
+}
+if (import.meta.url === new URL(process.argv[1] ?? "", "file:").href) {
+  main2().catch((err) => {
+    process.stderr.write(
+      `[github-graphql-mcp] fatal: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    process.exitCode = 1;
+  });
+}
+
+// ../tool-github-graphql/src/mcp-entry.ts
+var DEFAULT_GITHUB_GRAPHQL_API_URL2 = "https://api.github.com/graphql";
+function createGitHubGraphQLMcpServerEntry(options = {}) {
+  return {
+    command: "node",
+    args: [resolveGitHubGraphQLMcpServerEntryPoint()],
+    env: {
+      GITHUB_GRAPHQL_API_URL: options.githubGraphqlApiUrl ?? DEFAULT_GITHUB_GRAPHQL_API_URL2,
+      ...options.githubToken ? {
+        GITHUB_GRAPHQL_TOKEN: options.githubToken
+      } : {},
+      ...options.githubTokenBrokerUrl ? {
+        GITHUB_TOKEN_BROKER_URL: options.githubTokenBrokerUrl
+      } : {},
+      ...options.githubTokenBrokerSecret ? {
+        GITHUB_TOKEN_BROKER_SECRET: options.githubTokenBrokerSecret
+      } : {},
+      ...options.githubTokenCachePath ? {
+        GITHUB_TOKEN_CACHE_PATH: options.githubTokenCachePath
+      } : {},
+      ...options.githubProjectId ? {
+        GITHUB_PROJECT_ID: options.githubProjectId
+      } : {}
+    }
+  };
+}
+
+// ../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,
+  DEFAULT_WORKFLOW_LIFECYCLE,
+  isStateActive,
+  isStateTerminal,
+  matchesWorkflowState,
+  DEFAULT_MAX_FAILURE_RETRIES,
+  resolveWorkflowRuntimeCommand,
+  resolveWorkflowRuntimeTimeouts,
+  parseWorkflowMarkdown,
+  WorkflowConfigStore,
+  createDefaultWorkflowResolution,
+  createInvalidWorkflowResolution,
+  buildPromptVariables,
+  renderPrompt,
+  classifySessionExit,
+  scheduleRetryAt,
+  extractEnvForCodex,
+  extractEnvForClaude,
+  shouldReuseAgentCredentialCache,
+  readAgentCredentialCache,
+  writeAgentCredentialCache,
+  DEFAULT_AGENT_INPUT_REQUIRED_REASON,
+  buildAgentInputRequiredReason,
+  readEnvFile,
+  deriveIssueWorkspaceKeyFromIdentifier,
+  deriveIssueWorkspaceKey,
+  deriveLegacyIssueWorkspaceKey,
+  resolveIssueWorkspaceDirectory,
+  buildHookEnv,
+  executeWorkspaceHook,
+  buildProjectSnapshot,
+  readJsonFile,
+  safeReadDir,
+  isFileMissing,
+  parseRecentEvents,
+  isMatchingIssueRun,
+  mapIssueOrchestrationStateToStatus,
+  resolveGitHubGraphQLToken,
+  createGitHubGraphQLMcpServerEntry,
+  createClaudePrintRuntimeAdapter,
+  runClaudePreflight,
+  formatClaudePreflightText,
+  isClaudeRuntimeCommand,
+  resolveClaudeCommandBinary,
+  resolveRuntimeCommandBinary
+};