@gh-symphony/cli 0.0.14 → 0.0.16

package/dist/chunk-TF3QNWNC.js

@@ -0,0 +1,1121 @@
+#!/usr/bin/env node
+
+// ../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/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/workflow/exit-classification.js
+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/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 delay = baseDelayMs * 2 ** (normalizedAttempt - 1);
+  return Math.min(delay, 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/identity.js
+import { resolve, join } from "path";
+import { createHash } 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 createHash("sha256").update(input).digest("hex").slice(0, 16);
+}
+function resolveIssueWorkspaceDirectory(projectDirectory, workspaceKey) {
+  const normalizedProjectDirectory = resolve(projectDirectory);
+  const candidate = resolve(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, readdir } from "fs/promises";
+async function readJsonFile(path) {
+  try {
+    const raw = await readFile(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;
+  }
+}
+
+// ../core/dist/workflow/loader.js
+import { createHash as createHash2 } from "crypto";
+import { access, readFile as readFile2, 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 readFile2(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/workspace/safety.js
+import { resolve as resolve2 } from "path";
+
+export {
+  isOrchestratorChannelEvent,
+  DEFAULT_WORKFLOW_LIFECYCLE,
+  isStateActive,
+  isStateTerminal,
+  matchesWorkflowState,
+  parseWorkflowMarkdown,
+  WorkflowConfigStore,
+  createDefaultWorkflowResolution,
+  createInvalidWorkflowResolution,
+  buildPromptVariables,
+  renderPrompt,
+  classifySessionExit,
+  scheduleRetryAt,
+  readEnvFile,
+  deriveIssueWorkspaceKey,
+  deriveIssueWorkspaceKeyFromIdentifier,
+  deriveLegacyIssueWorkspaceKey,
+  resolveIssueWorkspaceDirectory,
+  buildHookEnv,
+  executeWorkspaceHook,
+  buildProjectSnapshot,
+  readJsonFile,
+  safeReadDir,
+  isFileMissing,
+  parseRecentEvents,
+  isMatchingIssueRun,
+  mapIssueOrchestrationStateToStatus
+};