@gh-symphony/cli 0.0.20 → 0.0.22

package/dist/{chunk-HZVDTAPS.js → chunk-PUDXVBSN.js}

@@ -1,4 +1,7 @@
 #!/usr/bin/env node
+import {
+  resolveTrackerAdapter
+} from "./chunk-2TSM3INR.js";
 import {
   DEFAULT_MAX_FAILURE_RETRIES,
   DEFAULT_WORKFLOW_LIFECYCLE,
@@ -24,22 +27,476 @@ import {
   readJsonFile,
   renderPrompt,
   resolveIssueWorkspaceDirectory,
+  resolveWorkflowRuntimeCommand,
+  resolveWorkflowRuntimeTimeouts,
   safeReadDir,
   scheduleRetryAt
-} from "./chunk-M3IFVLQS.js";
+} from "./chunk-EEQQWTXS.js";
+
+// ../tracker-file/src/file-tracker-adapter.ts
+import { readFile } 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 readFile(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/explain.ts
+var MAX_FAILURE_RETRIES_EXCEEDED_REASON = "max_failure_retries_exceeded";
+function explainIssueDispatch(input) {
+  const parsed = parseIssueIdentifier(input.identifier);
+  const repository = parsed ? `${parsed.owner}/${parsed.name}` : input.issue ? `${input.issue.repository.owner}/${input.issue.repository.name}` : "unknown";
+  const issue = input.issue;
+  const checks = [];
+  checks.push(explainRepositoryLinked(input.projectRepository, repository));
+  checks.push(explainProjectItemPresent(input.identifier, issue));
+  if (!issue) {
+    const dispatchable2 = false;
+    const blocking2 = checks.filter((check) => check.status === "block");
+    const summary2 = blocking2.length > 0 ? `Not dispatchable: ${blocking2[0].message}` : "Not dispatchable: the issue is not present in the managed GitHub Project item set.";
+    return {
+      issue: {
+        identifier: input.identifier,
+        id: null,
+        state: null,
+        repository,
+        title: null,
+        url: null
+      },
+      dispatchable: dispatchable2,
+      summary: summary2,
+      checks
+    };
+  }
+  checks.push(explainWorkflowState(issue, input.lifecycle));
+  checks.push(explainBlockers(issue, input.lifecycle, input.allIssues));
+  checks.push(explainRuntimeOwnership(issue, input.issueRecords, input.runs));
+  checks.push(
+    explainDispatchLimits(
+      issue,
+      input.runs,
+      input.activeRunCount,
+      input.maxConcurrentAgents,
+      input.maxConcurrentAgentsByState
+    )
+  );
+  const blocking = checks.filter((check) => check.status === "block");
+  const dispatchable = blocking.length === 0;
+  const summary = dispatchable ? "Dispatchable: no blocking project, workflow, runtime, or budget condition was found." : `Not dispatchable: ${blocking[0].message}`;
+  return {
+    issue: {
+      identifier: issue.identifier,
+      id: issue.id,
+      state: issue.state,
+      repository: `${issue.repository.owner}/${issue.repository.name}`,
+      title: issue.title,
+      url: issue.url
+    },
+    dispatchable,
+    summary,
+    checks
+  };
+}
+function isIssueCandidateEligibleWithReason(issue, lifecycle, issues) {
+  if (!isStateActive(issue.state, lifecycle)) {
+    return { eligible: false, reason: "inactive_state" };
+  }
+  if (!issueHasBlockingDependency(issue, lifecycle, issues)) {
+    return { eligible: true, reason: null };
+  }
+  return { eligible: false, reason: "blocked" };
+}
+function hasConvergenceLockedRunForIssue(runs, issueId, issueState, issueUpdatedAt) {
+  const latestRun = latestRunForIssue(runs, issueId);
+  if (latestRun?.runtimeSession?.exitClassification !== "convergence-detected" || latestRun.issueState !== issueState) {
+    return null;
+  }
+  const convergedAtMs = parseTimestampMs(
+    latestRun.completedAt ?? latestRun.updatedAt
+  );
+  const issueUpdatedAtMs = parseTimestampMs(issueUpdatedAt);
+  if (convergedAtMs === null || issueUpdatedAtMs === null) {
+    return latestRun;
+  }
+  return issueUpdatedAtMs <= convergedAtMs ? latestRun : null;
+}
+function isIssueOrchestrationClaimedState(state) {
+  return state === "claimed" || state === "running" || state === "retry_queued";
+}
+function isActiveRunRecordStatus(status) {
+  return status === "pending" || status === "starting" || status === "running" || status === "retrying";
+}
+function explainRepositoryLinked(projectRepository, repository) {
+  if (!projectRepository) {
+    return {
+      id: "repository_linked",
+      status: "warn",
+      message: "No repository is configured for the active managed project.",
+      hint: "Run 'gh-symphony repo add <owner/name>' or re-run 'gh-symphony project add'."
+    };
+  }
+  const configured = `${projectRepository.owner}/${projectRepository.name}`;
+  const linked = normalizeIdentifier(configured) === normalizeIdentifier(repository);
+  return {
+    id: "repository_linked",
+    status: linked ? "pass" : "block",
+    message: linked ? `Repository ${repository} is linked to the active managed project.` : `Repository ${repository} is not the active managed project repository (${configured}).`,
+    details: { configuredRepository: configured, issueRepository: repository },
+    hint: linked ? void 0 : "Run 'gh-symphony repo add <owner/name>' or select the correct project with 'gh-symphony project switch'."
+  };
+}
+function explainProjectItemPresent(identifier, issue) {
+  return {
+    id: "project_item_present",
+    status: issue ? "pass" : "block",
+    message: issue ? "Issue is present in the bound GitHub Project item set." : `Issue ${identifier} was not returned by the bound GitHub Project item set.`,
+    details: issue ? { itemId: issue.tracker.itemId } : void 0,
+    hint: issue ? void 0 : "Add the issue to the GitHub Project or run 'gh-symphony project status' to confirm the active project."
+  };
+}
+function explainWorkflowState(issue, lifecycle) {
+  if (isStateActive(issue.state, lifecycle)) {
+    return {
+      id: "workflow_state",
+      status: "pass",
+      message: `Project state "${issue.state}" maps to an active state in WORKFLOW.md.`,
+      details: { activeStates: lifecycle.activeStates }
+    };
+  }
+  const role = isStateTerminal(issue.state, lifecycle) ? "terminal" : "wait";
+  return {
+    id: "workflow_state",
+    status: "block",
+    message: `Project state "${issue.state}" maps to ${role}, not active, in WORKFLOW.md.`,
+    details: {
+      activeStates: lifecycle.activeStates,
+      terminalStates: lifecycle.terminalStates,
+      blockerCheckStates: lifecycle.blockerCheckStates
+    },
+    hint: "Move the GitHub Project item to an active state or run 'gh-symphony workflow preview' to inspect WORKFLOW.md state mappings."
+  };
+}
+function explainBlockers(issue, lifecycle, issues) {
+  if (!matchesWorkflowState(issue.state, lifecycle.blockerCheckStates)) {
+    return {
+      id: "blockers",
+      status: "pass",
+      message: `Blocker checks do not apply to state "${issue.state}".`,
+      details: { blockerCheckStates: lifecycle.blockerCheckStates }
+    };
+  }
+  const blockers = unresolvedBlockers(issue, lifecycle, issues);
+  if (blockers.length === 0) {
+    return {
+      id: "blockers",
+      status: "pass",
+      message: "No unresolved blockers prevent dispatch.",
+      details: { blockedBy: issue.blockedBy }
+    };
+  }
+  return {
+    id: "blockers",
+    status: "block",
+    message: `Issue has ${blockers.length} unresolved blocker${blockers.length === 1 ? "" : "s"}.`,
+    details: { blockers },
+    hint: "Move blocker issues to a terminal state or update the blocker relationship in GitHub."
+  };
+}
+function explainRuntimeOwnership(issue, issueRecords, runs) {
+  const record = issueRecords.find(
+    (candidate) => candidate.issueId === issue.id || candidate.identifier === issue.identifier
+  );
+  const latestRun = latestRunForIssue(runs, issue.id);
+  const activeRun = runs.find(
+    (run) => run.issueId === issue.id && isActiveRunRecordStatus(run.status)
+  );
+  if (activeRun) {
+    return {
+      id: "runtime_ownership",
+      status: "block",
+      message: `Existing ${activeRun.status} run ${activeRun.runId} already owns the issue.`,
+      details: {
+        runId: activeRun.runId,
+        status: activeRun.status,
+        retryKind: activeRun.retryKind,
+        nextRetryAt: activeRun.nextRetryAt
+      },
+      hint: "Run 'gh-symphony status' or 'gh-symphony logs --issue <owner/repo#number>' to inspect the current owner."
+    };
+  }
+  if (record && isIssueOrchestrationClaimedState(record.state)) {
+    return {
+      id: "runtime_ownership",
+      status: "block",
+      message: `Issue is already claimed by orchestration state "${record.state}".`,
+      details: {
+        state: record.state,
+        currentRunId: record.currentRunId,
+        retryEntry: record.retryEntry
+      },
+      hint: "Run 'gh-symphony status' to inspect active and retrying work."
+    };
+  }
+  const convergenceRun = hasConvergenceLockedRunForIssue(
+    runs,
+    issue.id,
+    issue.state,
+    issue.updatedAt
+  );
+  if (convergenceRun) {
+    return {
+      id: "runtime_ownership",
+      status: "block",
+      message: `Latest run ${convergenceRun.runId} is convergence-locked for state "${issue.state}".`,
+      details: {
+        runId: convergenceRun.runId,
+        completedAt: convergenceRun.completedAt,
+        lastError: convergenceRun.lastError
+      },
+      hint: "Update the GitHub Project item or issue activity to trigger a newer tracker timestamp after resolving the unchanged workspace diff."
+    };
+  }
+  if (record && record.failureRetryCount > 0 && latestRun?.status === "suppressed" && latestRun.issueState === issue.state && latestRun.lastError?.includes(MAX_FAILURE_RETRIES_EXCEEDED_REASON)) {
+    const issueUpdatedAtMs = parseTimestampMs(issue.updatedAt);
+    const suppressedAtMs = parseTimestampMs(
+      latestRun.completedAt ?? latestRun.updatedAt
+    );
+    if (issueUpdatedAtMs === null || suppressedAtMs === null || issueUpdatedAtMs <= suppressedAtMs) {
+      return {
+        id: "runtime_ownership",
+        status: "block",
+        message: "Failure retry limit has suppressed redispatch for the current tracker state.",
+        details: {
+          failureRetryCount: record.failureRetryCount,
+          runId: latestRun.runId,
+          lastError: latestRun.lastError
+        },
+        hint: "Fix the underlying failure and update the GitHub Project item or issue to create a newer tracker timestamp."
+      };
+    }
+  }
+  return {
+    id: "runtime_ownership",
+    status: "pass",
+    message: "No active run, retry, convergence lock, or suppression owns the issue.",
+    details: record ? {
+      orchestrationState: record.state,
+      currentRunId: record.currentRunId,
+      latestRunId: latestRun?.runId ?? null
+    } : void 0
+  };
+}
+function explainDispatchLimits(issue, runs, activeRunCount, maxConcurrentAgents, maxConcurrentAgentsByState) {
+  if (activeRunCount >= maxConcurrentAgents) {
+    return {
+      id: "dispatch_limits",
+      status: "block",
+      message: `Project concurrency is full (${activeRunCount}/${maxConcurrentAgents}).`,
+      details: { activeRunCount, maxConcurrentAgents },
+      hint: "Wait for an active run to finish or adjust agent.max_concurrent_agents in WORKFLOW.md."
+    };
+  }
+  const stateLimit = maxConcurrentAgentsByState[issue.state];
+  if (stateLimit !== void 0) {
+    const activeInState = runs.filter(
+      (run) => run.issueState === issue.state && isActiveRunRecordStatus(run.status)
+    ).length;
+    if (activeInState >= stateLimit) {
+      return {
+        id: "dispatch_limits",
+        status: "block",
+        message: `State concurrency is full for "${issue.state}" (${activeInState}/${stateLimit}).`,
+        details: { activeInState, stateLimit, state: issue.state },
+        hint: "Wait for a same-state run to finish or adjust agent.max_concurrent_agents_by_state in WORKFLOW.md."
+      };
+    }
+  }
+  return {
+    id: "dispatch_limits",
+    status: "pass",
+    message: "Project and per-state concurrency limits have available capacity.",
+    details: {
+      activeRunCount,
+      maxConcurrentAgents,
+      stateLimit: stateLimit ?? null
+    }
+  };
+}
+function issueHasBlockingDependency(issue, lifecycle, issues) {
+  if (!matchesWorkflowState(issue.state, lifecycle.blockerCheckStates) || issue.blockedBy.length === 0) {
+    return false;
+  }
+  return unresolvedBlockers(issue, lifecycle, issues).length > 0;
+}
+function unresolvedBlockers(issue, lifecycle, issues) {
+  return issue.blockedBy.filter((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;
+  });
+}
+function latestRunForIssue(runs, issueId) {
+  return runs.filter((run) => run.issueId === issueId).sort(
+    (left, right) => (parseTimestampMs(right.updatedAt) ?? -Infinity) - (parseTimestampMs(left.updatedAt) ?? -Infinity)
+  )[0] ?? null;
+}
+function parseTimestampMs(value) {
+  if (!value) {
+    return null;
+  }
+  const parsed = Date.parse(value);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+function parseIssueIdentifier(identifier) {
+  const match = identifier.match(/^([^/\s#]+)\/([^/\s#]+)#(\d+)$/);
+  if (!match) {
+    return null;
+  }
+  return {
+    owner: match[1],
+    name: match[2],
+    number: Number.parseInt(match[3], 10)
+  };
+}
+function normalizeIdentifier(value) {
+  return value.trim().toLowerCase();
+}
 
-// ../orchestrator/dist/service.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 { isAbsolute, join as join3 } from "path";
 import { StringDecoder } from "string_decoder";
 import { fileURLToPath } from "url";
 
-// ../orchestrator/dist/git.js
+// ../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 {
+  access,
+  mkdir,
+  readFile as readFile2,
+  rename,
+  rm,
+  stat,
+  writeFile
+} from "fs/promises";
 import { constants } from "fs";
 import { join } from "path";
 var workflowConfigStore = new WorkflowConfigStore();
@@ -81,7 +538,10 @@ async function syncRepositoryForRun(input) {
     } else {
       await rm(repositoryDirectory, { recursive: true, force: true });
     }
-    const tempRepositoryDirectory = join(input.targetDirectory, `repository.tmp-${process.pid}-${Date.now()}`);
+    const tempRepositoryDirectory = join(
+      input.targetDirectory,
+      `repository.tmp-${process.pid}-${Date.now()}`
+    );
     await rm(tempRepositoryDirectory, { recursive: true, force: true });
     try {
       await runCommand("git", [
@@ -102,10 +562,13 @@ async function syncRepositoryForRun(input) {
   });
 }
 async function ensureIssueWorkspaceRepository(input) {
-  return cloneRepositoryForRun({
-    repository: input.repository,
-    targetDirectory: input.issueWorkspacePath
-  });
+  if (!input.existingWorkspace) {
+    return cloneRepositoryForRun({
+      repository: input.repository,
+      targetDirectory: input.issueWorkspacePath
+    });
+  }
+  return syncExistingIssueWorkspaceRepository(input);
 }
 async function loadRepositoryWorkflow(repositoryDirectory, _repository) {
   const workflowPath = join(repositoryDirectory, "WORKFLOW.md");
@@ -115,7 +578,10 @@ async function loadRepositoryWorkflow(repositoryDirectory, _repository) {
     if (isMissingFileError(error)) {
       return createDefaultWorkflowResolution();
     }
-    return createInvalidWorkflowResolution(workflowPath, error instanceof Error ? error.message : "workflow_parse_error");
+    return createInvalidWorkflowResolution(
+      workflowPath,
+      error instanceof Error ? error.message : "workflow_parse_error"
+    );
   }
 }
 function runCommand(command, args) {
@@ -133,7 +599,11 @@ function runCommand(command, args) {
         resolve4();
         return;
       }
-      reject(new Error(stderr.trim() || `${command} exited with code ${code ?? "unknown"}`));
+      reject(
+        new Error(
+          stderr.trim() || `${command} exited with code ${code ?? "unknown"}`
+        )
+      );
     });
   });
 }
@@ -149,6 +619,107 @@ async function readGitHead(repositoryDirectory) {
     return null;
   }
 }
