@gh-symphony/cli 0.0.14 → 0.0.16

package/dist/chunk-EFMFGOWM.js

@@ -0,0 +1,3575 @@
+#!/usr/bin/env node
+import {
+  DEFAULT_WORKFLOW_LIFECYCLE,
+  WorkflowConfigStore,
+  buildHookEnv,
+  buildProjectSnapshot,
+  buildPromptVariables,
+  createDefaultWorkflowResolution,
+  createInvalidWorkflowResolution,
+  deriveIssueWorkspaceKey,
+  deriveIssueWorkspaceKeyFromIdentifier,
+  deriveLegacyIssueWorkspaceKey,
+  executeWorkspaceHook,
+  isFileMissing,
+  isMatchingIssueRun,
+  isOrchestratorChannelEvent,
+  isStateActive,
+  isStateTerminal,
+  mapIssueOrchestrationStateToStatus,
+  matchesWorkflowState,
+  parseRecentEvents,
+  readEnvFile,
+  readJsonFile,
+  renderPrompt,
+  resolveIssueWorkspaceDirectory,
+  safeReadDir,
+  scheduleRetryAt
+} from "./chunk-TF3QNWNC.js";
+
+// ../orchestrator/dist/service.js
+import { mkdir as mkdir3, readFile as readFile3, rm as rm3, writeFile as writeFile3 } from "fs/promises";
+import { createWriteStream, mkdirSync } from "fs";
+import { spawn as spawn2 } from "child_process";
+import { join as join3 } from "path";
+import { StringDecoder } from "string_decoder";
+import { fileURLToPath } from "url";
+
+// ../orchestrator/dist/git.js
+import { spawn } from "child_process";
+import { randomUUID } from "crypto";
+import { access, mkdir, readFile, rename, rm, stat, writeFile } from "fs/promises";
+import { constants } from "fs";
+import { join } from "path";
+var workflowConfigStore = new WorkflowConfigStore();
+var LOCK_RETRY_MS = 100;
+var LOCK_STALE_MS = 30 * 60 * 1e3;
+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 = join(input.targetDirectory, "repository");
+  const lockDirectory = join(input.targetDirectory, "repository.lock");
+  return withRepositoryLock(lockDirectory, async () => {
+    let hasGit = false;
+    try {
+      await access(join(repositoryDirectory, ".git"), constants.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 = join(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 = join(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((resolve4, reject) => {
+    const child = spawn(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) {
+        resolve4();
+        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((resolve4, reject) => {
+    const child = spawn(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) {
+        resolve4(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(join(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 stat(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 access(join(lockDirectory, "owner"), constants.R_OK);
+  const owner = await readFile(join(lockDirectory, "owner"), "utf8");
+  return owner.split("\n", 1)[0] || null;
+}
+function wait(ms) {
+  return new Promise((resolve4) => {
+    setTimeout(resolve4, 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 stat2, writeFile as writeFile2, appendFile } from "fs/promises";
+import { dirname, join as join2, relative, resolve } from "path";
+var OrchestratorFsStore = class {
+  runtimeRoot;
+  resolvedRuntimeRoot;
+  resolvedEventsMirrorRoot;
+  constructor(runtimeRoot, options = {}) {
+    this.runtimeRoot = runtimeRoot;
+    this.resolvedRuntimeRoot = resolve(runtimeRoot);
+    this.resolvedEventsMirrorRoot = options.eventsMirrorRoot ? resolve(options.eventsMirrorRoot) : null;
+  }
+  projectsRoot() {
+    return join2(this.runtimeRoot, "projects");
+  }
+  projectDir(projectId) {
+    return join2(this.projectsRoot(), projectId);
+  }
+  projectRunsDir(projectId) {
+    return join2(this.projectDir(projectId), "runs");
+  }
+  runDir(runId, projectId) {
+    if (!projectId) {
+      return join2(this.runtimeRoot, "projects", "__unknown__", "runs", runId);
+    }
+    return join2(this.projectRunsDir(projectId), runId);
+  }
+  async loadProjectConfig(projectId) {
+    return readJsonFile(join2(this.projectDir(projectId), "project.json"));
+  }
+  async saveProjectConfig(config) {
+    await writeJsonFile(join2(this.projectDir(config.projectId), "project.json"), config);
+  }
+  async loadProjectIssueOrchestrations(projectId) {
+    const issuesPath = join2(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(join2(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(join2(this.projectDir(projectId), "issues.json"), issues);
+  }
+  async saveProjectStatus(status) {
+    await writeJsonFile(join2(this.projectDir(status.projectId), "status.json"), status);
+  }
+  async loadProjectStatus(projectId) {
+    return await readJsonFile(join2(this.projectDir(projectId), "status.json")) ?? null;
+  }
+  async loadRun(runId, projectId) {
+    const runDirectory = projectId !== void 0 ? this.runDir(runId, projectId) : await this.findRunDir(runId);
+    if (!runDirectory) {
+      return null;
+    }
+    return await readJsonFile(join2(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(join2(directory, "run.json"))));
+    return runs.filter((run) => Boolean(run));
+  }
+  async saveRun(run) {
+    await writeJsonFile(join2(this.runDir(run.runId, run.projectId), "run.json"), run);
+  }
+  async appendRunEvent(runId, event) {
+    const resolvedProjectId = "projectId" in event && typeof event.projectId === "string" ? event.projectId : void 0;
+    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 = join2(runDirectory, "events.ndjson");
+    const resolvedPath = resolve(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 = join2(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 join2(this.projectDir(projectId), "issues", workspaceKey);
+  }
+  async loadIssueWorkspace(projectId, workspaceKey) {
+    return await readJsonFile(join2(this.issueWorkspaceDir(projectId, workspaceKey), "workspace.json")) ?? null;
+  }
+  async loadIssueWorkspaces(projectId) {
+    const issuesDir = join2(this.projectDir(projectId), "issues");
+    const entries = await safeReadDir(issuesDir);
+    const records = await Promise.all(entries.map((entry) => this.loadIssueWorkspace(projectId, entry)));
+    return records.filter((record) => Boolean(record));
+  }
+  async saveIssueWorkspace(record) {
+    await writeJsonFile(join2(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(join2(candidate, "run.json"));
+      if (run || await pathExists(join2(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 = join2(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 stat2(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 } 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 createHash("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 readFile2 } 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 readFile2(issuesPath, "utf-8");
+      const parsed = JSON.parse(raw);
+      if (!Array.isArray(parsed)) {
+        throw new Error(`Expected an array of issues in ${issuesPath}, got ${typeof parsed}`);
+      }
+      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_MS = 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: join3(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_MS;
+  }
+  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_MS;
+    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((resolve4) => {
+      release = resolve4;
+    });
+    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 = join3(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)(join3(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 ?? spawn2)("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((resolve4) => {
+      this.sleepResolver = () => {
+        this.sleepResolver = null;
+        this.sleepTimer = null;
+        resolve4();
+      };
+    });
+  }
+  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 = [
+      join3(run.workspaceRuntimeDir, "token-usage.json"),
+      join3(run.workspaceRuntimeDir, ".orchestrator", "runs", run.runId, "token-usage.json")
+    ];
+    for (const artifactPath of artifactPaths) {
+      try {
+        const raw = await readFile3(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 = join3(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_MS;
+  }
+  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 readFile3(resolution.workflowPath, "utf8");
+    await mkdir3(join3(cacheRoot, "last-known-good"), { recursive: true });
+    await writeFile3(snapshotPath, markdown, "utf8");
+    return snapshotPath;
+  }
+  lastKnownGoodWorkflowPath(cacheRoot) {
+    return join3(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 isRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function resolveProjectRateLimits(runs, issues) {
+  let latestRunRateLimits = null;
+  let latestRunTimestamp = -Infinity;
+  for (const run of runs) {
+    if (!isRecord(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 (isRecord(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 {
+    try {
+      const bundledWorker = join3(fileURLToPath(new URL(".", import.meta.url)), "worker-entry.js");
+      return `node ${bundledWorker}`;
+    } catch {
+      return DEFAULT_WORKER_COMMAND;
+    }
+  }
+}
+function createStore(runtimeRoot = ".runtime", options = {}) {
+  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((resolve4) => setTimeout(resolve4, 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 readFile4, rm as rm4 } from "fs/promises";
+import { dirname as dirname2, isAbsolute, join as join4, relative as relative2, resolve as resolve2 } from "path";
+import { setTimeout as delay } from "timers/promises";
+var LOCK_READ_RETRY_DELAY_MS = 10;
+var LOCK_READ_RETRY_LIMIT = 20;
+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 readFile4(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 = resolve2(runtimeRoot, "projects");
+  const projectDir = resolve2(store.projectDir(projectId));
+  const relativeProjectDir = relative2(projectsRoot, projectDir);
+  if (relativeProjectDir.length === 0 || relativeProjectDir.startsWith("..") || isAbsolute(relativeProjectDir)) {
+    throw new Error(`Invalid project ID "${projectId}". Project lock path must stay within "${projectsRoot}".`);
+  }
+  return join4(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 resolve3 } 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 = resolve3(parsed.runtimeRoot ?? ".runtime");
+  const stderr = dependencies.stderr ?? process.stderr;
+  const eventsDir = resolveOptionalPath(parsed.eventsDir ?? process.env.SYMPHONY_EVENTS_DIR);
+  const logLevel = resolveOrchestratorLogLevel(parsed.logLevel ?? process.env.SYMPHONY_LOG_LEVEL);
+  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 resolve3(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 {
+  OrchestratorService,
+  createStore,
+  acquireProjectLock,
+  releaseProjectLock,
+  resolveOrchestratorLogLevel,
+  runCli
+};