@gh-symphony/cli 0.0.19 → 0.0.21

package/dist/{chunk-6CI3UUMH.js → chunk-MYVJ6HK4.js}

@@ -1,4 +1,7 @@
 #!/usr/bin/env node
+import {
+  resolveTrackerAdapter
+} from "./chunk-SXGT7LOF.js";
 import {
   DEFAULT_MAX_FAILURE_RETRIES,
   DEFAULT_WORKFLOW_LIFECYCLE,
@@ -24,11 +27,13 @@ import {
   readJsonFile,
   renderPrompt,
   resolveIssueWorkspaceDirectory,
+  resolveWorkflowRuntimeCommand,
+  resolveWorkflowRuntimeTimeouts,
   safeReadDir,
   scheduleRetryAt
-} from "./chunk-M3IFVLQS.js";
+} from "./chunk-QEONJ5DZ.js";
 
-// ../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";
@@ -36,10 +41,18 @@ import { 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,
+  rename,
+  rm,
+  stat,
+  writeFile
+} from "fs/promises";
 import { constants } from "fs";
 import { join } from "path";
 var workflowConfigStore = new WorkflowConfigStore();
@@ -81,7 +94,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", [
@@ -115,7 +131,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 +152,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"}`
+        )
+      );
     });
   });
 }
@@ -168,7 +191,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 +213,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 +232,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,7 +265,9 @@ 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);
@@ -245,21 +280,30 @@ 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;
   }
+  resolvedRuntimeRoot;
+  resolvedEventsMirrorRoot;
   projectsRoot() {
     return join2(this.runtimeRoot, "projects");
   }
@@ -276,10 +320,15 @@ var OrchestratorFsStore = class {
     return join2(this.projectRunsDir(projectId), 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 +344,78 @@ 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.projectId), "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 runDirectories = await Promise.all(
+      projectIds.map(async (projectId) => {
+        const entries = await safeReadDir(this.projectRunsDir(projectId));
+        return entries.map((entry) => this.runDir(entry, projectId));
+      })
+    );
+    const runs = await Promise.all(
+      runDirectories.flat().map(
+        (directory) => readJsonFile(join2(directory, "run.json"))
+      )
+    );
     return runs.filter((run) => Boolean(run));
   }
   async saveRun(run) {
-    await writeJsonFile(join2(this.runDir(run.runId, run.projectId), "run.json"), run);
+    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 +436,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) {
@@ -410,16 +486,28 @@ var OrchestratorFsStore = class {
     return join2(this.projectDir(projectId), "issues", workspaceKey);
   }
   async loadIssueWorkspace(projectId, workspaceKey) {
-    return await readJsonFile(join2(this.issueWorkspaceDir(projectId, workspaceKey), "workspace.json")) ?? null;
+    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));
+    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);
+    await writeJsonFile(
+      join2(
+        this.issueWorkspaceDir(record.projectId, record.workspaceKey),
+        "workspace.json"
+      ),
+      record
+    );
   }
   async removeIssueWorkspace(projectId, workspaceKey) {
     const dir = this.issueWorkspaceDir(projectId, workspaceKey);
@@ -429,7 +517,9 @@ var OrchestratorFsStore = class {
     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"));
+      const run = await readJsonFile(
+        join2(candidate, "run.json")
+      );
       if (run || await pathExists(join2(candidate, "events.ndjson"))) {
         return candidate;
       }
@@ -466,848 +556,46 @@ async function pathExists(path) {
   }
 }
 
-// ../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
+// ../tracker-file/src/file-tracker-adapter.ts
 import { readFile as readFile2 } from "fs/promises";
-function requireTrackerSetting2(project, key) {
+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.`);
+    throw new Error(
+      `Tracker adapter "file" requires the "${key}" setting.`
+    );
   }
   return value;
 }
-function parseIssueNumber2(identifier) {
+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;
+  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");
+    const issuesPath = requireTrackerSetting(project, "issuesPath");
     try {
       const raw = await readFile2(issuesPath, "utf-8");
       const parsed = JSON.parse(raw);
       if (!Array.isArray(parsed)) {
-        throw new Error(`Expected an array of issues in ${issuesPath}, got ${typeof parsed}`);
+        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}
-`);
+          process.stderr.write(
+            `[tracker-file] Skipping invalid issue at index ${i} in ${issuesPath}
+`
+          );
         }
       }
       return valid;