+async function syncExistingIssueWorkspaceRepository(input) {
+  await mkdir(input.issueWorkspacePath, { recursive: true });
+  const repositoryDirectory = join(input.issueWorkspacePath, "repository");
+  const lockDirectory = join(input.issueWorkspacePath, "repository.lock");
+  return withRepositoryLock(lockDirectory, async () => {
+    const repositoryExists = await pathExists(repositoryDirectory);
+    const hasGit = await pathExists(join(repositoryDirectory, ".git"));
+    if (hasGit) {
+      let dirtyStatus;
+      try {
+        dirtyStatus = await readGitStatusPorcelain(repositoryDirectory);
+      } catch (error) {
+        throw createIssueWorkspacePreservedError(
+          repositoryDirectory,
+          `could not be inspected: ${formatCommandError(error, "git status --porcelain failed")}`
+        );
+      }
+      if (dirtyStatus.trim()) {
+        throw createIssueWorkspacePreservedError(
+          repositoryDirectory,
+          `has uncommitted changes: ${summarizeGitStatus(dirtyStatus)}`
+        );
+      }
+      try {
+        await runCommand("git", [
+          "-C",
+          repositoryDirectory,
+          "pull",
+          "--ff-only"
+        ]);
+      } catch (error) {
+        const message = formatCommandError(error, "git pull --ff-only failed");
+        throw createIssueWorkspacePreservedError(
+          repositoryDirectory,
+          `could not be fast-forwarded: ${message}`
+        );
+      }
+      return repositoryDirectory;
+    }
+    if (repositoryExists) {
+      throw createIssueWorkspacePreservedError(
+        repositoryDirectory,
+        "exists but is not a git checkout"
+      );
+    }
+    const tempRepositoryDirectory = join(
+      input.issueWorkspacePath,
+      `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;
+    } finally {
+      await rm(tempRepositoryDirectory, { recursive: true, force: true });
+    }
+  });
+}
+function createIssueWorkspacePreservedError(repositoryDirectory, reason) {
+  return new Error(
+    [
+      `Issue workspace repository at ${repositoryDirectory} was preserved because it ${reason}.`,
+      "Resolve or commit the local workspace changes, or run a configured recovery hook, before retrying."
+    ].join(" ")
+  );
+}
+function formatCommandError(error, fallback) {
+  const message = error instanceof Error ? error.message : fallback;
+  return normalizeWhitespace(message) || fallback;
+}
+function summarizeGitStatus(status) {
+  const lines = status.trim().split(/\r?\n/).map(normalizeWhitespace).filter(Boolean);
+  const summary = lines.slice(0, 5).join("; ");
+  return lines.length > 5 ? `${summary}; ...` : summary;
+}
+function normalizeWhitespace(value) {
+  return value.replace(/\s+/g, " ").trim();
+}
+async function readGitStatusPorcelain(repositoryDirectory) {
+  return runCommandCapture("git", [
+    "-C",
+    repositoryDirectory,
+    "status",
+    "--porcelain"
+  ]);
+}
+async function pathExists(path) {
+  try {
+    await access(path, constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
 function runCommandCapture(command, args) {
   return new Promise((resolve4, reject) => {
     const child = spawn(command, args, {
@@ -168,7 +739,11 @@ function runCommandCapture(command, args) {
         resolve4(stdout.trim());
         return;
       }
-      reject(new Error(stderr.trim() || `${command} exited with code ${code ?? "unknown"}`));
+      reject(
+        new Error(
+          stderr.trim() || `${command} exited with code ${code ?? "unknown"}`
+        )
+      );
     });
   });
 }
@@ -186,9 +761,13 @@ async function acquireRepositoryLock(lockDirectory) {
   for (; ; ) {
     try {
       await mkdir(lockDirectory);
-      await writeFile(join(lockDirectory, "owner"), `${ownerToken}
+      await writeFile(
+        join(lockDirectory, "owner"),
+        `${ownerToken}
 ${(/* @__PURE__ */ new Date()).toISOString()}
-`, "utf8");
+`,
+        "utf8"
+      );
       return ownerToken;
     } catch (error) {
       if (!isAlreadyExistsError(error)) {
@@ -201,7 +780,9 @@ ${(/* @__PURE__ */ new Date()).toISOString()}
       continue;
     }
     if (Date.now() - startedAt >= LOCK_TIMEOUT_MS) {
-      throw new Error(`Timed out waiting for repository cache lock: ${lockDirectory}`);
+      throw new Error(
+        `Timed out waiting for repository cache lock: ${lockDirectory}`
+      );
     }
     await wait(LOCK_RETRY_MS);
   }
@@ -232,11 +813,13 @@ async function isStaleLock(lockDirectory) {
   }
 }
 function isAlreadyExistsError(error) {
-  return Boolean(error && typeof error === "object" && "code" in error && error.code === "EEXIST");
+  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");
+  const owner = await readFile2(join(lockDirectory, "owner"), "utf8");
   return owner.split("\n", 1)[0] || null;
 }
 function wait(ms) {
@@ -245,41 +828,49 @@ function wait(ms) {
   });
 }
 function isMissingFileError(error) {
-  return Boolean(error && typeof error === "object" && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR"));
+  return Boolean(
+    error && typeof error === "object" && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR")
+  );
 }
 
-// ../orchestrator/dist/fs-store.js
-import { mkdir as mkdir2, open, rename as rename2, rm as rm2, stat as stat2, writeFile as writeFile2, appendFile } from "fs/promises";
+// ../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 {
-  runtimeRoot;
-  resolvedRuntimeRoot;
-  resolvedEventsMirrorRoot;
   constructor(runtimeRoot, options = {}) {
     this.runtimeRoot = runtimeRoot;
     this.resolvedRuntimeRoot = resolve(runtimeRoot);
     this.resolvedEventsMirrorRoot = options.eventsMirrorRoot ? resolve(options.eventsMirrorRoot) : null;
   }
-  projectsRoot() {
-    return join2(this.runtimeRoot, "projects");
-  }
-  projectDir(projectId) {
-    return join2(this.projectsRoot(), projectId);
+  resolvedRuntimeRoot;
+  resolvedEventsMirrorRoot;
+  projectDir(_projectId) {
+    return this.runtimeRoot;
   }
-  projectRunsDir(projectId) {
-    return join2(this.projectDir(projectId), "runs");
+  runsDir() {
+    return join2(this.runtimeRoot, "runs");
   }
-  runDir(runId, projectId) {
-    if (!projectId) {
-      return join2(this.runtimeRoot, "projects", "__unknown__", "runs", runId);
-    }
-    return join2(this.projectRunsDir(projectId), runId);
+  runDir(runId, _projectId) {
+    return join2(this.runsDir(), runId);
   }
   async loadProjectConfig(projectId) {
-    return readJsonFile(join2(this.projectDir(projectId), "project.json"));
+    return readJsonFile(
+      join2(this.projectDir(projectId), "project.json")
+    );
   }
   async saveProjectConfig(config) {
-    await writeJsonFile(join2(this.projectDir(config.projectId), "project.json"), config);
+    await writeJsonFile(
+      join2(this.projectDir(config.projectId), "project.json"),
+      config
+    );
   }
   async loadProjectIssueOrchestrations(projectId) {
     const issuesPath = join2(this.projectDir(projectId), "issues.json");
@@ -295,53 +886,74 @@ var OrchestratorFsStore = class {
     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
-    }));
+    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);
+    await writeJsonFile(
+      join2(this.projectDir(projectId), "issues.json"),
+      issues
+    );
   }
   async saveProjectStatus(status) {
-    await writeJsonFile(join2(this.projectDir(status.projectId), "status.json"), status);
+    await writeJsonFile(
+      join2(this.projectDir(), "status.json"),
+      status
+    );
   }
   async loadProjectStatus(projectId) {
-    return await readJsonFile(join2(this.projectDir(projectId), "status.json")) ?? null;
+    return await readJsonFile(
+      join2(this.projectDir(projectId), "status.json")
+    ) ?? null;
   }
   async loadRun(runId, projectId) {
     const runDirectory = projectId !== void 0 ? this.runDir(runId, projectId) : await this.findRunDir(runId);
     if (!runDirectory) {
       return null;
     }
-    return await readJsonFile(join2(runDirectory, "run.json")) ?? 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"))));
+    const runIds = await safeReadDir(this.runsDir());
+    const runs = await Promise.all(
+      runIds.map(
+        (runId) => readJsonFile(
+          join2(this.runDir(runId), "run.json")
+        )
+      )
+    );
     return runs.filter((run) => Boolean(run));
   }
   async saveRun(run) {
-    await writeJsonFile(join2(this.runDir(run.runId, run.projectId), "run.json"), run);
+    await writeJsonFile(
+      join2(this.runDir(run.runId, run.projectId), "run.json"),
+      run
+    );
   }
   async appendRunEvent(runId, event) {
     const resolvedProjectId = "projectId" in event && typeof event.projectId === "string" ? event.projectId : void 0;
     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}`);
+      throw new Error(
+        `Unable to resolve run directory for event append: ${runId}`
+      );
     }
     const path = join2(runDirectory, "events.ndjson");
     const resolvedPath = resolve(path);
@@ -362,7 +974,9 @@ var OrchestratorFsStore = class {
         mode: 420
       });
     } catch (error) {
-      console.warn(`Failed to mirror orchestrator event log to ${mirrorPath}: ${error instanceof Error ? error.message : String(error)}`);
+      console.warn(
+        `Failed to mirror orchestrator event log to ${mirrorPath}: ${error instanceof Error ? error.message : String(error)}`
+      );
     }
   }
   async loadRecentRunEvents(runId, limit = 20, projectId) {
@@ -387,999 +1001,111 @@ var OrchestratorFsStore = class {
           await handle.read(chunk, 0, readSize, position);
           tail = Buffer.concat([chunk, tail]);
           const events = parseRecentEvents(tail.toString("utf8"), limit, {
-            allowPartialFirstLine: position > 0
-          });
-          if (events.length >= limit) {
-            return events;
-          }
-        }
-        return parseRecentEvents(tail.toString("utf8"), limit, {
-          allowPartialFirstLine: false
-        });
-      } finally {
-        await handle.close();
-      }
-    } catch (error) {
-      if (isFileMissing(error)) {
-        return [];
-      }
-      throw error;
-    }
-  }
-  issueWorkspaceDir(projectId, workspaceKey) {
-    return join2(this.projectDir(projectId), "issues", workspaceKey);
-  }
-  async loadIssueWorkspace(projectId, workspaceKey) {
-    return await readJsonFile(join2(this.issueWorkspaceDir(projectId, workspaceKey), "workspace.json")) ?? null;
-  }
-  async loadIssueWorkspaces(projectId) {
-    const issuesDir = join2(this.projectDir(projectId), "issues");
-    const entries = await safeReadDir(issuesDir);
-    const records = await Promise.all(entries.map((entry) => this.loadIssueWorkspace(projectId, entry)));
-    return records.filter((record) => Boolean(record));
-  }
-  async saveIssueWorkspace(record) {
-    await writeJsonFile(join2(this.issueWorkspaceDir(record.projectId, record.workspaceKey), "workspace.json"), record);
-  }
-  async removeIssueWorkspace(projectId, workspaceKey) {
-    const dir = this.issueWorkspaceDir(projectId, workspaceKey);
-    await rm2(dir, { recursive: true, force: true });
-  }
-  async findRunDir(runId) {
-    const projectIds = await safeReadDir(this.projectsRoot());
-    for (const projectId of projectIds) {
-      const candidate = this.runDir(runId, projectId);
-      const run = await readJsonFile(join2(candidate, "run.json"));
-      if (run || await pathExists(join2(candidate, "events.ndjson"))) {
-        return candidate;
-      }
-    }
-    return null;
-  }
-  resolveMirroredEventsPath(primaryPath) {
-    if (!this.resolvedEventsMirrorRoot) {
-      return null;
-    }
-    const relativePath = relative(this.resolvedRuntimeRoot, primaryPath);
-    if (relativePath.startsWith("..")) {
-      return null;
-    }
-    const mirrorPath = join2(this.resolvedEventsMirrorRoot, relativePath);
-    return mirrorPath === primaryPath ? null : mirrorPath;
-  }
-};
-async function writeJsonFile(path, value) {
-  await mkdir2(dirname(path), { recursive: true });
-  const temporaryPath = `${path}.tmp`;
-  await writeFile2(temporaryPath, JSON.stringify(value, null, 2) + "\n", "utf8");
-  await rename2(temporaryPath, path);
-}
-async function pathExists(path) {
-  try {
-    await stat2(path);
-    return true;
-  } catch (error) {
-    if (isFileMissing(error)) {
-      return false;
-    }
-    throw error;
-  }
-}
-
-// ../tracker-github/dist/adapter.js
-import { createHash } from "crypto";
-var DEFAULT_API_URL = "https://api.github.com/graphql";
-var DEFAULT_PAGE_SIZE = 25;
-var DEFAULT_NETWORK_TIMEOUT_MS = 3e4;
-var RATE_LIMIT_THRESHOLD = 100;
-var MAX_RATE_LIMIT_WAIT_MS = 6e4;
-var GitHubTrackerError = class extends Error {
-};
-var GitHubTrackerHttpError = class extends GitHubTrackerError {
-  status;
-  details;
-  constructor(message, status, details) {
-    super(message);
-    this.status = status;
-    this.details = details;
-  }
-};
-var GitHubTrackerQueryError = class extends GitHubTrackerError {
-};
-var cachedGitHubGraphQLRateLimits = /* @__PURE__ */ new Map();
-function normalizeProjectItem(projectId, item, lifecycle = DEFAULT_WORKFLOW_LIFECYCLE, priority = {}, rateLimits = null) {
-  if (item.content?.__typename !== "Issue") {
-    return null;
-  }
-  const fieldValues = extractFieldValues(item.fieldValues?.nodes ?? []);
-  const state = fieldValues[lifecycle.stateFieldName] ?? "Unknown";
-  const repository = item.content.repository;
-  const blockedBy = (item.content.blockedBy?.nodes ?? []).flatMap((node) => node ? [
-    {
-      id: node.id,
-      identifier: `${node.repository.owner.login}/${node.repository.name}#${node.number}`,
-      state: normalizeBlockerState(node.state, lifecycle)
-    }
-  ] : []);
-  const issueUpdatedAtMs = parseTimestampMs(item.content.updatedAt);
-  const itemUpdatedAtMs = parseTimestampMs(item.updatedAt);
-  const trackedUpdatedAt = itemUpdatedAtMs !== null && (issueUpdatedAtMs === null || itemUpdatedAtMs > issueUpdatedAtMs) ? item.updatedAt : item.content.updatedAt ?? item.updatedAt;
-  return {
-    id: item.content.id,
-    identifier: `${repository.owner.login}/${repository.name}#${item.content.number}`,
-    number: item.content.number,
-    title: item.content.title,
-    description: item.content.body,
-    priority: resolvePriority(item, priority),
-    state,
-    branchName: null,
-    url: item.content.url,
-    labels: (item.content.labels?.nodes ?? []).flatMap((label) => label?.name ? [label.name.toLowerCase()] : []).sort(),
-    blockedBy,
-    createdAt: item.content.createdAt,
-    updatedAt: trackedUpdatedAt,
-    repository: {
-      owner: repository.owner.login,
-      name: repository.name,
-      url: repository.url,
-      cloneUrl: deriveCloneUrl(repository.url)
-    },
-    tracker: {
-      adapter: "github-project",
-      bindingId: projectId,
-      itemId: item.id
-    },
-    metadata: fieldValues,
-    rateLimits
-  };
-}
-async function fetchProjectIssues(config, fetchImpl = fetch) {
-  const issues = [];
-  let cursor = null;
-  const priorityOptionIds = config.priorityFieldName ? await fetchPriorityOptionOrder(config, config.priorityFieldName, fetchImpl) : void 0;
-  const currentUserLogin = config.assignedOnly ? await fetchCurrentUserLogin(config, fetchImpl) : null;
-  let excludedCount = 0;
-  let latestRateLimits = null;
-  do {
-    const pageResult = await fetchProjectItemsPage(config, cursor, fetchImpl);
-    const page = pageResult.page;
-    latestRateLimits = pageResult.rateLimits ?? latestRateLimits;
-    const pageIssues = (page.nodes ?? []).flatMap((item) => {
-      if (!item) {
-        return [];
-      }
-      const normalized = normalizeProjectItem(config.projectId, item, config.lifecycle, {
-        fieldName: config.priorityFieldName,
-        optionIds: priorityOptionIds
-      }, latestRateLimits);
-      if (!normalized) {
-        return [];
-      }
-      if (currentUserLogin && !isIssueAssignedToLogin(item, currentUserLogin)) {
-        excludedCount += 1;
-        return [];
-      }
-      return [normalized];
-    });
-    issues.push(...pageIssues);
-    cursor = page.pageInfo.hasNextPage ? page.pageInfo.endCursor : null;
-  } while (cursor);
-  if (currentUserLogin) {
-    emitAssignedOnlyFilterEvent({
-      projectId: config.projectId,
-      currentUserLogin,
-      includedCount: issues.length,
-      excludedCount
-    });
-  }
-  if (latestRateLimits) {
-    for (const issue of issues) {
-      issue.rateLimits = latestRateLimits;
-    }
-  }
-  return issues;
-}
-async function fetchIssueStatesByIds(config, issueIds, fetchImpl = fetch) {
-  if (issueIds.length === 0) {
-    return [];
-  }
-  const issues = [];
-  for (const issueIdBatch of chunkValues([...new Set(issueIds)], 100)) {
-    const result = await executeGraphQLQueryWithMetadata(config, ISSUE_STATES_BY_IDS_QUERY, {
-      issueIds: issueIdBatch
-    }, fetchImpl);
-    const data = result.data;
-    const rateLimits = result.rateLimits;
-    for (const node of data.nodes ?? []) {
-      const projectItem = await resolveIssueProjectItemForStateLookup(config, node, fetchImpl);
-      const normalized = normalizeIssueStateLookupNode(config.projectId, node, projectItem, config.lifecycle, rateLimits);
-      if (normalized) {
-        issues.push(normalized);
-      }
-    }
-  }
-  return issues;
-}
-async function fetchProjectItemsPage(config, cursor, fetchImpl) {
-  const result = await executeGraphQLQueryWithMetadata(config, PROJECT_ITEMS_QUERY, {
-    projectId: config.projectId,
-    cursor,
-    pageSize: config.pageSize ?? DEFAULT_PAGE_SIZE
-  }, fetchImpl);
-  const data = result.data;
-  const items = data.node?.items;
-  if (!items) {
-    throw new GitHubTrackerQueryError("GitHub GraphQL response did not include project items.");
-  }
-  return {
-    page: items,
-    rateLimits: result.rateLimits
-  };
-}
-var fetchGithubProjectIssues = fetchProjectIssues;
-var fetchGithubIssueStatesByIds = fetchIssueStatesByIds;
-async function fetchCurrentUserLogin(config, fetchImpl) {
-  const response = await fetchImpl(resolveRestUserApiUrl(config.apiUrl), {
-    method: "GET",
-    headers: {
-      authorization: `Bearer ${config.token}`,
-      "user-agent": "gh-symphony",
-      accept: "application/vnd.github+json"
-    },
-    signal: buildRequestSignal(config.timeoutMs)
-  });
-  if (!response.ok) {
-    const details = await response.text();
-    throw new GitHubTrackerHttpError(`GitHub REST request failed with status ${response.status}`, response.status, details);
-  }
-  const payload = await response.json();
-  if (!payload.login) {
-    throw new GitHubTrackerQueryError("GitHub REST response did not include the authenticated user login.");
-  }
-  return payload.login;
-}
-function isIssueAssignedToLogin(item, login) {
-  if (item.content?.__typename !== "Issue") {
-    return false;
-  }
-  return (item.content.assignees?.nodes ?? []).some((assignee) => assignee?.login === login);
-}
-function emitAssignedOnlyFilterEvent(input) {
-  console.info(JSON.stringify({
-    event: "tracker-assigned-only-filtered",
-    projectId: input.projectId,
-    currentUserLogin: input.currentUserLogin,
-    includedCount: input.includedCount,
-    excludedCount: input.excludedCount
-  }));
-}
-function extractFieldValues(nodes) {
-  return nodes.reduce((values, node) => {
-    const fieldName = node?.field?.name;
-    if (!fieldName) {
-      return values;
-    }
-    if (node.__typename === "ProjectV2ItemFieldSingleSelectValue" && node.name) {
-      values[fieldName] = node.name;
-    }
-    if (node.__typename === "ProjectV2ItemFieldTextValue" && node.text) {
-      values[fieldName] = node.text;
-    }
-    return values;
-  }, {});
-}
-function normalizeIssueStateLookupNode(projectId, issue, projectItem, lifecycle = DEFAULT_WORKFLOW_LIFECYCLE, rateLimits = null) {
-  if (issue?.__typename !== "Issue") {
-    return null;
-  }
-  if (!projectItem) {
-    return null;
-  }
-  const fieldValues = extractFieldValues(projectItem.fieldValues?.nodes ?? []);
-  const state = fieldValues[lifecycle.stateFieldName] ?? "Unknown";
-  const repository = issue.repository;
-  const identifier = `${repository.owner.login}/${repository.name}#${issue.number}`;
-  return {
-    id: issue.id,
-    identifier,
-    number: issue.number,
-    title: identifier,
-    description: null,
-    priority: null,
-    state,
-    branchName: null,
-    url: `${repository.url}/issues/${issue.number}`,
-    labels: [],
-    blockedBy: [],
-    createdAt: null,
-    updatedAt: projectItem.updatedAt ?? issue.updatedAt,
-    repository: {
-      owner: repository.owner.login,
-      name: repository.name,
-      url: repository.url,
-      cloneUrl: deriveCloneUrl(repository.url)
-    },
-    tracker: {
-      adapter: "github-project",
-      bindingId: projectId,
-      itemId: projectItem.id
-    },
-    metadata: fieldValues,
-    rateLimits
-  };
-}
-async function resolveIssueProjectItemForStateLookup(config, issue, fetchImpl) {
-  if (issue?.__typename !== "Issue") {
-    return null;
-  }
-  let connection = issue.projectItems;
-  let projectItem = findProjectItemByProjectId(connection?.nodes ?? [], config.projectId);
-  let cursor = connection?.pageInfo.endCursor ?? null;
-  while (!projectItem && connection?.pageInfo.hasNextPage) {
-    const nextPage = await fetchIssueProjectItemsPage(config, issue.id, cursor, fetchImpl);
-    projectItem = findProjectItemByProjectId(nextPage.nodes ?? [], config.projectId);
-    connection = nextPage;
-    cursor = nextPage.pageInfo.endCursor;
-  }
-  return projectItem;
-}
-async function fetchIssueProjectItemsPage(config, issueId, cursor, fetchImpl) {
-  const result = await executeGraphQLQueryWithMetadata(config, ISSUE_PROJECT_ITEMS_PAGE_QUERY, {
-    issueId,
-    cursor
-  }, fetchImpl);
-  const data = result.data;
-  const issue = data.node;
-  if (issue?.__typename !== "Issue" || !issue.projectItems) {
-    throw new GitHubTrackerQueryError("GitHub GraphQL response did not include issue project items.");
-  }
-  return issue.projectItems;
-}
-function findProjectItemByProjectId(nodes, projectId) {
-  return nodes.find((item) => item?.project?.id === projectId) ?? null;
-}
-function resolvePriority(item, priority) {
-  if (!priority.fieldName || !priority.optionIds) {
-    return null;
-  }
-  for (const node of item.fieldValues?.nodes ?? []) {
-    if (node?.__typename === "ProjectV2ItemFieldSingleSelectValue" && node.field?.name === priority.fieldName && node.optionId) {
-      return priority.optionIds[node.optionId] ?? null;
-    }
-  }
-  return null;
-}
-function extractPriorityOptionOrder(fields, priorityFieldName) {
-  for (const field of fields) {
-    if (isSingleSelectProjectField(field) && field.name === priorityFieldName) {
-      let nextPriority = 0;
-      const optionEntries = (field.options ?? []).flatMap((option) => {
-        if (!option?.id) {
-          return [];
-        }
-        const entry = [option.id, nextPriority];
-        nextPriority += 1;
-        return [entry];
-      });
-      return Object.fromEntries(optionEntries);
-    }
-  }
-  return void 0;
-}
-async function fetchPriorityOptionOrder(config, priorityFieldName, fetchImpl) {
-  const data = await executeGraphQLQuery(config, PROJECT_FIELDS_QUERY, { projectId: config.projectId }, fetchImpl);
-  return extractPriorityOptionOrder(data.node?.fields?.nodes ?? [], priorityFieldName);
-}
-function isSingleSelectProjectField(field) {
-  return field?.__typename === "ProjectV2SingleSelectField";
-}
-function deriveCloneUrl(repositoryUrl) {
-  if (repositoryUrl.startsWith("file://") || repositoryUrl.endsWith(".git")) {
-    return repositoryUrl;
-  }
-  return `${repositoryUrl}.git`;
-}
-function normalizeBlockerState(state, lifecycle) {
-  if (!state) {
-    return null;
-  }
-  const normalized = state.trim().toLowerCase();
-  if (normalized === "closed") {
-    return lifecycle.terminalStates[0] ?? state;
-  }
-  if (normalized === "open") {
-    return null;
-  }
-  return state;
-}
-function resolveRestUserApiUrl(apiUrl) {
-  const parsed = new URL(apiUrl ?? DEFAULT_API_URL);
-  const pathSegments = parsed.pathname.split("/").filter(Boolean);
-  if (pathSegments.at(-1) === "graphql") {
-    pathSegments.pop();
-  }
-  parsed.pathname = `/${pathSegments.join("/")}/user`.replace(/\/{2,}/g, "/");
-  parsed.search = "";
-  parsed.hash = "";
-  return parsed.toString();
-}
-function chunkValues(values, size) {
-  const chunks = [];
-  for (let index = 0; index < values.length; index += size) {
-    chunks.push(values.slice(index, index + size));
-  }
-  return chunks;
-}
-function buildRequestSignal(timeoutMs) {
-  return AbortSignal.timeout(resolveNetworkTimeoutMs(timeoutMs));
-}
-function resolveNetworkTimeoutMs(timeoutMs) {
-  if (timeoutMs !== void 0 && Number.isInteger(timeoutMs) && timeoutMs > 0) {
-    return timeoutMs;
-  }
-  return DEFAULT_NETWORK_TIMEOUT_MS;
-}
-async function executeGraphQLQuery(config, query, variables, fetchImpl) {
-  const result = await executeGraphQLQueryWithMetadata(config, query, variables, fetchImpl);
-  return result.data;
-}
-async function executeGraphQLQueryWithMetadata(config, query, variables, fetchImpl) {
-  const tokenFingerprint = fingerprintToken(config.token);
-  await guardGraphQLRateLimit(tokenFingerprint);
-  const response = await fetchImpl(config.apiUrl ?? DEFAULT_API_URL, {
-    method: "POST",
-    headers: {
-      "content-type": "application/json",
-      authorization: `Bearer ${config.token}`
-    },
-    body: JSON.stringify({
-      query,
-      variables
-    }),
-    signal: buildRequestSignal(config.timeoutMs)
-  });
-  if (!response.ok) {
-    const details = await response.text();
-    throw new GitHubTrackerHttpError(`GitHub GraphQL request failed with status ${response.status}`, response.status, details);
-  }
-  const payload = await response.json();
-  if (payload.errors?.length) {
-    throw new GitHubTrackerQueryError(payload.errors.map((error) => error.message).join("; "));
-  }
-  if (!payload.data) {
-    throw new GitHubTrackerQueryError("GitHub GraphQL response did not include data.");
-  }
-  const data = payload.data;
-  const rateLimits = extractGitHubRateLimits(response.headers);
-  cachedGitHubGraphQLRateLimits.set(tokenFingerprint, rateLimits);
-  return {
-    data,
-    rateLimits
-  };
-}
-async function guardGraphQLRateLimit(tokenFingerprint) {
-  const rateLimit = cachedGitHubGraphQLRateLimits.get(tokenFingerprint) ?? null;
-  if (!rateLimit) {
-    return;
-  }
-  const remaining = rateLimit.remaining;
-  if (remaining === null || remaining > RATE_LIMIT_THRESHOLD) {
-    return;
-  }
-  const resetAtMs = parseTimestampMs(rateLimit.resetAt);
-  if (resetAtMs === null) {
-    throw new GitHubTrackerError("Rate limit near exhaustion");
-  }
-  const waitMs = Math.max(0, resetAtMs - Date.now());
-  if (waitMs > MAX_RATE_LIMIT_WAIT_MS) {
-    throw new GitHubTrackerError("Rate limit near exhaustion");
-  }
-  cachedGitHubGraphQLRateLimits.delete(tokenFingerprint);
-  if (waitMs > 0) {
-    await sleep(waitMs);
-  }
-}
-function fingerprintToken(token) {
-  return createHash("sha256").update(token).digest("hex");
-}
-function extractGitHubRateLimits(headers) {
-  if (!headers || typeof headers.get !== "function") {
-    return null;
-  }
-  const limit = parseIntegerHeader(headers.get("x-ratelimit-limit"));
-  const remaining = parseIntegerHeader(headers.get("x-ratelimit-remaining"));
-  const used = parseIntegerHeader(headers.get("x-ratelimit-used"));
-  const reset = parseIntegerHeader(headers.get("x-ratelimit-reset"));
-  const resource = headers.get("x-ratelimit-resource");
-  if (limit === null && remaining === null && used === null && reset === null && resource === null) {
-    return null;
-  }
-  return {
-    source: "github",
-    limit,
-    remaining,
-    used,
-    reset,
-    resetAt: reset === null ? null : new Date(reset * 1e3).toISOString(),
-    resource
-  };
-}
-function parseIntegerHeader(value) {
-  if (value === null) {
-    return null;
-  }
-  const parsed = Number.parseInt(value, 10);
-  return Number.isFinite(parsed) ? parsed : null;
-}
-function parseTimestampMs(value) {
-  if (!value) {
-    return null;
-  }
-  const timestampMs = Date.parse(value);
-  return Number.isFinite(timestampMs) ? timestampMs : null;
-}
-function sleep(ms) {
-  return new Promise((resolve4) => {
-    setTimeout(resolve4, ms);
-  });
-}
-var PROJECT_ITEMS_QUERY = `
-  query ProjectItems($projectId: ID!, $cursor: String, $pageSize: Int!) {
-    node(id: $projectId) {
-      __typename
-      ... on ProjectV2 {
-        items(first: $pageSize, after: $cursor) {
-          nodes {
-            id
-            updatedAt
-            fieldValues(first: 20) {
-              nodes {
-                __typename
-                ... on ProjectV2ItemFieldSingleSelectValue {
-                  name
-                  optionId
-                  field {
-                    ... on ProjectV2SingleSelectField {
-                      name
-                    }
-                  }
-                }
-                ... on ProjectV2ItemFieldTextValue {
-                  text
-                  field {
-                    ... on ProjectV2FieldCommon {
-                      name
-                    }
-                  }
-                }
-              }
-            }
-            content {
-              __typename
-              ... on Issue {
-                id
-                number
-                title
-                body
-                url
-                createdAt
-                updatedAt
-                labels(first: 20) {
-                  nodes {
-                    name
-                  }
-                }
-                assignees(first: 20) {
-                  nodes {
-                    login
-                  }
-                }
-                repository {
-                  name
-                  url
-                  owner {
-                    login
-                  }
-                }
-                blockedBy(first: 100) {
-                  nodes {
-                    id
-                    number
-                    state
-                    repository {
-                      name
-                      owner {
-                        login
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-          pageInfo {
-            endCursor
-            hasNextPage
-          }
-        }
-      }
-    }
-  }
-`;
-var PROJECT_FIELDS_QUERY = `
-  query ProjectFields($projectId: ID!) {
-    node(id: $projectId) {
-      __typename
-      ... on ProjectV2 {
-        fields(first: 100) {
-          nodes {
-            __typename
-            ... on ProjectV2SingleSelectField {
-              name
-              options {
-                id
-                name
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-`;
-var ISSUE_STATES_BY_IDS_QUERY = `
-  query IssueStatesByIds($issueIds: [ID!]!) {
-    nodes(ids: $issueIds) {
-      __typename
-      ... on Issue {
-        id
-        number
-        updatedAt
-        repository {
-          name
-          url
-          owner {
-            login
-          }
-        }
-        projectItems(first: 100, includeArchived: false) {
-          nodes {
-            id
-            updatedAt
-            project {
-              id
-            }
-            fieldValues(first: 20) {
-              nodes {
-                __typename
-                ... on ProjectV2ItemFieldSingleSelectValue {
-                  name
-                  optionId
-                  field {
-                    ... on ProjectV2SingleSelectField {
-                      name
-                    }
-                  }
-                }
-                ... on ProjectV2ItemFieldTextValue {
-                  text
-                  field {
-                    ... on ProjectV2FieldCommon {
-                      name
-                    }
-                  }
-                }
-              }
-            }
-          }
-          pageInfo {
-            endCursor
-            hasNextPage
-          }
-        }
-      }
-    }
-  }
-`;
-var ISSUE_PROJECT_ITEMS_PAGE_QUERY = `
-  query IssueProjectItemsPage($issueId: ID!, $cursor: String) {
-    node(id: $issueId) {
-      __typename
-      ... on Issue {
-        id
-        number
-        updatedAt
-        repository {
-          name
-          url
-          owner {
-            login
-          }
-        }
-        projectItems(first: 100, after: $cursor, includeArchived: false) {
-          nodes {
-            id
-            updatedAt
-            project {
-              id
-            }
-            fieldValues(first: 20) {
-              nodes {
-                __typename
-                ... on ProjectV2ItemFieldSingleSelectValue {
-                  name
-                  optionId
-                  field {
-                    ... on ProjectV2SingleSelectField {
-                      name
-                    }
-                  }
-                }
-                ... on ProjectV2ItemFieldTextValue {
-                  text
-                  field {
-                    ... on ProjectV2FieldCommon {
-                      name
-                    }
-                  }
-                }
-              }
-            }
-          }
-          pageInfo {
-            endCursor
-            hasNextPage
-          }
-        }
-      }
-    }
-  }
-`;
-
-// ../tracker-github/dist/orchestrator-adapter.js
-import { createHash as createHash2 } from "crypto";
-var githubProjectTrackerAdapter = {
-  async listIssues(project, dependencies = {}) {
-    return listProjectIssues(project, dependencies);
-  },
-  async listIssuesByStates(project, states, dependencies = {}) {
-    if (states.length === 0) {
-      return [];
-    }
-    const issues = await listProjectIssues(project, dependencies);
-    const normalizedStates = new Set(states.map((state) => state.trim().toLowerCase()));
-    return issues.filter((issue) => normalizedStates.has(issue.state.trim().toLowerCase()));
-  },
-  async fetchIssueStatesByIds(project, issueIds, dependencies = {}) {
-    if (issueIds.length === 0) {
-      return [];
-    }
-    return fetchProjectIssueStatesByIds(project, issueIds, dependencies);
-  },
-  buildWorkerEnvironment(project) {
-    return {
-      GITHUB_PROJECT_ID: requireTrackerSetting(project.tracker, "projectId")
-    };
-  },
-  reviveIssue(project, run) {
-    return {
-      id: run.issueId,
-      identifier: run.issueIdentifier,
-      number: parseIssueNumber(run.issueIdentifier),
-      title: run.issueTitle ?? run.issueIdentifier,
-      description: null,
-      priority: null,
-      state: run.issueState,
-      branchName: null,
-      url: null,
-      labels: [],
-      blockedBy: [],
-      createdAt: null,
-      updatedAt: null,
-      repository: run.repository,
-      tracker: {
-        adapter: "github-project",
-        bindingId: project.tracker.bindingId,
-        itemId: run.issueId
-      },
-      metadata: {}
-    };
-  }
-};
-async function listProjectIssues(project, dependencies = {}) {
-  const trackerConfig = resolveGitHubTrackerConfig(project, dependencies);
-  const loadProjectIssues = () => fetchGithubProjectIssues(trackerConfig, dependencies.fetchImpl);
-  return dependencies.projectItemsCache?.getOrLoad(buildProjectItemsCacheKey(trackerConfig, dependencies), loadProjectIssues) ?? loadProjectIssues();
-}
-async function fetchProjectIssueStatesByIds(project, issueIds, dependencies = {}) {
-  const trackerConfig = resolveGitHubTrackerConfig(project, dependencies);
-  return fetchGithubIssueStatesByIds(trackerConfig, [...issueIds], dependencies.fetchImpl);
-}
-function resolveGitHubTrackerConfig(project, dependencies = {}) {
-  const token = dependencies.token ?? process.env.GITHUB_GRAPHQL_TOKEN;
-  if (!token) {
-    throw new Error("GITHUB_GRAPHQL_TOKEN environment variable is required. Run 'gh auth token' or set the variable.");
-  }
-  const githubProjectId = requireTrackerSetting(project.tracker, "projectId");
-  return {
-    projectId: githubProjectId,
-    token,
-    apiUrl: project.tracker.apiUrl,
-    assignedOnly: readBooleanTrackerSetting(project.tracker, "assignedOnly"),
-    priorityFieldName: readOptionalStringTrackerSetting(project.tracker, "priorityFieldName"),
-    timeoutMs: readNumberTrackerSetting(project.tracker, "timeoutMs")
-  };
-}
-function buildProjectItemsCacheKey(config, _dependencies) {
-  return JSON.stringify({
-    adapter: "github-project",
-    apiUrl: config.apiUrl,
-    assignedOnly: config.assignedOnly ?? false,
-    priorityFieldName: config.priorityFieldName ?? null,
-    projectId: config.projectId,
-    timeoutMs: config.timeoutMs,
-    tokenFingerprint: hashToken(config.token)
-  });
-}
-function hashToken(token) {
-  if (!token) {
-    return null;
-  }
-  return createHash2("sha256").update(token).digest("hex");
-}
-var trackerAdapters = {
-  "github-project": githubProjectTrackerAdapter
-};
-function resolveTrackerAdapter(tracker) {
-  const adapter = trackerAdapters[tracker.adapter];
-  if (!adapter) {
-    throw new Error(`Unsupported tracker adapter: ${tracker.adapter}`);
-  }
-  return adapter;
-}
-function requireTrackerSetting(tracker, key) {
-  const value = tracker.settings?.[key];
-  if (typeof value !== "string" || value.length === 0) {
-    throw new Error(`Tracker adapter "${tracker.adapter}" requires the "${key}" setting.`);
-  }
-  return value;
-}
-function readBooleanTrackerSetting(tracker, key) {
-  const value = tracker.settings?.[key];
-  return value === true || value === "true";
-}
-function readNumberTrackerSetting(tracker, key) {
-  const value = tracker.settings?.[key];
-  if (value === void 0) {
-    return void 0;
-  }
-  if (typeof value === "number" && Number.isInteger(value) && value > 0) {
-    return value;
-  }
-  if (typeof value === "string") {
-    const parsed = Number(value);
-    if (Number.isInteger(parsed) && parsed > 0) {
-      return parsed;
-    }
-  }
-  throw new Error(`Tracker adapter "${tracker.adapter}" requires the "${key}" setting to be a positive integer when provided.`);
-}
-function readOptionalStringTrackerSetting(tracker, key) {
-  const value = tracker.settings?.[key];
-  return typeof value === "string" && value.length > 0 ? value : void 0;
-}
-function parseIssueNumber(identifier) {
-  const match = identifier.match(/#(\d+)$/);
-  return match ? Number.parseInt(match[1] ?? "0", 10) : 0;
-}
-
-// ../tracker-file/dist/file-tracker-adapter.js
-import { readFile as readFile2 } from "fs/promises";
-function requireTrackerSetting2(project, key) {
-  const value = project.tracker.settings?.[key];
-  if (typeof value !== "string" || value.length === 0) {
-    throw new Error(`Tracker adapter "file" requires the "${key}" setting.`);
-  }
-  return value;
-}
-function parseIssueNumber2(identifier) {
-  const match = identifier.match(/#(\d+)$/);
-  return match ? Number.parseInt(match[1] ?? "0", 10) : 0;
-}
-function isValidIssueShape(entry) {
-  if (!entry || typeof entry !== "object")
-    return false;
-  const e = entry;
-  return typeof e.id === "string" && typeof e.identifier === "string" && typeof e.state === "string" && e.repository !== null && typeof e.repository === "object" && e.tracker !== null && typeof e.tracker === "object";
-}
-var fileTrackerAdapter = {
-  async listIssues(project) {
-    const issuesPath = requireTrackerSetting2(project, "issuesPath");
-    try {
-      const raw = await readFile2(issuesPath, "utf-8");
-      const parsed = JSON.parse(raw);
-      if (!Array.isArray(parsed)) {
-        throw new Error(`Expected an array of issues in ${issuesPath}, got ${typeof parsed}`);
-      }
-      const valid = [];
-      for (let i = 0; i < parsed.length; i++) {
-        if (isValidIssueShape(parsed[i])) {
-          valid.push(parsed[i]);
-        } else {
-          process.stderr.write(`[tracker-file] Skipping invalid issue at index ${i} in ${issuesPath}
-`);
+            allowPartialFirstLine: position > 0
+          });
+          if (events.length >= limit) {
+            return events;
+          }
         }
+        return parseRecentEvents(tail.toString("utf8"), limit, {
+          allowPartialFirstLine: false
+        });
+      } finally {
+        await handle.close();
       }
-      return valid;
-    } catch (err) {
-      if (err instanceof Error && "code" in err && err.code === "ENOENT") {
-        return [];
-      }
-      if (err instanceof SyntaxError) {
+    } catch (error) {
+      if (isFileMissing(error)) {
         return [];
       }
-      throw err;
+      throw error;
     }
-  },
-  async listIssuesByStates(project, states) {
-    if (states.length === 0) {
-      return [];
+  }
+  issueWorkspaceDir(projectId, workspaceKey) {
+    return join2(this.runtimeRoot, workspaceKey);
+  }
+  async loadIssueWorkspace(projectId, workspaceKey) {
+    return await readJsonFile(
+      join2(this.issueWorkspaceDir(projectId, workspaceKey), "workspace.json")
+    ) ?? null;
+  }
+  async loadIssueWorkspaces(projectId) {
+    const entries = await safeReadDir(this.runtimeRoot);
+    const records = await Promise.all(
+      entries.map(async (entry) => {
+        if (!await this.isIssueWorkspaceEntry(entry)) {
+          return null;
+        }
+        return this.loadIssueWorkspace(projectId, entry);
+      })
+    );
+    return records.filter(
+      (record) => Boolean(record)
+    );
+  }
+  async isIssueWorkspaceEntry(entry) {
+    if (entry.startsWith(".") || entry === "cache" || entry === "issues.json" || entry === "project.json" || entry === "runs" || entry === "status.json") {
+      return false;
     }
-    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 [];
+    try {
+      return (await stat2(join2(this.runtimeRoot, entry))).isDirectory();
+    } catch {
+      return false;
     }
-    const issues = await this.listIssues(project);
-    const ids = new Set(issueIds);
-    return issues.filter((issue) => ids.has(issue.id));
-  },
-  buildWorkerEnvironment(_project, _issue) {
-    return {
-      SYMPHONY_FILE_TRACKER: "true"
-    };
-  },
-  reviveIssue(project, run) {
-    return {
-      id: run.issueId,
-      identifier: run.issueIdentifier,
-      number: parseIssueNumber2(run.issueIdentifier),
-      title: run.issueTitle ?? run.issueIdentifier,
-      description: null,
-      priority: null,
-      state: run.issueState,
-      branchName: null,
-      url: null,
-      labels: [],
-      blockedBy: [],
-      createdAt: null,
-      updatedAt: null,
-      repository: run.repository,
-      tracker: {
-        adapter: "file",
-        bindingId: project.tracker.bindingId,
-        itemId: run.issueId
-      },
-      metadata: {}
-    };
+  }
+  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 candidate = this.runDir(runId);
+    const run = await readJsonFile(
+      join2(candidate, "run.json")
+    );
+    if (run || await pathExists2(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;
   }
 };
-
-// ../orchestrator/dist/tracker-adapters.js
-var localAdapters = /* @__PURE__ */ new Map([
-  ["file", fileTrackerAdapter]
-]);
-function resolveTrackerAdapter2(tracker) {
-  const local = localAdapters.get(tracker.adapter);
-  if (local)
-    return local;
-  return resolveTrackerAdapter(tracker);
+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 pathExists2(path) {
+  try {
+    await stat2(path);
+    return true;
+  } catch (error) {
+    if (isFileMissing(error)) {
+      return false;
+    }
+    throw error;
+  }
 }
 
-// ../orchestrator/dist/service.js
+// ../orchestrator/src/service.ts
 var DEFAULT_POLL_INTERVAL_MS = 3e4;
 var DEFAULT_CONCURRENCY = 3;
 var DEFAULT_RETRY_BACKOFF_MS = 3e4;
@@ -1387,7 +1113,7 @@ 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 MAX_FAILURE_RETRIES_EXCEEDED_REASON2 = "max_failure_retries_exceeded";
 var STUCK_WORKER_TIMEOUT_MS = 30 * 60 * 1e3;
 function isUsableWorkflowResolution(resolution) {
   return resolution.isValid || resolution.usedLastKnownGood;
@@ -1410,9 +1136,11 @@ function parseFiniteNumber(value) {
   return null;
 }
 var OrchestratorService = class {
-  store;
-  projectConfig;
-  dependencies;
+  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();
@@ -1427,23 +1155,25 @@ var OrchestratorService = class {
   sleepResolver = null;
   reconcilePromise = Promise.resolve();
   reconcileRequested = false;
-  constructor(store, projectConfig, dependencies = {}) {
-    this.store = store;
-    this.projectConfig = projectConfig;
-    this.dependencies = dependencies;
-  }
   async run(options = {}) {
     this.running = true;
-    await this.runSerialized(() => this.performStartupCleanup(this.createTrackerDependencies()));
+    await this.runSerialized(
+      () => this.performStartupCleanup(this.createTrackerDependencies())
+    );
     while (this.running) {
       try {
-        const snapshot = await this.runOnceInternal(options.issueIdentifier, this.createTrackerDependencies());
+        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)}`);
+        this.writeStderr(
+          `[orchestrator] run loop failed for ${this.projectConfig.projectId}: ${this.formatErrorMessage(error)}`
+        );
       }
       if (options.once || !this.running) {
         return;
@@ -1452,20 +1182,38 @@ var OrchestratorService = class {
     }
   }
   async runOnce(options = {}) {
-    return this.runOnceInternal(options.issueIdentifier, this.createTrackerDependencies());
+    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);
+    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 currentRunCandidate = issueRecord.currentRunId ? await this.store.loadRun(
+      issueRecord.currentRunId,
+      this.projectConfig.projectId
+    ) : null;
+    const currentRun = isMatchingIssueRun(
+      currentRunCandidate,
+      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 {
@@ -1502,7 +1250,10 @@ var OrchestratorService = class {
         codex_session_logs: currentRun === null ? [] : [
           {
             label: "worker",
-            path: join3(this.store.runDir(currentRun.runId, currentRun.projectId), "worker.log"),
+            path: join3(
+              this.store.runDir(currentRun.runId, currentRun.projectId),
+              "worker.log"
+            ),
             url: null
           }
         ]
@@ -1564,7 +1315,9 @@ var OrchestratorService = class {
     if (this.dependencies.pollIntervalMs) {
       return this.dependencies.pollIntervalMs;
     }
-    const configuredIntervals = [...this.projectPollIntervals.values()].filter((value) => Number.isFinite(value) && value > 0);
+    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 = {}) {
@@ -1577,27 +1330,57 @@ var OrchestratorService = class {
     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));
+    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) => isActiveRunRecordStatus(run.status));
     for (const run of activeRuns) {
-      const outcome = await this.reconcileRun(tenant, run, issueRecords, trackerDependencies);
+      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);
+    const reconciledRuns = (await this.store.loadAllRuns()).filter(
+      (run) => run.projectId === tenant.projectId && isActiveRunRecordStatus(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 currentActiveRuns = (await this.store.loadAllRuns()).filter(
+        (run) => run.projectId === tenant.projectId && isActiveRunRecordStatus(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);
+      const trackedIssuesByIdentifier = new Map(
+        syncedIssuesByIdentifier
+      );
       for (const issue of filteredIssues) {
         const existing = trackedIssuesByIdentifier.get(issue.identifier);
         trackedIssuesByIdentifier.set(issue.identifier, {
@@ -1618,17 +1401,33 @@ var OrchestratorService = class {
           rateLimits: existing.rateLimits ?? issue.rateLimits ?? null
         });
       }
-      rateLimits = resolveProjectRateLimits(syncedActiveRuns, trackedIssuesByIdentifier.values());
-      trackerRateLimits = resolveTrackerRateLimits(trackedIssuesByIdentifier.values());
+      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 currentlyActive = issueRecords.filter(
+        (record) => isIssueOrchestrationClaimedState(record.state)
+      ).length;
       const availableSlots = Math.max(0, concurrency - currentlyActive);
-      const latestRunsByIssueId = buildLatestRunMapByIssueId(projectRunsAfterReconcile);
+      const latestRunsByIssueId = buildLatestRunMapByIssueId(
+        projectRunsAfterReconcile
+      );
       const unscheduledCandidates = actionableCandidates.filter((issue) => {
-        if (hasConvergenceLockedRun(projectRunsAfterReconcile, issue.id, issue.state, issue.updatedAt)) {
+        if (hasConvergenceLockedRunForIssue(
+          projectRunsAfterReconcile,
+          issue.id,
+          issue.state,
+          issue.updatedAt
+        )) {
           return false;
         }
-        return !issueRecords.some((record) => record.issueId === issue.id && isIssueOrchestrationClaimed(record.state));
+        return !issueRecords.some(
+          (record) => record.issueId === issue.id && isIssueOrchestrationClaimedState(record.state)
+        );
       });
       const sortedCandidates = sortCandidatesForDispatch(unscheduledCandidates);
       const activeByState = /* @__PURE__ */ new Map();
@@ -1643,9 +1442,13 @@ var OrchestratorService = class {
         if (this.shuttingDown) {
           break;
         }
-        if (slotsRemaining <= 0)
-          break;
-        if (await this.isFailureRetrySuppressedIssue(tenant, issue, issueRecords, latestRunsByIssueId.get(issue.id) ?? null)) {
+        if (slotsRemaining <= 0) break;
+        if (await this.isFailureRetrySuppressedIssue(
+          tenant,
+          issue,
+          issueRecords,
+          latestRunsByIssueId.get(issue.id) ?? null
+        )) {
           continue;
         }
         const stateLimit = maxConcurrentByState[issue.state];
@@ -1655,11 +1458,13 @@ var OrchestratorService = class {
             continue;
           }
         }
-        const preferredWorkspaceKey = deriveIssueWorkspaceKey({
-          projectId: tenant.projectId,
-          adapter: issue.tracker.adapter,
-          issueSubjectId: issue.id
-        }, issue.identifier);
+        const preferredWorkspaceKey = deriveIssueWorkspaceKey(
+          {
+            adapter: issue.tracker.adapter,
+            issueSubjectId: issue.id
+          },
+          issue.identifier
+        );
         issueRecords = upsertIssueOrchestration(issueRecords, {
           issueId: issue.id,
           identifier: issue.identifier,
@@ -1695,13 +1500,18 @@ var OrchestratorService = class {
           issueId: run.issueId,
           issueState: issue.state
         });
-        this.logVerbose(`[dispatch] Issue ${issue.identifier} \u2192 run ${run.runId}`);
+        this.logVerbose(
+          `[dispatch] Issue ${issue.identifier} \u2192 run ${run.runId}`
+        );
         dispatched += 1;
         slotsRemaining -= 1;
-        activeByState.set(issue.state, (activeByState.get(issue.state) ?? 0) + 1);
+        activeByState.set(
+          issue.state,
+          (activeByState.get(issue.state) ?? 0) + 1
+        );
       }
       for (const issueRecord of issueRecords) {
-        if (!isIssueOrchestrationClaimed(issueRecord.state)) {
+        if (!isIssueOrchestrationClaimedState(issueRecord.state)) {
           continue;
         }
         const issue = trackedIssuesByIdentifier.get(issueRecord.identifier);
@@ -1709,8 +1519,16 @@ var OrchestratorService = class {
           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);
+        const activeRun = syncedActiveRuns.find(
+          (run) => isMatchingIssueRun(
+            run,
+            issueRecord.issueId,
+            issueRecord.identifier
+          )
+        ) ?? persistedRun;
+        const resolvedIssue = actionableCandidates.find(
+          (candidate) => candidate.identifier === issue.identifier
+        );
         if (resolvedIssue) {
           continue;
         }
@@ -1729,9 +1547,15 @@ var OrchestratorService = class {
             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}`);
+          this.logVerbose(
+            `[run-completed] ${suppressedRun.runId} status=${suppressedRun.status}`
+          );
         }
-        issueRecords = releaseIssueOrchestration(issueRecords, issueRecord.issueId, now);
+        issueRecords = releaseIssueOrchestration(
+          issueRecords,
+          issueRecord.issueId,
+          now
+        );
         suppressed += 1;
       }
       const terminalIssuesByIdentifier = /* @__PURE__ */ new Map();
@@ -1747,14 +1571,28 @@ var OrchestratorService = class {
     } catch (error) {
       lastError = error instanceof Error ? error.message : "Unknown orchestration error";
     }
-    const effectivePollIntervalMs = resolveAdaptivePollIntervalMs(pollIntervalMs, trackerRateLimits);
+    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.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));
+    await this.store.saveProjectIssueOrchestrations(
+      tenant.projectId,
+      issueRecords
+    );
+    const allTenantRuns = (await this.store.loadAllRuns()).filter(
+      (run) => run.projectId === tenant.projectId
+    );
+    const latestRuns = allTenantRuns.filter(
+      (run) => isActiveRunRecordStatus(run.status)
+    );
     rateLimits = rateLimits ?? resolveProjectRateLimits(latestRuns, []);
     const status = buildProjectSnapshot({
       project: tenant,
@@ -1771,7 +1609,9 @@ var OrchestratorService = class {
   async performStartupCleanup(trackerDependencies = {}) {
     const tenant = this.projectConfig;
     const now = this.now();
-    const workspaceRecords = await this.store.loadIssueWorkspaces(tenant.projectId);
+    const workspaceRecords = await this.store.loadIssueWorkspaces(
+      tenant.projectId
+    );
     if (workspaceRecords.length === 0) {
       return;
     }
@@ -1779,10 +1619,20 @@ var OrchestratorService = class {
     const workflowCache = /* @__PURE__ */ new Map();
     let issues;
     try {
-      issues = await trackerAdapter.listIssuesByStates(tenant, await this.resolveStartupCleanupTerminalStates(tenant, workspaceRecords, workflowCache), trackerDependencies);
+      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}`);
+      console.warn(
+        `[orchestrator] Startup cleanup skipped for project ${tenant.projectId}: ${message}`
+      );
       return;
     }
     const issuesById = new Map(issues.map((issue) => [issue.id, issue]));
@@ -1795,17 +1645,27 @@ var OrchestratorService = class {
         continue;
       }
       try {
-        const resolution = await this.loadStartupCleanupWorkflow(tenant, issue.repository, workflowCache);
+        const resolution = await this.loadStartupCleanupWorkflow(
+          tenant,
+          workflowCache
+        );
         if (!resolution.isValid) {
           continue;
         }
         if (!isStateTerminal(issue.state, resolution.lifecycle)) {
           continue;
         }
-        await this.cleanupTerminalIssueWorkspace(tenant, issue, now, resolution);
+        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}`);
+        console.warn(
+          `[orchestrator] Startup cleanup skipped workspace for ${issue.identifier}: ${message}`
+        );
       }
     }
   }
@@ -1816,7 +1676,9 @@ var OrchestratorService = class {
     try {
       await this.dependencies.onTick(snapshot);
     } catch (error) {
-      this.writeStderr(`[orchestrator] onTick callback failed: ${this.formatErrorMessage(error)}`);
+      this.writeStderr(
+        `[orchestrator] onTick callback failed: ${this.formatErrorMessage(error)}`
+      );
     }
   }
   formatErrorMessage(error) {
@@ -1825,25 +1687,22 @@ var OrchestratorService = class {
     }
     return String(error);
   }
-  async resolveStartupCleanupTerminalStates(tenant, workspaceRecords, workflowCache) {
+  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);
+    try {
+      const resolution = await this.loadStartupCleanupWorkflow(
+        tenant,
+        workflowCache
+      );
+      if (isUsableWorkflowResolution(resolution)) {
+        for (const state of resolution.lifecycle.terminalStates) {
+          const normalizedState = state.trim().toLowerCase();
+          if (!terminalStates.has(normalizedState)) {
+            terminalStates.set(normalizedState, state);
+          }
         }
       }
+    } catch {
     }
     if (terminalStates.size === 0) {
       for (const state of DEFAULT_WORKFLOW_LIFECYCLE.terminalStates) {
@@ -1852,49 +1711,16 @@ var OrchestratorService = class {
     }
     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);
+  async loadStartupCleanupWorkflow(tenant, workflowCache) {
+    const cacheKey = this.workflowCacheKey(tenant.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);
+    const resolutionPromise = this.loadProjectWorkflow(
+      tenant,
+      tenant.repository
+    );
     workflowCache.set(cacheKey, resolutionPromise);
     return resolutionPromise;
   }
@@ -1916,7 +1742,11 @@ var OrchestratorService = class {
       const workflowResolutionCache = /* @__PURE__ */ new Map();
       this.workflowResolutionCache = workflowResolutionCache;
       try {
-        return await this.reconcileProject(this.projectConfig, issueIdentifier, trackerDependencies);
+        return await this.reconcileProject(
+          this.projectConfig,
+          issueIdentifier,
+          trackerDependencies
+        );
       } finally {
         if (this.workflowResolutionCache === workflowResolutionCache) {
           this.workflowResolutionCache = null;
@@ -1931,14 +1761,21 @@ var OrchestratorService = class {
     };
   }
   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());
+    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);
+      const resolution = await this.loadProjectWorkflow(
+        tenant,
+        issue.repository
+      );
       if (!isUsableWorkflowResolution(resolution)) {
         continue;
       }
@@ -1950,8 +1787,11 @@ var OrchestratorService = class {
       }
       candidates.push(issue);
     }
-    if (!lifecycle && tenant.repositories.length > 0) {
-      const resolution = await this.loadProjectWorkflow(tenant, tenant.repositories[0]);
+    if (!lifecycle) {
+      const resolution = await this.loadProjectWorkflow(
+        tenant,
+        tenant.repository
+      );
       if (isUsableWorkflowResolution(resolution)) {
         lifecycle = resolution.lifecycle;
       }
@@ -1967,24 +1807,7 @@ var OrchestratorService = class {
     };
   }
   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;
-    });
+    return isIssueCandidateEligibleWithReason(issue, lifecycle, issues).eligible;
   }
   async loadProjectWorkflow(tenant, repository) {
     const cacheKey = this.workflowCacheKey(repository);
@@ -1994,24 +1817,39 @@ var OrchestratorService = class {
       if (cachedResolution) {
         return cachedResolution;
       }
-      const resolutionPromise = this.loadProjectWorkflowUncached(tenant, repository);
+      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({
+    const cacheRoot = join3(
+      this.store.projectDir(tenant.projectId),
+      "cache",
+      repository.owner,
+      repository.name
+    );
+    const repositoryDirectory = this.resolveWorkflowRepositoryDirectory(repository);
+    const resolution = await loadRepositoryWorkflow(
+      repositoryDirectory,
+      repository
+    );
+    return this.resolveWorkflowResolution(
       repository,
-      targetDirectory: cacheRoot
-    });
-    const resolution = await loadRepositoryWorkflow(repositoryDirectory, repository);
-    return this.resolveWorkflowResolution(repository, cacheRoot, resolution, changed);
+      cacheRoot,
+      resolution,
+      true
+    );
   }
   async startRun(tenant, issue) {
     if (this.shuttingDown || !this.running) {
-      throw new Error("Orchestrator is shutting down and cannot start new runs.");
+      throw new Error(
+        "Orchestrator is shutting down and cannot start new runs."
+      );
     }
     const trackerAdapter = resolveTrackerAdapter2(tenant.tracker);
     const now = this.now();
@@ -2020,19 +1858,34 @@ var OrchestratorService = class {
     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 preferredWorkspaceKey = deriveIssueWorkspaceKey(
+      identity,
+      issue.identifier
+    );
+    const legacyWorkspaceKey = deriveLegacyIssueWorkspaceKey(
+      identity,
+      tenant.projectId
+    );
+    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 issueWorkspacePath = resolveIssueWorkspaceDirectory(
+      projectDir,
+      workspaceKey
+    );
     const repositoryDirectory = await ensureIssueWorkspaceRepository({
       repository: issue.repository,
-      issueWorkspacePath
+      issueWorkspacePath,
+      existingWorkspace: Boolean(existingWorkspaceRecord)
     });
     if (!existingWorkspaceRecord) {
       const workspaceRecord = {
@@ -2049,14 +1902,20 @@ var OrchestratorService = class {
         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
-      });
+      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(),
@@ -2069,23 +1928,35 @@ var OrchestratorService = class {
     }
     const workflow = await this.loadProjectWorkflow(tenant, issue.repository);
     if (!isUsableWorkflowResolution(workflow)) {
-      throw new Error(workflow.validationError ?? "Invalid repository WORKFLOW.md");
+      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 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"
@@ -2108,57 +1979,65 @@ var OrchestratorService = class {
       }
       workerLogAvailable = false;
       const message = error instanceof Error ? error.message : String(error ?? "unknown");
-      this.writeStderr(`[orchestrator] failed to write worker log for ${runId}: ${message}`);
+      this.writeStderr(
+        `[orchestrator] failed to write worker log for ${runId}: ${message}`
+      );
     };
-    const child = (this.dependencies.spawnImpl ?? spawn2)("bash", ["-lc", resolveWorkerCommand()], {
-      cwd: process.cwd(),
-      env: this.buildProjectExecutionEnv(tenant.projectId, {
-        GITHUB_GRAPHQL_TOKEN: process.env.GITHUB_GRAPHQL_TOKEN ?? "",
-        CODEX_PROJECT_ID: tenant.projectId,
-        PROJECT_ID: tenant.projectId,
-        WORKING_DIRECTORY: repositoryDirectory,
-        WORKSPACE_RUNTIME_DIR: workspaceRuntimeDir,
-        SYMPHONY_RUN_ID: runId,
-        SYMPHONY_ISSUE_STATE: issue.state,
-        SYMPHONY_ISSUE_ID: issue.id,
-        SYMPHONY_ISSUE_IDENTIFIER: issue.identifier,
-        SYMPHONY_ISSUE_TITLE: issue.title,
-        SYMPHONY_ISSUE_SUBJECT_ID: issueSubjectId,
-        SYMPHONY_ISSUE_WORKSPACE_KEY: workspaceKey,
-        SYMPHONY_TRACKER_ADAPTER: issue.tracker.adapter,
-        SYMPHONY_TRACKER_BINDING_ID: issue.tracker.bindingId,
-        SYMPHONY_TRACKER_ITEM_ID: issue.tracker.itemId,
-        TARGET_REPOSITORY_CLONE_URL: issue.repository.cloneUrl,
-        TARGET_REPOSITORY_OWNER: issue.repository.owner,
-        TARGET_REPOSITORY_NAME: issue.repository.name,
-        TARGET_REPOSITORY_URL: issue.repository.url,
-        ...trackerAdapter.buildWorkerEnvironment(tenant, issue),
-        SYMPHONY_RENDERED_PROMPT: renderedPrompt,
-        SYMPHONY_WORKFLOW_PATH: workflow.workflowPath ?? "",
-        SYMPHONY_AGENT_COMMAND: workflow.workflow.codex.command,
-        SYMPHONY_APPROVAL_POLICY: workflow.workflow.codex.approvalPolicy ?? "",
-        SYMPHONY_THREAD_SANDBOX: workflow.workflow.codex.threadSandbox ?? "",
-        SYMPHONY_TURN_SANDBOX_POLICY: workflow.workflow.codex.turnSandboxPolicy ?? "",
-        SYMPHONY_MAX_TURNS: String(workflow.workflow.agent.maxTurns),
-        SYMPHONY_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(workflow.workflow.codex.readTimeoutMs),
-        SYMPHONY_TURN_TIMEOUT_MS: String(workflow.workflow.codex.turnTimeoutMs)
-      }),
-      detached: true,
-      stdio: ["ignore", "ignore", "pipe"]
-    });
+    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) {
@@ -2195,7 +2074,9 @@ var OrchestratorService = class {
       if (child.pid) {
         this.retireWorkerPid(child.pid);
       }
-      this.logVerbose(`[worker-exited] ${runId} (code=${code ?? "null"}, signal=${signal ?? "null"})`);
+      this.logVerbose(
+        `[worker-exited] ${runId} (code=${code ?? "null"}, signal=${signal ?? "null"})`
+      );
     };
     const finalizeWorkerStderr = (code, signal) => {
       if (workerExited || workerStderrFinalizing) {
@@ -2235,7 +2116,9 @@ var OrchestratorService = class {
     }
     child.on?.("error", (error) => {
       const message = error instanceof Error ? error.message : String(error ?? "unknown");
-      this.writeStderr(`[orchestrator] worker process error for ${runId}: ${message}`);
+      this.writeStderr(
+        `[orchestrator] worker process error for ${runId}: ${message}`
+      );
       finalizeWorkerStderr(null, null);
     });
     child.on?.("close", (code, signal) => {
@@ -2282,14 +2165,24 @@ var OrchestratorService = class {
         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 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);
+      const currentTrackerState = issueStateByIdentifier.get(
+        run.issueIdentifier
+      );
       if (!currentTrackerState || currentTrackerState === run.issueState) {
         syncedRuns.push(run);
         continue;
@@ -2312,7 +2205,9 @@ var OrchestratorService = class {
     if (run.processId && this.isProcessRunning(run.processId)) {
       const retryPolicy = await this.loadRetryPolicy(tenant, run.repository);
       const configuredStallTimeoutMs = retryPolicy?.stallTimeoutMs ?? null;
-      const lastActivityAtMs = parseTimestampMs2(run.lastEventAt ?? run.startedAt);
+      const lastActivityAtMs = parseTimestampMs2(
+        run.lastEventAt ?? run.startedAt
+      );
       const startedAtMs = parseTimestampMs2(run.startedAt);
       const elapsedSinceLastActivityMs = lastActivityAtMs === null ? null : now.getTime() - lastActivityAtMs;
       const runningSinceMs = startedAtMs === null ? null : now.getTime() - startedAtMs;
@@ -2324,9 +2219,13 @@ var OrchestratorService = class {
         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)`);
+          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.writeStderr(
+            `[orchestrator] stuck worker detected for ${run.runId} (elapsed ${elapsedSeconds}s > ${timeoutSeconds}s) \u2014 sending SIGTERM`
+          );
         }
         this.sendSignal(run.processId, "SIGTERM");
       } else {
@@ -2339,11 +2238,13 @@ var OrchestratorService = class {
         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),
+          workspaceKey: run.issueWorkspaceKey ?? deriveIssueWorkspaceKey(
+            {
+              adapter: tenant.tracker.adapter,
+              issueSubjectId: run.issueSubjectId
+            },
+            run.issueIdentifier
+          ),
           state: "running",
           currentRunId: run.runId,
           retryEntry: null,
@@ -2361,12 +2262,29 @@ var OrchestratorService = class {
     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),
+      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),
+      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)),
+      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,
@@ -2392,7 +2310,11 @@ var OrchestratorService = class {
           recovered: false
         };
       }
-      if (await this.resolveRetryRestartAction(tenant, run, trackerDependencies) === "release") {
+      if (await this.resolveRetryRestartAction(
+        tenant,
+        run,
+        trackerDependencies
+      ) === "release") {
         return this.releaseRetryingRun(runWithTokens, issueRecords, now);
       }
       return this.restartRun(tenant, run, issueRecords, now, workerSessionId);
@@ -2410,31 +2332,49 @@ var OrchestratorService = class {
         runPhase: runWithTokens.runPhase ?? "failed"
       };
       await this.store.saveRun(completedRun);
-      this.logVerbose(`[run-completed] ${completedRun.runId} status=${completedRun.status}`);
+      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 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 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);
+    const maxFailureRetries = await this.loadMaxFailureRetries(
+      tenant,
+      run.repository
+    );
     if (retryKind === "failure" && failureRetryCount >= maxFailureRetries) {
       const lastError = [
-        `Run suppressed: ${MAX_FAILURE_RETRIES_EXCEEDED_REASON}.`,
+        `Run suppressed: ${MAX_FAILURE_RETRIES_EXCEEDED_REASON2}.`,
         `failureRetryCount=${failureRetryCount}.`,
         `maxFailureRetries=${maxFailureRetries}.`
       ].join(" ");
@@ -2456,18 +2396,22 @@ var OrchestratorService = class {
         projectId: run.projectId,
         issueIdentifier: run.issueIdentifier,
         issueId: run.issueId,
-        reason: MAX_FAILURE_RETRIES_EXCEEDED_REASON
+        reason: MAX_FAILURE_RETRIES_EXCEEDED_REASON2
       });
-      this.logVerbose(`[run-completed] ${suppressedRun.runId} status=${suppressedRun.status}`);
+      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),
+          workspaceKey: run.issueWorkspaceKey ?? deriveIssueWorkspaceKey(
+            {
+              adapter: tenant.tracker.adapter,
+              issueSubjectId: run.issueSubjectId
+            },
+            run.issueIdentifier
+          ),
           state: "released",
           failureRetryCount,
           currentRunId: null,
@@ -2479,7 +2423,9 @@ var OrchestratorService = class {
     }
     let nextRetryAt;
     if (retryKind === "continuation") {
-      nextRetryAt = new Date(now.getTime() + CONTINUATION_RETRY_DELAY_MS).toISOString();
+      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;
@@ -2500,16 +2446,22 @@ var OrchestratorService = class {
       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}`);
+    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),
+      workspaceKey: run.issueWorkspaceKey ?? deriveIssueWorkspaceKey(
+        {
+          adapter: tenant.tracker.adapter,
+          issueSubjectId: run.issueSubjectId
+        },
+        run.issueIdentifier
+      ),
       state: "retry_queued",
       completedOnce: retryKind === "continuation" ? true : void 0,
       failureRetryCount,
@@ -2568,9 +2520,13 @@ var OrchestratorService = class {
       if (!isOrchestratorChannelEvent(parsed)) {
         return;
       }
-      void this.runSerialized(() => this.applyWorkerChannelEvent(runId, parsed)).catch((error) => {
+      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}`);
+        this.writeStderr(
+          `[orchestrator] failed to apply worker channel event for ${runId}: ${message}`
+        );
       });
     } catch {
     }
@@ -2587,15 +2543,29 @@ var OrchestratorService = class {
         ...run,
         updatedAt: nowIso2,
         lastEvent: "heartbeat",
-        lastTurnSummary: resolveLastTurnSummary(run.lastTurnSummary, event.lastError),
+        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),
+        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),
+        cumulativeTurnCount: resolveCumulativeTurnCount(
+          run,
+          event.sessionInfo?.turnCount ?? null
+        ),
         executionPhase: event.executionPhase ?? run.executionPhase,
         runPhase: event.runPhase ?? run.runPhase,
         lastError: event.lastError
@@ -2656,15 +2626,29 @@ var OrchestratorService = class {
       ...run,
       updatedAt: nowIso,
       lastEvent: event.event ?? run.lastEvent ?? null,
-      lastTurnSummary: resolveLastTurnSummary(run.lastTurnSummary, resolveLastTurnSummaryCandidate(event.event, event.lastError)),
+      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),
+      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),
+      cumulativeTurnCount: resolveCumulativeTurnCount(
+        run,
+        event.sessionInfo?.turnCount ?? null
+      ),
       executionPhase: event.executionPhase ?? run.executionPhase ?? null,
       runPhase: event.runPhase ?? run.runPhase ?? null,
       lastError: event.lastError ?? run.lastError
@@ -2729,7 +2713,11 @@ var OrchestratorService = class {
    */
   async classifyRetryKind(tenant, run, trackerDependencies = {}) {
     try {
-      const eligibleContext = await this.fetchTrackedIssueEligibilityContext(tenant, run.issueIdentifier, trackerDependencies);
+      const eligibleContext = await this.fetchTrackedIssueEligibilityContext(
+        tenant,
+        run.issueIdentifier,
+        trackerDependencies
+      );
       if (!eligibleContext) {
         return "failure";
       }
@@ -2737,14 +2725,22 @@ var OrchestratorService = class {
       if (!isUsableWorkflowResolution(resolution)) {
         return "failure";
       }
-      return this.isIssueCandidateEligible(eligibleContext.issue, resolution.lifecycle, eligibleContext.issues) ? "continuation" : "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);
+      const eligibleContext = await this.fetchTrackedIssueEligibilityContext(
+        tenant,
+        run.issueIdentifier,
+        trackerDependencies
+      );
       if (!eligibleContext) {
         return "release";
       }
@@ -2752,7 +2748,11 @@ var OrchestratorService = class {
       if (!isUsableWorkflowResolution(resolution)) {
         return "restart";
       }
-      return this.isIssueCandidateEligible(eligibleContext.issue, resolution.lifecycle, eligibleContext.issues) ? "restart" : "release";
+      return this.isIssueCandidateEligible(
+        eligibleContext.issue,
+        resolution.lifecycle,
+        eligibleContext.issues
+      ) ? "restart" : "release";
     } catch {
       return "restart";
     }
@@ -2763,7 +2763,9 @@ var OrchestratorService = class {
       fetchImpl: this.dependencies.fetchImpl,
       ...trackerDependencies
     });
-    const issue = issues.find((candidate) => candidate.identifier === issueIdentifier);
+    const issue = issues.find(
+      (candidate) => candidate.identifier === issueIdentifier
+    );
     return issue ? { issue, issues } : null;
   }
   async fetchWorkerRunInfo(run) {
@@ -2787,12 +2789,20 @@ var OrchestratorService = class {
   async readPersistedWorkerTokenUsage(run) {
     const artifactPaths = [
       join3(run.workspaceRuntimeDir, "token-usage.json"),
-      join3(run.workspaceRuntimeDir, ".orchestrator", "runs", run.runId, "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);
+        const tokenUsage = JSON.parse(
+          raw
+        );
         if (hasTokenUsage(tokenUsage)) {
           return tokenUsage;
         }
@@ -2813,7 +2823,10 @@ var OrchestratorService = class {
       if (!isUsableWorkflowResolution(workflowResolution)) {
         return null;
       }
-      const hookEnv = this.buildProjectExecutionEnv(tenant.projectId, buildHookEnv(context));
+      const hookEnv = this.buildProjectExecutionEnv(
+        tenant.projectId,
+        buildHookEnv(context)
+      );
       return executeWorkspaceHook({
         kind,
         hooks: workflowResolution.workflow.hooks,
@@ -2831,14 +2844,24 @@ var OrchestratorService = class {
       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}
-`);
+      (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"));
+    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,
@@ -2854,7 +2877,10 @@ var OrchestratorService = class {
       lastError: "Superseded by recovered run."
     };
     await this.store.saveRun(supersededRecord);
-    const issue = resolveTrackerAdapter2(tenant.tracker).reviveIssue(tenant, run);
+    const issue = resolveTrackerAdapter2(tenant.tracker).reviveIssue(
+      tenant,
+      run
+    );
     const restarted = await this.startRun(tenant, issue);
     const recoveredRecord = {
       ...restarted,
@@ -2880,11 +2906,13 @@ var OrchestratorService = class {
       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),
+        workspaceKey: recoveredRecord.issueWorkspaceKey ?? deriveIssueWorkspaceKey(
+          {
+            adapter: tenant.tracker.adapter,
+            issueSubjectId: recoveredRecord.issueSubjectId
+          },
+          recoveredRecord.issueIdentifier
+        ),
         state: "running",
         currentRunId: recoveredRecord.runId,
         retryEntry: null,
@@ -2905,40 +2933,34 @@ var OrchestratorService = class {
       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}`);
+    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;
+    const resolution = await this.loadProjectWorkflow(
+      tenant,
+      tenant.repository
+    );
+    const interval = isUsableWorkflowResolution(resolution) ? resolution.workflow.polling.intervalMs : NaN;
+    return Number.isFinite(interval) && interval > 0 ? interval : 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);
-      }
+    const resolution = await this.loadProjectWorkflow(
+      tenant,
+      tenant.repository
+    ).catch(() => null);
+    if (!resolution || !isUsableWorkflowResolution(resolution)) {
+      return result;
+    }
+    const stateLimits = resolution.workflow.agent.maxConcurrentAgentsByState;
+    for (const [state, limit] of Object.entries(stateLimits)) {
+      result[state] = typeof limit === "number" ? limit : Number(limit);
     }
     return result;
   }
@@ -2951,7 +2973,7 @@ var OrchestratorService = class {
       return {
         baseDelayMs: this.dependencies.retryBackoffMs ?? resolution.workflow.agent.retryBaseDelayMs,
         maxDelayMs: this.dependencies.retryBackoffMs ?? resolution.workflow.agent.maxRetryBackoffMs,
-        stallTimeoutMs: resolution.workflow.codex.stallTimeoutMs
+        stallTimeoutMs: resolveWorkflowRuntimeTimeouts(resolution.workflow).stallTimeoutMs
       };
     } catch {
       if (!this.dependencies.retryBackoffMs) {
@@ -2968,16 +2990,10 @@ var OrchestratorService = class {
     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;
+    const limit = await this.loadProjectWorkflow(project, project.repository).then(
+      (resolution) => isUsableWorkflowResolution(resolution) ? resolution.workflow.agent.maxConcurrentAgents : NaN
+    ).catch(() => NaN);
+    return Number.isFinite(limit) && limit >= 0 ? limit : DEFAULT_CONCURRENCY;
   }
   async resolveWorkflowResolution(repository, cacheRoot, resolution, changed) {
     const cacheKey = this.workflowCacheKey(repository);
@@ -2990,7 +3006,10 @@ var OrchestratorService = class {
       };
       let workflowPath = effectiveResolution.workflowPath;
       try {
-        workflowPath = await this.persistLastKnownGoodWorkflow(cacheRoot, effectiveResolution) ?? effectiveResolution.workflowPath;
+        workflowPath = await this.persistLastKnownGoodWorkflow(
+          cacheRoot,
+          effectiveResolution
+        ) ?? effectiveResolution.workflowPath;
       } catch {
         workflowPath = effectiveResolution.workflowPath;
       }
@@ -3005,8 +3024,10 @@ var OrchestratorService = class {
     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}
-`);
+      process.stderr.write(
+        `[orchestrator] failed to reload WORKFLOW.md for ${repository.owner}/${repository.name}: ${message}
+`
+      );
       this.lastReportedWorkflowErrors.set(cacheKey, message);
     }
     if (!cached) {
@@ -3036,6 +3057,26 @@ var OrchestratorService = class {
   workflowCacheKey(repository) {
     return `${repository.owner}/${repository.name}:${this.normalizeRepositoryCloneUrl(repository.cloneUrl)}`;
   }
+  resolveWorkflowRepositoryDirectory(repository) {
+    if (repository.path) {
+      return repository.path;
+    }
+    const localCloneUrlPath = this.resolveLocalCloneUrlPath(
+      repository.cloneUrl
+    );
+    if (localCloneUrlPath) {
+      return localCloneUrlPath;
+    }
+    return process.cwd();
+  }
+  resolveLocalCloneUrlPath(cloneUrl) {
+    try {
+      const url = new URL(cloneUrl);
+      return url.protocol === "file:" ? fileURLToPath(url) : null;
+    } catch {
+      return isAbsolute(cloneUrl) || cloneUrl.startsWith(".") ? cloneUrl : null;
+    }
+  }
   normalizeRepositoryCloneUrl(cloneUrl) {
     if (cloneUrl.startsWith("file://")) {
       try {
@@ -3092,14 +3133,28 @@ var OrchestratorService = class {
   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 preferredWorkspaceKey = deriveIssueWorkspaceKey(
+      identity,
+      issue.identifier
+    );
+    const legacyWorkspaceKey = deriveLegacyIssueWorkspaceKey(
+      identity,
+      tenant.projectId
+    );
     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));
+    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;
     }
@@ -3109,17 +3164,26 @@ var OrchestratorService = class {
       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);
+    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}`);
+      console.warn(
+        `[orchestrator] before_remove hook failed for ${issue.identifier}; continuing cleanup: ${errorMessage}`
+      );
     }
     try {
       await rm3(workspaceRecord.workspacePath, { recursive: true, force: true });
@@ -3137,19 +3201,26 @@ var OrchestratorService = class {
     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;
+    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);
+    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)) {
+    if (!latestRun || latestRun.status !== "suppressed" || latestRun.issueState !== issue.state || !latestRun.lastError?.includes(MAX_FAILURE_RETRIES_EXCEEDED_REASON2)) {
       return false;
     }
     const issueUpdatedAtMs = parseTimestampMs2(issue.updatedAt);
-    const suppressedAtMs = parseTimestampMs2(latestRun.completedAt ?? latestRun.updatedAt);
+    const suppressedAtMs = parseTimestampMs2(
+      latestRun.completedAt ?? latestRun.updatedAt
+    );
     if (issueUpdatedAtMs === null || suppressedAtMs === null) {
       return true;
     }
@@ -3165,7 +3236,9 @@ var OrchestratorService = class {
   }
 };
 function hasTokenUsage(tokenUsage) {
-  return Boolean(tokenUsage && (tokenUsage.inputTokens > 0 || tokenUsage.outputTokens > 0 || tokenUsage.totalTokens > 0));
+  return Boolean(
+    tokenUsage && (tokenUsage.inputTokens > 0 || tokenUsage.outputTokens > 0 || tokenUsage.totalTokens > 0)
+  );
 }
 function isRecord(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
@@ -3177,7 +3250,9 @@ function resolveProjectRateLimits(runs, issues) {
     if (!isRecord(run.rateLimits)) {
       continue;
     }
-    const timestamp = parseTimestampMs2(run.lastEventAt ?? run.updatedAt ?? run.startedAt);
+    const timestamp = parseTimestampMs2(
+      run.lastEventAt ?? run.updatedAt ?? run.startedAt
+    );
     const sortableTimestamp = timestamp ?? -Infinity;
     if (sortableTimestamp >= latestRunTimestamp) {
       latestRunTimestamp = sortableTimestamp;
@@ -3255,18 +3330,6 @@ function buildRuntimeSession(existing, sessionId, threadId, status, startedAt, u
 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 = parseTimestampMs2(latestRun.completedAt ?? latestRun.updatedAt);
-  const issueUpdatedAtMs = parseTimestampMs2(issueUpdatedAt);
-  if (convergedAtMs === null || issueUpdatedAtMs === null) {
-    return true;
-  }
-  return issueUpdatedAtMs <= convergedAtMs;
-}
 function resolveCumulativeTurnCount(run, turnCount) {
   const carriedTotal = resolvePersistedCumulativeTurnCount(run);
   if (turnCount === null) {
@@ -3309,7 +3372,10 @@ function resolveWorkerCommand() {
     return `node ${fileURLToPath(workerUrl)}`;
   } catch {
     try {
-      const bundledWorker = join3(fileURLToPath(new URL(".", import.meta.url)), "worker-entry.js");
+      const bundledWorker = join3(
+        fileURLToPath(new URL(".", import.meta.url)),
+        "worker-entry.js"
+      );
       return `node ${bundledWorker}`;
     } catch {
       return DEFAULT_WORKER_COMMAND;
@@ -3322,17 +3388,13 @@ function createStore(runtimeRoot = ".runtime", 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;
+      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;
+      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);
@@ -3381,12 +3443,11 @@ function buildLatestRunMapByIssueId(runs) {
   }
   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);
+  const remaining = issueRecords.filter(
+    (record) => record.issueId !== nextRecord.issueId
+  );
   return [
     ...remaining,
     {
@@ -3397,22 +3458,21 @@ function upsertIssueOrchestration(issueRecords, nextRecord) {
   ];
 }
 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";
+  return issueRecords.map(
+    (record) => record.issueId === issueId ? {
+      ...record,
+      state: "released",
+      currentRunId: null,
+      retryEntry: null,
+      updatedAt: now.toISOString()
+    } : record
+  );
 }
 
-// ../orchestrator/dist/lock.js
+// ../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 { dirname as dirname2, isAbsolute as isAbsolute2, 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;
@@ -3447,14 +3507,18 @@ async function acquireProjectLock(input) {
     if (existing.status === "invalid") {
       invalidReadAttempts += 1;
       if (invalidReadAttempts >= LOCK_READ_RETRY_LIMIT) {
-        throw new Error(`Project "${input.projectId}" lock file is unreadable at "${lockPath}".`);
+        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}).`);
+      throw new Error(
+        `Project "${input.projectId}" is already running (PID ${existing.record.pid}).`
+      );
     }
     await rm4(lockPath, { force: true });
   }
@@ -3493,16 +3557,20 @@ async function readProjectLock(lockPath) {
 }
 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.`);
+    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}".`);
+  const resolvedRuntimeRoot = resolve2(runtimeRoot);
+  const relativeProjectDir = relative2(resolvedRuntimeRoot, projectDir);
+  if (relativeProjectDir.startsWith("..") || isAbsolute2(relativeProjectDir)) {
+    throw new Error(
+      `Invalid project ID "${projectId}". Project lock path must stay within "${resolvedRuntimeRoot}".`
+    );
   }
   return join4(projectDir, ".lock");
 }
@@ -3530,15 +3598,24 @@ function isProcessRunning(pid) {
   }
 }
 function isAlreadyExistsError2(error) {
-  return Boolean(error && typeof error === "object" && "code" in error && error.code === "EEXIST");
+  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"));
+  return Boolean(
+    error && typeof error === "object" && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR")
+  );
 }
 
-// ../orchestrator/dist/index.js
+// ../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";
@@ -3546,7 +3623,9 @@ function resolveOrchestratorLogLevel(value) {
   if (value === "verbose") {
     return "verbose";
   }
-  throw new Error(`Unsupported log level: ${value}. Supported values: normal, verbose.`);
+  throw new Error(
+    `Unsupported log level: ${value}. Supported values: normal, verbose.`
+  );
 }
 async function runCli(argv, dependencies = {}) {
   const [command = "run-once", ...args] = argv;
@@ -3556,8 +3635,12 @@ async function runCli(argv, dependencies = {}) {
   }
   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 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,
@@ -3605,8 +3688,10 @@ async function runCli(argv, dependencies = {}) {
         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)}
-`);
+          stderr.write(
+            `Failed to shut down orchestrator after ${signal}: ${error instanceof Error ? error.message : String(error)}
+`
+          );
         }).finally(() => {
           exitProcess(exitCode);
         });
@@ -3733,13 +3818,19 @@ function resolveOptionalPath(value) {
 }
 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.stderr.write(
+      `${error instanceof Error ? error.message : "Unknown error"}
+`
+    );
     process.exitCode = 1;
   });
 }
 
 export {
+  resolveTrackerAdapter2 as resolveTrackerAdapter,
+  explainIssueDispatch,
+  isActiveRunRecordStatus,
+  parseIssueIdentifier,
   OrchestratorService,
   createStore,
   acquireProjectLock,