@gh-symphony/cli 0.0.21 → 0.0.22

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

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   resolveTrackerAdapter
-} from "./chunk-SXGT7LOF.js";
+} from "./chunk-2TSM3INR.js";
 import {
   DEFAULT_MAX_FAILURE_RETRIES,
   DEFAULT_WORKFLOW_LIFECYCLE,
@@ -31,13 +31,457 @@ import {
   resolveWorkflowRuntimeTimeouts,
   safeReadDir,
   scheduleRetryAt
-} from "./chunk-QEONJ5DZ.js";
+} from "./chunk-EEQQWTXS.js";
+
+// ../tracker-file/src/file-tracker-adapter.ts
+import { readFile } from "fs/promises";
+function requireTrackerSetting(project, key) {
+  const value = project.tracker.settings?.[key];
+  if (typeof value !== "string" || value.length === 0) {
+    throw new Error(
+      `Tracker adapter "file" requires the "${key}" setting.`
+    );
+  }
+  return value;
+}
+function parseIssueNumber(identifier) {
+  const match = identifier.match(/#(\d+)$/);
+  return match ? Number.parseInt(match[1] ?? "0", 10) : 0;
+}
+function isValidIssueShape(entry) {
+  if (!entry || typeof entry !== "object") return false;
+  const e = entry;
+  return typeof e.id === "string" && typeof e.identifier === "string" && typeof e.state === "string" && e.repository !== null && typeof e.repository === "object" && e.tracker !== null && typeof e.tracker === "object";
+}
+var fileTrackerAdapter = {
+  async listIssues(project) {
+    const issuesPath = requireTrackerSetting(project, "issuesPath");
+    try {
+      const raw = await readFile(issuesPath, "utf-8");
+      const parsed = JSON.parse(raw);
+      if (!Array.isArray(parsed)) {
+        throw new Error(
+          `Expected an array of issues in ${issuesPath}, got ${typeof parsed}`
+        );
+      }
+      const valid = [];
+      for (let i = 0; i < parsed.length; i++) {
+        if (isValidIssueShape(parsed[i])) {
+          valid.push(parsed[i]);
+        } else {
+          process.stderr.write(
+            `[tracker-file] Skipping invalid issue at index ${i} in ${issuesPath}
+`
+          );
+        }
+      }
+      return valid;
+    } catch (err) {
+      if (err instanceof Error && "code" in err && err.code === "ENOENT") {
+        return [];
+      }
+      if (err instanceof SyntaxError) {
+        return [];
+      }
+      throw err;
+    }
+  },
+  async listIssuesByStates(project, states) {
+    if (states.length === 0) {
+      return [];
+    }
+    const issues = await this.listIssues(project);
+    const normalizedStates = new Set(
+      states.map((state) => state.trim().toLowerCase())
+    );
+    return issues.filter(
+      (issue) => normalizedStates.has(issue.state.trim().toLowerCase())
+    );
+  },
+  async fetchIssueStatesByIds(project, issueIds) {
+    if (issueIds.length === 0) {
+      return [];
+    }
+    const issues = await this.listIssues(project);
+    const ids = new Set(issueIds);
+    return issues.filter((issue) => ids.has(issue.id));
+  },
+  buildWorkerEnvironment(_project, _issue) {
+    return {
+      SYMPHONY_FILE_TRACKER: "true"
+    };
+  },
+  reviveIssue(project, run) {
+    return {
+      id: run.issueId,
+      identifier: run.issueIdentifier,
+      number: parseIssueNumber(run.issueIdentifier),
+      title: run.issueTitle ?? run.issueIdentifier,
+      description: null,
+      priority: null,
+      state: run.issueState,
+      branchName: null,
+      url: null,
+      labels: [],
+      blockedBy: [],
+      createdAt: null,
+      updatedAt: null,
+      repository: run.repository,
+      tracker: {
+        adapter: "file",
+        bindingId: project.tracker.bindingId,
+        itemId: run.issueId
+      },
+      metadata: {}
+    };
+  }
+};
+
+// ../orchestrator/src/tracker-adapters.ts
+var localAdapters = /* @__PURE__ */ new Map([
+  ["file", fileTrackerAdapter]
+]);
+function resolveTrackerAdapter2(tracker) {
+  const local = localAdapters.get(tracker.adapter);
+  if (local) return local;
+  return resolveTrackerAdapter(tracker);
+}
+
+// ../orchestrator/src/explain.ts
+var MAX_FAILURE_RETRIES_EXCEEDED_REASON = "max_failure_retries_exceeded";
+function explainIssueDispatch(input) {
+  const parsed = parseIssueIdentifier(input.identifier);
+  const repository = parsed ? `${parsed.owner}/${parsed.name}` : input.issue ? `${input.issue.repository.owner}/${input.issue.repository.name}` : "unknown";
+  const issue = input.issue;
+  const checks = [];
+  checks.push(explainRepositoryLinked(input.projectRepository, repository));
+  checks.push(explainProjectItemPresent(input.identifier, issue));
+  if (!issue) {
+    const dispatchable2 = false;
+    const blocking2 = checks.filter((check) => check.status === "block");
+    const summary2 = blocking2.length > 0 ? `Not dispatchable: ${blocking2[0].message}` : "Not dispatchable: the issue is not present in the managed GitHub Project item set.";
+    return {
+      issue: {
+        identifier: input.identifier,
+        id: null,
+        state: null,
+        repository,
+        title: null,
+        url: null
+      },
+      dispatchable: dispatchable2,
+      summary: summary2,
+      checks
+    };
+  }
+  checks.push(explainWorkflowState(issue, input.lifecycle));
+  checks.push(explainBlockers(issue, input.lifecycle, input.allIssues));
+  checks.push(explainRuntimeOwnership(issue, input.issueRecords, input.runs));
+  checks.push(
+    explainDispatchLimits(
+      issue,
+      input.runs,
+      input.activeRunCount,
+      input.maxConcurrentAgents,
+      input.maxConcurrentAgentsByState
+    )
+  );
+  const blocking = checks.filter((check) => check.status === "block");
+  const dispatchable = blocking.length === 0;
+  const summary = dispatchable ? "Dispatchable: no blocking project, workflow, runtime, or budget condition was found." : `Not dispatchable: ${blocking[0].message}`;
+  return {
+    issue: {
+      identifier: issue.identifier,
+      id: issue.id,
+      state: issue.state,
+      repository: `${issue.repository.owner}/${issue.repository.name}`,
+      title: issue.title,
+      url: issue.url
+    },
+    dispatchable,
+    summary,
+    checks
+  };
+}
+function isIssueCandidateEligibleWithReason(issue, lifecycle, issues) {
+  if (!isStateActive(issue.state, lifecycle)) {
+    return { eligible: false, reason: "inactive_state" };
+  }
+  if (!issueHasBlockingDependency(issue, lifecycle, issues)) {
+    return { eligible: true, reason: null };
+  }
+  return { eligible: false, reason: "blocked" };
+}
+function hasConvergenceLockedRunForIssue(runs, issueId, issueState, issueUpdatedAt) {
+  const latestRun = latestRunForIssue(runs, issueId);
+  if (latestRun?.runtimeSession?.exitClassification !== "convergence-detected" || latestRun.issueState !== issueState) {
+    return null;
+  }
+  const convergedAtMs = parseTimestampMs(
+    latestRun.completedAt ?? latestRun.updatedAt
+  );
+  const issueUpdatedAtMs = parseTimestampMs(issueUpdatedAt);
+  if (convergedAtMs === null || issueUpdatedAtMs === null) {
+    return latestRun;
+  }
+  return issueUpdatedAtMs <= convergedAtMs ? latestRun : null;
+}
+function isIssueOrchestrationClaimedState(state) {
+  return state === "claimed" || state === "running" || state === "retry_queued";
+}
+function isActiveRunRecordStatus(status) {
+  return status === "pending" || status === "starting" || status === "running" || status === "retrying";
+}
+function explainRepositoryLinked(projectRepository, repository) {
+  if (!projectRepository) {
+    return {
+      id: "repository_linked",
+      status: "warn",
+      message: "No repository is configured for the active managed project.",
+      hint: "Run 'gh-symphony repo add <owner/name>' or re-run 'gh-symphony project add'."
+    };
+  }
+  const configured = `${projectRepository.owner}/${projectRepository.name}`;
+  const linked = normalizeIdentifier(configured) === normalizeIdentifier(repository);
+  return {
+    id: "repository_linked",
+    status: linked ? "pass" : "block",
+    message: linked ? `Repository ${repository} is linked to the active managed project.` : `Repository ${repository} is not the active managed project repository (${configured}).`,
+    details: { configuredRepository: configured, issueRepository: repository },
+    hint: linked ? void 0 : "Run 'gh-symphony repo add <owner/name>' or select the correct project with 'gh-symphony project switch'."
+  };
+}
+function explainProjectItemPresent(identifier, issue) {
+  return {
+    id: "project_item_present",
+    status: issue ? "pass" : "block",
+    message: issue ? "Issue is present in the bound GitHub Project item set." : `Issue ${identifier} was not returned by the bound GitHub Project item set.`,
+    details: issue ? { itemId: issue.tracker.itemId } : void 0,
+    hint: issue ? void 0 : "Add the issue to the GitHub Project or run 'gh-symphony project status' to confirm the active project."
+  };
+}
+function explainWorkflowState(issue, lifecycle) {
+  if (isStateActive(issue.state, lifecycle)) {
+    return {
+      id: "workflow_state",
+      status: "pass",
+      message: `Project state "${issue.state}" maps to an active state in WORKFLOW.md.`,
+      details: { activeStates: lifecycle.activeStates }
+    };
+  }
+  const role = isStateTerminal(issue.state, lifecycle) ? "terminal" : "wait";
+  return {
+    id: "workflow_state",
+    status: "block",
+    message: `Project state "${issue.state}" maps to ${role}, not active, in WORKFLOW.md.`,
+    details: {
+      activeStates: lifecycle.activeStates,
+      terminalStates: lifecycle.terminalStates,
+      blockerCheckStates: lifecycle.blockerCheckStates
+    },
+    hint: "Move the GitHub Project item to an active state or run 'gh-symphony workflow preview' to inspect WORKFLOW.md state mappings."
+  };
+}
+function explainBlockers(issue, lifecycle, issues) {
+  if (!matchesWorkflowState(issue.state, lifecycle.blockerCheckStates)) {
+    return {
+      id: "blockers",
+      status: "pass",
+      message: `Blocker checks do not apply to state "${issue.state}".`,
+      details: { blockerCheckStates: lifecycle.blockerCheckStates }
+    };
+  }
+  const blockers = unresolvedBlockers(issue, lifecycle, issues);
+  if (blockers.length === 0) {
+    return {
+      id: "blockers",
+      status: "pass",
+      message: "No unresolved blockers prevent dispatch.",
+      details: { blockedBy: issue.blockedBy }
+    };
+  }
+  return {
+    id: "blockers",
+    status: "block",
+    message: `Issue has ${blockers.length} unresolved blocker${blockers.length === 1 ? "" : "s"}.`,
+    details: { blockers },
+    hint: "Move blocker issues to a terminal state or update the blocker relationship in GitHub."
+  };
+}
+function explainRuntimeOwnership(issue, issueRecords, runs) {
+  const record = issueRecords.find(
+    (candidate) => candidate.issueId === issue.id || candidate.identifier === issue.identifier
+  );
+  const latestRun = latestRunForIssue(runs, issue.id);
+  const activeRun = runs.find(
+    (run) => run.issueId === issue.id && isActiveRunRecordStatus(run.status)
+  );
+  if (activeRun) {
+    return {
+      id: "runtime_ownership",
+      status: "block",
+      message: `Existing ${activeRun.status} run ${activeRun.runId} already owns the issue.`,
+      details: {
+        runId: activeRun.runId,
+        status: activeRun.status,
+        retryKind: activeRun.retryKind,
+        nextRetryAt: activeRun.nextRetryAt
+      },
+      hint: "Run 'gh-symphony status' or 'gh-symphony logs --issue <owner/repo#number>' to inspect the current owner."
+    };
+  }
+  if (record && isIssueOrchestrationClaimedState(record.state)) {
+    return {
+      id: "runtime_ownership",
+      status: "block",
+      message: `Issue is already claimed by orchestration state "${record.state}".`,
+      details: {
+        state: record.state,
+        currentRunId: record.currentRunId,
+        retryEntry: record.retryEntry
+      },
+      hint: "Run 'gh-symphony status' to inspect active and retrying work."
+    };
+  }
+  const convergenceRun = hasConvergenceLockedRunForIssue(
+    runs,
+    issue.id,
+    issue.state,
+    issue.updatedAt
+  );
+  if (convergenceRun) {
+    return {
+      id: "runtime_ownership",
+      status: "block",
+      message: `Latest run ${convergenceRun.runId} is convergence-locked for state "${issue.state}".`,
+      details: {
+        runId: convergenceRun.runId,
+        completedAt: convergenceRun.completedAt,
+        lastError: convergenceRun.lastError
+      },
+      hint: "Update the GitHub Project item or issue activity to trigger a newer tracker timestamp after resolving the unchanged workspace diff."
+    };
+  }
+  if (record && record.failureRetryCount > 0 && latestRun?.status === "suppressed" && latestRun.issueState === issue.state && latestRun.lastError?.includes(MAX_FAILURE_RETRIES_EXCEEDED_REASON)) {
+    const issueUpdatedAtMs = parseTimestampMs(issue.updatedAt);
+    const suppressedAtMs = parseTimestampMs(
+      latestRun.completedAt ?? latestRun.updatedAt
+    );
+    if (issueUpdatedAtMs === null || suppressedAtMs === null || issueUpdatedAtMs <= suppressedAtMs) {
+      return {
+        id: "runtime_ownership",
+        status: "block",
+        message: "Failure retry limit has suppressed redispatch for the current tracker state.",
+        details: {
+          failureRetryCount: record.failureRetryCount,
+          runId: latestRun.runId,
+          lastError: latestRun.lastError
+        },
+        hint: "Fix the underlying failure and update the GitHub Project item or issue to create a newer tracker timestamp."
+      };
+    }
+  }
+  return {
+    id: "runtime_ownership",
+    status: "pass",
+    message: "No active run, retry, convergence lock, or suppression owns the issue.",
+    details: record ? {
+      orchestrationState: record.state,
+      currentRunId: record.currentRunId,
+      latestRunId: latestRun?.runId ?? null
+    } : void 0
+  };
+}
+function explainDispatchLimits(issue, runs, activeRunCount, maxConcurrentAgents, maxConcurrentAgentsByState) {
+  if (activeRunCount >= maxConcurrentAgents) {
+    return {
+      id: "dispatch_limits",
+      status: "block",
+      message: `Project concurrency is full (${activeRunCount}/${maxConcurrentAgents}).`,
+      details: { activeRunCount, maxConcurrentAgents },
+      hint: "Wait for an active run to finish or adjust agent.max_concurrent_agents in WORKFLOW.md."
+    };
+  }
+  const stateLimit = maxConcurrentAgentsByState[issue.state];
+  if (stateLimit !== void 0) {
+    const activeInState = runs.filter(
+      (run) => run.issueState === issue.state && isActiveRunRecordStatus(run.status)
+    ).length;
+    if (activeInState >= stateLimit) {
+      return {
+        id: "dispatch_limits",
+        status: "block",
+        message: `State concurrency is full for "${issue.state}" (${activeInState}/${stateLimit}).`,
+        details: { activeInState, stateLimit, state: issue.state },
+        hint: "Wait for a same-state run to finish or adjust agent.max_concurrent_agents_by_state in WORKFLOW.md."
+      };
+    }
+  }
+  return {
+    id: "dispatch_limits",
+    status: "pass",
+    message: "Project and per-state concurrency limits have available capacity.",
+    details: {
+      activeRunCount,
+      maxConcurrentAgents,
+      stateLimit: stateLimit ?? null
+    }
+  };
+}
+function issueHasBlockingDependency(issue, lifecycle, issues) {
+  if (!matchesWorkflowState(issue.state, lifecycle.blockerCheckStates) || issue.blockedBy.length === 0) {
+    return false;
+  }
+  return unresolvedBlockers(issue, lifecycle, issues).length > 0;
+}
+function unresolvedBlockers(issue, lifecycle, issues) {
+  return issue.blockedBy.filter((blockerRef) => {
+    if (blockerRef.state && isStateTerminal(blockerRef.state, lifecycle)) {
+      return false;
+    }
+    if (blockerRef.identifier) {
+      const blockerIssue = issues.find(
+        (candidate) => candidate.identifier === blockerRef.identifier
+      );
+      if (blockerIssue?.state) {
+        return !isStateTerminal(blockerIssue.state, lifecycle);
+      }
+    }
+    return true;
+  });
+}
+function latestRunForIssue(runs, issueId) {
+  return runs.filter((run) => run.issueId === issueId).sort(
+    (left, right) => (parseTimestampMs(right.updatedAt) ?? -Infinity) - (parseTimestampMs(left.updatedAt) ?? -Infinity)
+  )[0] ?? null;
+}
+function parseTimestampMs(value) {
+  if (!value) {
+    return null;
+  }
+  const parsed = Date.parse(value);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+function parseIssueIdentifier(identifier) {
+  const match = identifier.match(/^([^/\s#]+)\/([^/\s#]+)#(\d+)$/);
+  if (!match) {
+    return null;
+  }
+  return {
+    owner: match[1],
+    name: match[2],
+    number: Number.parseInt(match[3], 10)
+  };
+}
+function normalizeIdentifier(value) {
+  return value.trim().toLowerCase();
+}
 
 // ../orchestrator/src/service.ts
 import { mkdir as mkdir3, readFile as readFile3, rm as rm3, writeFile as writeFile3 } from "fs/promises";
 import { createWriteStream, mkdirSync } from "fs";
 import { spawn as spawn2 } from "child_process";
-import { join as join3 } from "path";
+import { isAbsolute, join as join3 } from "path";
 import { StringDecoder } from "string_decoder";
 import { fileURLToPath } from "url";
 
@@ -47,7 +491,7 @@ import { randomUUID } from "crypto";
 import {
   access,
   mkdir,
-  readFile,
+  readFile as readFile2,
   rename,
   rm,
   stat,
@@ -118,10 +562,13 @@ async function syncRepositoryForRun(input) {
   });
 }
 async function ensureIssueWorkspaceRepository(input) {
-  return cloneRepositoryForRun({
-    repository: input.repository,
-    targetDirectory: input.issueWorkspacePath
-  });
+  if (!input.existingWorkspace) {
+    return cloneRepositoryForRun({
+      repository: input.repository,
+      targetDirectory: input.issueWorkspacePath
+    });
+  }
+  return syncExistingIssueWorkspaceRepository(input);
 }
 async function loadRepositoryWorkflow(repositoryDirectory, _repository) {
   const workflowPath = join(repositoryDirectory, "WORKFLOW.md");
@@ -160,16 +607,117 @@ function runCommand(command, args) {
     });
   });
 }
-async function readGitHead(repositoryDirectory) {
+async function readGitHead(repositoryDirectory) {
+  try {
+    return await runCommandCapture("git", [
+      "-C",
+      repositoryDirectory,
+      "rev-parse",
+      "HEAD"
+    ]);
+  } catch {
+    return null;
+  }
+}
+async function syncExistingIssueWorkspaceRepository(input) {
+  await mkdir(input.issueWorkspacePath, { recursive: true });
+  const repositoryDirectory = join(input.issueWorkspacePath, "repository");
+  const lockDirectory = join(input.issueWorkspacePath, "repository.lock");
+  return withRepositoryLock(lockDirectory, async () => {
+    const repositoryExists = await pathExists(repositoryDirectory);
+    const hasGit = await pathExists(join(repositoryDirectory, ".git"));
+    if (hasGit) {
+      let dirtyStatus;
+      try {
+        dirtyStatus = await readGitStatusPorcelain(repositoryDirectory);
+      } catch (error) {
+        throw createIssueWorkspacePreservedError(
+          repositoryDirectory,
+          `could not be inspected: ${formatCommandError(error, "git status --porcelain failed")}`
+        );
+      }
+      if (dirtyStatus.trim()) {
+        throw createIssueWorkspacePreservedError(
+          repositoryDirectory,
+          `has uncommitted changes: ${summarizeGitStatus(dirtyStatus)}`
+        );
+      }
+      try {
+        await runCommand("git", [
+          "-C",
+          repositoryDirectory,
+          "pull",
+          "--ff-only"
+        ]);
+      } catch (error) {
+        const message = formatCommandError(error, "git pull --ff-only failed");
+        throw createIssueWorkspacePreservedError(
+          repositoryDirectory,
+          `could not be fast-forwarded: ${message}`
+        );
+      }
+      return repositoryDirectory;
+    }
+    if (repositoryExists) {
+      throw createIssueWorkspacePreservedError(
+        repositoryDirectory,
+        "exists but is not a git checkout"
+      );
+    }
+    const tempRepositoryDirectory = join(
+      input.issueWorkspacePath,
+      `repository.tmp-${process.pid}-${Date.now()}`
+    );
+    await rm(tempRepositoryDirectory, { recursive: true, force: true });
+    try {
+      await runCommand("git", [
+        "clone",
+        "--depth",
+        "1",
+        input.repository.cloneUrl,
+        tempRepositoryDirectory
+      ]);
+      await rename(tempRepositoryDirectory, repositoryDirectory);
+      return repositoryDirectory;
+    } finally {
+      await rm(tempRepositoryDirectory, { recursive: true, force: true });
+    }
+  });
+}
+function createIssueWorkspacePreservedError(repositoryDirectory, reason) {
+  return new Error(
+    [
+      `Issue workspace repository at ${repositoryDirectory} was preserved because it ${reason}.`,
+      "Resolve or commit the local workspace changes, or run a configured recovery hook, before retrying."
+    ].join(" ")
+  );
+}
+function formatCommandError(error, fallback) {
+  const message = error instanceof Error ? error.message : fallback;
+  return normalizeWhitespace(message) || fallback;
+}
+function summarizeGitStatus(status) {
+  const lines = status.trim().split(/\r?\n/).map(normalizeWhitespace).filter(Boolean);
+  const summary = lines.slice(0, 5).join("; ");
+  return lines.length > 5 ? `${summary}; ...` : summary;
+}
+function normalizeWhitespace(value) {
+  return value.replace(/\s+/g, " ").trim();
+}
+async function readGitStatusPorcelain(repositoryDirectory) {
+  return runCommandCapture("git", [
+    "-C",
+    repositoryDirectory,
+    "status",
+    "--porcelain"
+  ]);
+}
+async function pathExists(path) {
   try {
-    return await runCommandCapture("git", [
-      "-C",
-      repositoryDirectory,
-      "rev-parse",
-      "HEAD"
-    ]);
+    await access(path, constants.F_OK);
+    return true;
   } catch {
-    return null;
+    return false;
   }
 }
 function runCommandCapture(command, args) {
@@ -271,7 +819,7 @@ function isAlreadyExistsError(error) {
 }
 async function readLockOwner(lockDirectory) {
   await access(join(lockDirectory, "owner"), constants.R_OK);
-  const owner = await readFile(join(lockDirectory, "owner"), "utf8");
+  const owner = await readFile2(join(lockDirectory, "owner"), "utf8");
   return owner.split("\n", 1)[0] || null;
 }
 function wait(ms) {
@@ -304,20 +852,14 @@ var OrchestratorFsStore = class {
   }
   resolvedRuntimeRoot;
   resolvedEventsMirrorRoot;
-  projectsRoot() {
-    return join2(this.runtimeRoot, "projects");
-  }
-  projectDir(projectId) {
-    return join2(this.projectsRoot(), projectId);
+  projectDir(_projectId) {
+    return this.runtimeRoot;
   }
-  projectRunsDir(projectId) {
-    return join2(this.projectDir(projectId), "runs");
+  runsDir() {
+    return join2(this.runtimeRoot, "runs");
   }
-  runDir(runId, projectId) {
-    if (!projectId) {
-      return join2(this.runtimeRoot, "projects", "__unknown__", "runs", runId);
-    }
-    return join2(this.projectRunsDir(projectId), runId);
+  runDir(runId, _projectId) {
+    return join2(this.runsDir(), runId);
   }
   async loadProjectConfig(projectId) {
     return readJsonFile(
@@ -370,7 +912,7 @@ var OrchestratorFsStore = class {
   }
   async saveProjectStatus(status) {
     await writeJsonFile(
-      join2(this.projectDir(status.projectId), "status.json"),
+      join2(this.projectDir(), "status.json"),
       status
     );
   }
@@ -389,16 +931,12 @@ var OrchestratorFsStore = class {
     ) ?? 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 runIds = await safeReadDir(this.runsDir());
     const runs = await Promise.all(
-      runDirectories.flat().map(
-        (directory) => readJsonFile(join2(directory, "run.json"))
+      runIds.map(
+        (runId) => readJsonFile(
+          join2(this.runDir(runId), "run.json")
+        )
       )
     );
     return runs.filter((run) => Boolean(run));
@@ -483,7 +1021,7 @@ var OrchestratorFsStore = class {
     }
   }
   issueWorkspaceDir(projectId, workspaceKey) {
-    return join2(this.projectDir(projectId), "issues", workspaceKey);
+    return join2(this.runtimeRoot, workspaceKey);
   }
   async loadIssueWorkspace(projectId, workspaceKey) {
     return await readJsonFile(
@@ -491,15 +1029,29 @@ var OrchestratorFsStore = class {
     ) ?? null;
   }
   async loadIssueWorkspaces(projectId) {
-    const issuesDir = join2(this.projectDir(projectId), "issues");
-    const entries = await safeReadDir(issuesDir);
+    const entries = await safeReadDir(this.runtimeRoot);
     const records = await Promise.all(
-      entries.map((entry) => this.loadIssueWorkspace(projectId, entry))
+      entries.map(async (entry) => {
+        if (!await this.isIssueWorkspaceEntry(entry)) {
+          return null;
+        }
+        return this.loadIssueWorkspace(projectId, entry);
+      })
     );
     return records.filter(
       (record) => Boolean(record)
     );
   }
+  async isIssueWorkspaceEntry(entry) {
+    if (entry.startsWith(".") || entry === "cache" || entry === "issues.json" || entry === "project.json" || entry === "runs" || entry === "status.json") {
+      return false;
+    }
+    try {
+      return (await stat2(join2(this.runtimeRoot, entry))).isDirectory();
+    } catch {
+      return false;
+    }
+  }
   async saveIssueWorkspace(record) {
     await writeJsonFile(
       join2(
@@ -514,15 +1066,12 @@ var OrchestratorFsStore = class {
     await rm2(dir, { recursive: true, force: true });
   }
   async findRunDir(runId) {
-    const projectIds = await safeReadDir(this.projectsRoot());
-    for (const projectId of projectIds) {
-      const candidate = this.runDir(runId, projectId);
-      const run = await readJsonFile(
-        join2(candidate, "run.json")
-      );
-      if (run || await pathExists(join2(candidate, "events.ndjson"))) {
-        return candidate;
-      }
+    const candidate = this.runDir(runId);
+    const run = await readJsonFile(
+      join2(candidate, "run.json")
+    );
+    if (run || await pathExists2(join2(candidate, "events.ndjson"))) {
+      return candidate;
     }
     return null;
   }
@@ -544,7 +1093,7 @@ async function writeJsonFile(path, value) {
   await writeFile2(temporaryPath, JSON.stringify(value, null, 2) + "\n", "utf8");
   await rename2(temporaryPath, path);
 }
-async function pathExists(path) {
+async function pathExists2(path) {
   try {
     await stat2(path);
     return true;
@@ -556,120 +1105,6 @@ async function pathExists(path) {
   }
 }
 
-// ../tracker-file/src/file-tracker-adapter.ts
-import { readFile as readFile2 } from "fs/promises";
-function requireTrackerSetting(project, key) {
-  const value = project.tracker.settings?.[key];
-  if (typeof value !== "string" || value.length === 0) {
-    throw new Error(
-      `Tracker adapter "file" requires the "${key}" setting.`
-    );
-  }
-  return value;
-}
-function parseIssueNumber(identifier) {
-  const match = identifier.match(/#(\d+)$/);
-  return match ? Number.parseInt(match[1] ?? "0", 10) : 0;
-}
-function isValidIssueShape(entry) {
-  if (!entry || typeof entry !== "object") return false;
-  const e = entry;
-  return typeof e.id === "string" && typeof e.identifier === "string" && typeof e.state === "string" && e.repository !== null && typeof e.repository === "object" && e.tracker !== null && typeof e.tracker === "object";
-}
-var fileTrackerAdapter = {
-  async listIssues(project) {
-    const issuesPath = requireTrackerSetting(project, "issuesPath");
-    try {
-      const raw = await readFile2(issuesPath, "utf-8");
-      const parsed = JSON.parse(raw);
-      if (!Array.isArray(parsed)) {
-        throw new Error(
-          `Expected an array of issues in ${issuesPath}, got ${typeof parsed}`
-        );
-      }
-      const valid = [];
-      for (let i = 0; i < parsed.length; i++) {
-        if (isValidIssueShape(parsed[i])) {
-          valid.push(parsed[i]);
-        } else {
-          process.stderr.write(
-            `[tracker-file] Skipping invalid issue at index ${i} in ${issuesPath}
-`
-          );
-        }
-      }
-      return valid;
-    } catch (err) {
-      if (err instanceof Error && "code" in err && err.code === "ENOENT") {
-        return [];
-      }
-      if (err instanceof SyntaxError) {
-        return [];
-      }
-      throw err;
-    }
-  },
-  async listIssuesByStates(project, states) {
-    if (states.length === 0) {
-      return [];
-    }
-    const issues = await this.listIssues(project);
-    const normalizedStates = new Set(
-      states.map((state) => state.trim().toLowerCase())
-    );
-    return issues.filter(
-      (issue) => normalizedStates.has(issue.state.trim().toLowerCase())
-    );
-  },
-  async fetchIssueStatesByIds(project, issueIds) {
-    if (issueIds.length === 0) {
-      return [];
-    }
-    const issues = await this.listIssues(project);
-    const ids = new Set(issueIds);
-    return issues.filter((issue) => ids.has(issue.id));
-  },
-  buildWorkerEnvironment(_project, _issue) {
-    return {
-      SYMPHONY_FILE_TRACKER: "true"
-    };
-  },
-  reviveIssue(project, run) {
-    return {
-      id: run.issueId,
-      identifier: run.issueIdentifier,
-      number: parseIssueNumber(run.issueIdentifier),
-      title: run.issueTitle ?? run.issueIdentifier,
-      description: null,
-      priority: null,
-      state: run.issueState,
-      branchName: null,
-      url: null,
-      labels: [],
-      blockedBy: [],
-      createdAt: null,
-      updatedAt: null,
-      repository: run.repository,
-      tracker: {
-        adapter: "file",
-        bindingId: project.tracker.bindingId,
-        itemId: run.issueId
-      },
-      metadata: {}
-    };
-  }
-};
-
-// ../orchestrator/src/tracker-adapters.ts
-var localAdapters = /* @__PURE__ */ new Map([
-  ["file", fileTrackerAdapter]
-]);
-function resolveTrackerAdapter2(tracker) {
-  const local = localAdapters.get(tracker.adapter);
-  if (local) return local;
-  return resolveTrackerAdapter(tracker);
-}
-
 // ../orchestrator/src/service.ts
 var DEFAULT_POLL_INTERVAL_MS = 3e4;
 var DEFAULT_CONCURRENCY = 3;
@@ -678,12 +1113,12 @@ var CONTINUATION_RETRY_DELAY_MS = 1e3;
 var DEFAULT_WORKER_COMMAND = "node packages/worker/dist/index.js";
 var DEFAULT_MAX_NONPRODUCTIVE_TURNS = 3;
 var LOW_RATE_LIMIT_WARNING_THRESHOLD = 0.05;
-var MAX_FAILURE_RETRIES_EXCEEDED_REASON = "max_failure_retries_exceeded";
+var MAX_FAILURE_RETRIES_EXCEEDED_REASON2 = "max_failure_retries_exceeded";
 var STUCK_WORKER_TIMEOUT_MS = 30 * 60 * 1e3;
 function isUsableWorkflowResolution(resolution) {
   return resolution.isValid || resolution.usedLastKnownGood;
 }
-function parseTimestampMs(value) {
+function parseTimestampMs2(value) {
   if (!value) {
     return null;
   }
@@ -771,7 +1206,6 @@ var OrchestratorService = class {
     ) : null;
     const currentRun = isMatchingIssueRun(
       currentRunCandidate,
-      this.projectConfig.projectId,
       issueRecord.issueId,
       issueIdentifier
     ) ? currentRunCandidate : await this.findLatestRunForIssue(issueRecord.issueId, issueIdentifier);
@@ -902,7 +1336,7 @@ var OrchestratorService = class {
     const allRuns = (await this.store.loadAllRuns()).filter(
       (run) => run.projectId === tenant.projectId
     );
-    const activeRuns = allRuns.filter((run) => isActiveRunStatus(run.status));
+    const activeRuns = allRuns.filter((run) => isActiveRunRecordStatus(run.status));
     for (const run of activeRuns) {
       const outcome = await this.reconcileRun(
         tenant,
@@ -916,7 +1350,7 @@ var OrchestratorService = class {
       }
     }
     const reconciledRuns = (await this.store.loadAllRuns()).filter(
-      (run) => run.projectId === tenant.projectId && isActiveRunStatus(run.status)
+      (run) => run.projectId === tenant.projectId && isActiveRunRecordStatus(run.status)
     );
     const projectRunsAfterReconcile = (await this.store.loadAllRuns()).filter(
       (run) => run.projectId === tenant.projectId
@@ -925,7 +1359,7 @@ var OrchestratorService = class {
     try {
       pollIntervalMs = await this.loadProjectPollInterval(tenant);
       const currentActiveRuns = (await this.store.loadAllRuns()).filter(
-        (run) => run.projectId === tenant.projectId && isActiveRunStatus(run.status)
+        (run) => run.projectId === tenant.projectId && isActiveRunRecordStatus(run.status)
       );
       const {
         runs: syncedActiveRuns,
@@ -976,14 +1410,14 @@ var OrchestratorService = class {
       );
       const concurrency = await this.getProjectConcurrency(tenant);
       const currentlyActive = issueRecords.filter(
-        (record) => isIssueOrchestrationClaimed(record.state)
+        (record) => isIssueOrchestrationClaimedState(record.state)
       ).length;
       const availableSlots = Math.max(0, concurrency - currentlyActive);
       const latestRunsByIssueId = buildLatestRunMapByIssueId(
         projectRunsAfterReconcile
       );
       const unscheduledCandidates = actionableCandidates.filter((issue) => {
-        if (hasConvergenceLockedRun(
+        if (hasConvergenceLockedRunForIssue(
           projectRunsAfterReconcile,
           issue.id,
           issue.state,
@@ -992,7 +1426,7 @@ var OrchestratorService = class {
           return false;
         }
         return !issueRecords.some(
-          (record) => record.issueId === issue.id && isIssueOrchestrationClaimed(record.state)
+          (record) => record.issueId === issue.id && isIssueOrchestrationClaimedState(record.state)
         );
       });
       const sortedCandidates = sortCandidatesForDispatch(unscheduledCandidates);
@@ -1026,7 +1460,6 @@ var OrchestratorService = class {
         }
         const preferredWorkspaceKey = deriveIssueWorkspaceKey(
           {
-            projectId: tenant.projectId,
             adapter: issue.tracker.adapter,
             issueSubjectId: issue.id
           },
@@ -1078,7 +1511,7 @@ var OrchestratorService = class {
         );
       }
       for (const issueRecord of issueRecords) {
-        if (!isIssueOrchestrationClaimed(issueRecord.state)) {
+        if (!isIssueOrchestrationClaimedState(issueRecord.state)) {
           continue;
         }
         const issue = trackedIssuesByIdentifier.get(issueRecord.identifier);
@@ -1089,7 +1522,6 @@ var OrchestratorService = class {
         const activeRun = syncedActiveRuns.find(
           (run) => isMatchingIssueRun(
             run,
-            tenant.projectId,
             issueRecord.issueId,
             issueRecord.identifier
           )
@@ -1159,7 +1591,7 @@ var OrchestratorService = class {
       (run) => run.projectId === tenant.projectId
     );
     const latestRuns = allTenantRuns.filter(
-      (run) => isActiveRunStatus(run.status)
+      (run) => isActiveRunRecordStatus(run.status)
     );
     rateLimits = rateLimits ?? resolveProjectRateLimits(latestRuns, []);
     const status = buildProjectSnapshot({
@@ -1215,7 +1647,6 @@ var OrchestratorService = class {
       try {
         const resolution = await this.loadStartupCleanupWorkflow(
           tenant,
-          issue.repository,
           workflowCache
         );
         if (!resolution.isValid) {
@@ -1256,32 +1687,22 @@ var OrchestratorService = class {
     }
     return String(error);
   }
-  async resolveStartupCleanupTerminalStates(tenant, workspaceRecords, workflowCache) {
+  async resolveStartupCleanupTerminalStates(tenant, _workspaceRecords, workflowCache) {
     const terminalStates = /* @__PURE__ */ new Map();
-    const repositories = this.resolveStartupCleanupRepositories(
-      tenant,
-      workspaceRecords
-    );
-    for (const repository of repositories) {
-      let resolution;
-      try {
-        resolution = await this.loadStartupCleanupWorkflow(
-          tenant,
-          repository,
-          workflowCache
-        );
-      } catch {
-        continue;
-      }
-      if (!isUsableWorkflowResolution(resolution)) {
-        continue;
-      }
-      for (const state of resolution.lifecycle.terminalStates) {
-        const normalizedState = state.trim().toLowerCase();
-        if (!terminalStates.has(normalizedState)) {
-          terminalStates.set(normalizedState, state);
+    try {
+      const resolution = await this.loadStartupCleanupWorkflow(
+        tenant,
+        workflowCache
+      );
+      if (isUsableWorkflowResolution(resolution)) {
+        for (const state of resolution.lifecycle.terminalStates) {
+          const normalizedState = state.trim().toLowerCase();
+          if (!terminalStates.has(normalizedState)) {
+            terminalStates.set(normalizedState, state);
+          }
         }
       }
+    } catch {
     }
     if (terminalStates.size === 0) {
       for (const state of DEFAULT_WORKFLOW_LIFECYCLE.terminalStates) {
@@ -1290,59 +1711,16 @@ var OrchestratorService = class {
     }
     return [...terminalStates.values()];
   }
-  resolveStartupCleanupRepositories(tenant, workspaceRecords) {
-    const repositories = /* @__PURE__ */ new Map();
-    for (const repository of tenant.repositories) {
-      repositories.set(
-        this.startupCleanupRepositoryKey(repository.owner, repository.name),
-        repository
-      );
-    }
-    for (const workspaceRecord of workspaceRecords) {
-      const repository = this.parseWorkspaceRepositoryRef(workspaceRecord);
-      if (!repository) {
-        continue;
-      }
-      const key = this.startupCleanupRepositoryKey(
-        repository.owner,
-        repository.name
-      );
-      if (!repositories.has(key)) {
-        repositories.set(key, repository);
-      }
-    }
-    return [...repositories.values()];
-  }
-  parseWorkspaceRepositoryRef(workspaceRecord) {
-    const match = workspaceRecord.issueIdentifier.match(
-      /^([^/]+)\/([^#]+)#\d+$/
-    );
-    if (!match) {
-      return null;
-    }
-    const owner = match[1];
-    const name = match[2];
-    if (!owner || !name) {
-      return null;
-    }
-    return {
-      owner,
-      name,
-      cloneUrl: workspaceRecord.repositoryPath
-    };
-  }
-  startupCleanupRepositoryKey(owner, name) {
-    return `${owner}/${name}`;
-  }
-  async loadStartupCleanupWorkflow(tenant, repository, workflowCache) {
-    const cacheKey = this.workflowCacheKey(repository);
+  async loadStartupCleanupWorkflow(tenant, workflowCache) {
+    const cacheKey = this.workflowCacheKey(tenant.repository);
     const cachedResolution = workflowCache.get(cacheKey);
     if (cachedResolution) {
       return cachedResolution;
     }
-    const resolutionPromise = tenant.repositories.some(
-      (candidate) => candidate.owner === repository.owner && candidate.name === repository.name
-    ) ? this.loadProjectWorkflow(tenant, repository) : loadRepositoryWorkflow(repository.cloneUrl, repository);
+    const resolutionPromise = this.loadProjectWorkflow(
+      tenant,
+      tenant.repository
+    );
     workflowCache.set(cacheKey, resolutionPromise);
     return resolutionPromise;
   }
@@ -1409,10 +1787,10 @@ var OrchestratorService = class {
       }
       candidates.push(issue);
     }
-    if (!lifecycle && tenant.repositories.length > 0) {
+    if (!lifecycle) {
       const resolution = await this.loadProjectWorkflow(
         tenant,
-        tenant.repositories[0]
+        tenant.repository
       );
       if (isUsableWorkflowResolution(resolution)) {
         lifecycle = resolution.lifecycle;
@@ -1429,26 +1807,7 @@ var OrchestratorService = class {
     };
   }
   isIssueCandidateEligible(issue, lifecycle, issues) {
-    if (!isStateActive(issue.state, lifecycle)) {
-      return false;
-    }
-    if (!matchesWorkflowState(issue.state, lifecycle.blockerCheckStates) || issue.blockedBy.length === 0) {
-      return true;
-    }
-    return !issue.blockedBy.some((blockerRef) => {
-      if (blockerRef.state && isStateTerminal(blockerRef.state, lifecycle)) {
-        return false;
-      }
-      if (blockerRef.identifier) {
-        const blockerIssue = issues.find(
-          (candidate) => candidate.identifier === blockerRef.identifier
-        );
-        if (blockerIssue?.state) {
-          return !isStateTerminal(blockerIssue.state, lifecycle);
-        }
-      }
-      return true;
-    });
+    return isIssueCandidateEligibleWithReason(issue, lifecycle, issues).eligible;
   }
   async loadProjectWorkflow(tenant, repository) {
     const cacheKey = this.workflowCacheKey(repository);
@@ -1474,10 +1833,7 @@ var OrchestratorService = class {
       repository.owner,
       repository.name
     );
-    const { repositoryDirectory, changed } = await syncRepositoryForRun({
-      repository,
-      targetDirectory: cacheRoot
-    });
+    const repositoryDirectory = this.resolveWorkflowRepositoryDirectory(repository);
     const resolution = await loadRepositoryWorkflow(
       repositoryDirectory,
       repository
@@ -1486,7 +1842,7 @@ var OrchestratorService = class {
       repository,
       cacheRoot,
       resolution,
-      changed
+      true
     );
   }
   async startRun(tenant, issue) {
@@ -1502,7 +1858,6 @@ var OrchestratorService = class {
     const workspaceRuntimeDir = runDir;
     const issueSubjectId = issue.id;
     const identity = {
-      projectId: tenant.projectId,
       adapter: issue.tracker.adapter,
       issueSubjectId
     };
@@ -1510,7 +1865,10 @@ var OrchestratorService = class {
       identity,
       issue.identifier
     );
-    const legacyWorkspaceKey = deriveLegacyIssueWorkspaceKey(identity);
+    const legacyWorkspaceKey = deriveLegacyIssueWorkspaceKey(
+      identity,
+      tenant.projectId
+    );
     const existingWorkspaceRecord = await this.store.loadIssueWorkspace(
       tenant.projectId,
       preferredWorkspaceKey
@@ -1526,7 +1884,8 @@ var OrchestratorService = class {
     );
     const repositoryDirectory = await ensureIssueWorkspaceRepository({
       repository: issue.repository,
-      issueWorkspacePath
+      issueWorkspacePath,
+      existingWorkspace: Boolean(existingWorkspaceRecord)
     });
     if (!existingWorkspaceRecord) {
       const workspaceRecord = {
@@ -1672,12 +2031,8 @@ var OrchestratorService = class {
           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
-          )
+          SYMPHONY_READ_TIMEOUT_MS: String(runtimeTimeouts.readTimeoutMs),
+          SYMPHONY_TURN_TIMEOUT_MS: String(runtimeTimeouts.turnTimeoutMs)
         }),
         detached: true,
         stdio: ["ignore", "ignore", "pipe"]
@@ -1850,10 +2205,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 = parseTimestampMs(
+      const lastActivityAtMs = parseTimestampMs2(
         run.lastEventAt ?? run.startedAt
       );
-      const startedAtMs = parseTimestampMs(run.startedAt);
+      const startedAtMs = parseTimestampMs2(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;
@@ -1885,7 +2240,6 @@ var OrchestratorService = class {
           identifier: run.issueIdentifier,
           workspaceKey: run.issueWorkspaceKey ?? deriveIssueWorkspaceKey(
             {
-              projectId: tenant.projectId,
               adapter: tenant.tracker.adapter,
               issueSubjectId: run.issueSubjectId
             },
@@ -2020,7 +2374,7 @@ var OrchestratorService = class {
     );
     if (retryKind === "failure" && failureRetryCount >= maxFailureRetries) {
       const lastError = [
-        `Run suppressed: ${MAX_FAILURE_RETRIES_EXCEEDED_REASON}.`,
+        `Run suppressed: ${MAX_FAILURE_RETRIES_EXCEEDED_REASON2}.`,
         `failureRetryCount=${failureRetryCount}.`,
         `maxFailureRetries=${maxFailureRetries}.`
       ].join(" ");
@@ -2042,7 +2396,7 @@ var OrchestratorService = class {
         projectId: run.projectId,
         issueIdentifier: run.issueIdentifier,
         issueId: run.issueId,
-        reason: MAX_FAILURE_RETRIES_EXCEEDED_REASON
+        reason: MAX_FAILURE_RETRIES_EXCEEDED_REASON2
       });
       this.logVerbose(
         `[run-completed] ${suppressedRun.runId} status=${suppressedRun.status}`
@@ -2053,7 +2407,6 @@ var OrchestratorService = class {
           identifier: run.issueIdentifier,
           workspaceKey: run.issueWorkspaceKey ?? deriveIssueWorkspaceKey(
             {
-              projectId: tenant.projectId,
               adapter: tenant.tracker.adapter,
               issueSubjectId: run.issueSubjectId
             },
@@ -2104,7 +2457,6 @@ var OrchestratorService = class {
       identifier: run.issueIdentifier,
       workspaceKey: run.issueWorkspaceKey ?? deriveIssueWorkspaceKey(
         {
-          projectId: tenant.projectId,
           adapter: tenant.tracker.adapter,
           issueSubjectId: run.issueSubjectId
         },
@@ -2556,7 +2908,6 @@ var OrchestratorService = class {
         identifier: recoveredRecord.issueIdentifier,
         workspaceKey: recoveredRecord.issueWorkspaceKey ?? deriveIssueWorkspaceKey(
           {
-            projectId: tenant.projectId,
             adapter: tenant.tracker.adapter,
             issueSubjectId: recoveredRecord.issueSubjectId
           },
@@ -2591,37 +2942,25 @@ var OrchestratorService = class {
     };
   }
   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 resolution = await this.loadProjectWorkflow(
+      tenant,
+      tenant.repository
     );
-    return validIntervals.length ? Math.min(...validIntervals) : DEFAULT_POLL_INTERVAL_MS;
+    const interval = isUsableWorkflowResolution(resolution) ? resolution.workflow.polling.intervalMs : NaN;
+    return Number.isFinite(interval) && interval > 0 ? interval : DEFAULT_POLL_INTERVAL_MS;
   }
   async loadProjectMaxConcurrentByState(tenant) {
     const result = {};
-    const resolutions = await Promise.all(
-      tenant.repositories.map(async (repository) => {
-        try {
-          return await this.loadProjectWorkflow(tenant, repository);
-        } catch {
-          return null;
-        }
-      })
-    );
-    for (const resolution of resolutions) {
-      if (!resolution) continue;
-      if (!isUsableWorkflowResolution(resolution)) continue;
-      const stateLimits = resolution.workflow.agent.maxConcurrentAgentsByState;
-      for (const [state, limit] of Object.entries(stateLimits)) {
-        const existing = result[state];
-        const numLimit = typeof limit === "number" ? limit : Number(limit);
-        result[state] = existing === void 0 ? numLimit : Math.min(existing, numLimit);
-      }
+    const resolution = await this.loadProjectWorkflow(
+      tenant,
+      tenant.repository
+    ).catch(() => null);
+    if (!resolution || !isUsableWorkflowResolution(resolution)) {
+      return result;
+    }
+    const stateLimits = resolution.workflow.agent.maxConcurrentAgentsByState;
+    for (const [state, limit] of Object.entries(stateLimits)) {
+      result[state] = typeof limit === "number" ? limit : Number(limit);
     }
     return result;
   }
@@ -2651,23 +2990,10 @@ var OrchestratorService = class {
     if (this.dependencies.concurrency !== void 0) {
       return this.dependencies.concurrency;
     }
-    const limits = await Promise.all(
-      project.repositories.map(async (repository) => {
-        try {
-          const resolution = await this.loadProjectWorkflow(
-            project,
-            repository
-          );
-          return isUsableWorkflowResolution(resolution) ? resolution.workflow.agent.maxConcurrentAgents : NaN;
-        } catch {
-          return NaN;
-        }
-      })
-    );
-    const validLimits = limits.filter(
-      (value) => Number.isFinite(value) && value >= 0
-    );
-    return validLimits.length ? Math.min(...validLimits) : DEFAULT_CONCURRENCY;
+    const limit = await this.loadProjectWorkflow(project, project.repository).then(
+      (resolution) => isUsableWorkflowResolution(resolution) ? resolution.workflow.agent.maxConcurrentAgents : NaN
+    ).catch(() => NaN);
+    return Number.isFinite(limit) && limit >= 0 ? limit : DEFAULT_CONCURRENCY;
   }
   async resolveWorkflowResolution(repository, cacheRoot, resolution, changed) {
     const cacheKey = this.workflowCacheKey(repository);
@@ -2731,6 +3057,26 @@ var OrchestratorService = class {
   workflowCacheKey(repository) {
     return `${repository.owner}/${repository.name}:${this.normalizeRepositoryCloneUrl(repository.cloneUrl)}`;
   }
+  resolveWorkflowRepositoryDirectory(repository) {
+    if (repository.path) {
+      return repository.path;
+    }
+    const localCloneUrlPath = this.resolveLocalCloneUrlPath(
+      repository.cloneUrl
+    );
+    if (localCloneUrlPath) {
+      return localCloneUrlPath;
+    }
+    return process.cwd();
+  }
+  resolveLocalCloneUrlPath(cloneUrl) {
+    try {
+      const url = new URL(cloneUrl);
+      return url.protocol === "file:" ? fileURLToPath(url) : null;
+    } catch {
+      return isAbsolute(cloneUrl) || cloneUrl.startsWith(".") ? cloneUrl : null;
+    }
+  }
   normalizeRepositoryCloneUrl(cloneUrl) {
     if (cloneUrl.startsWith("file://")) {
       try {
@@ -2787,7 +3133,6 @@ var OrchestratorService = class {
   async cleanupTerminalIssueWorkspace(tenant, issue, now, workflowResolution) {
     const issueSubjectId = issue.id;
     const identity = {
-      projectId: tenant.projectId,
       adapter: issue.tracker.adapter,
       issueSubjectId
     };
@@ -2795,7 +3140,10 @@ var OrchestratorService = class {
       identity,
       issue.identifier
     );
-    const legacyWorkspaceKey = deriveLegacyIssueWorkspaceKey(identity);
+    const legacyWorkspaceKey = deriveLegacyIssueWorkspaceKey(
+      identity,
+      tenant.projectId
+    );
     const orchestrationRecord = (await this.store.loadProjectIssueOrchestrations(tenant.projectId)).find((record) => record.issueId === issue.id);
     const workspaceRecord = (orchestrationRecord ? await this.store.loadIssueWorkspace(
       tenant.projectId,
@@ -2866,11 +3214,11 @@ var OrchestratorService = class {
     if (issueRecord.failureRetryCount < maxFailureRetries) {
       return false;
     }
-    if (!latestRun || latestRun.status !== "suppressed" || latestRun.issueState !== issue.state || !latestRun.lastError?.includes(MAX_FAILURE_RETRIES_EXCEEDED_REASON)) {
+    if (!latestRun || latestRun.status !== "suppressed" || latestRun.issueState !== issue.state || !latestRun.lastError?.includes(MAX_FAILURE_RETRIES_EXCEEDED_REASON2)) {
       return false;
     }
-    const issueUpdatedAtMs = parseTimestampMs(issue.updatedAt);
-    const suppressedAtMs = parseTimestampMs(
+    const issueUpdatedAtMs = parseTimestampMs2(issue.updatedAt);
+    const suppressedAtMs = parseTimestampMs2(
       latestRun.completedAt ?? latestRun.updatedAt
     );
     if (issueUpdatedAtMs === null || suppressedAtMs === null) {
@@ -2902,7 +3250,7 @@ function resolveProjectRateLimits(runs, issues) {
     if (!isRecord(run.rateLimits)) {
       continue;
     }
-    const timestamp = parseTimestampMs(
+    const timestamp = parseTimestampMs2(
       run.lastEventAt ?? run.updatedAt ?? run.startedAt
     );
     const sortableTimestamp = timestamp ?? -Infinity;
@@ -2982,22 +3330,6 @@ function buildRuntimeSession(existing, sessionId, threadId, status, startedAt, u
 function resolvePersistedCumulativeTurnCount(run) {
   return run.cumulativeTurnCount ?? run.turnCount ?? 0;
 }
-function hasConvergenceLockedRun(runs, issueId, issueState, issueUpdatedAt) {
-  const latestRun = runs.filter((run) => run.issueId === issueId).sort(
-    (left, right) => new Date(right.updatedAt).getTime() - new Date(left.updatedAt).getTime()
-  )[0];
-  if (latestRun?.runtimeSession?.exitClassification !== "convergence-detected" || latestRun.issueState !== issueState) {
-    return false;
-  }
-  const convergedAtMs = parseTimestampMs(
-    latestRun.completedAt ?? latestRun.updatedAt
-  );
-  const issueUpdatedAtMs = parseTimestampMs(issueUpdatedAt);
-  if (convergedAtMs === null || issueUpdatedAtMs === null) {
-    return true;
-  }
-  return issueUpdatedAtMs <= convergedAtMs;
-}
 function resolveCumulativeTurnCount(run, turnCount) {
   const carriedTotal = resolvePersistedCumulativeTurnCount(run);
   if (turnCount === null) {
@@ -3103,17 +3435,14 @@ function buildLatestRunMapByIssueId(runs) {
       latestRuns.set(run.issueId, run);
       continue;
     }
-    const runUpdatedAtMs = parseTimestampMs(run.updatedAt) ?? -Infinity;
-    const existingUpdatedAtMs = parseTimestampMs(existing.updatedAt) ?? -Infinity;
+    const runUpdatedAtMs = parseTimestampMs2(run.updatedAt) ?? -Infinity;
+    const existingUpdatedAtMs = parseTimestampMs2(existing.updatedAt) ?? -Infinity;
     if (runUpdatedAtMs > existingUpdatedAtMs) {
       latestRuns.set(run.issueId, run);
     }
   }
   return latestRuns;
 }
-function isIssueOrchestrationClaimed(state) {
-  return state === "claimed" || state === "running" || state === "retry_queued";
-}
 function upsertIssueOrchestration(issueRecords, nextRecord) {
   const existingRecord = issueRecords.find((record) => record.issueId === nextRecord.issueId) ?? null;
   const remaining = issueRecords.filter(
@@ -3139,14 +3468,11 @@ function releaseIssueOrchestration(issueRecords, issueId, now) {
     } : record
   );
 }
-function isActiveRunStatus(status) {
-  return status === "pending" || status === "starting" || status === "running" || status === "retrying";
-}
 
 // ../orchestrator/src/lock.ts
 import { randomUUID as randomUUID2 } from "crypto";
 import { mkdir as mkdir4, open as open2, readFile as readFile4, rm as rm4 } from "fs/promises";
-import { dirname as dirname2, isAbsolute, join as join4, relative as relative2, resolve as resolve2 } from "path";
+import { dirname as dirname2, isAbsolute as isAbsolute2, join as join4, relative as relative2, resolve as resolve2 } from "path";
 import { setTimeout as delay } from "timers/promises";
 var LOCK_READ_RETRY_DELAY_MS = 10;
 var LOCK_READ_RETRY_LIMIT = 20;
@@ -3238,12 +3564,12 @@ function assertValidProjectId(projectId) {
 }
 function resolveProjectLockPath(runtimeRoot, projectId) {
   const store = new OrchestratorFsStore(runtimeRoot);
-  const projectsRoot = resolve2(runtimeRoot, "projects");
   const projectDir = resolve2(store.projectDir(projectId));
-  const relativeProjectDir = relative2(projectsRoot, projectDir);
-  if (relativeProjectDir.length === 0 || relativeProjectDir.startsWith("..") || isAbsolute(relativeProjectDir)) {
+  const resolvedRuntimeRoot = resolve2(runtimeRoot);
+  const relativeProjectDir = relative2(resolvedRuntimeRoot, projectDir);
+  if (relativeProjectDir.startsWith("..") || isAbsolute2(relativeProjectDir)) {
     throw new Error(
-      `Invalid project ID "${projectId}". Project lock path must stay within "${projectsRoot}".`
+      `Invalid project ID "${projectId}". Project lock path must stay within "${resolvedRuntimeRoot}".`
     );
   }
   return join4(projectDir, ".lock");
@@ -3501,6 +3827,10 @@ if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href)
 }
 
 export {
+  resolveTrackerAdapter2 as resolveTrackerAdapter,
+  explainIssueDispatch,
+  isActiveRunRecordStatus,
+  parseIssueIdentifier,
   OrchestratorService,
   createStore,
   acquireProjectLock,