@@ -1326,8 +614,12 @@ var fileTrackerAdapter = {
       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()));
+    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) {
@@ -1346,7 +638,7 @@ var fileTrackerAdapter = {
     return {
       id: run.issueId,
       identifier: run.issueIdentifier,
-      number: parseIssueNumber2(run.issueIdentifier),
+      number: parseIssueNumber(run.issueIdentifier),
       title: run.issueTitle ?? run.issueIdentifier,
       description: null,
       priority: null,
@@ -1368,24 +660,21 @@ var fileTrackerAdapter = {
   }
 };
 
-// ../orchestrator/dist/tracker-adapters.js
+// ../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;
+  if (local) return local;
   return resolveTrackerAdapter(tracker);
 }
 
-// ../orchestrator/dist/service.js
+// ../orchestrator/src/service.ts
 var DEFAULT_POLL_INTERVAL_MS = 3e4;
 var DEFAULT_CONCURRENCY = 3;
 var DEFAULT_RETRY_BACKOFF_MS = 3e4;
 var CONTINUATION_RETRY_DELAY_MS = 1e3;
-var DEFAULT_GLOBAL_MAX_TURNS = 100;
-var DEFAULT_MAX_TOKENS = 256e3;
 var DEFAULT_WORKER_COMMAND = "node packages/worker/dist/index.js";
 var DEFAULT_MAX_NONPRODUCTIVE_TURNS = 3;
 var LOW_RATE_LIMIT_WARNING_THRESHOLD = 0.05;
@@ -1394,7 +683,7 @@ var STUCK_WORKER_TIMEOUT_MS = 30 * 60 * 1e3;
 function isUsableWorkflowResolution(resolution) {
   return resolution.isValid || resolution.usedLastKnownGood;
 }
-function parseTimestampMs2(value) {
+function parseTimestampMs(value) {
   if (!value) {
     return null;
   }
@@ -1412,9 +701,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();
@@ -1429,23 +720,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;
@@ -1454,20 +747,39 @@ 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,
+      this.projectConfig.projectId,
+      issueRecord.issueId,
+      issueIdentifier
+    ) ? currentRunCandidate : await this.findLatestRunForIssue(issueRecord.issueId, issueIdentifier);
+    const recentEvents = currentRun === null ? [] : await this.store.loadRecentRunEvents(
+      currentRun.runId,
+      20,
+      currentRun.projectId
+    );
     const latestEventMessage = recentEvents[recentEvents.length - 1]?.message ?? null;
     const currentAttempt = currentRun?.attempt ?? issueRecord.retryEntry?.attempt ?? 0;
     return {
@@ -1504,7 +816,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
           }
         ]
@@ -1566,7 +881,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 = {}) {
@@ -1579,27 +896,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);
+    let issueRecords = await this.store.loadProjectIssueOrchestrations(
+      tenant.projectId
+    );
+    const allRuns = (await this.store.loadAllRuns()).filter(
+      (run) => run.projectId === tenant.projectId
+    );
     const activeRuns = allRuns.filter((run) => isActiveRunStatus(run.status));
     for (const run of activeRuns) {
-      const outcome = await this.reconcileRun(tenant, run, issueRecords, trackerDependencies);
+      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 && isActiveRunStatus(run.status)
+    );
+    const projectRunsAfterReconcile = (await this.store.loadAllRuns()).filter(
+      (run) => run.projectId === tenant.projectId
+    );
     rateLimits = resolveProjectRateLimits(reconciledRuns, []);
     try {
       pollIntervalMs = await this.loadProjectPollInterval(tenant);
-      const currentActiveRuns = (await this.store.loadAllRuns()).filter((run) => run.projectId === tenant.projectId && isActiveRunStatus(run.status));
-      const { runs: syncedActiveRuns, issuesByIdentifier: syncedIssuesByIdentifier } = await this.syncActiveRunIssueStates(tenant, trackerAdapter, currentActiveRuns, now);
-      const issues = await trackerAdapter.listIssues(tenant, trackerDependencies);
-      const filteredIssues = issueIdentifier ? issues.filter((issue) => issue.identifier === issueIdentifier) : issues;
+      const currentActiveRuns = (await this.store.loadAllRuns()).filter(
+        (run) => run.projectId === tenant.projectId && isActiveRunStatus(run.status)
+      );
+      const {
+        runs: syncedActiveRuns,
+        issuesByIdentifier: syncedIssuesByIdentifier
+      } = await this.syncActiveRunIssueStates(
+        tenant,
+        trackerAdapter,
+        currentActiveRuns,
+        now
+      );
+      const issues = await trackerAdapter.listIssues(
+        tenant,
+        trackerDependencies
+      );
+      const filteredIssues = issueIdentifier ? issues.filter(
+        (issue) => issue.identifier === issueIdentifier
+      ) : issues;
       const { candidates: actionableCandidates, lifecycle } = await this.resolveActionableCandidates(tenant, filteredIssues);
-      const trackedIssuesByIdentifier = new Map(syncedIssuesByIdentifier);
+      const trackedIssuesByIdentifier = new Map(
+        syncedIssuesByIdentifier
+      );
       for (const issue of filteredIssues) {
         const existing = trackedIssuesByIdentifier.get(issue.identifier);
         trackedIssuesByIdentifier.set(issue.identifier, {
@@ -1620,17 +967,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) => isIssueOrchestrationClaimed(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 (hasConvergenceLockedRun(
+          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 && isIssueOrchestrationClaimed(record.state)
+        );
       });
       const sortedCandidates = sortCandidatesForDispatch(unscheduledCandidates);
       const activeByState = /* @__PURE__ */ new Map();
@@ -1645,12 +1008,13 @@ var OrchestratorService = class {
         if (this.shuttingDown) {
           break;
         }
-        if (slotsRemaining <= 0)
-          break;
-        if (await this.isFailureRetrySuppressedIssue(tenant, issue, issueRecords, latestRunsByIssueId.get(issue.id) ?? null)) {
-          continue;
-        }
-        if (isIssueBudgetExceeded(resolveIssueBudgetSnapshot(projectRunsAfterReconcile, issue.id), now)) {
+        if (slotsRemaining <= 0) break;
+        if (await this.isFailureRetrySuppressedIssue(
+          tenant,
+          issue,
+          issueRecords,
+          latestRunsByIssueId.get(issue.id) ?? null
+        )) {
           continue;
         }
         const stateLimit = maxConcurrentByState[issue.state];
@@ -1660,11 +1024,14 @@ var OrchestratorService = class {
             continue;
           }
         }
-        const preferredWorkspaceKey = deriveIssueWorkspaceKey({
-          projectId: tenant.projectId,
-          adapter: issue.tracker.adapter,
-          issueSubjectId: issue.id
-        }, issue.identifier);
+        const preferredWorkspaceKey = deriveIssueWorkspaceKey(
+          {
+            projectId: tenant.projectId,
+            adapter: issue.tracker.adapter,
+            issueSubjectId: issue.id
+          },
+          issue.identifier
+        );
         issueRecords = upsertIssueOrchestration(issueRecords, {
           issueId: issue.id,
           identifier: issue.identifier,
@@ -1700,10 +1067,15 @@ 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)) {
@@ -1714,8 +1086,17 @@ 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,
+            tenant.projectId,
+            issueRecord.issueId,
+            issueRecord.identifier
+          )
+        ) ?? persistedRun;
+        const resolvedIssue = actionableCandidates.find(
+          (candidate) => candidate.identifier === issue.identifier
+        );
         if (resolvedIssue) {
           continue;
         }
@@ -1734,9 +1115,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();
@@ -1752,14 +1139,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) => isActiveRunStatus(run.status)
+    );
     rateLimits = rateLimits ?? resolveProjectRateLimits(latestRuns, []);
     const status = buildProjectSnapshot({
       project: tenant,
@@ -1776,7 +1177,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;
     }
@@ -1784,10 +1187,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]));
@@ -1800,17 +1213,28 @@ var OrchestratorService = class {
         continue;
       }
       try {
-        const resolution = await this.loadStartupCleanupWorkflow(tenant, issue.repository, workflowCache);
+        const resolution = await this.loadStartupCleanupWorkflow(
+          tenant,
+          issue.repository,
+          workflowCache
+        );
         if (!resolution.isValid) {
           continue;
         }
         if (!isStateTerminal(issue.state, resolution.lifecycle)) {
           continue;
         }
-        await this.cleanupTerminalIssueWorkspace(tenant, issue, now, resolution);
+        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}`
+        );
       }
     }
   }
@@ -1821,7 +1245,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) {
@@ -1832,11 +1258,18 @@ var OrchestratorService = class {
   }
   async resolveStartupCleanupTerminalStates(tenant, workspaceRecords, workflowCache) {
     const terminalStates = /* @__PURE__ */ new Map();
-    const repositories = this.resolveStartupCleanupRepositories(tenant, workspaceRecords);
+    const repositories = this.resolveStartupCleanupRepositories(
+      tenant,
+      workspaceRecords
+    );
     for (const repository of repositories) {
       let resolution;
       try {
-        resolution = await this.loadStartupCleanupWorkflow(tenant, repository, workflowCache);
+        resolution = await this.loadStartupCleanupWorkflow(
+          tenant,
+          repository,
+          workflowCache
+        );
       } catch {
         continue;
       }
@@ -1860,14 +1293,20 @@ var OrchestratorService = class {
   resolveStartupCleanupRepositories(tenant, workspaceRecords) {
     const repositories = /* @__PURE__ */ new Map();
     for (const repository of tenant.repositories) {
-      repositories.set(this.startupCleanupRepositoryKey(repository.owner, repository.name), repository);
+      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);
+      const key = this.startupCleanupRepositoryKey(
+        repository.owner,
+        repository.name
+      );
       if (!repositories.has(key)) {
         repositories.set(key, repository);
       }
@@ -1875,7 +1314,9 @@ var OrchestratorService = class {
     return [...repositories.values()];
   }
   parseWorkspaceRepositoryRef(workspaceRecord) {
-    const match = workspaceRecord.issueIdentifier.match(/^([^/]+)\/([^#]+)#\d+$/);
+    const match = workspaceRecord.issueIdentifier.match(
+      /^([^/]+)\/([^#]+)#\d+$/
+    );
     if (!match) {
       return null;
     }
@@ -1899,7 +1340,9 @@ var OrchestratorService = class {
     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 = tenant.repositories.some(
+      (candidate) => candidate.owner === repository.owner && candidate.name === repository.name
+    ) ? this.loadProjectWorkflow(tenant, repository) : loadRepositoryWorkflow(repository.cloneUrl, repository);
     workflowCache.set(cacheKey, resolutionPromise);
     return resolutionPromise;
   }
@@ -1921,7 +1364,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;
@@ -1936,14 +1383,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;
       }
@@ -1956,7 +1410,10 @@ var OrchestratorService = class {
       candidates.push(issue);
     }
     if (!lifecycle && tenant.repositories.length > 0) {
-      const resolution = await this.loadProjectWorkflow(tenant, tenant.repositories[0]);
+      const resolution = await this.loadProjectWorkflow(
+        tenant,
+        tenant.repositories[0]
+      );
       if (isUsableWorkflowResolution(resolution)) {
         lifecycle = resolution.lifecycle;
       }
@@ -1983,7 +1440,9 @@ var OrchestratorService = class {
         return false;
       }
       if (blockerRef.identifier) {
-        const blockerIssue = issues.find((candidate) => candidate.identifier === blockerRef.identifier);
+        const blockerIssue = issues.find(
+          (candidate) => candidate.identifier === blockerRef.identifier
+        );
         if (blockerIssue?.state) {
           return !isStateTerminal(blockerIssue.state, lifecycle);
         }
@@ -1999,24 +1458,42 @@ 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 cacheRoot = join3(
+      this.store.projectDir(tenant.projectId),
+      "cache",
+      repository.owner,
+      repository.name
+    );
     const { repositoryDirectory, changed } = await syncRepositoryForRun({
       repository,
       targetDirectory: cacheRoot
     });
-    const resolution = await loadRepositoryWorkflow(repositoryDirectory, repository);
-    return this.resolveWorkflowResolution(repository, cacheRoot, resolution, changed);
+    const resolution = await loadRepositoryWorkflow(
+      repositoryDirectory,
+      repository
+    );
+    return this.resolveWorkflowResolution(
+      repository,
+      cacheRoot,
+      resolution,
+      changed
+    );
   }
-  async startRun(tenant, issue, resumeContext) {
+  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();
@@ -2029,12 +1506,24 @@ var OrchestratorService = class {
       adapter: issue.tracker.adapter,
       issueSubjectId
     };
-    const preferredWorkspaceKey = deriveIssueWorkspaceKey(identity, issue.identifier);
+    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 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
@@ -2054,14 +1543,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(),
@@ -2074,25 +1569,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 allProjectRuns = (await this.store.loadAllRuns()).filter((run) => run.projectId === tenant.projectId);
-    const issueBudgetSnapshot = resolveIssueBudgetSnapshot(allProjectRuns, issue.id);
     const promptVariables = buildPromptVariables(issue, {
       attempt: null
       // first execution
     });
-    const renderedPrompt = renderPrompt(workflow.promptTemplate, promptVariables);
-    await this.runHook("before_run", tenant, repositoryDirectory, issue.repository, {
-      projectId: tenant.projectId,
-      workspaceKey,
-      issueSubjectId,
-      issueIdentifier: issue.identifier,
-      workspacePath: issueWorkspacePath,
-      repositoryPath: repositoryDirectory,
-      runId,
-      state: issue.state
-    });
+    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"
@@ -2115,55 +1620,69 @@ 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_GLOBAL_MAX_TURNS: process.env.SYMPHONY_GLOBAL_MAX_TURNS ?? "",
-        SYMPHONY_MAX_TOKENS: process.env.SYMPHONY_MAX_TOKENS ?? "",
-        SYMPHONY_MAX_NONPRODUCTIVE_TURNS: process.env.SYMPHONY_MAX_NONPRODUCTIVE_TURNS ?? String(DEFAULT_MAX_NONPRODUCTIVE_TURNS),
-        SYMPHONY_SESSION_TIMEOUT_MS: process.env.SYMPHONY_SESSION_TIMEOUT_MS ?? "",
-        SYMPHONY_RESUME_THREAD_ID: resumeContext?.threadId ?? "",
-        SYMPHONY_CUMULATIVE_TURN_COUNT: String(Math.max(0, resumeContext?.cumulativeTurnCount ?? issueBudgetSnapshot.cumulativeTurnCount)),
-        SYMPHONY_CUMULATIVE_INPUT_TOKENS: String(issueBudgetSnapshot.tokenUsage.inputTokens),
-        SYMPHONY_CUMULATIVE_OUTPUT_TOKENS: String(issueBudgetSnapshot.tokenUsage.outputTokens),
-        SYMPHONY_CUMULATIVE_TOTAL_TOKENS: String(issueBudgetSnapshot.tokenUsage.totalTokens),
-        SYMPHONY_LAST_TURN_SUMMARY: resumeContext?.lastTurnSummary ?? "",
-        SYMPHONY_SESSION_STARTED_AT: issueBudgetSnapshot.sessionStartedAt ?? "",
-        SYMPHONY_READ_TIMEOUT_MS: String(workflow.workflow.codex.readTimeoutMs),
-        SYMPHONY_TURN_TIMEOUT_MS: String(workflow.workflow.codex.turnTimeoutMs)
-      }),
-      detached: true,
-      stdio: ["ignore", "ignore", "pipe"]
-    });
+    const 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) {
@@ -2200,7 +1719,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) {
@@ -2240,7 +1761,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) => {
@@ -2287,14 +1810,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;
@@ -2317,8 +1850,10 @@ 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 startedAtMs = parseTimestampMs2(run.startedAt);
+      const lastActivityAtMs = parseTimestampMs(
+        run.lastEventAt ?? run.startedAt
+      );
+      const startedAtMs = parseTimestampMs(run.startedAt);
       const elapsedSinceLastActivityMs = lastActivityAtMs === null ? null : now.getTime() - lastActivityAtMs;
       const runningSinceMs = startedAtMs === null ? null : now.getTime() - startedAtMs;
       const isStalledByWorkflowTimeout = configuredStallTimeoutMs !== null && configuredStallTimeoutMs > 0 && elapsedSinceLastActivityMs !== null && elapsedSinceLastActivityMs > configuredStallTimeoutMs;
@@ -2329,9 +1864,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 {
@@ -2344,11 +1883,14 @@ 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(
+            {
+              projectId: tenant.projectId,
+              adapter: tenant.tracker.adapter,
+              issueSubjectId: run.issueSubjectId
+            },
+            run.issueIdentifier
+          ),
           state: "running",
           currentRunId: run.runId,
           retryEntry: null,
@@ -2366,12 +1908,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,
@@ -2397,46 +1956,68 @@ 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);
     }
-    if (workerInfo.exitClassification === "budget-exceeded" || workerInfo.exitClassification === "convergence-detected") {
+    if (workerInfo.exitClassification === "convergence-detected") {
       const completedRun = {
         ...runWithTokens,
-        status: workerInfo.exitClassification === "budget-exceeded" ? "succeeded" : "failed",
+        status: "failed",
         processId: null,
         updatedAt: now.toISOString(),
         completedAt: now.toISOString(),
         nextRetryAt: null,
         retryKind: null,
-        lastError: workerInfo.exitClassification === "budget-exceeded" ? null : runWithTokens.lastError,
-        runPhase: runWithTokens.runPhase ?? (workerInfo.exitClassification === "budget-exceeded" ? "succeeded" : "failed")
+        lastError: runWithTokens.lastError,
+        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}.`,
@@ -2463,16 +2044,21 @@ var OrchestratorService = class {
         issueId: run.issueId,
         reason: MAX_FAILURE_RETRIES_EXCEEDED_REASON
       });
