@gh-symphony/cli 0.0.13 → 0.0.15

package/dist/chunk-RNWX7DQU.js

@@ -0,0 +1,4617 @@
+#!/usr/bin/env node
+
+// ../orchestrator/dist/service.js
+import { mkdir as mkdir3, readFile as readFile5, 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 { 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 { 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";
+var workflowConfigStore = new WorkflowConfigStore();
+var LOCK_RETRY_MS = 100;
+var LOCK_STALE_MS = 30 * 60 * 1e3;
+var LOCK_TIMEOUT_MS = 2 * 60 * 1e3;
+async function cloneRepositoryForRun(input) {
+  const result = await syncRepositoryForRun(input);
+  return result.repositoryDirectory;
+}
+async function syncRepositoryForRun(input) {
+  await mkdir(input.targetDirectory, { recursive: true });
+  const repositoryDirectory = join2(input.targetDirectory, "repository");
+  const lockDirectory = join2(input.targetDirectory, "repository.lock");
+  return withRepositoryLock(lockDirectory, async () => {
+    let hasGit = false;
+    try {
+      await access2(join2(repositoryDirectory, ".git"), constants2.R_OK);
+      hasGit = true;
+    } catch {
+    }
+    if (hasGit) {
+      try {
+        const beforeHead = await readGitHead(repositoryDirectory);
+        await runCommand("git", [
+          "-C",
+          repositoryDirectory,
+          "pull",
+          "--ff-only"
+        ]);
+        const afterHead = await readGitHead(repositoryDirectory);
+        return {
+          repositoryDirectory,
+          changed: beforeHead !== afterHead
+        };
+      } catch {
+        await rm(repositoryDirectory, { recursive: true, force: true });
+      }
+    } else {
+      await rm(repositoryDirectory, { recursive: true, force: true });
+    }
+    const tempRepositoryDirectory = join2(input.targetDirectory, `repository.tmp-${process.pid}-${Date.now()}`);
+    await rm(tempRepositoryDirectory, { recursive: true, force: true });
+    try {
+      await runCommand("git", [
+        "clone",
+        "--depth",
+        "1",
+        input.repository.cloneUrl,
+        tempRepositoryDirectory
+      ]);
+      await rename(tempRepositoryDirectory, repositoryDirectory);
+      return {
+        repositoryDirectory,
+        changed: true
+      };
+    } finally {
+      await rm(tempRepositoryDirectory, { recursive: true, force: true });
+    }
+  });
+}
+async function ensureIssueWorkspaceRepository(input) {
+  return cloneRepositoryForRun({
+    repository: input.repository,
+    targetDirectory: input.issueWorkspacePath
+  });
+}
+async function loadRepositoryWorkflow(repositoryDirectory, _repository) {
+  const workflowPath = join2(repositoryDirectory, "WORKFLOW.md");
+  try {
+    return await workflowConfigStore.load(workflowPath);
+  } catch (error) {
+    if (isMissingFileError(error)) {
+      return createDefaultWorkflowResolution();
+    }
+    return createInvalidWorkflowResolution(workflowPath, error instanceof Error ? error.message : "workflow_parse_error");
+  }
+}
+function runCommand(command, args) {
+  return new Promise((resolve6, reject) => {
+    const child = spawn2(command, args, {
+      stdio: "pipe"
+    });
+    let stderr = "";
+    child.stderr?.on("data", (chunk) => {
+      stderr += String(chunk);
+    });
+    child.once("error", reject);
+    child.once("exit", (code) => {
+      if (code === 0) {
+        resolve6();
+        return;
+      }
+      reject(new Error(stderr.trim() || `${command} exited with code ${code ?? "unknown"}`));
+    });
+  });
+}
+async function readGitHead(repositoryDirectory) {
+  try {
+    return await runCommandCapture("git", [
+      "-C",
+      repositoryDirectory,
+      "rev-parse",
+      "HEAD"
+    ]);
+  } catch {
+    return null;
+  }
+}
+function runCommandCapture(command, args) {
+  return new Promise((resolve6, reject) => {
+    const child = spawn2(command, args, {
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout?.on("data", (chunk) => {
+      stdout += String(chunk);
+    });
+    child.stderr?.on("data", (chunk) => {
+      stderr += String(chunk);
+    });
+    child.once("error", reject);
+    child.once("exit", (code) => {
+      if (code === 0) {
+        resolve6(stdout.trim());
+        return;
+      }
+      reject(new Error(stderr.trim() || `${command} exited with code ${code ?? "unknown"}`));
+    });
+  });
+}
+async function withRepositoryLock(lockDirectory, fn) {
+  const ownerToken = await acquireRepositoryLock(lockDirectory);
+  try {
+    return await fn();
+  } finally {
+    await releaseRepositoryLock(lockDirectory, ownerToken);
+  }
+}
+async function acquireRepositoryLock(lockDirectory) {
+  const startedAt = Date.now();
+  const ownerToken = `${process.pid}:${randomUUID()}`;
+  for (; ; ) {
+    try {
+      await mkdir(lockDirectory);
+      await writeFile(join2(lockDirectory, "owner"), `${ownerToken}
+${(/* @__PURE__ */ new Date()).toISOString()}
+`, "utf8");
+      return ownerToken;
+    } catch (error) {
+      if (!isAlreadyExistsError(error)) {
+        throw error;
+      }
+    }
+    const stale = await isStaleLock(lockDirectory);
+    if (stale) {
+      await rm(lockDirectory, { recursive: true, force: true });
+      continue;
+    }
+    if (Date.now() - startedAt >= LOCK_TIMEOUT_MS) {
+      throw new Error(`Timed out waiting for repository cache lock: ${lockDirectory}`);
+    }
+    await wait(LOCK_RETRY_MS);
+  }
+}
+async function releaseRepositoryLock(lockDirectory, ownerToken) {
+  try {
+    const owner = await readLockOwner(lockDirectory);
+    if (owner !== ownerToken) {
+      return;
+    }
+  } catch (error) {
+    if (isMissingFileError(error)) {
+      return;
+    }
+    throw error;
+  }
+  await rm(lockDirectory, { recursive: true, force: true });
+}
+async function isStaleLock(lockDirectory) {
+  try {
+    const details = await stat2(lockDirectory);
+    return Date.now() - details.mtimeMs >= LOCK_STALE_MS;
+  } catch (error) {
+    if (isMissingFileError(error)) {
+      return false;
+    }
+    throw error;
+  }
+}
+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");
+  return owner.split("\n", 1)[0] || null;
+}
+function wait(ms) {
+  return new Promise((resolve6) => {
+    setTimeout(resolve6, ms);
+  });
+}
+function isMissingFileError(error) {
+  return Boolean(error && typeof error === "object" && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR"));
+}
+
+// ../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";
+var OrchestratorFsStore = class {
+  runtimeRoot;
+  resolvedRuntimeRoot;
+  resolvedEventsMirrorRoot;
+  constructor(runtimeRoot, options = {}) {
+    this.runtimeRoot = runtimeRoot;
+    this.resolvedRuntimeRoot = resolve3(runtimeRoot);
+    this.resolvedEventsMirrorRoot = options.eventsMirrorRoot ? resolve3(options.eventsMirrorRoot) : null;
+  }
+  projectsRoot() {
+    return join3(this.runtimeRoot, "projects");
+  }
+  projectDir(projectId) {
+    return join3(this.projectsRoot(), projectId);
+  }
+  projectRunsDir(projectId) {
+    return join3(this.projectDir(projectId), "runs");
+  }
+  runDir(runId, projectId) {
+    if (!projectId) {
+      return join3(this.runtimeRoot, "projects", "__unknown__", "runs", runId);
+    }
+    return join3(this.projectRunsDir(projectId), runId);
+  }
+  async loadProjectConfig(projectId) {
+    return readJsonFile(join3(this.projectDir(projectId), "project.json"));
+  }
+  async saveProjectConfig(config) {
+    await writeJsonFile(join3(this.projectDir(config.projectId), "project.json"), config);
+  }
+  async loadProjectIssueOrchestrations(projectId) {
+    const issuesPath = join3(this.projectDir(projectId), "issues.json");
+    const issues = await readJsonFile(issuesPath);
+    if (issues) {
+      return issues.map((issue) => ({
+        ...issue,
+        completedOnce: issue.completedOnce ?? false
+      }));
+    }
+    const legacyLeases = await readJsonFile(join3(this.projectDir(projectId), "leases.json")) ?? [];
+    if (legacyLeases.length === 0) {
+      return [];
+    }
+    const migratedIssues = legacyLeases.map((lease) => ({
+      issueId: lease.issueId,
+      identifier: lease.issueIdentifier,
+      workspaceKey: deriveIssueWorkspaceKeyFromIdentifier(lease.issueIdentifier),
+      completedOnce: false,
+      state: lease.status === "active" ? "claimed" : "released",
+      currentRunId: lease.status === "active" ? lease.runId : null,
+      retryEntry: null,
+      updatedAt: lease.updatedAt
+    }));
+    await this.saveProjectIssueOrchestrations(projectId, migratedIssues);
+    return migratedIssues;
+  }
+  async saveProjectIssueOrchestrations(projectId, issues) {
+    await writeJsonFile(join3(this.projectDir(projectId), "issues.json"), issues);
+  }
+  async saveProjectStatus(status) {
+    await writeJsonFile(join3(this.projectDir(status.projectId), "status.json"), status);
+  }
+  async loadProjectStatus(projectId) {
+    return await readJsonFile(join3(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;
+  }
+  async loadAllRuns() {
+    const projectIds = await safeReadDir(this.projectsRoot());
+    const runDirectories = await Promise.all(projectIds.map(async (projectId) => {
+      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"))));
+    return runs.filter((run) => Boolean(run));
+  }
+  async saveRun(run) {
+    await writeJsonFile(join3(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;
+    const runDirectory = resolvedProjectId !== void 0 ? this.runDir(runId, resolvedProjectId) : await this.findRunDir(runId);
+    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 serializedEvent = JSON.stringify(event) + "\n";
+    await mkdir2(dirname(path), { recursive: true });
+    await appendFile(path, serializedEvent, {
+      encoding: "utf8",
+      mode: 420
+    });
+    const mirrorPath = this.resolveMirroredEventsPath(resolvedPath);
+    if (!mirrorPath) {
+      return;
+    }
+    try {
+      await mkdir2(dirname(mirrorPath), { recursive: true });
+      await appendFile(mirrorPath, serializedEvent, {
+        encoding: "utf8",
+        mode: 420
+      });
+    } catch (error) {
+      console.warn(`Failed to mirror orchestrator event log to ${mirrorPath}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  async loadRecentRunEvents(runId, limit = 20, projectId) {
+    const runDirectory = projectId !== void 0 ? this.runDir(runId, projectId) : await this.findRunDir(runId);
+    if (!runDirectory) {
+      return [];
+    }
+    const path = join3(runDirectory, "events.ndjson");
+    try {
+      if (limit <= 0) {
+        return [];
+      }
+      const handle = await open(path, "r");
+      try {
+        const stats = await handle.stat();
+        let position = stats.size;
+        let tail = Buffer.alloc(0);
+        while (position > 0) {
+          const readSize = Math.min(position, 4096);
+          position -= readSize;
+          const chunk = Buffer.allocUnsafe(readSize);
+          await handle.read(chunk, 0, readSize, position);
+          tail = Buffer.concat([chunk, tail]);
+          const events = parseRecentEvents(tail.toString("utf8"), limit, {
+            allowPartialFirstLine: position > 0
+          });
+          if (events.length >= limit) {
+            return events;
+          }
+        }
+        return parseRecentEvents(tail.toString("utf8"), limit, {
+          allowPartialFirstLine: false
+        });
+      } finally {
+        await handle.close();
+      }
+    } catch (error) {
+      if (isFileMissing(error)) {
+        return [];
+      }
+      throw error;
+    }
+  }
+  issueWorkspaceDir(projectId, workspaceKey) {
+    return join3(this.projectDir(projectId), "issues", workspaceKey);
+  }
+  async loadIssueWorkspace(projectId, workspaceKey) {
+    return await readJsonFile(join3(this.issueWorkspaceDir(projectId, workspaceKey), "workspace.json")) ?? null;
+  }
+  async loadIssueWorkspaces(projectId) {
+    const issuesDir = join3(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);
+  }
+  async removeIssueWorkspace(projectId, workspaceKey) {
+    const dir = this.issueWorkspaceDir(projectId, workspaceKey);
+    await rm2(dir, { recursive: true, force: true });
+  }
+  async findRunDir(runId) {
+    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"))) {
+        return candidate;
+      }
+    }
+    return null;
+  }
+  resolveMirroredEventsPath(primaryPath) {
+    if (!this.resolvedEventsMirrorRoot) {
+      return null;
+    }
+    const relativePath = relative(this.resolvedRuntimeRoot, primaryPath);
+    if (relativePath.startsWith("..")) {
+      return null;
+    }
+    const mirrorPath = join3(this.resolvedEventsMirrorRoot, relativePath);
+    return mirrorPath === primaryPath ? null : mirrorPath;
+  }
+};
+async function writeJsonFile(path, value) {
+  await mkdir2(dirname(path), { recursive: true });
+  const temporaryPath = `${path}.tmp`;
+  await writeFile2(temporaryPath, JSON.stringify(value, null, 2) + "\n", "utf8");
+  await rename2(temporaryPath, path);
+}
+async function pathExists(path) {
+  try {
+    await stat3(path);
+    return true;
+  } catch (error) {
+    if (isFileMissing(error)) {
+      return false;
+    }
+    throw error;
+  }
+}
+
+// ../tracker-github/dist/adapter.js
+var DEFAULT_API_URL = "https://api.github.com/graphql";
+var DEFAULT_PAGE_SIZE = 25;
+var DEFAULT_NETWORK_TIMEOUT_MS = 3e4;
+var GitHubTrackerError = class extends Error {
+};
+var GitHubTrackerHttpError = class extends GitHubTrackerError {
+  status;
+  details;
+  constructor(message, status, details) {
+    super(message);
+    this.status = status;
+    this.details = details;
+  }
+};
+var GitHubTrackerQueryError = class extends GitHubTrackerError {
+};
+function normalizeProjectItem(projectId, item, lifecycle = DEFAULT_WORKFLOW_LIFECYCLE, priority = {}, rateLimits = null) {
+  if (item.content?.__typename !== "Issue") {
+    return null;
+  }
+  const fieldValues = extractFieldValues(item.fieldValues?.nodes ?? []);
+  const state = fieldValues[lifecycle.stateFieldName] ?? "Unknown";
+  const repository = item.content.repository;
+  const blockedBy = (item.content.blockedBy?.nodes ?? []).flatMap((node) => node ? [
+    {
+      id: node.id,
+      identifier: `${node.repository.owner.login}/${node.repository.name}#${node.number}`,
+      state: normalizeBlockerState(node.state, lifecycle)
+    }
+  ] : []);
+  return {
+    id: item.content.id,
+    identifier: `${repository.owner.login}/${repository.name}#${item.content.number}`,
+    number: item.content.number,
+    title: item.content.title,
+    description: item.content.body,
+    priority: resolvePriority(item, priority),
+    state,
+    branchName: null,
+    url: item.content.url,
+    labels: (item.content.labels?.nodes ?? []).flatMap((label) => label?.name ? [label.name.toLowerCase()] : []).sort(),
+    blockedBy,
+    createdAt: item.content.createdAt,
+    updatedAt: item.content.updatedAt ?? item.updatedAt,
+    repository: {
+      owner: repository.owner.login,
+      name: repository.name,
+      url: repository.url,
+      cloneUrl: deriveCloneUrl(repository.url)
+    },
+    tracker: {
+      adapter: "github-project",
+      bindingId: projectId,
+      itemId: item.id
+    },
+    metadata: fieldValues,
+    rateLimits
+  };
+}
+async function fetchProjectIssues(config, fetchImpl = fetch) {
+  const issues = [];
+  let cursor = null;
+  const priorityOptionIds = config.priorityFieldName ? await fetchPriorityOptionOrder(config, config.priorityFieldName, fetchImpl) : void 0;
+  const currentUserLogin = config.assignedOnly ? await fetchCurrentUserLogin(config, fetchImpl) : null;
+  let excludedCount = 0;
+  let latestRateLimits = null;
+  do {
+    const pageResult = await fetchProjectItemsPage(config, cursor, fetchImpl);
+    const page = pageResult.page;
+    latestRateLimits = pageResult.rateLimits ?? latestRateLimits;
+    const pageIssues = (page.nodes ?? []).flatMap((item) => {
+      if (!item) {
+        return [];
+      }
+      const normalized = normalizeProjectItem(config.projectId, item, config.lifecycle, {
+        fieldName: config.priorityFieldName,
+        optionIds: priorityOptionIds
+      }, latestRateLimits);
+      if (!normalized) {
+        return [];
+      }
+      if (currentUserLogin && !isIssueAssignedToLogin(item, currentUserLogin)) {
+        excludedCount += 1;
+        return [];
+      }
+      return [normalized];
+    });
+    issues.push(...pageIssues);
+    cursor = page.pageInfo.hasNextPage ? page.pageInfo.endCursor : null;
+  } while (cursor);
+  if (currentUserLogin) {
+    emitAssignedOnlyFilterEvent({
+      projectId: config.projectId,
+      currentUserLogin,
+      includedCount: issues.length,
+      excludedCount
+    });
+  }
+  if (latestRateLimits) {
+    for (const issue of issues) {
+      issue.rateLimits = latestRateLimits;
+    }
+  }
+  return issues;
+}
+async function fetchIssueStatesByIds(config, issueIds, fetchImpl = fetch) {
+  if (issueIds.length === 0) {
+    return [];
+  }
+  const issues = [];
+  for (const issueIdBatch of chunkValues([...new Set(issueIds)], 100)) {
+    const result = await executeGraphQLQueryWithMetadata(config, ISSUE_STATES_BY_IDS_QUERY, {
+      issueIds: issueIdBatch
+    }, fetchImpl);
+    const data = result.data;
+    const rateLimits = result.rateLimits;
+    for (const node of data.nodes ?? []) {
+      const projectItem = await resolveIssueProjectItemForStateLookup(config, node, fetchImpl);
+      const normalized = normalizeIssueStateLookupNode(config.projectId, node, projectItem, config.lifecycle, rateLimits);
+      if (normalized) {
+        issues.push(normalized);
+      }
+    }
+  }
+  return issues;
+}
+async function fetchProjectItemsPage(config, cursor, fetchImpl) {
+  const result = await executeGraphQLQueryWithMetadata(config, PROJECT_ITEMS_QUERY, {
+    projectId: config.projectId,
+    cursor,
+    pageSize: config.pageSize ?? DEFAULT_PAGE_SIZE
+  }, fetchImpl);
+  const data = result.data;
+  const items = data.node?.items;
+  if (!items) {
+    throw new GitHubTrackerQueryError("GitHub GraphQL response did not include project items.");
+  }
+  return {
+    page: items,
+    rateLimits: result.rateLimits
+  };
+}
+var fetchGithubProjectIssues = fetchProjectIssues;
+var fetchGithubIssueStatesByIds = fetchIssueStatesByIds;
+async function fetchCurrentUserLogin(config, fetchImpl) {
+  const response = await fetchImpl(resolveRestUserApiUrl(config.apiUrl), {
+    method: "GET",
+    headers: {
+      authorization: `Bearer ${config.token}`,
+      "user-agent": "gh-symphony",
+      accept: "application/vnd.github+json"
+    },
+    signal: buildRequestSignal(config.timeoutMs)
+  });
+  if (!response.ok) {
+    const details = await response.text();
+    throw new GitHubTrackerHttpError(`GitHub REST request failed with status ${response.status}`, response.status, details);
+  }
+  const payload = await response.json();
+  if (!payload.login) {
+    throw new GitHubTrackerQueryError("GitHub REST response did not include the authenticated user login.");
+  }
+  return payload.login;
+}
+function isIssueAssignedToLogin(item, login) {
+  if (item.content?.__typename !== "Issue") {
+    return false;
+  }
+  return (item.content.assignees?.nodes ?? []).some((assignee) => assignee?.login === login);
+}
+function emitAssignedOnlyFilterEvent(input) {
+  console.info(JSON.stringify({
+    event: "tracker-assigned-only-filtered",
+    projectId: input.projectId,
+    currentUserLogin: input.currentUserLogin,
+    includedCount: input.includedCount,
+    excludedCount: input.excludedCount
+  }));
+}
+function extractFieldValues(nodes) {
+  return nodes.reduce((values, node) => {
+    const fieldName = node?.field?.name;
+    if (!fieldName) {
+      return values;
+    }
+    if (node.__typename === "ProjectV2ItemFieldSingleSelectValue" && node.name) {
+      values[fieldName] = node.name;
+    }
+    if (node.__typename === "ProjectV2ItemFieldTextValue" && node.text) {
+      values[fieldName] = node.text;
+    }
+    return values;
+  }, {});
+}
+function normalizeIssueStateLookupNode(projectId, issue, projectItem, lifecycle = DEFAULT_WORKFLOW_LIFECYCLE, rateLimits = null) {
+  if (issue?.__typename !== "Issue") {
+    return null;
+  }
+  if (!projectItem) {
+    return null;
+  }
+  const fieldValues = extractFieldValues(projectItem.fieldValues?.nodes ?? []);
+  const state = fieldValues[lifecycle.stateFieldName] ?? "Unknown";
+  const repository = issue.repository;
+  const identifier = `${repository.owner.login}/${repository.name}#${issue.number}`;
+  return {
+    id: issue.id,
+    identifier,
+    number: issue.number,
+    title: identifier,
+    description: null,
+    priority: null,
+    state,
+    branchName: null,
+    url: `${repository.url}/issues/${issue.number}`,
+    labels: [],
+    blockedBy: [],
+    createdAt: null,
+    updatedAt: projectItem.updatedAt ?? issue.updatedAt,
+    repository: {
+      owner: repository.owner.login,
+      name: repository.name,
+      url: repository.url,
+      cloneUrl: deriveCloneUrl(repository.url)
+    },
+    tracker: {
+      adapter: "github-project",
+      bindingId: projectId,
+      itemId: projectItem.id
+    },
+    metadata: fieldValues,
+    rateLimits
+  };
+}
+async function resolveIssueProjectItemForStateLookup(config, issue, fetchImpl) {
+  if (issue?.__typename !== "Issue") {
+    return null;
+  }
+  let connection = issue.projectItems;
+  let projectItem = findProjectItemByProjectId(connection?.nodes ?? [], config.projectId);
+  let cursor = connection?.pageInfo.endCursor ?? null;
+  while (!projectItem && connection?.pageInfo.hasNextPage) {
+    const nextPage = await fetchIssueProjectItemsPage(config, issue.id, cursor, fetchImpl);
+    projectItem = findProjectItemByProjectId(nextPage.nodes ?? [], config.projectId);
+    connection = nextPage;
+    cursor = nextPage.pageInfo.endCursor;
+  }
+  return projectItem;
+}
+async function fetchIssueProjectItemsPage(config, issueId, cursor, fetchImpl) {
+  const result = await executeGraphQLQueryWithMetadata(config, ISSUE_PROJECT_ITEMS_PAGE_QUERY, {
+    issueId,
+    cursor
+  }, fetchImpl);
+  const data = result.data;
+  const issue = data.node;
+  if (issue?.__typename !== "Issue" || !issue.projectItems) {
+    throw new GitHubTrackerQueryError("GitHub GraphQL response did not include issue project items.");
+  }
+  return issue.projectItems;
+}
+function findProjectItemByProjectId(nodes, projectId) {
+  return nodes.find((item) => item?.project?.id === projectId) ?? null;
+}
+function resolvePriority(item, priority) {
+  if (!priority.fieldName || !priority.optionIds) {
+    return null;
+  }
+  for (const node of item.fieldValues?.nodes ?? []) {
+    if (node?.__typename === "ProjectV2ItemFieldSingleSelectValue" && node.field?.name === priority.fieldName && node.optionId) {
+      return priority.optionIds[node.optionId] ?? null;
+    }
+  }
+  return null;
+}
+function extractPriorityOptionOrder(fields, priorityFieldName) {
+  for (const field of fields) {
+    if (isSingleSelectProjectField(field) && field.name === priorityFieldName) {
+      let nextPriority = 0;
+      const optionEntries = (field.options ?? []).flatMap((option) => {
+        if (!option?.id) {
+          return [];
+        }
+        const entry = [option.id, nextPriority];
+        nextPriority += 1;
+        return [entry];
+      });
+      return Object.fromEntries(optionEntries);
+    }
+  }
+  return void 0;
+}
+async function fetchPriorityOptionOrder(config, priorityFieldName, fetchImpl) {
+  const data = await executeGraphQLQuery(config, PROJECT_FIELDS_QUERY, { projectId: config.projectId }, fetchImpl);
+  return extractPriorityOptionOrder(data.node?.fields?.nodes ?? [], priorityFieldName);
+}
+function isSingleSelectProjectField(field) {
+  return field?.__typename === "ProjectV2SingleSelectField";
+}
+function deriveCloneUrl(repositoryUrl) {
+  if (repositoryUrl.startsWith("file://") || repositoryUrl.endsWith(".git")) {
+    return repositoryUrl;
+  }
+  return `${repositoryUrl}.git`;
+}
+function normalizeBlockerState(state, lifecycle) {
+  if (!state) {
+    return null;
+  }
+  const normalized = state.trim().toLowerCase();
+  if (normalized === "closed") {
+    return lifecycle.terminalStates[0] ?? state;
+  }
+  if (normalized === "open") {
+    return null;
+  }
+  return state;
+}
+function resolveRestUserApiUrl(apiUrl) {
+  const parsed = new URL(apiUrl ?? DEFAULT_API_URL);
+  const pathSegments = parsed.pathname.split("/").filter(Boolean);
+  if (pathSegments.at(-1) === "graphql") {
+    pathSegments.pop();
+  }
+  parsed.pathname = `/${pathSegments.join("/")}/user`.replace(/\/{2,}/g, "/");
+  parsed.search = "";
+  parsed.hash = "";
+  return parsed.toString();
+}
+function chunkValues(values, size) {
+  const chunks = [];
+  for (let index = 0; index < values.length; index += size) {
+    chunks.push(values.slice(index, index + size));
+  }
+  return chunks;
+}
+function buildRequestSignal(timeoutMs) {
+  return AbortSignal.timeout(resolveNetworkTimeoutMs(timeoutMs));
+}
+function resolveNetworkTimeoutMs(timeoutMs) {
+  if (timeoutMs !== void 0 && Number.isInteger(timeoutMs) && timeoutMs > 0) {
+    return timeoutMs;
+  }
+  return DEFAULT_NETWORK_TIMEOUT_MS;
+}
+async function executeGraphQLQuery(config, query, variables, fetchImpl) {
+  const result = await executeGraphQLQueryWithMetadata(config, query, variables, fetchImpl);
+  return result.data;
+}
+async function executeGraphQLQueryWithMetadata(config, query, variables, fetchImpl) {
+  const response = await fetchImpl(config.apiUrl ?? DEFAULT_API_URL, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      authorization: `Bearer ${config.token}`
+    },
+    body: JSON.stringify({
+      query,
+      variables
+    }),
+    signal: buildRequestSignal(config.timeoutMs)
+  });
+  if (!response.ok) {
+    const details = await response.text();
+    throw new GitHubTrackerHttpError(`GitHub GraphQL request failed with status ${response.status}`, response.status, details);
+  }
+  const payload = await response.json();
+  if (payload.errors?.length) {
+    throw new GitHubTrackerQueryError(payload.errors.map((error) => error.message).join("; "));
+  }
+  if (!payload.data) {
+    throw new GitHubTrackerQueryError("GitHub GraphQL response did not include data.");
+  }
+  const data = payload.data;
+  return {
+    data,
+    rateLimits: extractGitHubRateLimits(response.headers)
+  };
+}
+function extractGitHubRateLimits(headers) {
+  if (!headers || typeof headers.get !== "function") {
+    return null;
+  }
+  const limit = parseIntegerHeader(headers.get("x-ratelimit-limit"));
+  const remaining = parseIntegerHeader(headers.get("x-ratelimit-remaining"));
+  const used = parseIntegerHeader(headers.get("x-ratelimit-used"));
+  const reset = parseIntegerHeader(headers.get("x-ratelimit-reset"));
+  const resource = headers.get("x-ratelimit-resource");
+  if (limit === null && remaining === null && used === null && reset === null && resource === null) {
+    return null;
+  }
+  return {
+    source: "github",
+    limit,
+    remaining,
+    used,
+    reset,
+    resetAt: reset === null ? null : new Date(reset * 1e3).toISOString(),
+    resource
+  };
+}
+function parseIntegerHeader(value) {
+  if (value === null) {
+    return null;
+  }
+  const parsed = Number.parseInt(value, 10);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+var PROJECT_ITEMS_QUERY = `
+  query ProjectItems($projectId: ID!, $cursor: String, $pageSize: Int!) {
+    node(id: $projectId) {
+      __typename
+      ... on ProjectV2 {
+        items(first: $pageSize, after: $cursor) {
+          nodes {
+            id
+            updatedAt
+            fieldValues(first: 20) {
+              nodes {
+                __typename
+                ... on ProjectV2ItemFieldSingleSelectValue {
+                  name
+                  optionId
+                  field {
+                    ... on ProjectV2SingleSelectField {
+                      name
+                    }
+                  }
+                }
+                ... on ProjectV2ItemFieldTextValue {
+                  text
+                  field {
+                    ... on ProjectV2FieldCommon {
+                      name
+                    }
+                  }
+                }
+              }
+            }
+            content {
+              __typename
+              ... on Issue {
+                id
+                number
+                title
+                body
+                url
+                createdAt
+                updatedAt
+                labels(first: 20) {
+                  nodes {
+                    name
+                  }
+                }
+                assignees(first: 20) {
+                  nodes {
+                    login
+                  }
+                }
+                repository {
+                  name
+                  url
+                  owner {
+                    login
+                  }
+                }
+                blockedBy(first: 100) {
+                  nodes {
+                    id
+                    number
+                    state
+                    repository {
+                      name
+                      owner {
+                        login
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+          pageInfo {
+            endCursor
+            hasNextPage
+          }
+        }
+      }
+    }
+  }
+`;
+var PROJECT_FIELDS_QUERY = `
+  query ProjectFields($projectId: ID!) {
+    node(id: $projectId) {
+      __typename
+      ... on ProjectV2 {
+        fields(first: 100) {
+          nodes {
+            __typename
+            ... on ProjectV2SingleSelectField {
+              name
+              options {
+                id
+                name
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+`;
+var ISSUE_STATES_BY_IDS_QUERY = `
+  query IssueStatesByIds($issueIds: [ID!]!) {
+    nodes(ids: $issueIds) {
+      __typename
+      ... on Issue {
+        id
+        number
+        updatedAt
+        repository {
+          name
+          url
+          owner {
+            login
+          }
+        }
+        projectItems(first: 100, includeArchived: false) {
+          nodes {
+            id
+            updatedAt
+            project {
+              id
+            }
+            fieldValues(first: 20) {
+              nodes {
+                __typename
+                ... on ProjectV2ItemFieldSingleSelectValue {
+                  name
+                  optionId
+                  field {
+                    ... on ProjectV2SingleSelectField {
+                      name
+                    }
+                  }
+                }
+                ... on ProjectV2ItemFieldTextValue {
+                  text
+                  field {
+                    ... on ProjectV2FieldCommon {
+                      name
+                    }
+                  }
+                }
+              }
+            }
+          }
+          pageInfo {
+            endCursor
+            hasNextPage
+          }
+        }
+      }
+    }
+  }
+`;
+var ISSUE_PROJECT_ITEMS_PAGE_QUERY = `
+  query IssueProjectItemsPage($issueId: ID!, $cursor: String) {
+    node(id: $issueId) {
+      __typename
+      ... on Issue {
+        id
+        number
+        updatedAt
+        repository {
+          name
+          url
+          owner {
+            login
+          }
+        }
+        projectItems(first: 100, after: $cursor, includeArchived: false) {
+          nodes {
+            id
+            updatedAt
+            project {
+              id
+            }
+            fieldValues(first: 20) {
+              nodes {
+                __typename
+                ... on ProjectV2ItemFieldSingleSelectValue {
+                  name
+                  optionId
+                  field {
+                    ... on ProjectV2SingleSelectField {
+                      name
+                    }
+                  }
+                }
+                ... on ProjectV2ItemFieldTextValue {
+                  text
+                  field {
+                    ... on ProjectV2FieldCommon {
+                      name
+                    }
+                  }
+                }
+              }
+            }
+          }
+          pageInfo {
+            endCursor
+            hasNextPage
+          }
+        }
+      }
+    }
+  }
+`;
+
+// ../tracker-github/dist/orchestrator-adapter.js
+import { createHash as createHash3 } from "crypto";
+var githubProjectTrackerAdapter = {
+  async listIssues(project, dependencies = {}) {
+    return listProjectIssues(project, dependencies);
+  },
+  async listIssuesByStates(project, states, dependencies = {}) {
+    if (states.length === 0) {
+      return [];
+    }
+    const issues = await listProjectIssues(project, dependencies);
+    const normalizedStates = new Set(states.map((state) => state.trim().toLowerCase()));
+    return issues.filter((issue) => normalizedStates.has(issue.state.trim().toLowerCase()));
+  },
+  async fetchIssueStatesByIds(project, issueIds, dependencies = {}) {
+    if (issueIds.length === 0) {
+      return [];
+    }
+    return fetchProjectIssueStatesByIds(project, issueIds, dependencies);
+  },
+  buildWorkerEnvironment(project) {
+    return {
+      GITHUB_PROJECT_ID: requireTrackerSetting(project.tracker, "projectId")
+    };
+  },
+  reviveIssue(project, run) {
+    return {
+      id: run.issueId,
+      identifier: run.issueIdentifier,
+      number: parseIssueNumber(run.issueIdentifier),
+      title: run.issueTitle ?? run.issueIdentifier,
+      description: null,
+      priority: null,
+      state: run.issueState,
+      branchName: null,
+      url: null,
+      labels: [],
+      blockedBy: [],
+      createdAt: null,
+      updatedAt: null,
+      repository: run.repository,
+      tracker: {
+        adapter: "github-project",
+        bindingId: project.tracker.bindingId,
+        itemId: run.issueId
+      },
+      metadata: {}
+    };
+  }
+};
+async function listProjectIssues(project, dependencies = {}) {
+  const trackerConfig = resolveGitHubTrackerConfig(project, dependencies);
+  const loadProjectIssues = () => fetchGithubProjectIssues(trackerConfig, dependencies.fetchImpl);
+  return dependencies.projectItemsCache?.getOrLoad(buildProjectItemsCacheKey(trackerConfig, dependencies), loadProjectIssues) ?? loadProjectIssues();
+}
+async function fetchProjectIssueStatesByIds(project, issueIds, dependencies = {}) {
+  const trackerConfig = resolveGitHubTrackerConfig(project, dependencies);
+  return fetchGithubIssueStatesByIds(trackerConfig, [...issueIds], dependencies.fetchImpl);
+}
+function resolveGitHubTrackerConfig(project, dependencies = {}) {
+  const token = dependencies.token ?? process.env.GITHUB_GRAPHQL_TOKEN;
+  if (!token) {
+    throw new Error("GITHUB_GRAPHQL_TOKEN environment variable is required. Run 'gh auth token' or set the variable.");
+  }
+  const githubProjectId = requireTrackerSetting(project.tracker, "projectId");
+  return {
+    projectId: githubProjectId,
+    token,
+    apiUrl: project.tracker.apiUrl,
+    assignedOnly: readBooleanTrackerSetting(project.tracker, "assignedOnly"),
+    priorityFieldName: readOptionalStringTrackerSetting(project.tracker, "priorityFieldName"),
+    timeoutMs: readNumberTrackerSetting(project.tracker, "timeoutMs")
+  };
+}
+function buildProjectItemsCacheKey(config, _dependencies) {
+  return JSON.stringify({
+    adapter: "github-project",
+    apiUrl: config.apiUrl,
+    assignedOnly: config.assignedOnly ?? false,
+    priorityFieldName: config.priorityFieldName ?? null,
+    projectId: config.projectId,
+    timeoutMs: config.timeoutMs,
+    tokenFingerprint: hashToken(config.token)
+  });
+}
+function hashToken(token) {
+  if (!token) {
+    return null;
+  }
+  return createHash3("sha256").update(token).digest("hex");
+}
+var trackerAdapters = {
+  "github-project": githubProjectTrackerAdapter
+};
+function resolveTrackerAdapter(tracker) {
+  const adapter = trackerAdapters[tracker.adapter];
+  if (!adapter) {
+    throw new Error(`Unsupported tracker adapter: ${tracker.adapter}`);
+  }
+  return adapter;
+}
+function requireTrackerSetting(tracker, key) {
+  const value = tracker.settings?.[key];
+  if (typeof value !== "string" || value.length === 0) {
+    throw new Error(`Tracker adapter "${tracker.adapter}" requires the "${key}" setting.`);
+  }
+  return value;
+}
+function readBooleanTrackerSetting(tracker, key) {
+  const value = tracker.settings?.[key];
+  return value === true || value === "true";
+}
+function readNumberTrackerSetting(tracker, key) {
+  const value = tracker.settings?.[key];
+  if (value === void 0) {
+    return void 0;
+  }
+  if (typeof value === "number" && Number.isInteger(value) && value > 0) {
+    return value;
+  }
+  if (typeof value === "string") {
+    const parsed = Number(value);
+    if (Number.isInteger(parsed) && parsed > 0) {
+      return parsed;
+    }
+  }
+  throw new Error(`Tracker adapter "${tracker.adapter}" requires the "${key}" setting to be a positive integer when provided.`);
+}
+function readOptionalStringTrackerSetting(tracker, key) {
+  const value = tracker.settings?.[key];
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function parseIssueNumber(identifier) {
+  const match = identifier.match(/#(\d+)$/);
+  return match ? Number.parseInt(match[1] ?? "0", 10) : 0;
+}
+
+// ../tracker-file/dist/file-tracker-adapter.js
+import { readFile as readFile4 } from "fs/promises";
+function requireTrackerSetting2(project, key) {
+  const value = project.tracker.settings?.[key];
+  if (typeof value !== "string" || value.length === 0) {
+    throw new Error(`Tracker adapter "file" requires the "${key}" setting.`);
+  }
+  return value;
+}
+function parseIssueNumber2(identifier) {
+  const match = identifier.match(/#(\d+)$/);
+  return match ? Number.parseInt(match[1] ?? "0", 10) : 0;
+}
+function isValidIssueShape(entry) {
+  if (!entry || typeof entry !== "object")
+    return false;
+  const e = entry;
+  return typeof e.id === "string" && typeof e.identifier === "string" && typeof e.state === "string" && e.repository !== null && typeof e.repository === "object" && e.tracker !== null && typeof e.tracker === "object";
+}
+var fileTrackerAdapter = {
+  async listIssues(project) {
+    const issuesPath = requireTrackerSetting2(project, "issuesPath");
+    try {
+      const raw = await readFile4(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}`);
+      }
+      const valid = [];
+      for (let i = 0; i < parsed.length; i++) {
+        if (isValidIssueShape(parsed[i])) {
+          valid.push(parsed[i]);
+        } else {
+          process.stderr.write(`[tracker-file] Skipping invalid issue at index ${i} in ${issuesPath}
+`);
+        }
+      }
+      return valid;
+    } catch (err) {
+      if (err instanceof Error && "code" in err && err.code === "ENOENT") {
+        return [];
+      }
+      if (err instanceof SyntaxError) {
+        return [];
+      }
+      throw err;
+    }
+  },
+  async listIssuesByStates(project, states) {
+    if (states.length === 0) {
+      return [];
+    }
+    const issues = await this.listIssues(project);
+    const normalizedStates = new Set(states.map((state) => state.trim().toLowerCase()));
+    return issues.filter((issue) => normalizedStates.has(issue.state.trim().toLowerCase()));
+  },
+  async fetchIssueStatesByIds(project, issueIds) {
+    if (issueIds.length === 0) {
+      return [];
+    }
+    const issues = await this.listIssues(project);
+    const ids = new Set(issueIds);
+    return issues.filter((issue) => ids.has(issue.id));
+  },
+  buildWorkerEnvironment(_project, _issue) {
+    return {
+      SYMPHONY_FILE_TRACKER: "true"
+    };
+  },
+  reviveIssue(project, run) {
+    return {
+      id: run.issueId,
+      identifier: run.issueIdentifier,
+      number: parseIssueNumber2(run.issueIdentifier),
+      title: run.issueTitle ?? run.issueIdentifier,
+      description: null,
+      priority: null,
+      state: run.issueState,
+      branchName: null,
+      url: null,
+      labels: [],
+      blockedBy: [],
+      createdAt: null,
+      updatedAt: null,
+      repository: run.repository,
+      tracker: {
+        adapter: "file",
+        bindingId: project.tracker.bindingId,
+        itemId: run.issueId
+      },
+      metadata: {}
+    };
+  }
+};
+
+// ../orchestrator/dist/tracker-adapters.js
+var localAdapters = /* @__PURE__ */ new Map([
+  ["file", fileTrackerAdapter]
+]);
+function resolveTrackerAdapter2(tracker) {
+  const local = localAdapters.get(tracker.adapter);
+  if (local)
+    return local;
+  return resolveTrackerAdapter(tracker);
+}
+
+// ../orchestrator/dist/service.js
+var DEFAULT_POLL_INTERVAL_MS2 = 3e4;
+var DEFAULT_CONCURRENCY = 3;
+var DEFAULT_RETRY_BACKOFF_MS = 3e4;
+var CONTINUATION_RETRY_DELAY_MS = 1e3;
+var DEFAULT_WORKER_COMMAND = "node packages/worker/dist/index.js";
+var DEFAULT_MAX_NONPRODUCTIVE_TURNS = 3;
+var STUCK_WORKER_TIMEOUT_MS = 30 * 60 * 1e3;
+function isUsableWorkflowResolution(resolution) {
+  return resolution.isValid || resolution.usedLastKnownGood;
+}
+function parseTimestampMs(value) {
+  if (!value) {
+    return null;
+  }
+  const parsed = new Date(value).getTime();
+  return Number.isFinite(parsed) ? parsed : null;
+}
+var OrchestratorService = class {
+  store;
+  projectConfig;
+  dependencies;
+  projectPollIntervals = /* @__PURE__ */ new Map();
+  activeWorkerPids = /* @__PURE__ */ new Set();
+  workerStderrBuffers = /* @__PURE__ */ new Map();
+  workerStderrDecoders = /* @__PURE__ */ new Map();
+  lastKnownGoodWorkflows = /* @__PURE__ */ new Map();
+  lastReportedWorkflowErrors = /* @__PURE__ */ new Map();
+  workflowResolutionCache = null;
+  running = true;
+  shuttingDown = false;
+  shutdownPromise = null;
+  sleepTimer = null;
+  sleepResolver = null;
+  reconcilePromise = Promise.resolve();
+  reconcileRequested = false;
+  constructor(store, projectConfig, dependencies = {}) {
+    this.store = store;
+    this.projectConfig = projectConfig;
+    this.dependencies = dependencies;
+  }
+  async run(options = {}) {
+    this.running = true;
+    await this.runSerialized(() => this.performStartupCleanup(this.createTrackerDependencies()));
+    while (this.running) {
+      try {
+        const snapshot = await this.runOnceInternal(options.issueIdentifier, this.createTrackerDependencies());
+        await this.notifyTick(snapshot);
+      } catch (error) {
+        if (options.once) {
+          throw error;
+        }
+        this.writeStderr(`[orchestrator] run loop failed for ${this.projectConfig.projectId}: ${this.formatErrorMessage(error)}`);
+      }
+      if (options.once || !this.running) {
+        return;
+      }
+      await this.waitForNextPoll();
+    }
+  }
+  async runOnce(options = {}) {
+    return this.runOnceInternal(options.issueIdentifier, this.createTrackerDependencies());
+  }
+  async status() {
+    return this.store.loadProjectStatus(this.projectConfig.projectId);
+  }
+  async statusForIssue(issueIdentifier) {
+    const issueRecords = await this.store.loadProjectIssueOrchestrations(this.projectConfig.projectId);
+    const issueRecord = issueRecords.find((record) => record.identifier === issueIdentifier);
+    if (!issueRecord) {
+      return null;
+    }
+    const currentRunCandidate = issueRecord.currentRunId ? await this.store.loadRun(issueRecord.currentRunId, this.projectConfig.projectId) : null;
+    const currentRun = isMatchingIssueRun(currentRunCandidate, this.projectConfig.projectId, issueRecord.issueId, issueIdentifier) ? currentRunCandidate : await this.findLatestRunForIssue(issueRecord.issueId, issueIdentifier);
+    const recentEvents = currentRun === null ? [] : await this.store.loadRecentRunEvents(currentRun.runId, 20, currentRun.projectId);
+    const latestEventMessage = recentEvents[recentEvents.length - 1]?.message ?? null;
+    const currentAttempt = currentRun?.attempt ?? issueRecord.retryEntry?.attempt ?? 0;
+    return {
+      issue_identifier: issueRecord.identifier,
+      issue_id: issueRecord.issueId,
+      status: currentRun?.status ?? mapIssueOrchestrationStateToStatus(issueRecord.state),
+      workspace: {
+        path: currentRun?.workingDirectory ?? null
+      },
+      attempts: {
+        restart_count: Math.max(0, currentAttempt - 1),
+        current_retry_attempt: currentAttempt
+      },
+      running: currentRun === null ? null : {
+        session_id: currentRun.runtimeSession?.sessionId ?? null,
+        turn_count: currentRun.turnCount ?? null,
+        state: currentRun.issueState ?? null,
+        started_at: currentRun.startedAt ?? null,
+        last_event: currentRun.lastEvent ?? null,
+        last_message: latestEventMessage,
+        last_event_at: currentRun.lastEventAt ?? null,
+        tokens: currentRun.tokenUsage ? {
+          input_tokens: currentRun.tokenUsage.inputTokens,
+          output_tokens: currentRun.tokenUsage.outputTokens,
+          total_tokens: currentRun.tokenUsage.totalTokens
+        } : null
+      },
+      retry: currentRun?.nextRetryAt ?? issueRecord.retryEntry?.dueAt ? {
+        due_at: currentRun?.nextRetryAt ?? issueRecord.retryEntry?.dueAt ?? "",
+        kind: currentRun?.retryKind ?? null,
+        error: currentRun?.lastError ?? issueRecord.retryEntry?.error ?? null
+      } : null,
+      logs: {
+        codex_session_logs: currentRun === null ? [] : [
+          {
+            label: "worker",
+            path: join4(this.store.runDir(currentRun.runId, currentRun.projectId), "worker.log"),
+            url: null
+          }
+        ]
+      },
+      recent_events: recentEvents,
+      last_error: currentRun?.lastError ?? issueRecord.retryEntry?.error ?? null,
+      tracked: {
+        issue_orchestration_state: issueRecord.state,
+        current_run_id: issueRecord.currentRunId,
+        workspace_key: issueRecord.workspaceKey,
+        run_phase: currentRun?.runPhase ?? null,
+        execution_phase: currentRun?.executionPhase ?? null
+      }
+    };
+  }
+  async recover() {
+    return this.runOnce();
+  }
+  requestReconcile() {
+    this.reconcileRequested = true;
+    this.cancelPendingSleep();
+  }
+  async shutdown() {
+    if (this.shutdownPromise) {
+      return this.shutdownPromise;
+    }
+    this.shuttingDown = true;
+    this.shutdownPromise = (async () => {
+      this.running = false;
+      this.cancelPendingSleep();
+      const workerPids = [...this.activeWorkerPids];
+      for (const pid of workerPids) {
+        this.sendSignal(pid, "SIGTERM");
+      }
+      if (workerPids.length === 0) {
+        return;
+      }
+      let waitedMs = 0;
+      while (this.activeWorkerPids.size > 0 && waitedMs < 1e4) {
+        this.pruneExitedWorkerPids();
+        if (this.activeWorkerPids.size === 0) {
+          return;
+        }
+        await (this.dependencies.waitImpl ?? wait2)(100);
+        waitedMs += 100;
+      }
+      for (const pid of [...this.activeWorkerPids]) {
+        if (!this.isProcessRunning(pid)) {
+          this.retireWorkerPid(pid);
+          continue;
+        }
+        this.sendSignal(pid, "SIGKILL");
+        this.retireWorkerPid(pid);
+      }
+    })();
+    return this.shutdownPromise;
+  }
+  getEffectivePollIntervalMs() {
+    if (this.dependencies.pollIntervalMs) {
+      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;
+  }
+  async reconcileProject(tenant, issueIdentifier, trackerDependencies = {}) {
+    const trackerAdapter = resolveTrackerAdapter2(tenant.tracker);
+    const now = this.now();
+    let lastError = null;
+    let dispatched = 0;
+    let suppressed = 0;
+    let recovered = 0;
+    let pollIntervalMs = DEFAULT_POLL_INTERVAL_MS2;
+    let rateLimits = null;
+    let issueRecords = await this.store.loadProjectIssueOrchestrations(tenant.projectId);
+    const allRuns = (await this.store.loadAllRuns()).filter((run) => run.projectId === tenant.projectId);
+    const activeRuns = allRuns.filter((run) => isActiveRunStatus(run.status));
+    for (const run of activeRuns) {
+      const outcome = await this.reconcileRun(tenant, run, issueRecords);
+      issueRecords = outcome.issueRecords;
+      if (outcome.recovered) {
+        recovered += 1;
+      }
+    }
+    const reconciledRuns = (await this.store.loadAllRuns()).filter((run) => run.projectId === tenant.projectId && isActiveRunStatus(run.status));
+    const projectRunsAfterReconcile = (await this.store.loadAllRuns()).filter((run) => run.projectId === tenant.projectId);
+    rateLimits = resolveProjectRateLimits(reconciledRuns, []);
+    try {
+      pollIntervalMs = await this.loadProjectPollInterval(tenant);
+      const currentActiveRuns = (await this.store.loadAllRuns()).filter((run) => run.projectId === tenant.projectId && isActiveRunStatus(run.status));
+      const { runs: syncedActiveRuns, issuesByIdentifier: syncedIssuesByIdentifier } = await this.syncActiveRunIssueStates(tenant, trackerAdapter, currentActiveRuns, now);
+      const issues = await trackerAdapter.listIssues(tenant, trackerDependencies);
+      const filteredIssues = issueIdentifier ? issues.filter((issue) => issue.identifier === issueIdentifier) : issues;
+      const { candidates: actionableCandidates, lifecycle } = await this.resolveActionableCandidates(tenant, filteredIssues);
+      const trackedIssuesByIdentifier = new Map(syncedIssuesByIdentifier);
+      for (const issue of filteredIssues) {
+        const existing = trackedIssuesByIdentifier.get(issue.identifier);
+        trackedIssuesByIdentifier.set(issue.identifier, {
+          ...existing ?? issue,
+          ...issue,
+          rateLimits: issue.rateLimits ?? existing?.rateLimits ?? null
+        });
+      }
+      for (const [identifier, issue] of syncedIssuesByIdentifier) {
+        const existing = trackedIssuesByIdentifier.get(identifier);
+        if (!existing) {
+          trackedIssuesByIdentifier.set(identifier, issue);
+          continue;
+        }
+        trackedIssuesByIdentifier.set(identifier, {
+          ...issue,
+          ...existing,
+          rateLimits: existing.rateLimits ?? issue.rateLimits ?? null
+        });
+      }
+      rateLimits = resolveProjectRateLimits(syncedActiveRuns, trackedIssuesByIdentifier.values());
+      const concurrency = await this.getProjectConcurrency(tenant);
+      const currentlyActive = issueRecords.filter((record) => isIssueOrchestrationClaimed(record.state)).length;
+      const availableSlots = Math.max(0, concurrency - currentlyActive);
+      const unscheduledCandidates = actionableCandidates.filter((issue) => {
+        if (hasConvergenceLockedRun(projectRunsAfterReconcile, issue.id, issue.state)) {
+          return false;
+        }
+        return !issueRecords.some((record) => record.issueId === issue.id && isIssueOrchestrationClaimed(record.state));
+      });
+      const sortedCandidates = sortCandidatesForDispatch(unscheduledCandidates);
+      const activeByState = /* @__PURE__ */ new Map();
+      for (const run of syncedActiveRuns) {
+        const state = run.issueState;
+        const count = activeByState.get(state) ?? 0;
+        activeByState.set(state, count + 1);
+      }
+      const maxConcurrentByState = await this.loadProjectMaxConcurrentByState(tenant);
+      let slotsRemaining = availableSlots;
+      for (const issue of sortedCandidates) {
+        if (this.shuttingDown) {
+          break;
+        }
+        if (slotsRemaining <= 0)
+          break;
+        if (isIssueBudgetExceeded(resolveIssueBudgetSnapshot(projectRunsAfterReconcile, issue.id), now)) {
+          continue;
+        }
+        const stateLimit = maxConcurrentByState[issue.state];
+        if (stateLimit !== void 0) {
+          const activeInState = activeByState.get(issue.state) ?? 0;
+          if (activeInState >= stateLimit) {
+            continue;
+          }
+        }
+        const preferredWorkspaceKey = deriveIssueWorkspaceKey({
+          projectId: tenant.projectId,
+          adapter: issue.tracker.adapter,
+          issueSubjectId: issue.id
+        }, issue.identifier);
+        issueRecords = upsertIssueOrchestration(issueRecords, {
+          issueId: issue.id,
+          identifier: issue.identifier,
+          workspaceKey: preferredWorkspaceKey,
+          state: "claimed",
+          currentRunId: null,
+          retryEntry: null,
+          updatedAt: now.toISOString()
+        });
+        let run;
+        try {
+          run = await this.startRun(tenant, issue);
+        } catch (error) {
+          issueRecords = releaseIssueOrchestration(issueRecords, issue.id, now);
+          throw error;
+        }
+        issueRecords = upsertIssueOrchestration(issueRecords, {
+          issueId: run.issueId,
+          identifier: run.issueIdentifier,
+          workspaceKey: run.issueWorkspaceKey ?? preferredWorkspaceKey,
+          state: "running",
+          currentRunId: run.runId,
+          retryEntry: null,
+          updatedAt: now.toISOString()
+        });
+        await this.store.saveRun(run);
+        await this.store.appendRunEvent(run.runId, {
+          at: now.toISOString(),
+          event: "run-dispatched",
+          projectId: tenant.projectId,
+          issueIdentifier: issue.identifier,
+          issueId: run.issueId,
+          issueState: issue.state
+        });
+        this.logVerbose(`[dispatch] Issue ${issue.identifier} \u2192 run ${run.runId}`);
+        dispatched += 1;
+        slotsRemaining -= 1;
+        activeByState.set(issue.state, (activeByState.get(issue.state) ?? 0) + 1);
+      }
+      for (const issueRecord of issueRecords) {
+        if (!isIssueOrchestrationClaimed(issueRecord.state)) {
+          continue;
+        }
+        const issue = trackedIssuesByIdentifier.get(issueRecord.identifier);
+        if (!issue) {
+          continue;
+        }
+        const persistedRun = issueRecord.currentRunId ? await this.store.loadRun(issueRecord.currentRunId, tenant.projectId) : null;
+        const activeRun = syncedActiveRuns.find((run) => isMatchingIssueRun(run, tenant.projectId, issueRecord.issueId, issueRecord.identifier)) ?? persistedRun;
+        const resolvedIssue = actionableCandidates.find((candidate) => candidate.identifier === issue.identifier);
+        if (resolvedIssue) {
+          continue;
+        }
+        if (activeRun?.processId) {
+          this.sendSignal(activeRun.processId, "SIGTERM");
+          this.retireWorkerPid(activeRun.processId);
+        }
+        if (activeRun) {
+          const suppressedRun = {
+            ...activeRun,
+            status: "suppressed",
+            processId: null,
+            completedAt: now.toISOString(),
+            updatedAt: now.toISOString(),
+            runPhase: "canceled_by_reconciliation",
+            lastError: "Run suppressed because the tracker state is no longer actionable."
+          };
+          await this.store.saveRun(suppressedRun);
+          this.logVerbose(`[run-completed] ${suppressedRun.runId} status=${suppressedRun.status}`);
+        }
+        issueRecords = releaseIssueOrchestration(issueRecords, issueRecord.issueId, now);
+        suppressed += 1;
+      }
+      const terminalIssuesByIdentifier = /* @__PURE__ */ new Map();
+      for (const issue of trackedIssuesByIdentifier.values()) {
+        if (!isStateTerminal(issue.state, lifecycle)) {
+          continue;
+        }
+        terminalIssuesByIdentifier.set(issue.identifier, issue);
+      }
+      for (const issue of terminalIssuesByIdentifier.values()) {
+        await this.cleanupTerminalIssueWorkspace(tenant, issue, now);
+      }
+    } catch (error) {
+      lastError = error instanceof Error ? error.message : "Unknown orchestration error";
+    }
+    this.projectPollIntervals.set(tenant.projectId, pollIntervalMs);
+    await this.store.saveProjectIssueOrchestrations(tenant.projectId, issueRecords);
+    const allTenantRuns = (await this.store.loadAllRuns()).filter((run) => run.projectId === tenant.projectId);
+    const latestRuns = allTenantRuns.filter((run) => isActiveRunStatus(run.status));
+    rateLimits = rateLimits ?? resolveProjectRateLimits(latestRuns, []);
+    const status = buildProjectSnapshot({
+      project: tenant,
+      activeRuns: latestRuns,
+      allRuns: allTenantRuns,
+      summary: { dispatched, suppressed, recovered },
+      lastTickAt: now.toISOString(),
+      lastError,
+      rateLimits
+    });
+    await this.store.saveProjectStatus(status);
+    return status;
+  }
+  async performStartupCleanup(trackerDependencies = {}) {
+    const tenant = this.projectConfig;
+    const now = this.now();
+    const workspaceRecords = await this.store.loadIssueWorkspaces(tenant.projectId);
+    if (workspaceRecords.length === 0) {
+      return;
+    }
+    const trackerAdapter = resolveTrackerAdapter2(tenant.tracker);
+    const workflowCache = /* @__PURE__ */ new Map();
+    let issues;
+    try {
+      issues = await trackerAdapter.listIssuesByStates(tenant, await this.resolveStartupCleanupTerminalStates(tenant, workspaceRecords, workflowCache), trackerDependencies);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown tracker error";
+      console.warn(`[orchestrator] Startup cleanup skipped for project ${tenant.projectId}: ${message}`);
+      return;
+    }
+    const issuesById = new Map(issues.map((issue) => [issue.id, issue]));
+    for (const workspaceRecord of workspaceRecords) {
+      if (workspaceRecord.status === "removed") {
+        continue;
+      }
+      const issue = issuesById.get(workspaceRecord.issueSubjectId);
+      if (!issue) {
+        continue;
+      }
+      try {
+        const resolution = await this.loadStartupCleanupWorkflow(tenant, issue.repository, workflowCache);
+        if (!resolution.isValid) {
+          continue;
+        }
+        if (!isStateTerminal(issue.state, resolution.lifecycle)) {
+          continue;
+        }
+        await this.cleanupTerminalIssueWorkspace(tenant, issue, now, resolution);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown startup cleanup error";
+        console.warn(`[orchestrator] Startup cleanup skipped workspace for ${issue.identifier}: ${message}`);
+      }
+    }
+  }
+  async notifyTick(snapshot) {
+    if (!this.dependencies.onTick) {
+      return;
+    }
+    try {
+      await this.dependencies.onTick(snapshot);
+    } catch (error) {
+      this.writeStderr(`[orchestrator] onTick callback failed: ${this.formatErrorMessage(error)}`);
+    }
+  }
+  formatErrorMessage(error) {
+    if (error instanceof Error) {
+      return error.stack ?? error.message;
+    }
+    return String(error);
+  }
+  async resolveStartupCleanupTerminalStates(tenant, workspaceRecords, workflowCache) {
+    const terminalStates = /* @__PURE__ */ new Map();
+    const repositories = this.resolveStartupCleanupRepositories(tenant, workspaceRecords);
+    for (const repository of repositories) {
+      let resolution;
+      try {
+        resolution = await this.loadStartupCleanupWorkflow(tenant, repository, workflowCache);
+      } catch {
+        continue;
+      }
+      if (!isUsableWorkflowResolution(resolution)) {
+        continue;
+      }
+      for (const state of resolution.lifecycle.terminalStates) {
+        const normalizedState = state.trim().toLowerCase();
+        if (!terminalStates.has(normalizedState)) {
+          terminalStates.set(normalizedState, state);
+        }
+      }
+    }
+    if (terminalStates.size === 0) {
+      for (const state of DEFAULT_WORKFLOW_LIFECYCLE.terminalStates) {
+        terminalStates.set(state.trim().toLowerCase(), state);
+      }
+    }
+    return [...terminalStates.values()];
+  }
+  resolveStartupCleanupRepositories(tenant, workspaceRecords) {
+    const repositories = /* @__PURE__ */ new Map();
+    for (const repository of tenant.repositories) {
+      repositories.set(this.startupCleanupRepositoryKey(repository.owner, repository.name), repository);
+    }
+    for (const workspaceRecord of workspaceRecords) {
+      const repository = this.parseWorkspaceRepositoryRef(workspaceRecord);
+      if (!repository) {
+        continue;
+      }
+      const key = this.startupCleanupRepositoryKey(repository.owner, repository.name);
+      if (!repositories.has(key)) {
+        repositories.set(key, repository);
+      }
+    }
+    return [...repositories.values()];
+  }
+  parseWorkspaceRepositoryRef(workspaceRecord) {
+    const match = workspaceRecord.issueIdentifier.match(/^([^/]+)\/([^#]+)#\d+$/);
+    if (!match) {
+      return null;
+    }
+    const owner = match[1];
+    const name = match[2];
+    if (!owner || !name) {
+      return null;
+    }
+    return {
+      owner,
+      name,
+      cloneUrl: workspaceRecord.repositoryPath
+    };
+  }
+  startupCleanupRepositoryKey(owner, name) {
+    return `${owner}/${name}`;
+  }
+  async loadStartupCleanupWorkflow(tenant, repository, workflowCache) {
+    const cacheKey = this.workflowCacheKey(repository);
+    const cachedResolution = workflowCache.get(cacheKey);
+    if (cachedResolution) {
+      return cachedResolution;
+    }
+    const resolutionPromise = tenant.repositories.some((candidate) => candidate.owner === repository.owner && candidate.name === repository.name) ? this.loadProjectWorkflow(tenant, repository) : loadRepositoryWorkflow(repository.cloneUrl, repository);
+    workflowCache.set(cacheKey, resolutionPromise);
+    return resolutionPromise;
+  }
+  async runSerialized(operation) {
+    const previous = this.reconcilePromise;
+    let release;
+    this.reconcilePromise = new Promise((resolve6) => {
+      release = resolve6;
+    });
+    await previous;
+    try {
+      return await operation();
+    } finally {
+      release();
+    }
+  }
+  async runOnceInternal(issueIdentifier, trackerDependencies) {
+    return this.runSerialized(async () => {
+      const workflowResolutionCache = /* @__PURE__ */ new Map();
+      this.workflowResolutionCache = workflowResolutionCache;
+      try {
+        return await this.reconcileProject(this.projectConfig, issueIdentifier, trackerDependencies);
+      } finally {
+        if (this.workflowResolutionCache === workflowResolutionCache) {
+          this.workflowResolutionCache = null;
+        }
+      }
+    });
+  }
+  createTrackerDependencies() {
+    return {
+      fetchImpl: this.dependencies.fetchImpl,
+      projectItemsCache: createProjectItemsCache()
+    };
+  }
+  async findLatestRunForIssue(issueId, issueIdentifier) {
+    const matchingRuns = (await this.store.loadAllRuns()).filter((run) => run.projectId === this.projectConfig.projectId).filter((run) => run.issueId === issueId || run.issueIdentifier === issueIdentifier).sort((left, right) => new Date(right.updatedAt).getTime() - new Date(left.updatedAt).getTime());
+    return matchingRuns[0] ?? null;
+  }
+  async resolveActionableCandidates(tenant, issues) {
+    const candidates = [];
+    let lifecycle = null;
+    for (const issue of issues) {
+      const resolution = await this.loadProjectWorkflow(tenant, issue.repository);
+      if (!isUsableWorkflowResolution(resolution)) {
+        continue;
+      }
+      if (!lifecycle) {
+        lifecycle = resolution.lifecycle;
+      }
+      if (!isStateActive(issue.state, resolution.lifecycle)) {
+        continue;
+      }
+      if (matchesWorkflowState(issue.state, resolution.lifecycle.blockerCheckStates) && issue.blockedBy.length > 0) {
+        const hasNonTerminalBlocker = issue.blockedBy.some((blockerRef) => {
+          if (blockerRef.state && isStateTerminal(blockerRef.state, resolution.lifecycle)) {
+            return false;
+          }
+          if (blockerRef.identifier) {
+            const blockerIssue = issues.find((candidate) => candidate.identifier === blockerRef.identifier);
+            if (blockerIssue?.state) {
+              return !isStateTerminal(blockerIssue.state, resolution.lifecycle);
+            }
+          }
+          return true;
+        });
+        if (hasNonTerminalBlocker) {
+          continue;
+        }
+      }
+      candidates.push(issue);
+    }
+    if (!lifecycle && tenant.repositories.length > 0) {
+      const resolution = await this.loadProjectWorkflow(tenant, tenant.repositories[0]);
+      if (isUsableWorkflowResolution(resolution)) {
+        lifecycle = resolution.lifecycle;
+      }
+    }
+    return {
+      candidates,
+      lifecycle: lifecycle ?? {
+        stateFieldName: "Status",
+        activeStates: ["Todo", "In Progress"],
+        terminalStates: ["Done"],
+        blockerCheckStates: ["Todo"]
+      }
+    };
+  }
+  async loadProjectWorkflow(tenant, repository) {
+    const cacheKey = this.workflowCacheKey(repository);
+    const pendingCache = this.workflowResolutionCache;
+    if (pendingCache) {
+      const cachedResolution = pendingCache.get(cacheKey);
+      if (cachedResolution) {
+        return cachedResolution;
+      }
+      const resolutionPromise = this.loadProjectWorkflowUncached(tenant, repository);
+      pendingCache.set(cacheKey, resolutionPromise);
+      return resolutionPromise;
+    }
+    return this.loadProjectWorkflowUncached(tenant, repository);
+  }
+  async loadProjectWorkflowUncached(tenant, repository) {
+    const cacheRoot = join4(this.store.projectDir(tenant.projectId), "cache", repository.owner, repository.name);
+    const { repositoryDirectory, changed } = await syncRepositoryForRun({
+      repository,
+      targetDirectory: cacheRoot
+    });
+    const resolution = await loadRepositoryWorkflow(repositoryDirectory, repository);
+    return this.resolveWorkflowResolution(repository, cacheRoot, resolution, changed);
+  }
+  async startRun(tenant, issue, resumeContext) {
+    if (this.shuttingDown || !this.running) {
+      throw new Error("Orchestrator is shutting down and cannot start new runs.");
+    }
+    const trackerAdapter = resolveTrackerAdapter2(tenant.tracker);
+    const now = this.now();
+    const runId = createRunId(now, tenant.projectId, issue.identifier);
+    const runDir = this.store.runDir(runId, tenant.projectId);
+    const workspaceRuntimeDir = runDir;
+    const issueSubjectId = issue.id;
+    const identity = {
+      projectId: tenant.projectId,
+      adapter: issue.tracker.adapter,
+      issueSubjectId
+    };
+    const preferredWorkspaceKey = deriveIssueWorkspaceKey(identity, issue.identifier);
+    const legacyWorkspaceKey = deriveLegacyIssueWorkspaceKey(identity);
+    const existingWorkspaceRecord = await this.store.loadIssueWorkspace(tenant.projectId, preferredWorkspaceKey) ?? (legacyWorkspaceKey === preferredWorkspaceKey ? null : await this.store.loadIssueWorkspace(tenant.projectId, legacyWorkspaceKey));
+    const workspaceKey = existingWorkspaceRecord?.workspaceKey ?? preferredWorkspaceKey;
+    const projectDir = this.store.projectDir(tenant.projectId);
+    const issueWorkspacePath = resolveIssueWorkspaceDirectory(projectDir, workspaceKey);
+    const repositoryDirectory = await ensureIssueWorkspaceRepository({
+      repository: issue.repository,
+      issueWorkspacePath
+    });
+    if (!existingWorkspaceRecord) {
+      const workspaceRecord = {
+        workspaceKey,
+        projectId: tenant.projectId,
+        adapter: issue.tracker.adapter,
+        issueSubjectId,
+        issueIdentifier: issue.identifier,
+        workspacePath: issueWorkspacePath,
+        repositoryPath: repositoryDirectory,
+        status: "active",
+        createdAt: now.toISOString(),
+        updatedAt: now.toISOString(),
+        lastError: null
+      };
+      await this.store.saveIssueWorkspace(workspaceRecord);
+      const afterCreateResult = await this.runHook("after_create", tenant, repositoryDirectory, issue.repository, {
+        projectId: tenant.projectId,
+        workspaceKey,
+        issueSubjectId,
+        issueIdentifier: issue.identifier,
+        workspacePath: issueWorkspacePath,
+        repositoryPath: repositoryDirectory
+      });
+      if (afterCreateResult && afterCreateResult.outcome !== "success" && afterCreateResult.outcome !== "skipped") {
+        await this.store.appendRunEvent(runId, {
+          at: now.toISOString(),
+          event: "hook-failed",
+          projectId: tenant.projectId,
+          hook: "after_create",
+          error: afterCreateResult.error ?? null
+        });
+      }
+    }
+    const workflow = await this.loadProjectWorkflow(tenant, issue.repository);
+    if (!isUsableWorkflowResolution(workflow)) {
+      throw new Error(workflow.validationError ?? "Invalid repository WORKFLOW.md");
+    }
+    const allProjectRuns = (await this.store.loadAllRuns()).filter((run) => run.projectId === tenant.projectId);
+    const issueBudgetSnapshot = resolveIssueBudgetSnapshot(allProjectRuns, issue.id);
+    const promptVariables = buildPromptVariables(issue, {
+      attempt: null
+      // first execution
+    });
+    const renderedPrompt = renderPrompt(workflow.promptTemplate, promptVariables);
+    await this.runHook("before_run", tenant, repositoryDirectory, issue.repository, {
+      projectId: tenant.projectId,
+      workspaceKey,
+      issueSubjectId,
+      issueIdentifier: issue.identifier,
+      workspacePath: issueWorkspacePath,
+      repositoryPath: repositoryDirectory,
+      runId,
+      state: issue.state
+    });
+    mkdirSync(runDir, { recursive: true });
+    const workerLogStream = (this.dependencies.createWriteStreamImpl ?? createWriteStream)(join4(runDir, "worker.log"), {
+      flags: "a"
+    });
+    let workerLogAvailable = true;
+    let workerExited = false;
+    let workerStderrFinalizing = false;
+    let workerLogBackpressured = false;
+    const resumeWorkerStderr = () => {
+      if (!workerLogBackpressured) {
+        return;
+      }
+      workerLogBackpressured = false;
+      child.stderr?.resume?.();
+    };
+    const markWorkerLogUnavailable = (error) => {
+      resumeWorkerStderr();
+      if (!workerLogAvailable) {
+        return;
+      }
+      workerLogAvailable = false;
+      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()], {
+      cwd: process.cwd(),
+      env: this.buildProjectExecutionEnv(tenant.projectId, {
+        GITHUB_GRAPHQL_TOKEN: process.env.GITHUB_GRAPHQL_TOKEN ?? "",
+        CODEX_PROJECT_ID: tenant.projectId,
+        PROJECT_ID: tenant.projectId,
+        WORKING_DIRECTORY: repositoryDirectory,
+        WORKSPACE_RUNTIME_DIR: workspaceRuntimeDir,
+        SYMPHONY_RUN_ID: runId,
+        SYMPHONY_ISSUE_STATE: issue.state,
+        SYMPHONY_ISSUE_ID: issue.id,
+        SYMPHONY_ISSUE_IDENTIFIER: issue.identifier,
+        SYMPHONY_ISSUE_TITLE: issue.title,
+        SYMPHONY_ISSUE_SUBJECT_ID: issueSubjectId,
+        SYMPHONY_ISSUE_WORKSPACE_KEY: workspaceKey,
+        SYMPHONY_TRACKER_ADAPTER: issue.tracker.adapter,
+        SYMPHONY_TRACKER_BINDING_ID: issue.tracker.bindingId,
+        SYMPHONY_TRACKER_ITEM_ID: issue.tracker.itemId,
+        TARGET_REPOSITORY_CLONE_URL: issue.repository.cloneUrl,
+        TARGET_REPOSITORY_OWNER: issue.repository.owner,
+        TARGET_REPOSITORY_NAME: issue.repository.name,
+        TARGET_REPOSITORY_URL: issue.repository.url,
+        ...trackerAdapter.buildWorkerEnvironment(tenant, issue),
+        SYMPHONY_RENDERED_PROMPT: renderedPrompt,
+        SYMPHONY_WORKFLOW_PATH: workflow.workflowPath ?? "",
+        SYMPHONY_AGENT_COMMAND: workflow.workflow.codex.command,
+        SYMPHONY_APPROVAL_POLICY: workflow.workflow.codex.approvalPolicy ?? "",
+        SYMPHONY_THREAD_SANDBOX: workflow.workflow.codex.threadSandbox ?? "",
+        SYMPHONY_TURN_SANDBOX_POLICY: workflow.workflow.codex.turnSandboxPolicy ?? "",
+        SYMPHONY_MAX_TURNS: String(workflow.workflow.agent.maxTurns),
+        SYMPHONY_GLOBAL_MAX_TURNS: process.env.SYMPHONY_GLOBAL_MAX_TURNS ?? "",
+        SYMPHONY_MAX_TOKENS: process.env.SYMPHONY_MAX_TOKENS ?? "",
+        SYMPHONY_MAX_NONPRODUCTIVE_TURNS: process.env.SYMPHONY_MAX_NONPRODUCTIVE_TURNS ?? String(DEFAULT_MAX_NONPRODUCTIVE_TURNS),
+        SYMPHONY_SESSION_TIMEOUT_MS: process.env.SYMPHONY_SESSION_TIMEOUT_MS ?? "",
+        SYMPHONY_RESUME_THREAD_ID: resumeContext?.threadId ?? "",
+        SYMPHONY_CUMULATIVE_TURN_COUNT: String(Math.max(0, resumeContext?.cumulativeTurnCount ?? issueBudgetSnapshot.cumulativeTurnCount)),
+        SYMPHONY_CUMULATIVE_INPUT_TOKENS: String(issueBudgetSnapshot.tokenUsage.inputTokens),
+        SYMPHONY_CUMULATIVE_OUTPUT_TOKENS: String(issueBudgetSnapshot.tokenUsage.outputTokens),
+        SYMPHONY_CUMULATIVE_TOTAL_TOKENS: String(issueBudgetSnapshot.tokenUsage.totalTokens),
+        SYMPHONY_LAST_TURN_SUMMARY: resumeContext?.lastTurnSummary ?? "",
+        SYMPHONY_SESSION_STARTED_AT: issueBudgetSnapshot.sessionStartedAt ?? "",
+        SYMPHONY_READ_TIMEOUT_MS: String(workflow.workflow.codex.readTimeoutMs),
+        SYMPHONY_TURN_TIMEOUT_MS: String(workflow.workflow.codex.turnTimeoutMs)
+      }),
+      detached: true,
+      stdio: ["ignore", "ignore", "pipe"]
+    });
+    const handleWorkerStderrChunk = (chunk) => {
+      const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk), "utf8");
+      if (workerLogAvailable) {
+        try {
+          if (!workerLogStream.write(buffer)) {
+            workerLogBackpressured = true;
+            child.stderr?.pause?.();
+          }
+        } catch (error) {
+          markWorkerLogUnavailable(error);
+        }
+      }
+      this.consumeWorkerStderrChunk(runId, buffer);
+    };
+    const drainWorkerStderr = () => {
+      const stderr = child.stderr;
+      if (!stderr || typeof stderr.read !== "function") {
+        return;
+      }
+      let chunk;
+      while ((chunk = stderr.read()) !== null) {
+        handleWorkerStderrChunk(chunk);
+      }
+    };
+    const completeWorkerStderrFinalization = (code, signal) => {
+      if (workerExited) {
+        return;
+      }
+      workerExited = true;
+      workerStderrFinalizing = false;
+      child.stderr?.removeListener("data", handleWorkerStderrChunk);
+      this.flushWorkerStderrBuffer(runId);
+      workerLogStream.end();
+      if (child.pid) {
+        this.retireWorkerPid(child.pid);
+      }
+      this.logVerbose(`[worker-exited] ${runId} (code=${code ?? "null"}, signal=${signal ?? "null"})`);
+    };
+    const finalizeWorkerStderr = (code, signal) => {
+      if (workerExited || workerStderrFinalizing) {
+        return;
+      }
+      workerStderrFinalizing = true;
+      const stderr = child.stderr;
+      const finish = () => {
+        stderr?.removeListener("end", finish);
+        stderr?.removeListener("close", finish);
+        drainWorkerStderr();
+        completeWorkerStderrFinalization(code, signal);
+      };
+      resumeWorkerStderr();
+      drainWorkerStderr();
+      if (!stderr) {
+        completeWorkerStderrFinalization(code, signal);
+        return;
+      }
+      if (stderr.readableEnded || stderr.readable === false) {
+        finish();
+        return;
+      }
+      stderr.once("end", finish);
+      stderr.once("close", finish);
+    };
+    workerLogStream.on("error", (error) => {
+      markWorkerLogUnavailable(error);
+    });
+    workerLogStream.on("drain", () => {
+      resumeWorkerStderr();
+    });
+    child.stderr?.on("data", handleWorkerStderrChunk);
+    if (child.pid) {
+      this.activeWorkerPids.add(child.pid);
+      this.logVerbose(`[worker-started] ${runId} (pid=${child.pid})`);
+    }
+    child.on?.("error", (error) => {
+      const message = error instanceof Error ? error.message : String(error ?? "unknown");
+      this.writeStderr(`[orchestrator] worker process error for ${runId}: ${message}`);
+      finalizeWorkerStderr(null, null);
+    });
+    child.on?.("close", (code, signal) => {
+      finalizeWorkerStderr(code, signal);
+    });
+    child.unref();
+    return {
+      runId,
+      projectId: tenant.projectId,
+      projectSlug: tenant.slug,
+      issueId: issue.id,
+      issueSubjectId,
+      issueIdentifier: issue.identifier,
+      issueTitle: issue.title,
+      issueState: issue.state,
+      repository: issue.repository,
+      status: "running",
+      attempt: 1,
+      processId: child.pid ?? null,
+      port: null,
+      workingDirectory: repositoryDirectory,
+      issueWorkspaceKey: workspaceKey,
+      workspaceRuntimeDir,
+      workflowPath: workflow.workflowPath,
+      retryKind: null,
+      threadId: null,
+      cumulativeTurnCount: 0,
+      lastTurnSummary: null,
+      createdAt: now.toISOString(),
+      updatedAt: now.toISOString(),
+      startedAt: now.toISOString(),
+      completedAt: null,
+      lastError: null,
+      nextRetryAt: null,
+      runPhase: "preparing_workspace",
+      rateLimits: issue.rateLimits ?? null
+    };
+  }
+  async syncActiveRunIssueStates(tenant, trackerAdapter, activeRuns, now) {
+    const activeIssueIds = [...new Set(activeRuns.map((run) => run.issueId))];
+    if (activeIssueIds.length === 0) {
+      return {
+        runs: activeRuns,
+        issuesByIdentifier: /* @__PURE__ */ new Map()
+      };
+    }
+    const issues = await trackerAdapter.fetchIssueStatesByIds(tenant, activeIssueIds, {
+      fetchImpl: this.dependencies.fetchImpl
+    });
+    const issuesByIdentifier = new Map(issues.map((issue) => [issue.identifier, issue]));
+    const issueStateByIdentifier = new Map(issues.map((issue) => [issue.identifier, issue.state]));
+    const syncedRuns = [];
+    for (const run of activeRuns) {
+      const currentTrackerState = issueStateByIdentifier.get(run.issueIdentifier);
+      if (!currentTrackerState || currentTrackerState === run.issueState) {
+        syncedRuns.push(run);
+        continue;
+      }
+      const updatedRun = {
+        ...run,
+        issueState: currentTrackerState,
+        updatedAt: now.toISOString()
+      };
+      await this.store.saveRun(updatedRun);
+      syncedRuns.push(updatedRun);
+    }
+    return {
+      runs: syncedRuns,
+      issuesByIdentifier
+    };
+  }
+  async reconcileRun(tenant, run, issueRecords) {
+    const now = this.now();
+    if (run.processId && this.isProcessRunning(run.processId)) {
+      const retryPolicy = await this.loadRetryPolicy(tenant, run.repository);
+      const configuredStallTimeoutMs = retryPolicy?.stallTimeoutMs ?? null;
+      const lastActivityAtMs = parseTimestampMs(run.lastEventAt ?? run.startedAt);
+      const startedAtMs = parseTimestampMs(run.startedAt);
+      const elapsedSinceLastActivityMs = lastActivityAtMs === null ? null : now.getTime() - lastActivityAtMs;
+      const runningSinceMs = startedAtMs === null ? null : now.getTime() - startedAtMs;
+      const isStalledByWorkflowTimeout = configuredStallTimeoutMs !== null && configuredStallTimeoutMs > 0 && elapsedSinceLastActivityMs !== null && elapsedSinceLastActivityMs > configuredStallTimeoutMs;
+      const isStalledByFallbackTimeout = runningSinceMs !== null && runningSinceMs > STUCK_WORKER_TIMEOUT_MS;
+      if (isStalledByWorkflowTimeout || isStalledByFallbackTimeout) {
+        const elapsedMs = isStalledByWorkflowTimeout ? elapsedSinceLastActivityMs : runningSinceMs;
+        const timeoutMs = isStalledByWorkflowTimeout ? configuredStallTimeoutMs : STUCK_WORKER_TIMEOUT_MS;
+        const elapsedSeconds = Math.round((elapsedMs ?? 0) / 1e3);
+        const timeoutSeconds = Math.round((timeoutMs ?? 0) / 1e3);
+        if (this.isVerboseLoggingEnabled()) {
+          this.writeStderr(`[stall-detected] ${run.runId} (elapsed=${elapsedSeconds}s > ${timeoutSeconds}s)`);
+        } else {
+          this.writeStderr(`[orchestrator] stuck worker detected for ${run.runId} (elapsed ${elapsedSeconds}s > ${timeoutSeconds}s) \u2014 sending SIGTERM`);
+        }
+        this.sendSignal(run.processId, "SIGTERM");
+      } else {
+        const runningRecord = {
+          ...run,
+          status: "running",
+          updatedAt: now.toISOString()
+        };
+        await this.store.saveRun(runningRecord);
+        issueRecords = upsertIssueOrchestration(issueRecords, {
+          issueId: run.issueId,
+          identifier: run.issueIdentifier,
+          workspaceKey: run.issueWorkspaceKey ?? deriveIssueWorkspaceKey({
+            projectId: tenant.projectId,
+            adapter: tenant.tracker.adapter,
+            issueSubjectId: run.issueSubjectId
+          }, run.issueIdentifier),
+          state: "running",
+          currentRunId: run.runId,
+          retryEntry: null,
+          updatedAt: now.toISOString()
+        });
+        return {
+          issueRecords,
+          recovered: false
+        };
+      }
+    }
+    if (run.processId) {
+      this.retireWorkerPid(run.processId);
+    }
+    const workerInfo = await this.fetchWorkerRunInfo(run);
+    const runWithTokens = {
+      ...run,
+      runtimeSession: buildRuntimeSession(run.runtimeSession, workerInfo.sessionId, workerInfo.threadId, run.status === "running" ? "failed" : run.runtimeSession?.status ?? null, run.runtimeSession?.startedAt ?? run.startedAt ?? now.toISOString(), now.toISOString(), workerInfo.exitClassification),
+      threadId: workerInfo.threadId ?? run.threadId ?? null,
+      cumulativeTurnCount: resolveCumulativeTurnCount(run, workerInfo.turnCount ?? null),
+      tokenUsage: workerInfo.tokenUsage ?? run.tokenUsage,
+      lastEvent: workerInfo.lastEvent ?? run.lastEvent,
+      lastTurnSummary: resolveLastTurnSummary(run.lastTurnSummary, resolveLastTurnSummaryCandidate(workerInfo.lastEvent, workerInfo.lastError)),
+      lastEventAt: workerInfo.lastEventAt ?? run.lastEventAt ?? void 0,
+      lastEventAtSource: workerInfo.lastEventAtSource ?? run.lastEventAtSource ?? void 0,
+      executionPhase: workerInfo.executionPhase ?? run.executionPhase ?? null,
+      runPhase: workerInfo.runPhase ?? run.runPhase ?? null,
+      rateLimits: workerInfo.rateLimits ?? run.rateLimits ?? null
+    };
+    const workerSessionId = workerInfo.sessionId;
+    if (workerInfo.lastError) {
+      await this.store.appendRunEvent(run.runId, {
+        at: now.toISOString(),
+        event: "worker-error",
+        projectId: run.projectId,
+        runId: run.runId,
+        issueIdentifier: run.issueIdentifier,
+        error: workerInfo.lastError,
+        attempt: run.attempt
+      });
+    }
+    if (run.status === "retrying" && run.nextRetryAt) {
+      if (new Date(run.nextRetryAt).getTime() > now.getTime()) {
+        return {
+          issueRecords,
+          recovered: false
+        };
+      }
+      if (await this.resolveRetryRestartAction(tenant, run) === "release") {
+        return this.releaseRetryingRun(runWithTokens, issueRecords, now);
+      }
+      return this.restartRun(tenant, run, issueRecords, now, workerSessionId);
+    }
+    if (workerInfo.exitClassification === "budget-exceeded" || workerInfo.exitClassification === "convergence-detected") {
+      const completedRun = {
+        ...runWithTokens,
+        status: workerInfo.exitClassification === "budget-exceeded" ? "succeeded" : "failed",
+        processId: null,
+        updatedAt: now.toISOString(),
+        completedAt: now.toISOString(),
+        nextRetryAt: null,
+        retryKind: null,
+        lastError: workerInfo.exitClassification === "budget-exceeded" ? null : runWithTokens.lastError,
+        runPhase: runWithTokens.runPhase ?? (workerInfo.exitClassification === "budget-exceeded" ? "succeeded" : "failed")
+      };
+      await this.store.saveRun(completedRun);
+      this.logVerbose(`[run-completed] ${completedRun.runId} status=${completedRun.status}`);
+      return {
+        issueRecords: releaseIssueOrchestration(issueRecords, run.issueId, now),
+        recovered: false
+      };
+    }
+    if (run.issueWorkspaceKey) {
+      const issueWorkspacePath = resolveIssueWorkspaceDirectory(this.store.projectDir(tenant.projectId), run.issueWorkspaceKey);
+      await this.runHook("after_run", tenant, run.workingDirectory, run.repository, {
+        projectId: run.projectId,
+        workspaceKey: run.issueWorkspaceKey,
+        issueSubjectId: run.issueSubjectId,
+        issueIdentifier: run.issueIdentifier,
+        workspacePath: issueWorkspacePath,
+        repositoryPath: run.workingDirectory,
+        runId: run.runId,
+        state: run.issueState
+      });
+    }
+    const retryKind = await this.classifyRetryKind(tenant, run);
+    let nextRetryAt;
+    if (retryKind === "continuation") {
+      nextRetryAt = new Date(now.getTime() + CONTINUATION_RETRY_DELAY_MS).toISOString();
+    } else {
+      const retryOptions = await this.loadRetryPolicy(tenant, run.repository);
+      const backoffMs = this.dependencies.retryBackoffMs ?? DEFAULT_RETRY_BACKOFF_MS;
+      nextRetryAt = (retryOptions ? scheduleRetryAt(now, run.attempt + 1, retryOptions) : new Date(now.getTime() + backoffMs)).toISOString();
+    }
+    const retryRecord = {
+      ...runWithTokens,
+      status: "retrying",
+      attempt: runWithTokens.attempt + 1,
+      processId: null,
+      updatedAt: now.toISOString(),
+      nextRetryAt,
+      retryKind,
+      threadId: runWithTokens.threadId ?? runWithTokens.runtimeSession?.threadId ?? run.threadId ?? run.runtimeSession?.threadId ?? null,
+      cumulativeTurnCount: runWithTokens.cumulativeTurnCount ?? run.cumulativeTurnCount ?? 0,
+      lastTurnSummary: runWithTokens.lastTurnSummary ?? run.lastTurnSummary ?? null,
+      runPhase: runWithTokens.runPhase ?? "failed",
+      lastError: retryKind === "continuation" ? null : "Worker process exited unexpectedly."
+    };
+    await this.store.saveRun(retryRecord);
+    this.logVerbose(`[retry-scheduled] ${retryRecord.runId} kind=${retryKind} attempt=${retryRecord.attempt} nextAt=${nextRetryAt}`);
+    this.logVerbose(`[run-completed] ${retryRecord.runId} status=${retryRecord.status}`);
+    issueRecords = upsertIssueOrchestration(issueRecords, {
+      issueId: run.issueId,
+      identifier: run.issueIdentifier,
+      workspaceKey: run.issueWorkspaceKey ?? deriveIssueWorkspaceKey({
+        projectId: tenant.projectId,
+        adapter: tenant.tracker.adapter,
+        issueSubjectId: run.issueSubjectId
+      }, run.issueIdentifier),
+      state: "retry_queued",
+      completedOnce: retryKind === "continuation" ? true : void 0,
+      currentRunId: run.runId,
+      retryEntry: {
+        attempt: retryRecord.attempt,
+        dueAt: nextRetryAt,
+        error: retryRecord.lastError
+      },
+      updatedAt: now.toISOString()
+    });
+    return {
+      issueRecords,
+      recovered: false
+    };
+  }
+  now() {
+    return this.dependencies.now?.() ?? /* @__PURE__ */ new Date();
+  }
+  isVerboseLoggingEnabled() {
+    return this.dependencies.logLevel === "verbose";
+  }
+  writeStderr(message) {
+    (this.dependencies.stderr ?? process.stderr).write(`${message}
+`);
+  }
+  consumeWorkerStderrChunk(runId, chunk) {
+    let decoder = this.workerStderrDecoders.get(runId);
+    if (!decoder) {
+      decoder = new StringDecoder("utf8");
+      this.workerStderrDecoders.set(runId, decoder);
+    }
+    const nextBuffer = (this.workerStderrBuffers.get(runId) ?? "") + decoder.write(chunk);
+    const lines = nextBuffer.split("\n");
+    this.workerStderrBuffers.set(runId, lines.pop() ?? "");
+    for (const line of lines) {
+      this.consumeWorkerStderrLine(runId, line);
+    }
+  }
+  flushWorkerStderrBuffer(runId) {
+    const decoder = this.workerStderrDecoders.get(runId);
+    const remainder = (this.workerStderrBuffers.get(runId) ?? "") + (decoder?.end() ?? "");
+    this.workerStderrBuffers.delete(runId);
+    this.workerStderrDecoders.delete(runId);
+    if (remainder && remainder.trim()) {
+      this.consumeWorkerStderrLine(runId, remainder);
+    }
+  }
+  consumeWorkerStderrLine(runId, line) {
+    const trimmed = line.trim();
+    if (!trimmed || !trimmed.startsWith("{")) {
+      return;
+    }
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (!isOrchestratorChannelEvent(parsed)) {
+        return;
+      }
+      void this.runSerialized(() => this.applyWorkerChannelEvent(runId, parsed)).catch((error) => {
+        const message = error instanceof Error ? error.message : String(error ?? "unknown");
+        this.writeStderr(`[orchestrator] failed to apply worker channel event for ${runId}: ${message}`);
+      });
+    } catch {
+    }
+  }
+  async applyWorkerChannelEvent(runId, event) {
+    const run = await this.store.loadRun(runId, this.projectConfig.projectId);
+    if (!run || !canApplyWorkerChannelUpdate(run.status) || run.issueId !== event.issueId) {
+      return;
+    }
+    if (event.type === "heartbeat") {
+      const nowIso2 = this.now().toISOString();
+      const persistedLastEventAt = event.lastEventAt ?? run.lastEventAt ?? null;
+      await this.store.saveRun({
+        ...run,
+        updatedAt: nowIso2,
+        lastEvent: "heartbeat",
+        lastTurnSummary: resolveLastTurnSummary(run.lastTurnSummary, event.lastError),
+        lastEventAt: persistedLastEventAt,
+        lastEventAtSource: event.lastEventAt != null ? "event-channel" : run.lastEventAtSource ?? null,
+        tokenUsage: event.tokenUsage,
+        rateLimits: event.rateLimits,
+        runtimeSession: buildRuntimeSession(run.runtimeSession, resolveChannelSessionId(event.sessionInfo), event.sessionInfo?.threadId ?? null, "active", run.startedAt ?? run.runtimeSession?.startedAt ?? nowIso2, nowIso2, event.sessionInfo?.exitClassification ?? null),
+        threadId: event.sessionInfo?.threadId ?? run.threadId ?? run.runtimeSession?.threadId ?? null,
+        turnCount: event.sessionInfo && event.sessionInfo.turnCount != null ? event.sessionInfo.turnCount : run.turnCount,
+        cumulativeTurnCount: resolveCumulativeTurnCount(run, event.sessionInfo?.turnCount ?? null),
+        executionPhase: event.executionPhase ?? run.executionPhase,
+        runPhase: event.runPhase ?? run.runPhase,
+        lastError: event.lastError
+      });
+      return;
+    }
+    if (event.type === "turn_started") {
+      await this.store.appendRunEvent(runId, {
+        at: event.startedAt,
+        event: "turn_started",
+        projectId: run.projectId,
+        issueIdentifier: run.issueIdentifier,
+        issueId: run.issueId,
+        sessionId: event.sessionId,
+        threadId: event.threadId,
+        turnId: event.turnId,
+        turnCount: event.turnCount
+      });
+      return;
+    }
+    if (event.type === "turn_completed") {
+      await this.store.appendRunEvent(runId, {
+        at: event.completedAt,
+        event: "turn_completed",
+        projectId: run.projectId,
+        issueIdentifier: run.issueIdentifier,
+        issueId: run.issueId,
+        sessionId: event.sessionId,
+        threadId: event.threadId,
+        turnId: event.turnId,
+        turnCount: event.turnCount,
+        startedAt: event.startedAt,
+        durationMs: event.durationMs,
+        tokenUsage: event.tokenUsage
+      });
+      return;
+    }
+    if (event.type === "turn_failed") {
+      await this.store.appendRunEvent(runId, {
+        at: event.failedAt,
+        event: "turn_failed",
+        projectId: run.projectId,
+        issueIdentifier: run.issueIdentifier,
+        issueId: run.issueId,
+        sessionId: event.sessionId,
+        threadId: event.threadId,
+        turnId: event.turnId,
+        turnCount: event.turnCount,
+        startedAt: event.startedAt,
+        durationMs: event.durationMs,
+        tokenUsage: event.tokenUsage,
+        error: event.error
+      });
+      return;
+    }
+    const nowIso = this.now().toISOString();
+    await this.store.saveRun({
+      ...run,
+      updatedAt: nowIso,
+      lastEvent: event.event ?? run.lastEvent ?? null,
+      lastTurnSummary: resolveLastTurnSummary(run.lastTurnSummary, resolveLastTurnSummaryCandidate(event.event, event.lastError)),
+      lastEventAt: event.lastEventAt,
+      lastEventAtSource: "event-channel",
+      tokenUsage: event.tokenUsage ?? run.tokenUsage,
+      rateLimits: event.rateLimits ?? run.rateLimits ?? null,
+      runtimeSession: buildRuntimeSession(run.runtimeSession, resolveChannelSessionId(event.sessionInfo), event.sessionInfo?.threadId ?? run.runtimeSession?.threadId ?? null, "active", run.startedAt ?? run.runtimeSession?.startedAt ?? nowIso, nowIso, event.sessionInfo?.exitClassification ?? null),
+      threadId: event.sessionInfo?.threadId ?? run.threadId ?? run.runtimeSession?.threadId ?? null,
+      turnCount: event.sessionInfo && event.sessionInfo.turnCount != null ? event.sessionInfo.turnCount : run.turnCount,
+      cumulativeTurnCount: resolveCumulativeTurnCount(run, event.sessionInfo?.turnCount ?? null),
+      executionPhase: event.executionPhase ?? run.executionPhase ?? null,
+      runPhase: event.runPhase ?? run.runPhase ?? null,
+      lastError: event.lastError ?? run.lastError
+    });
+  }
+  logVerbose(message) {
+    if (!this.isVerboseLoggingEnabled()) {
+      return;
+    }
+    this.writeStderr(message);
+  }
+  async waitForNextPoll() {
+    if (this.consumePendingReconcileRequest()) {
+      return;
+    }
+    const customWait = this.dependencies.waitImpl;
+    const pollIntervalMs = this.getEffectivePollIntervalMs();
+    const waitPromise = this.createPendingSleepPromise();
+    try {
+      if (customWait) {
+        await Promise.race([customWait(pollIntervalMs), waitPromise]);
+      } else {
+        this.sleepTimer = setTimeout(() => {
+          this.sleepResolver?.();
+        }, pollIntervalMs);
+        await waitPromise;
+      }
+    } finally {
+      this.cancelPendingSleep();
+    }
+    this.consumePendingReconcileRequest();
+  }
+  cancelPendingSleep() {
+    if (this.sleepTimer) {
+      clearTimeout(this.sleepTimer);
+      this.sleepTimer = null;
+    }
+    this.sleepResolver?.();
+    this.sleepResolver = null;
+  }
+  createPendingSleepPromise() {
+    return new Promise((resolve6) => {
+      this.sleepResolver = () => {
+        this.sleepResolver = null;
+        this.sleepTimer = null;
+        resolve6();
+      };
+    });
+  }
+  consumePendingReconcileRequest() {
+    if (!this.reconcileRequested) {
+      return false;
+    }
+    this.reconcileRequested = false;
+    return true;
+  }
+  /**
+   * Classify whether a process exit should be treated as continuation retry
+   * or failure retry. Continuation applies when the issue is still actionable
+   * — the worker completed its session and the issue hasn't transitioned away.
+   * Failure applies when we cannot confirm the issue is still actionable.
+   */
+  async classifyRetryKind(tenant, run) {
+    try {
+      const trackerAdapter = resolveTrackerAdapter2(tenant.tracker);
+      const issues = await trackerAdapter.listIssues(tenant, {
+        fetchImpl: this.dependencies.fetchImpl
+      });
+      const runIssue = issues.find((issue) => issue.identifier === run.issueIdentifier);
+      if (!runIssue) {
+        return "failure";
+      }
+      const resolution = await this.loadProjectWorkflow(tenant, run.repository);
+      if (!isUsableWorkflowResolution(resolution)) {
+        return "failure";
+      }
+      return isStateActive(runIssue.state, resolution.lifecycle) ? "continuation" : "failure";
+    } catch {
+      return "failure";
+    }
+  }
+  async resolveRetryRestartAction(tenant, run) {
+    try {
+      if (isIssueBudgetExceeded(resolveIssueBudgetSnapshot((await this.store.loadAllRuns()).filter((candidate) => candidate.projectId === tenant.projectId), run.issueId), this.now())) {
+        return "release";
+      }
+      const runIssue = await this.fetchTrackedIssueById(tenant, run.issueId);
+      if (!runIssue) {
+        return "release";
+      }
+      const resolution = await this.loadProjectWorkflow(tenant, run.repository);
+      if (!isUsableWorkflowResolution(resolution)) {
+        return "restart";
+      }
+      return isStateActive(runIssue.state, resolution.lifecycle) ? "restart" : "release";
+    } catch {
+      return "restart";
+    }
+  }
+  async fetchTrackedIssueById(tenant, issueId) {
+    const trackerAdapter = resolveTrackerAdapter2(tenant.tracker);
+    const issues = await trackerAdapter.fetchIssueStatesByIds(tenant, [issueId], {
+      fetchImpl: this.dependencies.fetchImpl
+    });
+    return issues[0] ?? null;
+  }
+  async fetchWorkerRunInfo(run) {
+    const latestRun = await this.store.loadRun(run.runId, run.projectId) ?? run;
+    const persistedTokenUsage = await this.readPersistedWorkerTokenUsage(latestRun);
+    return {
+      tokenUsage: persistedTokenUsage,
+      sessionId: latestRun.runtimeSession?.sessionId ?? null,
+      threadId: latestRun.threadId ?? latestRun.runtimeSession?.threadId ?? null,
+      turnCount: latestRun.turnCount ?? null,
+      exitClassification: latestRun.runtimeSession?.exitClassification ?? null,
+      lastError: latestRun.lastError ?? null,
+      lastEvent: latestRun.lastEvent ?? null,
+      lastEventAt: latestRun.lastEventAt ?? null,
+      lastEventAtSource: latestRun.lastEventAtSource ?? null,
+      executionPhase: latestRun.executionPhase ?? null,
+      runPhase: latestRun.runPhase ?? null,
+      rateLimits: latestRun.rateLimits ?? null
+    };
+  }
+  async readPersistedWorkerTokenUsage(run) {
+    const artifactPaths = [
+      join4(run.workspaceRuntimeDir, "token-usage.json"),
+      join4(run.workspaceRuntimeDir, ".orchestrator", "runs", run.runId, "token-usage.json")
+    ];
+    for (const artifactPath of artifactPaths) {
+      try {
+        const raw = await readFile5(artifactPath, "utf8");
+        const tokenUsage = JSON.parse(raw);
+        if (hasTokenUsage(tokenUsage)) {
+          return tokenUsage;
+        }
+      } catch {
+        continue;
+      }
+    }
+    return null;
+  }
+  /**
+   * Execute a workspace lifecycle hook using the workflow configuration
+   * loaded from the repository. Returns the hook result or null if the
+   * workflow could not be loaded.
+   */
+  async runHook(kind, tenant, repositoryDirectory, repository, context, resolution) {
+    try {
+      const workflowResolution = resolution ?? await this.loadProjectWorkflow(tenant, repository);
+      if (!isUsableWorkflowResolution(workflowResolution)) {
+        return null;
+      }
+      const hookEnv = this.buildProjectExecutionEnv(tenant.projectId, buildHookEnv(context));
+      return executeWorkspaceHook({
+        kind,
+        hooks: workflowResolution.workflow.hooks,
+        repositoryPath: repositoryDirectory,
+        env: hookEnv,
+        timeoutMs: workflowResolution.workflow.hooks.timeoutMs
+      });
+    } catch {
+      return null;
+    }
+  }
+  readProjectEnv(projectId) {
+    const envPath = join4(this.store.projectDir(projectId), ".env");
+    try {
+      return readEnvFile(envPath);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error occurred.";
+      (this.dependencies.stderr ?? process.stderr).write(`[warn] Failed to load project env for ${projectId} from ${envPath}: ${message}
+`);
+      return {};
+    }
+  }
+  buildProjectExecutionEnv(projectId, env) {
+    const inheritedEnv = Object.fromEntries(Object.entries(process.env).filter((entry) => typeof entry[1] === "string"));
+    const explicitEnv = Object.fromEntries(Object.entries(env).filter((entry) => typeof entry[1] === "string"));
+    return {
+      ...this.readProjectEnv(projectId),
+      ...inheritedEnv,
+      ...explicitEnv
+    };
+  }
+  async restartRun(tenant, run, issueRecords, now, sessionId) {
+    const supersededRecord = {
+      ...run,
+      status: "failed",
+      completedAt: now.toISOString(),
+      updatedAt: now.toISOString(),
+      lastError: "Superseded by recovered run."
+    };
+    await this.store.saveRun(supersededRecord);
+    const issue = resolveTrackerAdapter2(tenant.tracker).reviveIssue(tenant, run);
+    const restarted = await this.startRun(tenant, issue, {
+      threadId: run.threadId ?? run.runtimeSession?.threadId ?? null,
+      cumulativeTurnCount: resolvePersistedCumulativeTurnCount(run),
+      lastTurnSummary: run.lastTurnSummary ?? null
+    });
+    const recoveredRecord = {
+      ...restarted,
+      attempt: run.attempt,
+      retryKind: run.retryKind ?? "recovery",
+      createdAt: run.createdAt,
+      issueWorkspaceKey: run.issueWorkspaceKey,
+      threadId: run.threadId ?? run.runtimeSession?.threadId ?? null,
+      cumulativeTurnCount: resolvePersistedCumulativeTurnCount(run),
+      lastTurnSummary: run.lastTurnSummary ?? null,
+      turnCount: 0
+    };
+    await this.store.saveRun(recoveredRecord);
+    await this.store.appendRunEvent(run.runId, {
+      at: now.toISOString(),
+      event: "run-recovered",
+      projectId: run.projectId,
+      issueIdentifier: run.issueIdentifier,
+      issueId: run.issueId,
+      sessionId: sessionId ?? void 0
+    });
+    return {
+      issueRecords: upsertIssueOrchestration(issueRecords, {
+        issueId: recoveredRecord.issueId,
+        identifier: recoveredRecord.issueIdentifier,
+        workspaceKey: recoveredRecord.issueWorkspaceKey ?? deriveIssueWorkspaceKey({
+          projectId: tenant.projectId,
+          adapter: tenant.tracker.adapter,
+          issueSubjectId: recoveredRecord.issueSubjectId
+        }, recoveredRecord.issueIdentifier),
+        state: "running",
+        currentRunId: recoveredRecord.runId,
+        retryEntry: null,
+        updatedAt: now.toISOString()
+      }),
+      recovered: true
+    };
+  }
+  async releaseRetryingRun(run, issueRecords, now) {
+    const suppressedRun = {
+      ...run,
+      status: "suppressed",
+      processId: null,
+      completedAt: now.toISOString(),
+      updatedAt: now.toISOString(),
+      nextRetryAt: null,
+      runPhase: "canceled_by_reconciliation",
+      lastError: "Retry canceled because the tracker issue is no longer actionable."
+    };
+    await this.store.saveRun(suppressedRun);
+    this.logVerbose(`[run-completed] ${suppressedRun.runId} status=${suppressedRun.status}`);
+    return {
+      issueRecords: releaseIssueOrchestration(issueRecords, run.issueId, now),
+      recovered: false
+    };
+  }
+  async loadProjectPollInterval(tenant) {
+    const intervals = await Promise.all(tenant.repositories.map(async (repository) => {
+      const resolution = await this.loadProjectWorkflow(tenant, repository);
+      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;
+  }
+  async loadProjectMaxConcurrentByState(tenant) {
+    const result = {};
+    const resolutions = await Promise.all(tenant.repositories.map(async (repository) => {
+      try {
+        return await this.loadProjectWorkflow(tenant, repository);
+      } catch {
+        return null;
+      }
+    }));
+    for (const resolution of resolutions) {
+      if (!resolution)
+        continue;
+      if (!isUsableWorkflowResolution(resolution))
+        continue;
+      const stateLimits = resolution.workflow.agent.maxConcurrentAgentsByState;
+      for (const [state, limit] of Object.entries(stateLimits)) {
+        const existing = result[state];
+        const numLimit = typeof limit === "number" ? limit : Number(limit);
+        result[state] = existing === void 0 ? numLimit : Math.min(existing, numLimit);
+      }
+    }
+    return result;
+  }
+  async loadRetryPolicy(tenant, repository) {
+    try {
+      const resolution = await this.loadProjectWorkflow(tenant, repository);
+      if (!isUsableWorkflowResolution(resolution)) {
+        return null;
+      }
+      return {
+        baseDelayMs: this.dependencies.retryBackoffMs ?? resolution.workflow.agent.retryBaseDelayMs,
+        maxDelayMs: this.dependencies.retryBackoffMs ?? resolution.workflow.agent.maxRetryBackoffMs,
+        stallTimeoutMs: resolution.workflow.codex.stallTimeoutMs
+      };
+    } catch {
+      if (!this.dependencies.retryBackoffMs) {
+        return null;
+      }
+      return {
+        baseDelayMs: this.dependencies.retryBackoffMs,
+        maxDelayMs: this.dependencies.retryBackoffMs,
+        stallTimeoutMs: null
+      };
+    }
+  }
+  async getProjectConcurrency(project) {
+    if (this.dependencies.concurrency !== void 0) {
+      return this.dependencies.concurrency;
+    }
+    const limits = await Promise.all(project.repositories.map(async (repository) => {
+      try {
+        const resolution = await this.loadProjectWorkflow(project, repository);
+        return isUsableWorkflowResolution(resolution) ? resolution.workflow.agent.maxConcurrentAgents : NaN;
+      } catch {
+        return NaN;
+      }
+    }));
+    const validLimits = limits.filter((value) => Number.isFinite(value) && value >= 0);
+    return validLimits.length ? Math.min(...validLimits) : DEFAULT_CONCURRENCY;
+  }
+  async resolveWorkflowResolution(repository, cacheRoot, resolution, changed) {
+    const cacheKey = this.workflowCacheKey(repository);
+    if (resolution.isValid) {
+      const effectiveResolution = {
+        ...resolution,
+        isValid: true,
+        usedLastKnownGood: false,
+        validationError: null
+      };
+      let workflowPath = effectiveResolution.workflowPath;
+      try {
+        workflowPath = await this.persistLastKnownGoodWorkflow(cacheRoot, effectiveResolution) ?? effectiveResolution.workflowPath;
+      } catch {
+        workflowPath = effectiveResolution.workflowPath;
+      }
+      this.lastKnownGoodWorkflows.set(cacheKey, {
+        ...effectiveResolution,
+        workflowPath
+      });
+      this.lastReportedWorkflowErrors.delete(cacheKey);
+      return effectiveResolution;
+    }
+    const cached = this.lastKnownGoodWorkflows.get(cacheKey);
+    const message = resolution.validationError ?? "Invalid repository WORKFLOW.md";
+    const previousMessage = this.lastReportedWorkflowErrors.get(cacheKey);
+    if (changed || previousMessage !== message) {
+      process.stderr.write(`[orchestrator] failed to reload WORKFLOW.md for ${repository.owner}/${repository.name}: ${message}
+`);
+      this.lastReportedWorkflowErrors.set(cacheKey, message);
+    }
+    if (!cached) {
+      return resolution;
+    }
+    return {
+      ...cached,
+      workflowPath: cached.workflowPath,
+      isValid: false,
+      usedLastKnownGood: true,
+      validationError: message
+    };
+  }
+  async persistLastKnownGoodWorkflow(cacheRoot, resolution) {
+    if (!resolution.workflowPath) {
+      return null;
+    }
+    const snapshotPath = this.lastKnownGoodWorkflowPath(cacheRoot);
+    const markdown = await readFile5(resolution.workflowPath, "utf8");
+    await mkdir3(join4(cacheRoot, "last-known-good"), { recursive: true });
+    await writeFile3(snapshotPath, markdown, "utf8");
+    return snapshotPath;
+  }
+  lastKnownGoodWorkflowPath(cacheRoot) {
+    return join4(cacheRoot, "last-known-good", "WORKFLOW.md");
+  }
+  workflowCacheKey(repository) {
+    return `${repository.owner}/${repository.name}:${this.normalizeRepositoryCloneUrl(repository.cloneUrl)}`;
+  }
+  normalizeRepositoryCloneUrl(cloneUrl) {
+    if (cloneUrl.startsWith("file://")) {
+      try {
+        return fileURLToPath(cloneUrl);
+      } catch {
+        return cloneUrl;
+      }
+    }
+    return cloneUrl;
+  }
+  isProcessRunning(processId) {
+    if (this.dependencies.isProcessRunning) {
+      return this.dependencies.isProcessRunning(processId);
+    }
+    try {
+      process.kill(-processId, 0);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  sendSignal(processId, signal) {
+    try {
+      const kill = this.dependencies.killImpl;
+      if (kill) {
+        kill(processId, signal);
+      } else {
+        process.kill(-processId, signal);
+      }
+    } catch {
+      this.retireWorkerPid(processId);
+    }
+  }
+  pruneExitedWorkerPids() {
+    for (const pid of [...this.activeWorkerPids]) {
+      if (!this.isProcessRunning(pid)) {
+        this.retireWorkerPid(pid);
+      }
+    }
+  }
+  retireWorkerPid(processId) {
+    if (processId) {
+      this.activeWorkerPids.delete(processId);
+    }
+  }
+  /**
+   * Clean up the issue workspace for a terminal issue.
+   *
+   * Runs the `before_remove` hook if configured. Hook failures are logged and
+   * ignored so workspace cleanup still proceeds per spec 9.4. The workspace
+   * directory is removed and the record set to `removed`. Orchestration
+   * records (runs) are preserved.
+   */
+  async cleanupTerminalIssueWorkspace(tenant, issue, now, workflowResolution) {
+    const issueSubjectId = issue.id;
+    const identity = {
+      projectId: tenant.projectId,
+      adapter: issue.tracker.adapter,
+      issueSubjectId
+    };
+    const preferredWorkspaceKey = deriveIssueWorkspaceKey(identity, issue.identifier);
+    const legacyWorkspaceKey = deriveLegacyIssueWorkspaceKey(identity);
+    const orchestrationRecord = (await this.store.loadProjectIssueOrchestrations(tenant.projectId)).find((record) => record.issueId === issue.id);
+    const workspaceRecord = (orchestrationRecord ? await this.store.loadIssueWorkspace(tenant.projectId, orchestrationRecord.workspaceKey) : null) ?? await this.store.loadIssueWorkspace(tenant.projectId, preferredWorkspaceKey) ?? (legacyWorkspaceKey === preferredWorkspaceKey ? null : await this.store.loadIssueWorkspace(tenant.projectId, legacyWorkspaceKey));
+    if (!workspaceRecord || workspaceRecord.status === "removed") {
+      return;
+    }
+    const pendingRecord = {
+      ...workspaceRecord,
+      status: "cleanup_pending",
+      updatedAt: now.toISOString()
+    };
+    await this.store.saveIssueWorkspace(pendingRecord);
+    const hookResult = await this.runHook("before_remove", tenant, workspaceRecord.repositoryPath, issue.repository, {
+      projectId: tenant.projectId,
+      workspaceKey: workspaceRecord.workspaceKey,
+      issueSubjectId,
+      issueIdentifier: issue.identifier,
+      workspacePath: workspaceRecord.workspacePath,
+      repositoryPath: workspaceRecord.repositoryPath
+    }, workflowResolution);
+    if (hookResult && hookResult.outcome !== "success" && hookResult.outcome !== "skipped") {
+      const errorMessage = hookResult.error ?? `before_remove hook ${hookResult.outcome}`;
+      console.warn(`[orchestrator] before_remove hook failed for ${issue.identifier}; continuing cleanup: ${errorMessage}`);
+    }
+    try {
+      await rm3(workspaceRecord.workspacePath, { recursive: true, force: true });
+    } catch {
+    }
+    const removedRecord = {
+      ...workspaceRecord,
+      status: "removed",
+      updatedAt: now.toISOString(),
+      lastError: null
+    };
+    await this.store.saveIssueWorkspace(removedRecord);
+  }
+};
+function hasTokenUsage(tokenUsage) {
+  return Boolean(tokenUsage && (tokenUsage.inputTokens > 0 || tokenUsage.outputTokens > 0 || tokenUsage.totalTokens > 0));
+}
+function isRecord2(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)) {
+      continue;
+    }
+    const timestamp = parseTimestampMs(run.lastEventAt ?? run.updatedAt ?? run.startedAt);
+    const sortableTimestamp = timestamp ?? -Infinity;
+    if (sortableTimestamp >= latestRunTimestamp) {
+      latestRunTimestamp = sortableTimestamp;
+      latestRunRateLimits = run.rateLimits;
+    }
+  }
+  if (latestRunRateLimits) {
+    return latestRunRateLimits;
+  }
+  for (const issue of issues) {
+    if (isRecord2(issue.rateLimits)) {
+      return issue.rateLimits;
+    }
+  }
+  return null;
+}
+function buildRuntimeSession(existing, sessionId, threadId, status, startedAt, updatedAt, exitClassification = void 0) {
+  if (existing === void 0 && sessionId === null && threadId === null && status === null && (exitClassification === void 0 || exitClassification === null)) {
+    return void 0;
+  }
+  return {
+    sessionId: sessionId ?? existing?.sessionId ?? null,
+    threadId: threadId ?? existing?.threadId ?? null,
+    status: status ?? existing?.status ?? null,
+    startedAt: existing?.startedAt ?? startedAt,
+    updatedAt,
+    exitClassification: exitClassification === void 0 ? existing?.exitClassification ?? null : exitClassification
+  };
+}
+function resolvePersistedCumulativeTurnCount(run) {
+  return run.cumulativeTurnCount ?? run.turnCount ?? 0;
+}
+function hasConvergenceLockedRun(runs, issueId, issueState) {
+  const latestRun = runs.filter((run) => run.issueId === issueId).sort((left, right) => new Date(right.updatedAt).getTime() - new Date(left.updatedAt).getTime())[0];
+  return latestRun?.runtimeSession?.exitClassification === "convergence-detected" && latestRun.issueState === issueState;
+}
+function resolveIssueBudgetSnapshot(runs, issueId) {
+  const issueRuns = runs.filter((run) => run.issueId === issueId);
+  const startedAtCandidates = issueRuns.map((run) => run.startedAt).filter((value) => typeof value === "string");
+  return {
+    cumulativeTurnCount: issueRuns.reduce((total, run) => total + resolvePersistedCumulativeTurnCount(run), 0),
+    tokenUsage: issueRuns.reduce((total, run) => ({
+      inputTokens: total.inputTokens + (run.tokenUsage?.inputTokens ?? 0),
+      outputTokens: total.outputTokens + (run.tokenUsage?.outputTokens ?? 0),
+      totalTokens: total.totalTokens + (run.tokenUsage?.totalTokens ?? 0)
+    }), {
+      inputTokens: 0,
+      outputTokens: 0,
+      totalTokens: 0
+    }),
+    sessionStartedAt: startedAtCandidates.sort((left, right) => left.localeCompare(right))[0] ?? null
+  };
+}
+function isIssueBudgetExceeded(snapshot, now, env = process.env) {
+  const globalMaxTurns = parsePositiveInteger(env.SYMPHONY_GLOBAL_MAX_TURNS ?? "");
+  if (globalMaxTurns !== null && snapshot.cumulativeTurnCount >= globalMaxTurns) {
+    return true;
+  }
+  const maxTokens = parsePositiveInteger(env.SYMPHONY_MAX_TOKENS ?? "");
+  if (maxTokens !== null && snapshot.tokenUsage.totalTokens >= maxTokens) {
+    return true;
+  }
+  const sessionTimeoutMs = parsePositiveInteger(env.SYMPHONY_SESSION_TIMEOUT_MS ?? "");
+  if (sessionTimeoutMs === null || snapshot.sessionStartedAt === null) {
+    return false;
+  }
+  return now.getTime() - new Date(snapshot.sessionStartedAt).getTime() >= sessionTimeoutMs;
+}
+function parsePositiveInteger(value) {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    return null;
+  }
+  return Math.floor(parsed);
+}
+function resolveCumulativeTurnCount(run, turnCount) {
+  const carriedTotal = resolvePersistedCumulativeTurnCount(run);
+  if (turnCount === null) {
+    return carriedTotal;
+  }
+  const previousSessionTurnCount = run.turnCount ?? 0;
+  const baseTurnCount = Math.max(0, carriedTotal - previousSessionTurnCount);
+  return baseTurnCount + turnCount;
+}
+function isTerminalTurnEvent(event) {
+  return event === "turn/completed" || event === "turn/failed" || event === "turn/cancelled";
+}
+function resolveLastTurnSummaryCandidate(event, lastError) {
+  if (typeof lastError === "string" && lastError.trim()) {
+    return lastError.trim();
+  }
+  return typeof event === "string" && isTerminalTurnEvent(event) ? event : null;
+}
+function resolveLastTurnSummary(existing, candidate) {
+  if (typeof candidate === "string" && candidate.trim()) {
+    return candidate.trim();
+  }
+  return existing ?? null;
+}
+function canApplyWorkerChannelUpdate(status) {
+  return status === "running" || status === "retrying";
+}
+function resolveChannelSessionId(sessionInfo) {
+  if (!sessionInfo) {
+    return null;
+  }
+  return sessionInfo.sessionId ?? (sessionInfo.threadId && sessionInfo.turnId ? `${sessionInfo.threadId}-${sessionInfo.turnId}` : null);
+}
+function resolveWorkerCommand() {
+  if (process.env.SYMPHONY_WORKER_COMMAND) {
+    return process.env.SYMPHONY_WORKER_COMMAND;
+  }
+  try {
+    const workerUrl = import.meta.resolve("@gh-symphony/worker");
+    return `node ${fileURLToPath(workerUrl)}`;
+  } catch {
+    return DEFAULT_WORKER_COMMAND;
+  }
+}
+function createStore(runtimeRoot = ".runtime", options = {}) {
+  return new OrchestratorFsStore(runtimeRoot, options);
+}
+function sortCandidatesForDispatch(candidates) {
+  return [...candidates].sort((a, b) => {
+    if (a.priority !== b.priority) {
+      if (a.priority === null)
+        return 1;
+      if (b.priority === null)
+        return -1;
+      return a.priority - b.priority;
+    }
+    if (a.createdAt !== b.createdAt) {
+      if (a.createdAt === null)
+        return 1;
+      if (b.createdAt === null)
+        return -1;
+      return a.createdAt < b.createdAt ? -1 : 1;
+    }
+    return a.identifier.localeCompare(b.identifier);
+  });
+}
+function createProjectItemsCache() {
+  const entries = /* @__PURE__ */ new Map();
+  return {
+    getOrLoad(key, load) {
+      const cached = entries.get(key);
+      if (cached) {
+        return cached;
+      }
+      const pending = load().catch((error) => {
+        entries.delete(key);
+        throw error;
+      });
+      entries.set(key, pending);
+      return pending;
+    }
+  };
+}
+function wait2(ms) {
+  return new Promise((resolve6) => setTimeout(resolve6, ms));
+}
+function createRunId(now, projectId, issueIdentifier) {
+  return [
+    projectId,
+    issueIdentifier.replace(/[^a-zA-Z0-9]+/g, "-"),
+    now.getTime().toString(36)
+  ].join("-");
+}
+function isIssueOrchestrationClaimed(state) {
+  return state === "claimed" || state === "running" || state === "retry_queued";
+}
+function upsertIssueOrchestration(issueRecords, nextRecord) {
+  const existingRecord = issueRecords.find((record) => record.issueId === nextRecord.issueId) ?? null;
+  const remaining = issueRecords.filter((record) => record.issueId !== nextRecord.issueId);
+  return [
+    ...remaining,
+    {
+      ...nextRecord,
+      completedOnce: nextRecord.completedOnce ?? existingRecord?.completedOnce ?? false
+    }
+  ];
+}
+function releaseIssueOrchestration(issueRecords, issueId, now) {
+  return issueRecords.map((record) => record.issueId === issueId ? {
+    ...record,
+    state: "released",
+    currentRunId: null,
+    retryEntry: null,
+    updatedAt: now.toISOString()
+  } : record);
+}
+function isActiveRunStatus(status) {
+  return status === "pending" || status === "starting" || status === "running" || status === "retrying";
+}
+
+// ../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 { setTimeout as delay } from "timers/promises";
+var LOCK_READ_RETRY_DELAY_MS = 10;
+var LOCK_READ_RETRY_LIMIT = 20;
+async function acquireProjectLock(input) {
+  assertValidProjectId(input.projectId);
+  const pid = input.pid ?? process.pid;
+  const startedAt = (input.now ?? /* @__PURE__ */ new Date()).toISOString();
+  const ownerToken = `${pid}:${randomUUID2()}`;
+  const lockPath = resolveProjectLockPath(input.runtimeRoot, input.projectId);
+  const record = { ownerToken, pid, startedAt };
+  let invalidReadAttempts = 0;
+  for (; ; ) {
+    try {
+      await mkdir4(dirname2(lockPath), { recursive: true });
+      const handle = await open2(lockPath, "wx");
+      try {
+        await handle.writeFile(JSON.stringify(record, null, 2) + "\n", "utf8");
+      } finally {
+        await handle.close();
+      }
+      return { lockPath, ownerToken, pid, startedAt };
+    } catch (error) {
+      if (!isAlreadyExistsError2(error)) {
+        throw error;
+      }
+    }
+    const existing = await readProjectLock(lockPath);
+    if (existing.status === "missing") {
+      invalidReadAttempts = 0;
+      continue;
+    }
+    if (existing.status === "invalid") {
+      invalidReadAttempts += 1;
+      if (invalidReadAttempts >= LOCK_READ_RETRY_LIMIT) {
+        throw new Error(`Project "${input.projectId}" lock file is unreadable at "${lockPath}".`);
+      }
+      await delay(LOCK_READ_RETRY_DELAY_MS);
+      continue;
+    }
+    invalidReadAttempts = 0;
+    if ((input.isProcessRunning ?? isProcessRunning)(existing.record.pid)) {
+      throw new Error(`Project "${input.projectId}" is already running (PID ${existing.record.pid}).`);
+    }
+    await rm4(lockPath, { force: true });
+  }
+}
+async function releaseProjectLock(lock) {
+  if (!lock) {
+    return;
+  }
+  try {
+    const existing = await readProjectLock(lock.lockPath);
+    if (existing.status !== "valid" || existing.record.ownerToken !== lock.ownerToken) {
+      return;
+    }
+  } catch (error) {
+    if (isMissingFileError2(error)) {
+      return;
+    }
+    throw error;
+  }
+  await rm4(lock.lockPath, { force: true });
+}
+async function readProjectLock(lockPath) {
+  try {
+    const raw = await readFile6(lockPath, "utf8");
+    const record = parseProjectLock(raw);
+    if (!record) {
+      return { status: "invalid" };
+    }
+    return { status: "valid", record };
+  } catch (error) {
+    if (isMissingFileError2(error)) {
+      return { status: "missing" };
+    }
+    throw error;
+  }
+}
+function assertValidProjectId(projectId) {
+  if (projectId.length === 0 || projectId === "." || projectId === ".." || projectId.includes("/") || projectId.includes("\\")) {
+    throw new Error(`Invalid project ID "${projectId}". Project IDs must not contain path separators or traversal segments.`);
+  }
+}
+function resolveProjectLockPath(runtimeRoot, projectId) {
+  const store = new OrchestratorFsStore(runtimeRoot);
+  const projectsRoot = resolve4(runtimeRoot, "projects");
+  const projectDir = resolve4(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");
+}
+function parseProjectLock(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.ownerToken !== "string" || typeof parsed.pid !== "number" || !Number.isInteger(parsed.pid) || parsed.pid <= 0 || typeof parsed.startedAt !== "string") {
+      return null;
+    }
+    return {
+      ownerToken: parsed.ownerToken,
+      pid: parsed.pid,
+      startedAt: parsed.startedAt
+    };
+  } catch {
+    return null;
+  }
+}
+function isProcessRunning(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return !(error && typeof error === "object" && "code" in error && error.code === "ESRCH");
+  }
+}
+function isAlreadyExistsError2(error) {
+  return Boolean(error && typeof error === "object" && "code" in error && error.code === "EEXIST");
+}
+function isMissingFileError2(error) {
+  return Boolean(error && typeof error === "object" && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR"));
+}
+
+// ../orchestrator/dist/index.js
+import { pathToFileURL } from "url";
+import { resolve as resolve5 } from "path";
+function resolveOrchestratorLogLevel(value) {
+  if (!value || value === "normal") {
+    return "normal";
+  }
+  if (value === "verbose") {
+    return "verbose";
+  }
+  throw new Error(`Unsupported log level: ${value}. Supported values: normal, verbose.`);
+}
+async function runCli(argv, dependencies = {}) {
+  const [command = "run-once", ...args] = argv;
+  const parsed = parseArgs(args);
+  if (parsed.projectId) {
+    assertValidProjectId(parsed.projectId);
+  }
+  const runtimeRoot = resolve5(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);
+  const service = await dependencies.createService?.(runtimeRoot, parsed.projectId, {
+    eventsDir,
+    logLevel,
+    stderr
+  }) ?? await createServiceForRuntime(runtimeRoot, parsed.projectId, {
+    eventsDir,
+    logLevel,
+    stderr
+  });
+  const stdout = dependencies.stdout ?? process.stdout;
+  const exitProcess = dependencies.exitProcess ?? process.exit;
+  const signalTarget = dependencies.signalTarget ?? process;
+  switch (command) {
+    case "run": {
+      let lock = null;
+      let cleanupPromise = null;
+      let shuttingDownForSignal = false;
+      const cleanup = async () => {
+        if (cleanupPromise) {
+          return cleanupPromise;
+        }
+        cleanupPromise = (async () => {
+          let cleanupError;
+          const shutdownPromise = service.shutdown();
+          try {
+            await shutdownPromise;
+          } catch (error) {
+            cleanupError = error;
+          } finally {
+            try {
+              await (dependencies.releaseLock ?? releaseProjectLock)(lock);
+              lock = null;
+            } catch (lockError) {
+              cleanupError ??= lockError;
+            }
+          }
+          if (cleanupError) {
+            throw cleanupError;
+          }
+        })();
+        return cleanupPromise;
+      };
+      const handleSignal = (signal) => {
+        shuttingDownForSignal = true;
+        let exitCode = 0;
+        void cleanup().catch((error) => {
+          exitCode = 1;
+          stderr.write(`Failed to shut down orchestrator after ${signal}: ${error instanceof Error ? error.message : String(error)}
+`);
+        }).finally(() => {
+          exitProcess(exitCode);
+        });
+      };
+      const sigintHandler = () => handleSignal("SIGINT");
+      const sigtermHandler = () => handleSignal("SIGTERM");
+      try {
+        if (parsed.projectId) {
+          lock = await (dependencies.acquireLock ?? acquireProjectLock)({
+            runtimeRoot,
+            projectId: parsed.projectId
+          });
+        }
+        signalTarget.once("SIGINT", sigintHandler);
+        signalTarget.once("SIGTERM", sigtermHandler);
+        await service.run({
+          issueIdentifier: parsed.issueIdentifier
+        });
+        await cleanup();
+      } finally {
+        signalTarget.off("SIGINT", sigintHandler);
+        signalTarget.off("SIGTERM", sigtermHandler);
+        if (!shuttingDownForSignal) {
+          await cleanup();
+        }
+      }
+      return;
+    }
+    case "run-once":
+    case "dispatch": {
+      const result = await service.runOnce({
+        issueIdentifier: parsed.issueIdentifier
+      });
+      stdout.write(JSON.stringify(result, null, 2) + "\n");
+      return;
+    }
+    case "run-issue": {
+      if (!parsed.projectId || !parsed.issueIdentifier) {
+        throw new Error("run-issue requires --project-id and --issue.");
+      }
+      const result = await service.runOnce({
+        issueIdentifier: parsed.issueIdentifier
+      });
+      stdout.write(JSON.stringify(result, null, 2) + "\n");
+      return;
+    }
+    case "recover": {
+      const result = await service.recover();
+      stdout.write(JSON.stringify(result, null, 2) + "\n");
+      return;
+    }
+    case "status": {
+      const result = await service.status();
+      stdout.write(JSON.stringify(result, null, 2) + "\n");
+      return;
+    }
+    default:
+      throw new Error(`Unsupported command: ${command}`);
+  }
+}
+async function createServiceForRuntime(runtimeRoot, projectId, options) {
+  if (!projectId) {
+    throw new Error("Orchestrator CLI requires --project-id.");
+  }
+  const store = createStore(runtimeRoot, {
+    eventsMirrorRoot: options?.eventsDir
+  });
+  const projectConfig = await store.loadProjectConfig(projectId);
+  if (!projectConfig) {
+    throw new Error(`Project config not found for "${projectId}".`);
+  }
+  return new OrchestratorService(store, projectConfig, options);
+}
+async function main() {
+  await runCli(process.argv.slice(2));
+}
+function parseArgs(args) {
+  const parsed = {};
+  for (let index = 0; index < args.length; index += 1) {
+    const argument = args[index];
+    const value = args[index + 1];
+    if (!argument?.startsWith("--")) {
+      continue;
+    }
+    switch (argument) {
+      case "--runtime-root":
+        parsed.runtimeRoot = value;
+        index += 1;
+        break;
+      case "--project":
+      case "--project-id":
+        parsed.projectId = value;
+        index += 1;
+        break;
+      case "--issue":
+        parsed.issueIdentifier = value;
+        index += 1;
+        break;
+      case "--events-dir":
+        if (!value || value.startsWith("-")) {
+          throw new Error(`Option '${argument}' argument missing`);
+        }
+        parsed.eventsDir = value;
+        index += 1;
+        break;
+      case "--log-level":
+        if (!value || value.startsWith("-")) {
+          throw new Error(`Option '${argument}' argument missing`);
+        }
+        parsed.logLevel = value;
+        index += 1;
+        break;
+      default:
+        throw new Error(`Unknown option: ${argument}`);
+    }
+  }
+  return parsed;
+}
+function resolveOptionalPath(value) {
+  if (!value || value.trim().length === 0) {
+    return void 0;
+  }
+  return resolve5(value.trim());
+}
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  main().catch((error) => {
+    process.stderr.write(`${error instanceof Error ? error.message : "Unknown error"}
+`);
+    process.exitCode = 1;
+  });
+}
+
+export {
+  deriveIssueWorkspaceKeyFromIdentifier,
+  readJsonFile,
+  safeReadDir,
+  isFileMissing,
+  parseRecentEvents,
+  isMatchingIssueRun,
+  mapIssueOrchestrationStateToStatus,
+  OrchestratorService,
+  createStore,
+  acquireProjectLock,
+  releaseProjectLock,
+  resolveOrchestratorLogLevel,
+  runCli
+};