@gh-symphony/cli 0.0.15 → 0.0.17

package/dist/{chunk-RNWX7DQU.js → chunk-EFMFGOWM.js}

@@ -1,1086 +1,46 @@
 #!/usr/bin/env node
+import {
+  DEFAULT_WORKFLOW_LIFECYCLE,
+  WorkflowConfigStore,
+  buildHookEnv,
+  buildProjectSnapshot,
+  buildPromptVariables,
+  createDefaultWorkflowResolution,
+  createInvalidWorkflowResolution,
+  deriveIssueWorkspaceKey,
+  deriveIssueWorkspaceKeyFromIdentifier,
+  deriveLegacyIssueWorkspaceKey,
+  executeWorkspaceHook,
+  isFileMissing,
+  isMatchingIssueRun,
+  isOrchestratorChannelEvent,
+  isStateActive,
+  isStateTerminal,
+  mapIssueOrchestrationStateToStatus,
+  matchesWorkflowState,
+  parseRecentEvents,
+  readEnvFile,
+  readJsonFile,
+  renderPrompt,
+  resolveIssueWorkspaceDirectory,
+  safeReadDir,
+  scheduleRetryAt
+} from "./chunk-TF3QNWNC.js";
 
 // ../orchestrator/dist/service.js
-import { mkdir as mkdir3, readFile as readFile5, rm as rm3, writeFile as writeFile3 } from "fs/promises";
+import { mkdir as mkdir3, readFile as readFile3, rm as rm3, writeFile as writeFile3 } from "fs/promises";
 import { createWriteStream, mkdirSync } from "fs";
-import { spawn as spawn3 } from "child_process";
-import { join as join4 } from "path";
+import { spawn as spawn2 } from "child_process";
+import { join as join3 } from "path";
 import { StringDecoder } from "string_decoder";
 import { fileURLToPath } from "url";
 