-      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(
+            {
+              projectId: tenant.projectId,
+              adapter: tenant.tracker.adapter,
+              issueSubjectId: run.issueSubjectId
+            },
+            run.issueIdentifier
+          ),
           state: "released",
           failureRetryCount,
           currentRunId: null,
@@ -2484,7 +2070,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;
@@ -2505,16 +2093,23 @@ 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(
+        {
+          projectId: tenant.projectId,
+          adapter: tenant.tracker.adapter,
+          issueSubjectId: run.issueSubjectId
+        },
+        run.issueIdentifier
+      ),
       state: "retry_queued",
       completedOnce: retryKind === "continuation" ? true : void 0,
       failureRetryCount,
@@ -2573,9 +2168,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 {
     }
@@ -2592,15 +2191,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
@@ -2661,15 +2274,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
@@ -2734,7 +2361,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";
       }
@@ -2742,17 +2373,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 {
-      if (isIssueBudgetExceeded(resolveIssueBudgetSnapshot((await this.store.loadAllRuns()).filter((candidate) => candidate.projectId === tenant.projectId), run.issueId), this.now())) {
-        return "release";
-      }
-      const eligibleContext = await this.fetchTrackedIssueEligibilityContext(tenant, run.issueIdentifier, trackerDependencies);
+      const eligibleContext = await this.fetchTrackedIssueEligibilityContext(
+        tenant,
+        run.issueIdentifier,
+        trackerDependencies
+      );
       if (!eligibleContext) {
         return "release";
       }
@@ -2760,7 +2396,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";
     }
