@gh-symphony/cli 0.0.21 → 0.1.2

package/dist/chunk-MYVJ6HK4.js

@@ -1,3510 +0,0 @@
-#!/usr/bin/env node
-import {
-  resolveTrackerAdapter
-} from "./chunk-SXGT7LOF.js";
-import {
-  DEFAULT_MAX_FAILURE_RETRIES,
-  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,
-  resolveWorkflowRuntimeCommand,
-  resolveWorkflowRuntimeTimeouts,
-  safeReadDir,
-  scheduleRetryAt
-} from "./chunk-QEONJ5DZ.js";
-
-// ../orchestrator/src/service.ts
-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/src/git.ts
-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/src/fs-store.ts
-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 {
-  constructor(runtimeRoot, options = {}) {
-    this.runtimeRoot = runtimeRoot;
-    this.resolvedRuntimeRoot = resolve(runtimeRoot);
-    this.resolvedEventsMirrorRoot = options.eventsMirrorRoot ? resolve(options.eventsMirrorRoot) : null;
-  }
-  resolvedRuntimeRoot;
-  resolvedEventsMirrorRoot;
-  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,
-        failureRetryCount: issue.failureRetryCount ?? 0
-      }));
-    }
-    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,
-        failureRetryCount: 0,
-        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-file/src/file-tracker-adapter.ts
-import { readFile as readFile2 } from "fs/promises";
-function requireTrackerSetting(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 parseIssueNumber(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 = requireTrackerSetting(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: 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: "file",
-        bindingId: project.tracker.bindingId,
-        itemId: run.issueId
-      },
-      metadata: {}
-    };
-  }
-};
-
-// ../orchestrator/src/tracker-adapters.ts
-var localAdapters = /* @__PURE__ */ new Map([
-  ["file", fileTrackerAdapter]
-]);
-function resolveTrackerAdapter2(tracker) {
-  const local = localAdapters.get(tracker.adapter);
-  if (local) return local;
-  return resolveTrackerAdapter(tracker);
-}
-
-// ../orchestrator/src/service.ts
-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 LOW_RATE_LIMIT_WARNING_THRESHOLD = 0.05;
-var MAX_FAILURE_RETRIES_EXCEEDED_REASON = "max_failure_retries_exceeded";
-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;
-}
-function parseFiniteNumber(value) {
-  if (typeof value === "number" && Number.isFinite(value)) {
-    return value;
-  }
-  if (typeof value === "string" && value.trim()) {
-    const parsed = Number(value);
-    return Number.isFinite(parsed) ? parsed : null;
-  }
-  return null;
-}
-var OrchestratorService = class {
-  constructor(store, projectConfig, dependencies = {}) {
-    this.store = store;
-    this.projectConfig = projectConfig;
-    this.dependencies = 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;
-  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 trackerRateLimits = 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,
-        trackerDependencies
-      );
-      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()
-      );
-      trackerRateLimits = resolveTrackerRateLimits(
-        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 latestRunsByIssueId = buildLatestRunMapByIssueId(
-        projectRunsAfterReconcile
-      );
-      const unscheduledCandidates = actionableCandidates.filter((issue) => {
-        if (hasConvergenceLockedRun(
-          projectRunsAfterReconcile,
-          issue.id,
-          issue.state,
-          issue.updatedAt
-        )) {
-          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 (await this.isFailureRetrySuppressedIssue(
-          tenant,
-          issue,
-          issueRecords,
-          latestRunsByIssueId.get(issue.id) ?? null
-        )) {
-          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",
-          failureRetryCount: 0,
-          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";
-    }
-    const effectivePollIntervalMs = resolveAdaptivePollIntervalMs(
-      pollIntervalMs,
-      trackerRateLimits
-    );
-    if (effectivePollIntervalMs > pollIntervalMs && isLowRateLimit(trackerRateLimits, LOW_RATE_LIMIT_WARNING_THRESHOLD)) {
-      this.writeStderr(
-        `[orchestrator] low GitHub rate limit for ${tenant.projectId}: interval=${effectivePollIntervalMs}ms rateLimits=${JSON.stringify(
-          trackerRateLimits
-        )}`
-      );
-    }
-    this.projectPollIntervals.set(tenant.projectId, effectivePollIntervalMs);
-    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 (!this.isIssueCandidateEligible(issue, resolution.lifecycle, issues)) {
-        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"]
-      }
-    };
-  }
-  isIssueCandidateEligible(issue, lifecycle, issues) {
-    if (!isStateActive(issue.state, lifecycle)) {
-      return false;
-    }
-    if (!matchesWorkflowState(issue.state, lifecycle.blockerCheckStates) || issue.blockedBy.length === 0) {
-      return true;
-    }
-    return !issue.blockedBy.some((blockerRef) => {
-      if (blockerRef.state && isStateTerminal(blockerRef.state, lifecycle)) {
-        return false;
-      }
-      if (blockerRef.identifier) {
-        const blockerIssue = issues.find(
-          (candidate) => candidate.identifier === blockerRef.identifier
-        );
-        if (blockerIssue?.state) {
-          return !isStateTerminal(blockerIssue.state, lifecycle);
-        }
-      }
-      return true;
-    });
-  }
-  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) {
-    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 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
-      }
-    );
-    const runtimeTimeouts = resolveWorkflowRuntimeTimeouts(workflow.workflow);
-    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: resolveWorkflowRuntimeCommand(
-            workflow.workflow
-          ),
-          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_MAX_NONPRODUCTIVE_TURNS: process.env.SYMPHONY_MAX_NONPRODUCTIVE_TURNS ?? String(DEFAULT_MAX_NONPRODUCTIVE_TURNS),
-          // Clear legacy resume/budget env so fresh worker sessions do not
-          // inherit stale process-level values.
-          SYMPHONY_GLOBAL_MAX_TURNS: "",
-          SYMPHONY_MAX_TOKENS: "",
-          SYMPHONY_SESSION_TIMEOUT_MS: "",
-          SYMPHONY_RESUME_THREAD_ID: "",
-          SYMPHONY_CUMULATIVE_TURN_COUNT: "0",
-          SYMPHONY_CUMULATIVE_INPUT_TOKENS: "0",
-          SYMPHONY_CUMULATIVE_OUTPUT_TOKENS: "0",
-          SYMPHONY_CUMULATIVE_TOTAL_TOKENS: "0",
-          SYMPHONY_LAST_TURN_SUMMARY: "",
-          SYMPHONY_SESSION_STARTED_AT: "",
-          SYMPHONY_READ_TIMEOUT_MS: String(
-            runtimeTimeouts.readTimeoutMs
-          ),
-          SYMPHONY_TURN_TIMEOUT_MS: String(
-            runtimeTimeouts.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, trackerDependencies = {}) {
-    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,
-        trackerDependencies
-      ) === "release") {
-        return this.releaseRetryingRun(runWithTokens, issueRecords, now);
-      }
-      return this.restartRun(tenant, run, issueRecords, now, workerSessionId);
-    }
-    if (workerInfo.exitClassification === "convergence-detected") {
-      const completedRun = {
-        ...runWithTokens,
-        status: "failed",
-        processId: null,
-        updatedAt: now.toISOString(),
-        completedAt: now.toISOString(),
-        nextRetryAt: null,
-        retryKind: null,
-        lastError: runWithTokens.lastError,
-        runPhase: runWithTokens.runPhase ?? "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,
-      trackerDependencies
-    );
-    const failureRetryCount = retryKind === "failure" ? (this.resolveFailureRetryCount(issueRecords, run.issueId) ?? 0) + 1 : this.resolveFailureRetryCount(issueRecords, run.issueId) ?? 0;
-    const maxFailureRetries = await this.loadMaxFailureRetries(
-      tenant,
-      run.repository
-    );
-    if (retryKind === "failure" && failureRetryCount >= maxFailureRetries) {
-      const lastError = [
-        `Run suppressed: ${MAX_FAILURE_RETRIES_EXCEEDED_REASON}.`,
-        `failureRetryCount=${failureRetryCount}.`,
-        `maxFailureRetries=${maxFailureRetries}.`
-      ].join(" ");
-      const suppressedRun = {
-        ...runWithTokens,
-        status: "suppressed",
-        processId: null,
-        updatedAt: now.toISOString(),
-        completedAt: now.toISOString(),
-        nextRetryAt: null,
-        retryKind: null,
-        runPhase: runWithTokens.runPhase ?? "failed",
-        lastError
-      };
-      await this.store.saveRun(suppressedRun);
-      await this.store.appendRunEvent(run.runId, {
-        at: now.toISOString(),
-        event: "run-suppressed",
-        projectId: run.projectId,
-        issueIdentifier: run.issueIdentifier,
-        issueId: run.issueId,
-        reason: MAX_FAILURE_RETRIES_EXCEEDED_REASON
-      });
-      this.logVerbose(
-        `[run-completed] ${suppressedRun.runId} status=${suppressedRun.status}`
-      );
-      return {
-        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: "released",
-          failureRetryCount,
-          currentRunId: null,
-          retryEntry: null,
-          updatedAt: now.toISOString()
-        }),
-        recovered: false
-      };
-    }
-    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,
-      failureRetryCount,
-      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, trackerDependencies = {}) {
-    try {
-      const eligibleContext = await this.fetchTrackedIssueEligibilityContext(
-        tenant,
-        run.issueIdentifier,
-        trackerDependencies
-      );
-      if (!eligibleContext) {
-        return "failure";
-      }
-      const resolution = await this.loadProjectWorkflow(tenant, run.repository);
-      if (!isUsableWorkflowResolution(resolution)) {
-        return "failure";
-      }
-      return this.isIssueCandidateEligible(
-        eligibleContext.issue,
-        resolution.lifecycle,
-        eligibleContext.issues
-      ) ? "continuation" : "failure";
-    } catch {
-      return "failure";
-    }
-  }
-  async resolveRetryRestartAction(tenant, run, trackerDependencies = {}) {
-    try {
-      const eligibleContext = await this.fetchTrackedIssueEligibilityContext(
-        tenant,
-        run.issueIdentifier,
-        trackerDependencies
-      );
-      if (!eligibleContext) {
-        return "release";
-      }
-      const resolution = await this.loadProjectWorkflow(tenant, run.repository);
-      if (!isUsableWorkflowResolution(resolution)) {
-        return "restart";
-      }
-      return this.isIssueCandidateEligible(
-        eligibleContext.issue,
-        resolution.lifecycle,
-        eligibleContext.issues
-      ) ? "restart" : "release";
-    } catch {
-      return "restart";
-    }
-  }
-  async fetchTrackedIssueEligibilityContext(tenant, issueIdentifier, trackerDependencies = {}) {
-    const trackerAdapter = resolveTrackerAdapter2(tenant.tracker);
-    const issues = await trackerAdapter.listIssues(tenant, {
-      fetchImpl: this.dependencies.fetchImpl,
-      ...trackerDependencies
-    });
-    const issue = issues.find(
-      (candidate) => candidate.identifier === issueIdentifier
-    );
-    return issue ? { issue, issues } : 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);
-    const recoveredRecord = {
-      ...restarted,
-      attempt: run.attempt,
-      retryKind: run.retryKind ?? "recovery",
-      createdAt: run.createdAt,
-      issueWorkspaceKey: run.issueWorkspaceKey,
-      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: resolveWorkflowRuntimeTimeouts(resolution.workflow).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);
-  }
-  resolveFailureRetryCount(issueRecords, issueId) {
-    return issueRecords.find((record) => record.issueId === issueId)?.failureRetryCount ?? null;
-  }
-  async isFailureRetrySuppressedIssue(tenant, issue, issueRecords, latestRun) {
-    const issueRecord = issueRecords.find(
-      (record) => record.issueId === issue.id || record.identifier === issue.identifier
-    ) ?? null;
-    if (!issueRecord || issueRecord.failureRetryCount <= 0) {
-      return false;
-    }
-    const maxFailureRetries = await this.loadMaxFailureRetries(
-      tenant,
-      issue.repository
-    );
-    if (issueRecord.failureRetryCount < maxFailureRetries) {
-      return false;
-    }
-    if (!latestRun || latestRun.status !== "suppressed" || latestRun.issueState !== issue.state || !latestRun.lastError?.includes(MAX_FAILURE_RETRIES_EXCEEDED_REASON)) {
-      return false;
-    }
-    const issueUpdatedAtMs = parseTimestampMs(issue.updatedAt);
-    const suppressedAtMs = parseTimestampMs(
-      latestRun.completedAt ?? latestRun.updatedAt
-    );
-    if (issueUpdatedAtMs === null || suppressedAtMs === null) {
-      return true;
-    }
-    return issueUpdatedAtMs <= suppressedAtMs;
-  }
-  async loadMaxFailureRetries(tenant, repository) {
-    try {
-      const resolution = await this.loadProjectWorkflow(tenant, repository);
-      return isUsableWorkflowResolution(resolution) ? resolution.workflow.agent.maxFailureRetries : DEFAULT_MAX_FAILURE_RETRIES;
-    } catch {
-      return DEFAULT_MAX_FAILURE_RETRIES;
-    }
-  }
-};
-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 resolveTrackerRateLimits(issues) {
-  for (const issue of issues) {
-    if (isGitHubTrackerRateLimits(issue.rateLimits)) {
-      return issue.rateLimits;
-    }
-  }
-  return null;
-}
-function resolveAdaptivePollIntervalMs(basePollIntervalMs, rateLimits) {
-  if (!Number.isFinite(basePollIntervalMs) || basePollIntervalMs <= 0) {
-    return DEFAULT_POLL_INTERVAL_MS;
-  }
-  const ratio = extractRateLimitRatio(rateLimits);
-  if (ratio === null || ratio > 0.5) {
-    return basePollIntervalMs;
-  }
-  if (ratio >= 0.2) {
-    return basePollIntervalMs * 2;
-  }
-  if (ratio >= LOW_RATE_LIMIT_WARNING_THRESHOLD) {
-    return basePollIntervalMs * 4;
-  }
-  return basePollIntervalMs * 10;
-}
-function extractRateLimitRatio(rateLimits) {
-  if (!isRecord(rateLimits)) {
-    return null;
-  }
-  const limit = parseFiniteNumber(rateLimits.limit);
-  const remaining = parseFiniteNumber(rateLimits.remaining);
-  if (limit === null || remaining === null || limit <= 0 || remaining < 0) {
-    return null;
-  }
-  return remaining / limit;
-}
-function isGitHubTrackerRateLimits(rateLimits) {
-  if (!isRecord(rateLimits) || rateLimits.source !== "github") {
-    return false;
-  }
-  return rateLimits.resource === void 0 || rateLimits.resource === null || rateLimits.resource === "graphql";
-}
-function isLowRateLimit(rateLimits, threshold) {
-  const ratio = extractRateLimitRatio(rateLimits);
-  return ratio !== null && ratio < threshold;
-}
-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, issueUpdatedAt) {
-  const latestRun = runs.filter((run) => run.issueId === issueId).sort(
-    (left, right) => new Date(right.updatedAt).getTime() - new Date(left.updatedAt).getTime()
-  )[0];
-  if (latestRun?.runtimeSession?.exitClassification !== "convergence-detected" || latestRun.issueState !== issueState) {
-    return false;
-  }
-  const convergedAtMs = parseTimestampMs(
-    latestRun.completedAt ?? latestRun.updatedAt
-  );
-  const issueUpdatedAtMs = parseTimestampMs(issueUpdatedAt);
-  if (convergedAtMs === null || issueUpdatedAtMs === null) {
-    return true;
-  }
-  return issueUpdatedAtMs <= convergedAtMs;
-}
-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 buildLatestRunMapByIssueId(runs) {
-  const latestRuns = /* @__PURE__ */ new Map();
-  for (const run of runs) {
-    const existing = latestRuns.get(run.issueId);
-    if (!existing) {
-      latestRuns.set(run.issueId, run);
-      continue;
-    }
-    const runUpdatedAtMs = parseTimestampMs(run.updatedAt) ?? -Infinity;
-    const existingUpdatedAtMs = parseTimestampMs(existing.updatedAt) ?? -Infinity;
-    if (runUpdatedAtMs > existingUpdatedAtMs) {
-      latestRuns.set(run.issueId, run);
-    }
-  }
-  return latestRuns;
-}
-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,
-      failureRetryCount: nextRecord.failureRetryCount ?? existingRecord?.failureRetryCount ?? 0
-    }
-  ];
-}
-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/src/lock.ts
-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/src/index.ts
-import { pathToFileURL } from "url";
-import { resolve as resolve3 } from "path";
-
-// ../orchestrator/src/runtime-factory.ts
-import { join as join5 } from "path";
-
-// ../orchestrator/src/index.ts
-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
-};