-// ../core/dist/contracts/status-surface.js
-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/dist/contracts/run-attempt-phase.js
-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/dist/contracts/orchestrator-channel.js
-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/dist/workflow/lifecycle.js
-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/dist/workflow/config.js
-var DEFAULT_CODEX_COMMAND = "codex app-server";
-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_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: {},
-  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,
-  codex: DEFAULT_WORKFLOW_CODEX,
-  lifecycle: DEFAULT_WORKFLOW_LIFECYCLE,
-  format: "default",
-  githubProjectId: null,
-  agentCommand: DEFAULT_CODEX_COMMAND,
-  hookPath: null,
-  maxConcurrentByState: {}
-};
-
-// ../core/dist/workflow/parser.js
-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 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 command = readOptionalString(codex, "command", env) ?? DEFAULT_AGENT_COMMAND;
-  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,
-      maxTurns: readOptionalIntegerLike(agent, "max_turns") ?? DEFAULT_MAX_TURNS,
-      retryBaseDelayMs: readOptionalIntegerLike(agent, "retry_base_delay_ms") ?? DEFAULT_BASE_DELAY_MS
-    },
-    codex: {
-      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
-    },
-    lifecycle: {
-      stateFieldName: readOptionalString(tracker, "state_field", env) ?? DEFAULT_WORKFLOW_TRACKER.stateFieldName,
-      activeStates,
-      terminalStates,
-      blockerCheckStates
-    },
-    format: "front-matter",
-    githubProjectId: readOptionalString(tracker, "project_id", env),
-    agentCommand: command,
-    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 (/^-?\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 readObject(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.`);
-  }
-  return value;
-}
-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 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/dist/workflow/loader.js
-import { createHash } from "crypto";
-import { access, readFile, stat } from "fs/promises";
-import { constants } from "fs";
-var WorkflowConfigStore = class {
-  cache = /* @__PURE__ */ new Map();
-  async load(workflowPath, env = process.env) {
-    await access(workflowPath, constants.R_OK);
-    const fileStat = await stat(workflowPath);
-    const fingerprint = `${fileStat.mtimeMs}:${fileStat.size}`;
-    const cached = this.cache.get(workflowPath);
-    if (cached && cached.fingerprint === fingerprint) {
-      return toWorkflowResolution(workflowPath, cached.workflow, {
-        isValid: true,
-        usedLastKnownGood: false,
-        validationError: null
-      });
-    }
-    const markdown = await readFile(workflowPath, "utf8");
-    try {
-      const workflow = parseWorkflowMarkdown(markdown, env);
-      this.cache.set(workflowPath, {
-        fingerprint,
-        workflow,
-        loadedAt: (/* @__PURE__ */ new Date()).toISOString()
-      });
-      return toWorkflowResolution(workflowPath, workflow, {
-        isValid: true,
-        usedLastKnownGood: false,
-        validationError: null
-      });
-    } catch (error) {
-      if (cached) {
-        return toWorkflowResolution(workflowPath, cached.workflow, {
-          isValid: false,
-          usedLastKnownGood: true,
-          validationError: error instanceof Error ? error.message : "Invalid workflow definition."
-        });
-      }
-      throw error;
-    }
-  }
-};
-function createDefaultWorkflowResolution() {
-  return createInvalidWorkflowResolution(null, "missing_workflow_file");
-}
-function createInvalidWorkflowResolution(workflowPath, validationError) {
-  return toWorkflowResolution(workflowPath, DEFAULT_WORKFLOW_DEFINITION, {
-    isValid: false,
-    usedLastKnownGood: false,
-    validationError
-  });
-}
-function toWorkflowResolution(workflowPath, workflow, metadata) {
-  return {
-    workflowPath,
-    workflow,
-    lifecycle: workflow.lifecycle,
-    promptTemplate: workflow.promptTemplate,
-    agentCommand: workflow.agentCommand,
-    hookPath: workflow.hookPath ?? "",
-    isValid: metadata.isValid,
-    usedLastKnownGood: metadata.usedLastKnownGood,
-    validationError: metadata.validationError
-  };
-}
-
-// ../core/dist/workflow/render.js
-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/dist/orchestration/retry-policy.js
-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 delay2 = baseDelayMs * 2 ** (normalizedAttempt - 1);
-  return Math.min(delay2, maxDelayMs);
-}
-function scheduleRetryAt(now, attempt, options = {}) {
-  return new Date(now.getTime() + calculateRetryDelay(attempt, options));
-}
-
-// ../core/dist/workspace/env-file.js
-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/dist/workspace/safety.js
-import { resolve } from "path";
-
-// ../core/dist/workspace/identity.js
-import { resolve as resolve2, join } from "path";
-import { createHash as createHash2 } from "crypto";
-function deriveIssueWorkspaceKey(identity, issueIdentifier) {
-  if (issueIdentifier) {
-    return deriveIssueWorkspaceKeyFromIdentifier(issueIdentifier);
-  }
-  return deriveLegacyIssueWorkspaceKey(identity);
-}
-function deriveIssueWorkspaceKeyFromIdentifier(issueIdentifier) {
-  const sanitized = issueIdentifier.replace(/[^A-Za-z0-9._-]+/g, "_").replace(/^_+|_+$/g, "");
-  if (!sanitized || /^[.]+$/.test(sanitized)) {
-    return "issue";
-  }
-  return sanitized;
-}
-function deriveLegacyIssueWorkspaceKey(identity) {
-  const input = [
-    identity.projectId,
-    identity.adapter,
-    identity.issueSubjectId
-  ].join(":");
-  return createHash2("sha256").update(input).digest("hex").slice(0, 16);
-}
-function resolveIssueWorkspaceDirectory(projectDirectory, workspaceKey) {
-  const normalizedProjectDirectory = resolve2(projectDirectory);
-  const candidate = resolve2(normalizedProjectDirectory, "issues", workspaceKey);
-  if (!candidate.startsWith(`${normalizedProjectDirectory}/`)) {
-    throw new Error("Issue workspace path escapes the configured project directory.");
-  }
-  return candidate;
-}
-
-// ../core/dist/workspace/hooks.js
-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/dist/observability/snapshot-builder.js
-function buildProjectSnapshot(input) {
-  const { project, activeRuns, allRuns, summary, lastTickAt, lastError, rateLimits } = input;
-  return {
-    projectId: project.projectId,
-    slug: project.slug,
-    tracker: {
-      adapter: project.tracker.adapter,
-      bindingId: project.tracker.bindingId
-    },
-    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: run.tokenUsage
-    })),
-    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 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/dist/observability/fs-reader.js
-import { readFile as readFile2, readdir } from "fs/promises";
-async function readJsonFile(path) {
-  try {
-    const raw = await readFile2(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/dist/observability/event-formatter.js
-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`;
-    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/dist/observability/status-assembler.js
-function isMatchingIssueRun(run, projectId, issueId, issueIdentifier) {
-  return Boolean(run && run.projectId === projectId && (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;
-  }
-}
-
 // ../orchestrator/dist/git.js
-import { spawn as spawn2 } from "child_process";
+import { spawn } from "child_process";
 import { randomUUID } from "crypto";
-import { access as access2, mkdir, readFile as readFile3, rename, rm, stat as stat2, writeFile } from "fs/promises";
-import { constants as constants2 } from "fs";
-import { join as join2 } from "path";
+import { access, mkdir, readFile, rename, rm, stat, writeFile } from "fs/promises";
+import { constants } from "fs";
+import { join } from "path";
 var workflowConfigStore = new WorkflowConfigStore();
 var LOCK_RETRY_MS = 100;
 var LOCK_STALE_MS = 30 * 60 * 1e3;
@@ -1091,12 +51,12 @@ async function cloneRepositoryForRun(input) {
 }
 async function syncRepositoryForRun(input) {
   await mkdir(input.targetDirectory, { recursive: true });
-  const repositoryDirectory = join2(input.targetDirectory, "repository");
-  const lockDirectory = join2(input.targetDirectory, "repository.lock");
+  const repositoryDirectory = join(input.targetDirectory, "repository");
+  const lockDirectory = join(input.targetDirectory, "repository.lock");
   return withRepositoryLock(lockDirectory, async () => {
     let hasGit = false;
     try {
-      await access2(join2(repositoryDirectory, ".git"), constants2.R_OK);
+      await access(join(repositoryDirectory, ".git"), constants.R_OK);
       hasGit = true;
     } catch {
     }
@@ -1120,7 +80,7 @@ async function syncRepositoryForRun(input) {
     } else {
       await rm(repositoryDirectory, { recursive: true, force: true });
     }
-    const tempRepositoryDirectory = join2(input.targetDirectory, `repository.tmp-${process.pid}-${Date.now()}`);
+    const tempRepositoryDirectory = join(input.targetDirectory, `repository.tmp-${process.pid}-${Date.now()}`);
     await rm(tempRepositoryDirectory, { recursive: true, force: true });
     try {
       await runCommand("git", [
@@ -1147,7 +107,7 @@ async function ensureIssueWorkspaceRepository(input) {
   });
 }
 async function loadRepositoryWorkflow(repositoryDirectory, _repository) {
-  const workflowPath = join2(repositoryDirectory, "WORKFLOW.md");
+  const workflowPath = join(repositoryDirectory, "WORKFLOW.md");
   try {
     return await workflowConfigStore.load(workflowPath);
   } catch (error) {
@@ -1158,8 +118,8 @@ async function loadRepositoryWorkflow(repositoryDirectory, _repository) {
   }
 }
 function runCommand(command, args) {
-  return new Promise((resolve6, reject) => {
-    const child = spawn2(command, args, {
+  return new Promise((resolve4, reject) => {
+    const child = spawn(command, args, {
       stdio: "pipe"
     });
     let stderr = "";
@@ -1169,7 +129,7 @@ function runCommand(command, args) {
     child.once("error", reject);
     child.once("exit", (code) => {
       if (code === 0) {
-        resolve6();
+        resolve4();
         return;
       }
       reject(new Error(stderr.trim() || `${command} exited with code ${code ?? "unknown"}`));
@@ -1189,8 +149,8 @@ async function readGitHead(repositoryDirectory) {
   }
 }
 function runCommandCapture(command, args) {
-  return new Promise((resolve6, reject) => {
-    const child = spawn2(command, args, {
+  return new Promise((resolve4, reject) => {
+    const child = spawn(command, args, {
       stdio: ["ignore", "pipe", "pipe"]
     });
     let stdout = "";
@@ -1204,7 +164,7 @@ function runCommandCapture(command, args) {
     child.once("error", reject);
     child.once("exit", (code) => {
       if (code === 0) {
-        resolve6(stdout.trim());
+        resolve4(stdout.trim());
         return;
       }
       reject(new Error(stderr.trim() || `${command} exited with code ${code ?? "unknown"}`));
@@ -1225,7 +185,7 @@ async function acquireRepositoryLock(lockDirectory) {
   for (; ; ) {
     try {
       await mkdir(lockDirectory);
-      await writeFile(join2(lockDirectory, "owner"), `${ownerToken}
+      await writeFile(join(lockDirectory, "owner"), `${ownerToken}
 ${(/* @__PURE__ */ new Date()).toISOString()}
 `, "utf8");
       return ownerToken;
@@ -1261,7 +221,7 @@ async function releaseRepositoryLock(lockDirectory, ownerToken) {
 }
 async function isStaleLock(lockDirectory) {
   try {
-    const details = await stat2(lockDirectory);
+    const details = await stat(lockDirectory);
     return Date.now() - details.mtimeMs >= LOCK_STALE_MS;
   } catch (error) {
     if (isMissingFileError(error)) {
@@ -1274,13 +234,13 @@ function isAlreadyExistsError(error) {
   return Boolean(error && typeof error === "object" && "code" in error && error.code === "EEXIST");
 }
 async function readLockOwner(lockDirectory) {
-  await access2(join2(lockDirectory, "owner"), constants2.R_OK);
-  const owner = await readFile3(join2(lockDirectory, "owner"), "utf8");
+  await access(join(lockDirectory, "owner"), constants.R_OK);
+  const owner = await readFile(join(lockDirectory, "owner"), "utf8");
   return owner.split("\n", 1)[0] || null;
 }
 function wait(ms) {
-  return new Promise((resolve6) => {
-    setTimeout(resolve6, ms);
+  return new Promise((resolve4) => {
+    setTimeout(resolve4, ms);
   });
 }
 function isMissingFileError(error) {
@@ -1288,40 +248,40 @@ function isMissingFileError(error) {
 }
 
 // ../orchestrator/dist/fs-store.js
-import { mkdir as mkdir2, open, rename as rename2, rm as rm2, stat as stat3, writeFile as writeFile2, appendFile } from "fs/promises";
-import { dirname, join as join3, relative, resolve as resolve3 } from "path";
+import { mkdir as mkdir2, open, rename as rename2, rm as rm2, stat as stat2, writeFile as writeFile2, appendFile } from "fs/promises";
+import { dirname, join as join2, relative, resolve } from "path";
 var OrchestratorFsStore = class {
   runtimeRoot;
   resolvedRuntimeRoot;
   resolvedEventsMirrorRoot;
   constructor(runtimeRoot, options = {}) {
     this.runtimeRoot = runtimeRoot;
-    this.resolvedRuntimeRoot = resolve3(runtimeRoot);
-    this.resolvedEventsMirrorRoot = options.eventsMirrorRoot ? resolve3(options.eventsMirrorRoot) : null;
+    this.resolvedRuntimeRoot = resolve(runtimeRoot);
+    this.resolvedEventsMirrorRoot = options.eventsMirrorRoot ? resolve(options.eventsMirrorRoot) : null;
   }
   projectsRoot() {
-    return join3(this.runtimeRoot, "projects");
+    return join2(this.runtimeRoot, "projects");
   }
   projectDir(projectId) {
-    return join3(this.projectsRoot(), projectId);
+    return join2(this.projectsRoot(), projectId);
   }
   projectRunsDir(projectId) {
-    return join3(this.projectDir(projectId), "runs");
+    return join2(this.projectDir(projectId), "runs");
   }
   runDir(runId, projectId) {
     if (!projectId) {
-      return join3(this.runtimeRoot, "projects", "__unknown__", "runs", runId);
+      return join2(this.runtimeRoot, "projects", "__unknown__", "runs", runId);
     }
-    return join3(this.projectRunsDir(projectId), runId);
+    return join2(this.projectRunsDir(projectId), runId);
   }
   async loadProjectConfig(projectId) {
-    return readJsonFile(join3(this.projectDir(projectId), "project.json"));
+    return readJsonFile(join2(this.projectDir(projectId), "project.json"));
   }
   async saveProjectConfig(config) {
-    await writeJsonFile(join3(this.projectDir(config.projectId), "project.json"), config);
+    await writeJsonFile(join2(this.projectDir(config.projectId), "project.json"), config);
   }
   async loadProjectIssueOrchestrations(projectId) {
-    const issuesPath = join3(this.projectDir(projectId), "issues.json");
+    const issuesPath = join2(this.projectDir(projectId), "issues.json");
     const issues = await readJsonFile(issuesPath);
     if (issues) {
       return issues.map((issue) => ({
@@ -1329,7 +289,7 @@ var OrchestratorFsStore = class {
         completedOnce: issue.completedOnce ?? false
       }));
     }
-    const legacyLeases = await readJsonFile(join3(this.projectDir(projectId), "leases.json")) ?? [];
+    const legacyLeases = await readJsonFile(join2(this.projectDir(projectId), "leases.json")) ?? [];
     if (legacyLeases.length === 0) {
       return [];
     }
@@ -1347,20 +307,20 @@ var OrchestratorFsStore = class {
     return migratedIssues;
   }
   async saveProjectIssueOrchestrations(projectId, issues) {
-    await writeJsonFile(join3(this.projectDir(projectId), "issues.json"), issues);
+    await writeJsonFile(join2(this.projectDir(projectId), "issues.json"), issues);
   }
   async saveProjectStatus(status) {
-    await writeJsonFile(join3(this.projectDir(status.projectId), "status.json"), status);
+    await writeJsonFile(join2(this.projectDir(status.projectId), "status.json"), status);
   }
   async loadProjectStatus(projectId) {
-    return await readJsonFile(join3(this.projectDir(projectId), "status.json")) ?? null;
+    return await readJsonFile(join2(this.projectDir(projectId), "status.json")) ?? null;
   }
   async loadRun(runId, projectId) {
     const runDirectory = projectId !== void 0 ? this.runDir(runId, projectId) : await this.findRunDir(runId);
     if (!runDirectory) {
       return null;
     }
-    return await readJsonFile(join3(runDirectory, "run.json")) ?? null;
+    return await readJsonFile(join2(runDirectory, "run.json")) ?? null;
   }
   async loadAllRuns() {
     const projectIds = await safeReadDir(this.projectsRoot());
@@ -1368,11 +328,11 @@ var OrchestratorFsStore = class {
       const entries = await safeReadDir(this.projectRunsDir(projectId));
       return entries.map((entry) => this.runDir(entry, projectId));
     }));
-    const runs = await Promise.all(runDirectories.flat().map((directory) => readJsonFile(join3(directory, "run.json"))));
+    const runs = await Promise.all(runDirectories.flat().map((directory) => readJsonFile(join2(directory, "run.json"))));
     return runs.filter((run) => Boolean(run));
   }
   async saveRun(run) {
-    await writeJsonFile(join3(this.runDir(run.runId, run.projectId), "run.json"), run);
+    await writeJsonFile(join2(this.runDir(run.runId, run.projectId), "run.json"), run);
   }
   async appendRunEvent(runId, event) {
     const resolvedProjectId = "projectId" in event && typeof event.projectId === "string" ? event.projectId : void 0;
@@ -1380,8 +340,8 @@ var OrchestratorFsStore = class {
     if (!runDirectory) {
       throw new Error(`Unable to resolve run directory for event append: ${runId}`);
     }
-    const path = join3(runDirectory, "events.ndjson");
-    const resolvedPath = resolve3(path);
+    const path = join2(runDirectory, "events.ndjson");
+    const resolvedPath = resolve(path);
     const serializedEvent = JSON.stringify(event) + "\n";
     await mkdir2(dirname(path), { recursive: true });
     await appendFile(path, serializedEvent, {
@@ -1407,7 +367,7 @@ var OrchestratorFsStore = class {
     if (!runDirectory) {
       return [];
     }
-    const path = join3(runDirectory, "events.ndjson");
+    const path = join2(runDirectory, "events.ndjson");
     try {
       if (limit <= 0) {
         return [];
@@ -1444,19 +404,19 @@ var OrchestratorFsStore = class {
     }
   }
   issueWorkspaceDir(projectId, workspaceKey) {
-    return join3(this.projectDir(projectId), "issues", workspaceKey);
+    return join2(this.projectDir(projectId), "issues", workspaceKey);
   }
   async loadIssueWorkspace(projectId, workspaceKey) {
-    return await readJsonFile(join3(this.issueWorkspaceDir(projectId, workspaceKey), "workspace.json")) ?? null;
+    return await readJsonFile(join2(this.issueWorkspaceDir(projectId, workspaceKey), "workspace.json")) ?? null;
   }
   async loadIssueWorkspaces(projectId) {
-    const issuesDir = join3(this.projectDir(projectId), "issues");
+    const issuesDir = join2(this.projectDir(projectId), "issues");
     const entries = await safeReadDir(issuesDir);
     const records = await Promise.all(entries.map((entry) => this.loadIssueWorkspace(projectId, entry)));
     return records.filter((record) => Boolean(record));
   }
   async saveIssueWorkspace(record) {
-    await writeJsonFile(join3(this.issueWorkspaceDir(record.projectId, record.workspaceKey), "workspace.json"), record);
+    await writeJsonFile(join2(this.issueWorkspaceDir(record.projectId, record.workspaceKey), "workspace.json"), record);
   }
   async removeIssueWorkspace(projectId, workspaceKey) {
     const dir = this.issueWorkspaceDir(projectId, workspaceKey);
@@ -1466,8 +426,8 @@ var OrchestratorFsStore = class {
     const projectIds = await safeReadDir(this.projectsRoot());
     for (const projectId of projectIds) {
       const candidate = this.runDir(runId, projectId);
-      const run = await readJsonFile(join3(candidate, "run.json"));
-      if (run || await pathExists(join3(candidate, "events.ndjson"))) {
+      const run = await readJsonFile(join2(candidate, "run.json"));
+      if (run || await pathExists(join2(candidate, "events.ndjson"))) {
         return candidate;
       }
     }
@@ -1481,7 +441,7 @@ var OrchestratorFsStore = class {
     if (relativePath.startsWith("..")) {
       return null;
     }
-    const mirrorPath = join3(this.resolvedEventsMirrorRoot, relativePath);
+    const mirrorPath = join2(this.resolvedEventsMirrorRoot, relativePath);
     return mirrorPath === primaryPath ? null : mirrorPath;
   }
 };
@@ -1493,7 +453,7 @@ async function writeJsonFile(path, value) {
 }
 async function pathExists(path) {
   try {
-    await stat3(path);
+    await stat2(path);
     return true;
   } catch (error) {
     if (isFileMissing(error)) {
@@ -2126,7 +1086,7 @@ var ISSUE_PROJECT_ITEMS_PAGE_QUERY = `
 `;
 
 // ../tracker-github/dist/orchestrator-adapter.js
-import { createHash as createHash3 } from "crypto";
+import { createHash } from "crypto";
 var githubProjectTrackerAdapter = {
   async listIssues(project, dependencies = {}) {
     return listProjectIssues(project, dependencies);
@@ -2214,7 +1174,7 @@ function hashToken(token) {
   if (!token) {
     return null;
   }
-  return createHash3("sha256").update(token).digest("hex");
+  return createHash("sha256").update(token).digest("hex");
 }
 var trackerAdapters = {
   "github-project": githubProjectTrackerAdapter
@@ -2263,7 +1223,7 @@ function parseIssueNumber(identifier) {
 }
 
 // ../tracker-file/dist/file-tracker-adapter.js
-import { readFile as readFile4 } from "fs/promises";
+import { readFile as readFile2 } from "fs/promises";
 function requireTrackerSetting2(project, key) {
   const value = project.tracker.settings?.[key];
   if (typeof value !== "string" || value.length === 0) {
@@ -2285,7 +1245,7 @@ var fileTrackerAdapter = {
   async listIssues(project) {
     const issuesPath = requireTrackerSetting2(project, "issuesPath");
     try {
-      const raw = await readFile4(issuesPath, "utf-8");
+      const raw = await readFile2(issuesPath, "utf-8");
       const parsed = JSON.parse(raw);
       if (!Array.isArray(parsed)) {
         throw new Error(`Expected an array of issues in ${issuesPath}, got ${typeof parsed}`);
@@ -2369,7 +1329,7 @@ function resolveTrackerAdapter2(tracker) {
 }
 
 // ../orchestrator/dist/service.js
-var DEFAULT_POLL_INTERVAL_MS2 = 3e4;
+var DEFAULT_POLL_INTERVAL_MS = 3e4;
 var DEFAULT_CONCURRENCY = 3;
 var DEFAULT_RETRY_BACKOFF_MS = 3e4;
 var CONTINUATION_RETRY_DELAY_MS = 1e3;
@@ -2479,7 +1439,7 @@ var OrchestratorService = class {
         codex_session_logs: currentRun === null ? [] : [
           {
             label: "worker",
-            path: join4(this.store.runDir(currentRun.runId, currentRun.projectId), "worker.log"),
+            path: join3(this.store.runDir(currentRun.runId, currentRun.projectId), "worker.log"),
             url: null
           }
         ]
@@ -2542,7 +1502,7 @@ var OrchestratorService = class {
       return this.dependencies.pollIntervalMs;
     }
     const configuredIntervals = [...this.projectPollIntervals.values()].filter((value) => Number.isFinite(value) && value > 0);
-    return configuredIntervals.length ? Math.min(...configuredIntervals) : DEFAULT_POLL_INTERVAL_MS2;
+    return configuredIntervals.length ? Math.min(...configuredIntervals) : DEFAULT_POLL_INTERVAL_MS;
   }
   async reconcileProject(tenant, issueIdentifier, trackerDependencies = {}) {
     const trackerAdapter = resolveTrackerAdapter2(tenant.tracker);
@@ -2551,7 +1511,7 @@ var OrchestratorService = class {
     let dispatched = 0;
     let suppressed = 0;
     let recovered = 0;
-    let pollIntervalMs = DEFAULT_POLL_INTERVAL_MS2;
+    let pollIntervalMs = DEFAULT_POLL_INTERVAL_MS;
     let rateLimits = null;
     let issueRecords = await this.store.loadProjectIssueOrchestrations(tenant.projectId);
     const allRuns = (await this.store.loadAllRuns()).filter((run) => run.projectId === tenant.projectId);
@@ -2870,8 +1830,8 @@ var OrchestratorService = class {
   async runSerialized(operation) {
     const previous = this.reconcilePromise;
     let release;
-    this.reconcilePromise = new Promise((resolve6) => {
-      release = resolve6;
+    this.reconcilePromise = new Promise((resolve4) => {
+      release = resolve4;
     });
     await previous;
     try {
@@ -2967,7 +1927,7 @@ var OrchestratorService = class {
     return this.loadProjectWorkflowUncached(tenant, repository);
   }
   async loadProjectWorkflowUncached(tenant, repository) {
-    const cacheRoot = join4(this.store.projectDir(tenant.projectId), "cache", repository.owner, repository.name);
+    const cacheRoot = join3(this.store.projectDir(tenant.projectId), "cache", repository.owner, repository.name);
     const { repositoryDirectory, changed } = await syncRepositoryForRun({
       repository,
       targetDirectory: cacheRoot
@@ -3055,7 +2015,7 @@ var OrchestratorService = class {
       state: issue.state
     });
     mkdirSync(runDir, { recursive: true });
-    const workerLogStream = (this.dependencies.createWriteStreamImpl ?? createWriteStream)(join4(runDir, "worker.log"), {
+    const workerLogStream = (this.dependencies.createWriteStreamImpl ?? createWriteStream)(join3(runDir, "worker.log"), {
       flags: "a"
     });
     let workerLogAvailable = true;
@@ -3078,7 +2038,7 @@ var OrchestratorService = class {
       const message = error instanceof Error ? error.message : String(error ?? "unknown");
       this.writeStderr(`[orchestrator] failed to write worker log for ${runId}: ${message}`);
     };
-    const child = (this.dependencies.spawnImpl ?? spawn3)("bash", ["-lc", resolveWorkerCommand()], {
+    const child = (this.dependencies.spawnImpl ?? spawn2)("bash", ["-lc", resolveWorkerCommand()], {
       cwd: process.cwd(),
       env: this.buildProjectExecutionEnv(tenant.projectId, {
         GITHUB_GRAPHQL_TOKEN: process.env.GITHUB_GRAPHQL_TOKEN ?? "",
@@ -3624,11 +2584,11 @@ var OrchestratorService = class {
     this.sleepResolver = null;
   }
   createPendingSleepPromise() {
-    return new Promise((resolve6) => {
+    return new Promise((resolve4) => {
       this.sleepResolver = () => {
         this.sleepResolver = null;
         this.sleepTimer = null;
-        resolve6();
+        resolve4();
       };
     });
   }
@@ -3709,12 +2669,12 @@ var OrchestratorService = class {
   }
   async readPersistedWorkerTokenUsage(run) {
     const artifactPaths = [
-      join4(run.workspaceRuntimeDir, "token-usage.json"),
-      join4(run.workspaceRuntimeDir, ".orchestrator", "runs", run.runId, "token-usage.json")
+      join3(run.workspaceRuntimeDir, "token-usage.json"),
+      join3(run.workspaceRuntimeDir, ".orchestrator", "runs", run.runId, "token-usage.json")
     ];
     for (const artifactPath of artifactPaths) {
       try {
-        const raw = await readFile5(artifactPath, "utf8");
+        const raw = await readFile3(artifactPath, "utf8");
         const tokenUsage = JSON.parse(raw);
         if (hasTokenUsage(tokenUsage)) {
           return tokenUsage;
@@ -3749,7 +2709,7 @@ var OrchestratorService = class {
     }
   }
   readProjectEnv(projectId) {
-    const envPath = join4(this.store.projectDir(projectId), ".env");
+    const envPath = join3(this.store.projectDir(projectId), ".env");
     try {
       return readEnvFile(envPath);
     } catch (error) {
@@ -3844,7 +2804,7 @@ var OrchestratorService = class {
       return isUsableWorkflowResolution(resolution) ? resolution.workflow.polling.intervalMs : NaN;
     }));
     const validIntervals = intervals.filter((value) => Number.isFinite(value) && value > 0);
-    return validIntervals.length ? Math.min(...validIntervals) : DEFAULT_POLL_INTERVAL_MS2;
+    return validIntervals.length ? Math.min(...validIntervals) : DEFAULT_POLL_INTERVAL_MS;
   }
   async loadProjectMaxConcurrentByState(tenant) {
     const result = {};
@@ -3952,13 +2912,13 @@ var OrchestratorService = class {
       return null;
     }
     const snapshotPath = this.lastKnownGoodWorkflowPath(cacheRoot);
-    const markdown = await readFile5(resolution.workflowPath, "utf8");
-    await mkdir3(join4(cacheRoot, "last-known-good"), { recursive: true });
+    const markdown = await readFile3(resolution.workflowPath, "utf8");
+    await mkdir3(join3(cacheRoot, "last-known-good"), { recursive: true });
     await writeFile3(snapshotPath, markdown, "utf8");
     return snapshotPath;
   }
   lastKnownGoodWorkflowPath(cacheRoot) {
-    return join4(cacheRoot, "last-known-good", "WORKFLOW.md");
+    return join3(cacheRoot, "last-known-good", "WORKFLOW.md");
   }
   workflowCacheKey(repository) {
     return `${repository.owner}/${repository.name}:${this.normalizeRepositoryCloneUrl(repository.cloneUrl)}`;
@@ -4064,14 +3024,14 @@ var OrchestratorService = class {
 function hasTokenUsage(tokenUsage) {
   return Boolean(tokenUsage && (tokenUsage.inputTokens > 0 || tokenUsage.outputTokens > 0 || tokenUsage.totalTokens > 0));
 }
-function isRecord2(value) {
+function isRecord(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
 }
 function resolveProjectRateLimits(runs, issues) {
   let latestRunRateLimits = null;
   let latestRunTimestamp = -Infinity;
   for (const run of runs) {
-    if (!isRecord2(run.rateLimits)) {
+    if (!isRecord(run.rateLimits)) {
       continue;
     }
     const timestamp = parseTimestampMs(run.lastEventAt ?? run.updatedAt ?? run.startedAt);
@@ -4085,7 +3045,7 @@ function resolveProjectRateLimits(runs, issues) {
     return latestRunRateLimits;
   }
   for (const issue of issues) {
-    if (isRecord2(issue.rateLimits)) {
+    if (isRecord(issue.rateLimits)) {
       return issue.rateLimits;
     }
   }
@@ -4191,7 +3151,12 @@ function resolveWorkerCommand() {
     const workerUrl = import.meta.resolve("@gh-symphony/worker");
     return `node ${fileURLToPath(workerUrl)}`;
   } catch {
-    return DEFAULT_WORKER_COMMAND;
+    try {
+      const bundledWorker = join3(fileURLToPath(new URL(".", import.meta.url)), "worker-entry.js");
+      return `node ${bundledWorker}`;
+    } catch {
+      return DEFAULT_WORKER_COMMAND;
+    }
   }
 }
 function createStore(runtimeRoot = ".runtime", options = {}) {
@@ -4234,7 +3199,7 @@ function createProjectItemsCache() {
   };
 }
 function wait2(ms) {
-  return new Promise((resolve6) => setTimeout(resolve6, ms));
+  return new Promise((resolve4) => setTimeout(resolve4, ms));
 }
 function createRunId(now, projectId, issueIdentifier) {
   return [
@@ -4272,8 +3237,8 @@ function isActiveRunStatus(status) {
 
 // ../orchestrator/dist/lock.js
 import { randomUUID as randomUUID2 } from "crypto";
-import { mkdir as mkdir4, open as open2, readFile as readFile6, rm as rm4 } from "fs/promises";
-import { dirname as dirname2, isAbsolute, join as join5, relative as relative2, resolve as resolve4 } from "path";
+import { mkdir as mkdir4, open as open2, readFile as readFile4, rm as rm4 } from "fs/promises";
+import { dirname as dirname2, isAbsolute, join as join4, relative as relative2, resolve as resolve2 } from "path";
 import { setTimeout as delay } from "timers/promises";
 var LOCK_READ_RETRY_DELAY_MS = 10;
 var LOCK_READ_RETRY_LIMIT = 20;
@@ -4339,7 +3304,7 @@ async function releaseProjectLock(lock) {
 }
 async function readProjectLock(lockPath) {
   try {
-    const raw = await readFile6(lockPath, "utf8");
+    const raw = await readFile4(lockPath, "utf8");
     const record = parseProjectLock(raw);
     if (!record) {
       return { status: "invalid" };
@@ -4359,13 +3324,13 @@ function assertValidProjectId(projectId) {
 }
 function resolveProjectLockPath(runtimeRoot, projectId) {
   const store = new OrchestratorFsStore(runtimeRoot);
-  const projectsRoot = resolve4(runtimeRoot, "projects");
-  const projectDir = resolve4(store.projectDir(projectId));
+  const projectsRoot = resolve2(runtimeRoot, "projects");
+  const projectDir = resolve2(store.projectDir(projectId));
   const relativeProjectDir = relative2(projectsRoot, projectDir);
   if (relativeProjectDir.length === 0 || relativeProjectDir.startsWith("..") || isAbsolute(relativeProjectDir)) {
     throw new Error(`Invalid project ID "${projectId}". Project lock path must stay within "${projectsRoot}".`);
   }
-  return join5(projectDir, ".lock");
+  return join4(projectDir, ".lock");
 }
 function parseProjectLock(raw) {
   try {
@@ -4399,7 +3364,7 @@ function isMissingFileError2(error) {
 
 // ../orchestrator/dist/index.js
 import { pathToFileURL } from "url";
-import { resolve as resolve5 } from "path";
+import { resolve as resolve3 } from "path";
 function resolveOrchestratorLogLevel(value) {
   if (!value || value === "normal") {
     return "normal";
@@ -4415,7 +3380,7 @@ async function runCli(argv, dependencies = {}) {
   if (parsed.projectId) {
     assertValidProjectId(parsed.projectId);
   }
-  const runtimeRoot = resolve5(parsed.runtimeRoot ?? ".runtime");
+  const runtimeRoot = resolve3(parsed.runtimeRoot ?? ".runtime");
   const stderr = dependencies.stderr ?? process.stderr;
   const eventsDir = resolveOptionalPath(parsed.eventsDir ?? process.env.SYMPHONY_EVENTS_DIR);
   const logLevel = resolveOrchestratorLogLevel(parsed.logLevel ?? process.env.SYMPHONY_LOG_LEVEL);
@@ -4590,7 +3555,7 @@ function resolveOptionalPath(value) {
   if (!value || value.trim().length === 0) {
     return void 0;
   }
-  return resolve5(value.trim());
+  return resolve3(value.trim());
 }
 if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
   main().catch((error) => {
@@ -4601,13 +3566,6 @@ if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href)
 }
 
 export {
-  deriveIssueWorkspaceKeyFromIdentifier,
-  readJsonFile,
-  safeReadDir,
-  isFileMissing,
-  parseRecentEvents,
-  isMatchingIssueRun,
-  mapIssueOrchestrationStateToStatus,
   OrchestratorService,
   createStore,
   acquireProjectLock,