@@ -2771,7 +2411,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) {
@@ -2795,12 +2437,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;
         }
@@ -2821,7 +2471,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,
@@ -2839,14 +2492,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,
@@ -2862,19 +2525,18 @@ var OrchestratorService = class {
       lastError: "Superseded by recovered run."
     };
     await this.store.saveRun(supersededRecord);
-    const issue = resolveTrackerAdapter2(tenant.tracker).reviveIssue(tenant, run);
-    const restarted = await this.startRun(tenant, issue, {
-      threadId: run.threadId ?? run.runtimeSession?.threadId ?? null,
-      cumulativeTurnCount: resolvePersistedCumulativeTurnCount(run),
-      lastTurnSummary: run.lastTurnSummary ?? null
-    });
+    const issue = resolveTrackerAdapter2(tenant.tracker).reviveIssue(
+      tenant,
+      run
+    );
+    const restarted = await this.startRun(tenant, issue);
     const recoveredRecord = {
       ...restarted,
       attempt: run.attempt,
       retryKind: run.retryKind ?? "recovery",
       createdAt: run.createdAt,
       issueWorkspaceKey: run.issueWorkspaceKey,
-      threadId: run.threadId ?? run.runtimeSession?.threadId ?? null,
+      threadId: null,
       cumulativeTurnCount: resolvePersistedCumulativeTurnCount(run),
       lastTurnSummary: run.lastTurnSummary ?? null,
       turnCount: 0
@@ -2892,11 +2554,14 @@ 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(
+          {
+            projectId: tenant.projectId,
+            adapter: tenant.tracker.adapter,
+            issueSubjectId: recoveredRecord.issueSubjectId
+          },
+          recoveredRecord.issueIdentifier
+        ),
         state: "running",
         currentRunId: recoveredRecord.runId,
         retryEntry: null,
@@ -2917,34 +2582,40 @@ 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);
+    const intervals = await Promise.all(
+      tenant.repositories.map(async (repository) => {
+        const resolution = await this.loadProjectWorkflow(tenant, repository);
+        return isUsableWorkflowResolution(resolution) ? resolution.workflow.polling.intervalMs : NaN;
+      })
+    );
+    const validIntervals = intervals.filter(
+      (value) => Number.isFinite(value) && value > 0
+    );
     return validIntervals.length ? Math.min(...validIntervals) : DEFAULT_POLL_INTERVAL_MS;
   }
   async loadProjectMaxConcurrentByState(tenant) {
     const result = {};
-    const resolutions = await Promise.all(tenant.repositories.map(async (repository) => {
-      try {
-        return await this.loadProjectWorkflow(tenant, repository);
-      } catch {
-        return null;
-      }
-    }));
+    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;
+      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];
@@ -2963,7 +2634,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) {
@@ -2980,15 +2651,22 @@ 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);
+    const limits = await Promise.all(
+      project.repositories.map(async (repository) => {
+        try {
+          const resolution = await this.loadProjectWorkflow(
+            project,
+            repository
+          );
+          return isUsableWorkflowResolution(resolution) ? resolution.workflow.agent.maxConcurrentAgents : NaN;
+        } catch {
+          return NaN;
+        }
+      })
+    );
+    const validLimits = limits.filter(
+      (value) => Number.isFinite(value) && value >= 0
+    );
     return validLimits.length ? Math.min(...validLimits) : DEFAULT_CONCURRENCY;
   }
   async resolveWorkflowResolution(repository, cacheRoot, resolution, changed) {
@@ -3002,7 +2680,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;
       }
@@ -3017,8 +2698,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) {
@@ -3108,10 +2791,22 @@ var OrchestratorService = class {
       adapter: issue.tracker.adapter,
       issueSubjectId
     };
-    const preferredWorkspaceKey = deriveIssueWorkspaceKey(identity, issue.identifier);
+    const preferredWorkspaceKey = deriveIssueWorkspaceKey(
+      identity,
+      issue.identifier
+    );
     const legacyWorkspaceKey = deriveLegacyIssueWorkspaceKey(identity);
     const orchestrationRecord = (await this.store.loadProjectIssueOrchestrations(tenant.projectId)).find((record) => record.issueId === issue.id);
-    const workspaceRecord = (orchestrationRecord ? await this.store.loadIssueWorkspace(tenant.projectId, orchestrationRecord.workspaceKey) : null) ?? await this.store.loadIssueWorkspace(tenant.projectId, preferredWorkspaceKey) ?? (legacyWorkspaceKey === preferredWorkspaceKey ? null : await this.store.loadIssueWorkspace(tenant.projectId, legacyWorkspaceKey));
+    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;
     }
@@ -3121,17 +2816,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 });
@@ -3149,19 +2853,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)) {
       return false;
     }
-    const issueUpdatedAtMs = parseTimestampMs2(issue.updatedAt);
-    const suppressedAtMs = parseTimestampMs2(latestRun.completedAt ?? latestRun.updatedAt);
+    const issueUpdatedAtMs = parseTimestampMs(issue.updatedAt);
+    const suppressedAtMs = parseTimestampMs(
+      latestRun.completedAt ?? latestRun.updatedAt
+    );
     if (issueUpdatedAtMs === null || suppressedAtMs === null) {
       return true;
     }
@@ -3177,7 +2888,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);
@@ -3189,7 +2902,9 @@ function resolveProjectRateLimits(runs, issues) {
     if (!isRecord(run.rateLimits)) {
       continue;
     }
-    const timestamp = parseTimestampMs2(run.lastEventAt ?? run.updatedAt ?? run.startedAt);
+    const timestamp = parseTimestampMs(
+      run.lastEventAt ?? run.updatedAt ?? run.startedAt
+    );
     const sortableTimestamp = timestamp ?? -Infinity;
     if (sortableTimestamp >= latestRunTimestamp) {
       latestRunTimestamp = sortableTimestamp;
@@ -3268,56 +2983,21 @@ 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];
+  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);
+  const convergedAtMs = parseTimestampMs(
+    latestRun.completedAt ?? latestRun.updatedAt
+  );
+  const issueUpdatedAtMs = parseTimestampMs(issueUpdatedAt);
   if (convergedAtMs === null || issueUpdatedAtMs === null) {
     return true;
   }
   return issueUpdatedAtMs <= convergedAtMs;
 }
-function resolveIssueBudgetSnapshot(runs, issueId) {
-  const issueRuns = runs.filter((run) => run.issueId === issueId);
-  const startedAtCandidates = issueRuns.map((run) => run.startedAt).filter((value) => typeof value === "string");
-  return {
-    cumulativeTurnCount: issueRuns.reduce((total, run) => total + resolvePersistedCumulativeTurnCount(run), 0),
-    tokenUsage: issueRuns.reduce((total, run) => ({
-      inputTokens: total.inputTokens + (run.tokenUsage?.inputTokens ?? 0),
-      outputTokens: total.outputTokens + (run.tokenUsage?.outputTokens ?? 0),
-      totalTokens: total.totalTokens + (run.tokenUsage?.totalTokens ?? 0)
-    }), {
-      inputTokens: 0,
-      outputTokens: 0,
-      totalTokens: 0
-    }),
-    sessionStartedAt: startedAtCandidates.sort((left, right) => left.localeCompare(right))[0] ?? null
-  };
-}
-function isIssueBudgetExceeded(snapshot, now, env = process.env) {
-  const globalMaxTurns = parsePositiveInteger(env.SYMPHONY_GLOBAL_MAX_TURNS ?? "") ?? DEFAULT_GLOBAL_MAX_TURNS;
-  if (snapshot.cumulativeTurnCount >= globalMaxTurns) {
-    return true;
-  }
-  const maxTokens = parsePositiveInteger(env.SYMPHONY_MAX_TOKENS ?? "") ?? DEFAULT_MAX_TOKENS;
-  if (snapshot.tokenUsage.totalTokens >= maxTokens) {
-    return true;
-  }
-  const sessionTimeoutMs = parsePositiveInteger(env.SYMPHONY_SESSION_TIMEOUT_MS ?? "");
-  if (sessionTimeoutMs === null || snapshot.sessionStartedAt === null) {
-    return false;
-  }
-  return now.getTime() - new Date(snapshot.sessionStartedAt).getTime() >= sessionTimeoutMs;
-}
-function parsePositiveInteger(value) {
-  const parsed = Number(value);
-  if (!Number.isFinite(parsed) || parsed <= 0) {
-    return null;
-  }
-  return Math.floor(parsed);
-}
 function resolveCumulativeTurnCount(run, turnCount) {
   const carriedTotal = resolvePersistedCumulativeTurnCount(run);
   if (turnCount === null) {
@@ -3360,7 +3040,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;
@@ -3373,17 +3056,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);
@@ -3424,8 +3103,8 @@ function buildLatestRunMapByIssueId(runs) {
       latestRuns.set(run.issueId, run);
       continue;
     }
-    const runUpdatedAtMs = parseTimestampMs2(run.updatedAt) ?? -Infinity;
-    const existingUpdatedAtMs = parseTimestampMs2(existing.updatedAt) ?? -Infinity;
+    const runUpdatedAtMs = parseTimestampMs(run.updatedAt) ?? -Infinity;
+    const existingUpdatedAtMs = parseTimestampMs(existing.updatedAt) ?? -Infinity;
     if (runUpdatedAtMs > existingUpdatedAtMs) {
       latestRuns.set(run.issueId, run);
     }
@@ -3437,7 +3116,9 @@ function isIssueOrchestrationClaimed(state) {
 }
 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,
     {
@@ -3448,19 +3129,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);
+  return issueRecords.map(
+    (record) => record.issueId === issueId ? {
+      ...record,
+      state: "released",
+      currentRunId: null,
+      retryEntry: null,
+      updatedAt: now.toISOString()
+    } : record
+  );
 }
 function isActiveRunStatus(status) {
   return status === "pending" || status === "starting" || status === "running" || status === "retrying";
 }
 
-// ../orchestrator/dist/lock.js
+// ../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";
@@ -3498,14 +3181,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 });
   }
@@ -3544,7 +3231,9 @@ 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) {
@@ -3553,7 +3242,9 @@ function resolveProjectLockPath(runtimeRoot, projectId) {
   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}".`);
+    throw new Error(
+      `Invalid project ID "${projectId}". Project lock path must stay within "${projectsRoot}".`
+    );
   }
   return join4(projectDir, ".lock");
 }
@@ -3581,15 +3272,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";
@@ -3597,7 +3297,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;
@@ -3607,8 +3309,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,
@@ -3656,8 +3362,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);
         });
@@ -3784,8 +3492,10 @@ 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;
   });
 }