@gh-symphony/cli 0.1.4 → 0.2.0

package/dist/repo-OJLSMOR3.js

@@ -0,0 +1,2693 @@
+#!/usr/bin/env node
+import {
+  blue,
+  bold,
+  clearScreen,
+  cyan,
+  dim,
+  green,
+  hideCursor,
+  magenta,
+  red,
+  setNoColor,
+  showCursor,
+  stripAnsi,
+  yellow
+} from "./chunk-MVRF7BES.js";
+import {
+  initRepoRuntime,
+  parseRepoRuntimeFlags
+} from "./chunk-C44DYDNU.js";
+import {
+  OrchestratorService,
+  acquireProjectLock,
+  createStore,
+  explainIssueDispatch,
+  findGithubProjectIssue,
+  handleMissingManagedProjectConfig,
+  isActiveRunRecordStatus,
+  parseIssueIdentifier,
+  releaseProjectLock,
+  resolveCanonicalSubjectIssues,
+  resolveManagedProjectConfig,
+  resolveOrchestratorLogLevel,
+  resolveTrackerAdapter,
+  runCli
+} from "./chunk-CTTFIZYG.js";
+import "./chunk-B6OHDUSH.js";
+import {
+  resolveRepoRuntimeRoot,
+  resolveRuntimeRoot
+} from "./chunk-6I753NYO.js";
+import {
+  GhAuthError,
+  getGhToken
+} from "./chunk-Z3NZOPLZ.js";
+import {
+  WorkflowConfigStore,
+  deriveIssueWorkspaceKeyFromIdentifier,
+  isFileMissing,
+  isMatchingIssueRun,
+  mapIssueOrchestrationStateToStatus,
+  parseRecentEvents,
+  readJsonFile,
+  safeReadDir
+} from "./chunk-Q3UEPUE3.js";
+import {
+  daemonPidPath,
+  httpStatusPath,
+  loadActiveProjectConfig,
+  orchestratorLogPath,
+  writeJsonFile
+} from "./chunk-WOVNN5NW.js";
+
+// src/commands/logs.ts
+import { readFile, readdir, stat } from "fs/promises";
+import { join, resolve } from "path";
+import { createReadStream } from "fs";
+import { createInterface } from "readline";
+function parseLogsArgs(args) {
+  const parsed = { follow: false };
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === "--follow" || arg === "-f") {
+      parsed.follow = true;
+    }
+    if (arg === "--issue") {
+      parsed.issue = args[i + 1];
+      i += 1;
+    }
+    if (arg === "--run") {
+      parsed.run = args[i + 1];
+      i += 1;
+    }
+    if (arg === "--level") {
+      parsed.level = args[i + 1];
+      i += 1;
+    }
+    if (arg === "--project" || arg === "--project-id") {
+      parsed.projectId = args[i + 1];
+      i += 1;
+    }
+  }
+  return parsed;
+}
+var handler = async (args, options) => {
+  const parsed = parseLogsArgs(args);
+  const runtimeRoot = resolve(options.configDir);
+  if (parsed.run) {
+    const eventsPath = parsed.projectId ? join(
+      runtimeRoot,
+      "projects",
+      parsed.projectId,
+      "runs",
+      parsed.run,
+      "events.ndjson"
+    ) : await resolveRunEventsPath(runtimeRoot, parsed.run);
+    if (!eventsPath) {
+      process.stderr.write(`No events found for run: ${parsed.run}
+`);
+      process.exitCode = 1;
+      return;
+    }
+    try {
+      const content = await readFile(eventsPath, "utf8");
+      const lines = content.trim().split("\n").filter(Boolean);
+      for (const line of lines) {
+        const event = JSON.parse(line);
+        if (parsed.projectId && event.projectId !== parsed.projectId) continue;
+        if (parsed.level && event.level !== parsed.level) continue;
+        if (parsed.issue && event.issueIdentifier !== parsed.issue) continue;
+        process.stdout.write(formatEvent(event) + "\n");
+      }
+    } catch {
+      process.stderr.write(`No events found for run: ${parsed.run}
+`);
+      process.exitCode = 1;
+    }
+    return;
+  }
+  if (parsed.follow) {
+    const projectConfig = await resolveManagedProjectConfig({
+      configDir: options.configDir,
+      requestedProjectId: parsed.projectId
+    });
+    if (!projectConfig) {
+      handleMissingManagedProjectConfig();
+      return;
+    }
+    const logPath = orchestratorLogPath(
+      options.configDir,
+      projectConfig.projectId
+    );
+    try {
+      const stream = createReadStream(logPath, { encoding: "utf8" });
+      const rl = createInterface({ input: stream });
+      for await (const line of rl) {
+        process.stdout.write(line + "\n");
+      }
+      const { watchFile } = await import("fs");
+      let lastSize = 0;
+      watchFile(logPath, { interval: 1e3 }, async (curr) => {
+        if (curr.size > lastSize) {
+          const fd = await import("fs/promises");
+          const handle = await fd.open(logPath, "r");
+          const buf = Buffer.alloc(curr.size - lastSize);
+          await handle.read(buf, 0, buf.length, lastSize);
+          await handle.close();
+          process.stdout.write(buf.toString("utf8"));
+          lastSize = curr.size;
+        }
+      });
+      await new Promise(() => {
+      });
+    } catch {
+      process.stderr.write(
+        "No log file found. Start the orchestrator first.\n"
+      );
+      process.exitCode = 1;
+    }
+    return;
+  }
+  const runRoots = parsed.projectId ? [join(runtimeRoot, "projects", parsed.projectId, "runs")] : await listProjectRunRoots(runtimeRoot);
+  let foundRuns = false;
+  try {
+    for (const runsDir of runRoots) {
+      const entries = await safeReadDir2(runsDir);
+      if (entries.length === 0) {
+        continue;
+      }
+      foundRuns = true;
+      for (const entry of entries) {
+        const eventsPath = join(runsDir, entry, "events.ndjson");
+        try {
+          const content = await readFile(eventsPath, "utf8");
+          const lines = content.trim().split("\n").filter(Boolean);
+          for (const line of lines) {
+            const event = JSON.parse(line);
+            if (parsed.projectId && event.projectId !== parsed.projectId)
+              continue;
+            if (parsed.level && event.level !== parsed.level) continue;
+            if (parsed.issue && event.issueIdentifier !== parsed.issue) continue;
+            process.stdout.write(formatEvent(event) + "\n");
+          }
+        } catch {
+        }
+      }
+    }
+  } catch {
+  }
+  if (!foundRuns) {
+    process.stderr.write("No runs found. Start the orchestrator first.\n");
+  }
+};
+var logs_default = handler;
+function formatEvent(event) {
+  const at = event.at ?? "";
+  const eventType = event.event ?? "unknown";
+  const issue = event.issueIdentifier ?? "";
+  const extra = event.error ? ` error=${event.error}` : "";
+  return `[${at}] ${eventType} ${issue}${extra}`;
+}
+async function listProjectRunRoots(runtimeRoot) {
+  const roots = [join(runtimeRoot, "runs")];
+  try {
+    const projectIds = await readdir(join(runtimeRoot, "projects"));
+    roots.push(
+      ...projectIds.map(
+        (projectId) => join(runtimeRoot, "projects", projectId, "runs")
+      )
+    );
+  } catch {
+  }
+  return roots;
+}
+async function resolveRunEventsPath(runtimeRoot, runId) {
+  for (const runsDir of await listProjectRunRoots(runtimeRoot)) {
+    const eventsPath = join(runsDir, runId, "events.ndjson");
+    try {
+      await stat(eventsPath);
+      return eventsPath;
+    } catch {
+    }
+  }
+  return null;
+}
+async function safeReadDir2(path) {
+  try {
+    return await readdir(path);
+  } catch {
+    return [];
+  }
+}
+
+// src/commands/recover.ts
+import { readFile as readFile2, readdir as readdir2 } from "fs/promises";
+import { join as join2 } from "path";
+function parseRecoverArgs(args) {
+  const parsed = { dryRun: false };
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === "--dry-run") {
+      parsed.dryRun = true;
+    }
+    if (arg === "--project" || arg === "--project-id") {
+      parsed.projectId = args[i + 1];
+      i += 1;
+    }
+  }
+  return parsed;
+}
+var handler2 = async (args, options) => {
+  const parsed = parseRecoverArgs(args);
+  const projectConfig = await resolveManagedProjectConfig({
+    configDir: options.configDir,
+    requestedProjectId: parsed.projectId
+  });
+  if (!projectConfig) {
+    handleMissingManagedProjectConfig();
+    return;
+  }
+  const runtimeRoot = resolveRuntimeRoot(options.configDir);
+  const projectId = projectConfig.projectId;
+  if (parsed.dryRun) {
+    process.stdout.write("Dry run \u2014 scanning for stalled runs...\n");
+    const candidates = await listRecoverCandidates(runtimeRoot, projectId);
+    if (options.json) {
+      process.stdout.write(JSON.stringify(candidates, null, 2) + "\n");
+      return;
+    }
+    if (candidates.length === 0) {
+      process.stdout.write("No recoverable runs found.\n");
+      return;
+    }
+    for (const candidate of candidates) {
+      process.stdout.write(
+        `${candidate.issueIdentifier} (${candidate.runId}) \u2014 ${candidate.reason}
+`
+      );
+    }
+    return;
+  }
+  process.stdout.write("Recovering stalled runs...\n");
+  await runCli([
+    "recover",
+    "--runtime-root",
+    runtimeRoot,
+    "--project-id",
+    projectId
+  ]);
+};
+var recover_default = handler2;
+async function listRecoverCandidates(runtimeRoot, projectId) {
+  const runRoots = [
+    join2(runtimeRoot, "runs"),
+    join2(runtimeRoot, "projects", projectId, "runs")
+  ];
+  const candidates = [];
+  for (const runsDir of runRoots) {
+    let entries = [];
+    try {
+      entries = await readdir2(runsDir);
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const runPath = join2(runsDir, entry, "run.json");
+      try {
+        const raw = await readFile2(runPath, "utf8");
+        const run = JSON.parse(raw);
+        if (run.projectId && run.projectId !== projectId) {
+          continue;
+        }
+        const reason = detectRecoveryReason(run);
+        if (!reason) {
+          continue;
+        }
+        if (!candidates.some((candidate) => candidate.runId === run.runId)) {
+          candidates.push({
+            runId: run.runId,
+            issueIdentifier: run.issueIdentifier,
+            status: run.status,
+            reason
+          });
+        }
+      } catch {
+      }
+    }
+  }
+  return candidates;
+}
+function detectRecoveryReason(run) {
+  if (run.processId) {
+    const startedAt = run.startedAt ? new Date(run.startedAt).getTime() : 0;
+    const runningForMs = Date.now() - startedAt;
+    if (isProcessRunning(run.processId) && runningForMs > 30 * 60 * 1e3) {
+      return "worker appears stuck";
+    }
+    if (!isProcessRunning(run.processId)) {
+      return "worker process is no longer running";
+    }
+  }
+  if (run.status === "retrying" && run.nextRetryAt && new Date(run.nextRetryAt).getTime() <= Date.now()) {
+    return "retry window has elapsed";
+  }
+  return null;
+}
+function isProcessRunning(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/commands/repo-explain.ts
+import { readdir as readdir3, readFile as readFile3 } from "fs/promises";
+import { join as join3, resolve as resolve2 } from "path";
+function parseRepoExplainFlags(args) {
+  const parsed = {};
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === "--workflow" || arg === "--workflow-path") {
+      const value = args[i + 1];
+      if (!value || value.startsWith("-")) {
+        parsed.error = `Option '${arg}' argument missing`;
+        return parsed;
+      }
+      parsed.workflowPath = value;
+      i += 1;
+      continue;
+    }
+    if (arg?.startsWith("-")) {
+      parsed.error = `Unknown option '${arg}'`;
+      return parsed;
+    }
+    if (parsed.identifier) {
+      parsed.error = "Only one issue identifier can be explained at a time";
+      return parsed;
+    }
+    parsed.identifier = arg;
+  }
+  if (!parsed.identifier) {
+    parsed.error = "Issue identifier argument missing";
+  } else if (!parseIssueIdentifier(parsed.identifier)) {
+    parsed.error = "Issue identifier must use the form <owner>/<repo>#<number>";
+  }
+  return parsed;
+}
+var handler3 = async (args, options) => {
+  const parsed = parseRepoExplainFlags(args);
+  if (parsed.error) {
+    process.stderr.write(`${parsed.error}
+`);
+    process.stderr.write(
+      "Usage: gh-symphony repo explain <owner/repo#number> [--workflow <path>]\n"
+    );
+    process.exitCode = 2;
+    return;
+  }
+  const projectConfig = await loadActiveProjectConfig(options.configDir);
+  if (!projectConfig) {
+    process.stderr.write(
+      "No repository runtime configured. Run 'gh-symphony repo init' in the target repository.\n"
+    );
+    process.exitCode = 1;
+    return;
+  }
+  const identifier = parsed.identifier;
+  const parsedIdentifier = parseIssueIdentifier(identifier);
+  const fallbackRepository = {
+    owner: parsedIdentifier.owner,
+    name: parsedIdentifier.name,
+    cloneUrl: `https://github.com/${parsedIdentifier.owner}/${parsedIdentifier.name}.git`
+  };
+  const workflowRepository = projectConfig.repository ?? fallbackRepository;
+  let token;
+  try {
+    token = getGhToken();
+  } catch (error) {
+    if (error instanceof GhAuthError) {
+      process.stderr.write(
+        `Error: GitHub authentication is required for repo explain. ${error.message}
+`
+      );
+      process.stderr.write(
+        "Run 'gh auth login --scopes repo,read:org,project' or set GITHUB_GRAPHQL_TOKEN, then re-run this command.\n"
+      );
+      process.exitCode = 2;
+      return;
+    }
+    throw error;
+  }
+  const trackerAdapter = resolveTrackerAdapter(projectConfig.tracker);
+  const orchestratorProject = {
+    ...projectConfig,
+    repository: workflowRepository
+  };
+  const trackerDependencies = {
+    token,
+    projectItemsCache: createProjectItemsCache()
+  };
+  const runtimeRoot = options.configDir;
+  const issuesPromise = trackerAdapter.listIssues(
+    orchestratorProject,
+    trackerDependencies
+  );
+  const issuePromise = projectConfig.tracker.adapter === "github-project" ? findGithubProjectIssue(
+    orchestratorProject,
+    identifier,
+    trackerDependencies
+  ) : issuesPromise.then(
+    (issues2) => issues2.find(
+      (candidate) => candidate.identifier.trim().toLowerCase() === identifier.trim().toLowerCase()
+    ) ?? null
+  );
+  const [issues, issue, issueRecords, runs, snapshot] = await Promise.all([
+    issuesPromise,
+    issuePromise,
+    readJsonFile2(join3(runtimeRoot, "issues.json")),
+    readRuns(runtimeRoot, projectConfig.projectId),
+    readJsonFile2(join3(runtimeRoot, "status.json"))
+  ]);
+  const canonicalIssues = resolveCanonicalSubjectIssues(issues);
+  const canonicalIssue = canonicalIssues.find(
+    (candidate) => matchesExplainIdentifier(candidate, identifier)
+  ) ?? issue;
+  let workflow;
+  try {
+    workflow = await loadExplainWorkflow({
+      explicitWorkflowPath: parsed.workflowPath,
+      repository: workflowRepository,
+      runs
+    });
+  } catch (error) {
+    if (error instanceof RepoExplainWorkflowError) {
+      process.stderr.write(`Error: ${error.message}
+`);
+      process.stderr.write(
+        "Hint: pass --workflow <path-to-WORKFLOW.md> or run 'gh-symphony workflow preview --file <path>' to verify the workflow file.\n"
+      );
+      process.exitCode = 2;
+      return;
+    }
+    throw error;
+  }
+  const activeRunCount = runs.filter(
+    (run) => isActiveRunRecordStatus(run.status)
+  ).length;
+  const report = explainIssueDispatch({
+    identifier,
+    issue: canonicalIssue,
+    projectRepository: projectConfig.repository ?? null,
+    allIssues: canonicalIssues,
+    lifecycle: workflow.lifecycle,
+    issueRecords: issueRecords ?? [],
+    runs,
+    activeRunCount,
+    maxConcurrentAgents: workflow.maxConcurrentAgents,
+    maxConcurrentAgentsByState: workflow.maxConcurrentAgentsByState
+  });
+  const enrichedReport = {
+    ...report,
+    project: {
+      id: projectConfig.projectId,
+      slug: projectConfig.slug,
+      tracker: projectConfig.tracker,
+      lastTickAt: snapshot?.lastTickAt ?? null,
+      health: snapshot?.health ?? null
+    }
+  };
+  if (options.json) {
+    process.stdout.write(JSON.stringify(enrichedReport, null, 2) + "\n");
+    return;
+  }
+  process.stdout.write(renderRepoExplainReport(report, options.noColor));
+};
+var repo_explain_default = handler3;
+function matchesExplainIdentifier(issue, identifier) {
+  const normalizedIdentifier = identifier.trim().toLowerCase();
+  if (issue.identifier.trim().toLowerCase() === normalizedIdentifier) {
+    return true;
+  }
+  const linkedPullRequests = Array.isArray(issue.metadata.linkedPullRequests) ? issue.metadata.linkedPullRequests : [];
+  return linkedPullRequests.some(
+    (pullRequest) => typeof pullRequest === "object" && pullRequest !== null && "identifier" in pullRequest && typeof pullRequest.identifier === "string" && pullRequest.identifier.trim().toLowerCase() === normalizedIdentifier
+  );
+}
+var RepoExplainWorkflowError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "RepoExplainWorkflowError";
+  }
+};
+async function loadExplainWorkflow(input) {
+  const workflowPaths = resolveExplainWorkflowCandidates(input);
+  if (workflowPaths.length === 0) {
+    throw new RepoExplainWorkflowError(
+      "No WORKFLOW.md path could be resolved from --workflow, the configured repository path, or previous run records."
+    );
+  }
+  const failures = [];
+  for (const workflowPath of workflowPaths) {
+    try {
+      const resolution = await new WorkflowConfigStore().load(workflowPath);
+      return {
+        lifecycle: resolution.lifecycle,
+        maxConcurrentAgents: resolution.workflow.agent.maxConcurrentAgents,
+        maxConcurrentAgentsByState: resolution.workflow.agent.maxConcurrentAgentsByState
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      failures.push(`${workflowPath}: ${message}`);
+    }
+  }
+  throw new RepoExplainWorkflowError(
+    `Unable to load WORKFLOW.md for repo explain. Checked: ${failures.join("; ")}`
+  );
+}
+function resolveExplainWorkflowCandidates(input) {
+  const paths = [];
+  if (input.explicitWorkflowPath) {
+    paths.push(resolve2(input.explicitWorkflowPath));
+  }
+  if (input.repository.path) {
+    paths.push(join3(resolve2(input.repository.path), "WORKFLOW.md"));
+  }
+  const newestRuns = [...input.runs].sort(
+    (left, right) => (Date.parse(right.updatedAt) || 0) - (Date.parse(left.updatedAt) || 0)
+  );
+  for (const run of newestRuns) {
+    if (run.workflowPath) {
+      paths.push(resolve2(run.workflowPath));
+    }
+    if (run.workingDirectory) {
+      paths.push(join3(resolve2(run.workingDirectory), "WORKFLOW.md"));
+    }
+  }
+  return [...new Set(paths)];
+}
+function createProjectItemsCache() {
+  const entries = /* @__PURE__ */ new Map();
+  return {
+    getOrLoad(key, load) {
+      const cached = entries.get(key);
+      if (cached) {
+        return cached;
+      }
+      const pending = load().catch((error) => {
+        entries.delete(key);
+        throw error;
+      });
+      entries.set(key, pending);
+      return pending;
+    }
+  };
+}
+async function readRuns(runtimeRoot, projectId) {
+  let runIds;
+  try {
+    runIds = await readdir3(join3(runtimeRoot, "runs"));
+  } catch {
+    return [];
+  }
+  const runs = await Promise.all(
+    runIds.map(
+      (runId) => readJsonFile2(
+        join3(runtimeRoot, "runs", runId, "run.json")
+      )
+    )
+  );
+  return runs.filter(
+    (run) => run !== null && (!run.projectId || run.projectId === projectId)
+  );
+}
+async function readJsonFile2(path) {
+  try {
+    return JSON.parse(await readFile3(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function renderRepoExplainReport(report, noColor) {
+  const apply = noColor ? (value) => stripAnsi(value) : (value) => value;
+  const lines = [
+    apply(bold(`Issue dispatch explanation: ${report.issue.identifier}`)),
+    report.summary,
+    "",
+    `State: ${report.issue.state ?? "unknown"}`,
+    `Repository: ${report.issue.repository}`,
+    "",
+    "Checks:"
+  ];
+  for (const check of report.checks) {
+    const marker = check.status === "pass" ? green("\u2713") : check.status === "warn" ? yellow("!") : red("\u2717");
+    lines.push(`  ${apply(marker)} ${check.message}`);
+    if (check.hint) {
+      lines.push(`    Hint: ${check.hint}`);
+    }
+  }
+  lines.push("");
+  lines.push("Related commands:");
+  lines.push("  gh-symphony workflow preview");
+  lines.push("  gh-symphony doctor");
+  lines.push("  gh-symphony repo status");
+  lines.push("  gh-symphony repo logs --issue " + report.issue.identifier);
+  return lines.join("\n") + "\n";
+}
+
+// src/commands/run.ts
+function parseRunArgs(args) {
+  const parsed = {
+    watch: false
+  };
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === "--watch" || arg === "-w") {
+      parsed.watch = true;
+    } else if (arg === "--project" || arg === "--project-id") {
+      const value = args[i + 1];
+      if (!value || value.startsWith("-")) {
+        parsed.error = `Option '${arg}' argument missing`;
+        return parsed;
+      }
+      parsed.projectId = value;
+      i += 1;
+    } else if (arg === "--log-level") {
+      const value = args[i + 1];
+      if (!value || value.startsWith("-")) {
+        parsed.error = `Option '${arg}' argument missing`;
+        return parsed;
+      }
+      parsed.logLevel = value;
+      i += 1;
+    } else if (!arg?.startsWith("-")) {
+      parsed.issue = arg;
+    } else {
+      parsed.error = `Unknown option '${arg}'`;
+      return parsed;
+    }
+  }
+  return parsed;
+}
+var handler4 = async (args, options) => {
+  const parsed = parseRunArgs(args);
+  if (parsed.error) {
+    process.stderr.write(`${parsed.error}
+`);
+    process.exitCode = 2;
+    return;
+  }
+  if (!parsed.issue) {
+    process.stderr.write("Usage: gh-symphony repo run <owner/repo#number>\n");
+    process.exitCode = 2;
+    return;
+  }
+  const projectConfig = await resolveManagedProjectConfig({
+    configDir: options.configDir,
+    requestedProjectId: parsed.projectId
+  });
+  if (!projectConfig) {
+    handleMissingManagedProjectConfig();
+    return;
+  }
+  const runtimeRoot = resolveRuntimeRoot(options.configDir);
+  const projectId = projectConfig.projectId;
+  const [repoSpec] = parsed.issue.split("#");
+  const configuredRepos = [projectConfig.repository].filter(
+    (repository) => Boolean(repository?.owner && repository.name)
+  ).map((repository) => `${repository.owner}/${repository.name}`);
+  const configuredRepoSet = new Set(configuredRepos);
+  if (configuredRepoSet.size === 0) {
+    process.stderr.write(
+      "No repository is configured in this project. Run 'gh-symphony repo init' from the target repository first.\n"
+    );
+    process.exitCode = 1;
+    return;
+  }
+  if (repoSpec && !configuredRepoSet.has(repoSpec)) {
+    process.stderr.write(
+      `Repository "${repoSpec}" is not configured in this project.
+Configured repo: ${configuredRepos.join(", ")}
+`
+    );
+    process.exitCode = 1;
+    return;
+  }
+  process.stdout.write(`Dispatching issue: ${parsed.issue}
+`);
+  await runCli([
+    "run-issue",
+    "--runtime-root",
+    runtimeRoot,
+    "--project-id",
+    projectId,
+    "--issue",
+    parsed.issue,
+    ...parsed.logLevel ? ["--log-level", parsed.logLevel] : []
+  ]);
+  if (parsed.watch) {
+    process.stdout.write("\nWatching for status changes...\n");
+    await runCli([
+      "status",
+      "--runtime-root",
+      runtimeRoot,
+      "--project-id",
+      projectId
+    ]);
+  }
+};
+var run_default = handler4;
+
+// src/commands/start.ts
+import { writeFile, mkdir, readFile as readFile5, rm } from "fs/promises";
+import { dirname as dirname2, join as join6 } from "path";
+import { spawn } from "child_process";
+import { createServer as createServer3 } from "http";
+
+// ../dashboard/src/store.ts
+import { open } from "fs/promises";
+import { join as join4, resolve as resolve3 } from "path";
+var DEFAULT_RECENT_EVENT_LIMIT = 20;
+var RECENT_EVENT_CHUNK_SIZE = 4096;
+var MAX_RECENT_EVENT_SCAN_BYTES = 64 * 1024;
+var RUN_RECORD_LOAD_CONCURRENCY = 8;
+var DashboardFsReader = class {
+  constructor(runtimeRoot) {
+    this.runtimeRoot = runtimeRoot;
+    this.resolvedRuntimeRoot = resolve3(runtimeRoot);
+  }
+  resolvedRuntimeRoot;
+  projectDir() {
+    return this.resolvedRuntimeRoot;
+  }
+  runDir(runId) {
+    assertValidDashboardRunId(runId);
+    return join4(this.resolvedRuntimeRoot, "runs", runId);
+  }
+  async loadProjectStatus() {
+    const snapshot = await readJsonFile(join4(this.projectDir(), "status.json"));
+    if (!snapshot) {
+      return null;
+    }
+    const status = { ...snapshot };
+    delete status.projectId;
+    delete status.slug;
+    if (!isRepositoryRef(status.repository)) {
+      return null;
+    }
+    return status;
+  }
+  async loadProjectState() {
+    const snapshot = await this.loadProjectStatus();
+    if (!snapshot) {
+      return null;
+    }
+    const issues = await this.loadProjectIssueOrchestrations();
+    return {
+      ...snapshot,
+      completedCount: issues.filter((issue) => issue.completedOnce).length,
+      issues
+    };
+  }
+  async loadProjectIssueOrchestrations() {
+    const issues = await readJsonFile(
+      join4(this.projectDir(), "issues.json")
+    );
+    if (issues) {
+      return issues.map((issue) => ({
+        ...issue,
+        completedOnce: issue.completedOnce ?? false,
+        failureRetryCount: issue.failureRetryCount ?? 0
+      }));
+    }
+    const legacyLeases = await readJsonFile(join4(this.projectDir(), "leases.json")) ?? [];
+    return 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
+    }));
+  }
+  async loadRun(runId) {
+    return readJsonFile(
+      join4(this.runDir(runId), "run.json")
+    );
+  }
+  async loadAllRuns() {
+    const runIds = await safeReadDir(join4(this.projectDir(), "runs"));
+    const runs = await mapWithConcurrency(
+      runIds,
+      RUN_RECORD_LOAD_CONCURRENCY,
+      (runId) => this.loadRun(runId)
+    );
+    return runs.filter((run) => Boolean(run));
+  }
+  async loadRunsForIssue(issueId, issueIdentifier) {
+    const runIds = await safeReadDir(join4(this.projectDir(), "runs"));
+    const runs = await mapWithConcurrency(
+      runIds,
+      RUN_RECORD_LOAD_CONCURRENCY,
+      async (runId) => {
+        try {
+          const run = await this.loadRun(runId);
+          if (!run) {
+            return null;
+          }
+          return run.issueId === issueId || run.issueIdentifier === issueIdentifier ? run : null;
+        } catch (error) {
+          if (isFileMissing(error)) {
+            return null;
+          }
+          return null;
+        }
+      }
+    );
+    return runs.filter((run) => Boolean(run));
+  }
+  async loadRecentRunEvents(runId, limit = DEFAULT_RECENT_EVENT_LIMIT) {
+    if (limit <= 0) {
+      return [];
+    }
+    const path = join4(this.runDir(runId), "events.ndjson");
+    try {
+      const handle = await open(path, "r");
+      try {
+        const stats = await handle.stat();
+        let position = stats.size;
+        let bytesScanned = 0;
+        let newlineCount = 0;
+        const chunks = [];
+        while (position > 0 && bytesScanned < MAX_RECENT_EVENT_SCAN_BYTES && newlineCount <= limit) {
+          const readSize = Math.min(
+            position,
+            RECENT_EVENT_CHUNK_SIZE,
+            MAX_RECENT_EVENT_SCAN_BYTES - bytesScanned
+          );
+          position -= readSize;
+          const chunk = Buffer.allocUnsafe(readSize);
+          const { bytesRead } = await handle.read(chunk, 0, readSize, position);
+          if (bytesRead === 0) {
+            break;
+          }
+          const populatedChunk = chunk.subarray(0, bytesRead);
+          chunks.unshift(populatedChunk);
+          bytesScanned += bytesRead;
+          newlineCount += countNewlines(populatedChunk);
+        }
+        return parseRecentEvents(
+          Buffer.concat(chunks).toString("utf8"),
+          limit,
+          {
+            allowPartialFirstLine: position > 0
+          }
+        );
+      } finally {
+        await handle.close();
+      }
+    } catch (error) {
+      if (isFileMissing(error)) {
+        return [];
+      }
+      throw error;
+    }
+  }
+};
+function countNewlines(chunk) {
+  let count = 0;
+  for (const byte of chunk) {
+    if (byte === 10) {
+      count += 1;
+    }
+  }
+  return count;
+}
+async function statusForIssue(reader, issueIdentifier) {
+  const issueRecords = await reader.loadProjectIssueOrchestrations();
+  const issueRecord = issueRecords.find(
+    (record) => record.identifier === issueIdentifier
+  );
+  if (!issueRecord) {
+    return null;
+  }
+  const currentRunCandidate = issueRecord.currentRunId ? await reader.loadRun(issueRecord.currentRunId) : null;
+  const currentRun = isMatchingIssueRun(
+    currentRunCandidate,
+    issueRecord.issueId,
+    issueIdentifier
+  ) ? currentRunCandidate : null;
+  const issueRuns = currentRun === null ? await reader.loadRunsForIssue(issueRecord.issueId, issueIdentifier) : currentRun.tokenUsage ? await reader.loadRunsForIssue(issueRecord.issueId, issueIdentifier) : null;
+  const resolvedRun = currentRun ?? findLatestRunForIssue(issueRuns ?? []);
+  const recentEvents = resolvedRun === null ? [] : await reader.loadRecentRunEvents(resolvedRun.runId);
+  const cumulativeTokens = aggregateIssueTokenUsage(issueRuns ?? []);
+  const latestEventMessage = recentEvents[recentEvents.length - 1]?.message ?? null;
+  const currentAttempt = resolvedRun?.attempt ?? issueRecord.retryEntry?.attempt ?? 0;
+  return {
+    issue_identifier: issueRecord.identifier,
+    issue_id: issueRecord.issueId,
+    status: resolvedRun?.status ?? mapIssueOrchestrationStateToStatus(issueRecord.state),
+    workspace: {
+      path: resolvedRun?.workingDirectory ?? null
+    },
+    attempts: {
+      restart_count: Math.max(0, currentAttempt - 1),
+      current_retry_attempt: currentAttempt
+    },
+    running: resolvedRun === null ? null : {
+      session_id: resolvedRun.runtimeSession?.sessionId ?? null,
+      turn_count: resolvedRun.turnCount ?? null,
+      state: resolvedRun.issueState ?? null,
+      started_at: resolvedRun.startedAt ?? null,
+      last_event: resolvedRun.lastEvent ?? null,
+      last_message: latestEventMessage,
+      last_event_at: resolvedRun.lastEventAt ?? null,
+      tokens: resolvedRun.tokenUsage ? {
+        input_tokens: resolvedRun.tokenUsage.inputTokens,
+        output_tokens: resolvedRun.tokenUsage.outputTokens,
+        total_tokens: resolvedRun.tokenUsage.totalTokens,
+        cumulative_input_tokens: cumulativeTokens.inputTokens,
+        cumulative_output_tokens: cumulativeTokens.outputTokens,
+        cumulative_total_tokens: cumulativeTokens.totalTokens
+      } : null
+    },
+    retry: resolvedRun?.nextRetryAt ?? issueRecord.retryEntry?.dueAt ? {
+      due_at: resolvedRun?.nextRetryAt ?? issueRecord.retryEntry?.dueAt ?? "",
+      kind: resolvedRun?.retryKind ?? null,
+      error: resolvedRun?.lastError ?? issueRecord.retryEntry?.error ?? null
+    } : null,
+    logs: {
+      codex_session_logs: resolvedRun === null ? [] : [
+        {
+          label: "worker",
+          path: join4(reader.runDir(resolvedRun.runId), "worker.log"),
+          url: null
+        }
+      ]
+    },
+    recent_events: recentEvents,
+    last_error: resolvedRun?.lastError ?? issueRecord.retryEntry?.error ?? null,
+    tracked: {
+      issue_orchestration_state: issueRecord.state,
+      current_run_id: issueRecord.currentRunId,
+      workspace_key: issueRecord.workspaceKey,
+      completed_once: issueRecord.completedOnce,
+      run_phase: resolvedRun?.runPhase ?? null,
+      execution_phase: resolvedRun?.executionPhase ?? null
+    }
+  };
+}
+function aggregateIssueTokenUsage(runs) {
+  return runs.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
+    }
+  );
+}
+function findLatestRunForIssue(matchingRuns) {
+  const sortedRuns = [...matchingRuns].sort(
+    (left, right) => new Date(right.updatedAt).getTime() - new Date(left.updatedAt).getTime()
+  );
+  return sortedRuns[0] ?? null;
+}
+function assertValidDashboardRunId(runId) {
+  if (runId.length === 0 || runId === "." || runId === ".." || runId.includes("/") || runId.includes("\\")) {
+    throw new Error(
+      `Invalid run ID "${runId}". Run IDs must not contain path separators or traversal segments.`
+    );
+  }
+}
+function isRepositoryRef(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const repository = value;
+  return typeof repository.owner === "string" && repository.owner.length > 0 && typeof repository.name === "string" && repository.name.length > 0 && typeof repository.cloneUrl === "string";
+}
+async function mapWithConcurrency(items, concurrency, mapper) {
+  const results = new Array(items.length);
+  let nextIndex = 0;
+  const worker = async () => {
+    while (nextIndex < items.length) {
+      const currentIndex = nextIndex;
+      nextIndex += 1;
+      results[currentIndex] = await mapper(items[currentIndex]);
+    }
+  };
+  const workerCount = Math.min(Math.max(concurrency, 1), items.length);
+  await Promise.all(Array.from({ length: workerCount }, () => worker()));
+  return results;
+}
+
+// ../dashboard/src/server.ts
+import {
+  createServer
+} from "http";
+async function resolveDashboardResponse(options) {
+  const method = options.method ?? "GET";
+  if (options.pathname === "/healthz") {
+    return {
+      status: 200,
+      payload: { ok: true }
+    };
+  }
+  if (options.pathname === "/api/v1/state") {
+    if (method !== "GET") {
+      return {
+        status: 405,
+        payload: { error: "Method not allowed" }
+      };
+    }
+    const snapshot = await options.reader.loadProjectState();
+    if (!snapshot) {
+      return {
+        status: 404,
+        payload: { error: "Project status not found." }
+      };
+    }
+    return {
+      status: 200,
+      payload: snapshot
+    };
+  }
+  if (options.pathname.startsWith("/api/v1/")) {
+    if (method !== "GET") {
+      return {
+        status: 405,
+        payload: { error: "Method not allowed" }
+      };
+    }
+    const rawIdentifier = options.pathname.slice("/api/v1/".length);
+    if (!rawIdentifier || rawIdentifier === "state") {
+      return {
+        status: 404,
+        payload: { error: "Not found" }
+      };
+    }
+    let issueIdentifier;
+    try {
+      issueIdentifier = decodeURIComponent(rawIdentifier);
+    } catch {
+      return {
+        status: 400,
+        payload: {
+          error: {
+            code: "invalid_issue_identifier",
+            message: "Issue identifier path segment is not valid URL encoding."
+          }
+        }
+      };
+    }
+    const issueStatus = await statusForIssue(options.reader, issueIdentifier);
+    if (!issueStatus) {
+      return {
+        status: 404,
+        payload: {
+          error: {
+            code: "issue_not_found",
+            message: `Issue "${issueIdentifier}" is unknown to the current filesystem state.`
+          }
+        }
+      };
+    }
+    return {
+      status: 200,
+      payload: issueStatus
+    };
+  }
+  return {
+    status: 404,
+    payload: { error: "Not found" }
+  };
+}
+
+// ../control-plane/src/server.ts
+import {
+  createServer as createServer2
+} from "http";
+import { readFile as readFile4, stat as stat2 } from "fs/promises";
+import { dirname, extname, join as join5, resolve as resolve4, sep } from "path";
+import { fileURLToPath } from "url";
+var CLIENT_DIST_DIR = join5(
+  dirname(fileURLToPath(import.meta.url)),
+  "../client/dist"
+);
+var BUNDLED_CLIENT_DIST_DIR = join5(
+  dirname(fileURLToPath(import.meta.url)),
+  "../../control-plane/client/dist"
+);
+var WORKSPACE_CLIENT_DIST_DIR = join5(
+  process.cwd(),
+  "packages/control-plane/client/dist"
+);
+var NODE_MODULES_CLIENT_DIST_DIR = join5(
+  process.cwd(),
+  "node_modules/@gh-symphony/control-plane/client/dist"
+);
+var CLIENT_DIST_DIR_CANDIDATES = [
+  CLIENT_DIST_DIR,
+  BUNDLED_CLIENT_DIST_DIR,
+  WORKSPACE_CLIENT_DIST_DIR,
+  NODE_MODULES_CLIENT_DIST_DIR
+];
+var clientDistDirPromise;
+var TEXT_CONTENT_TYPES = /* @__PURE__ */ new Set([
+  "application/javascript",
+  "application/json",
+  "image/svg+xml",
+  "text/css",
+  "text/html",
+  "text/plain"
+]);
+var CONTENT_TYPES = {
+  ".css": "text/css",
+  ".gif": "image/gif",
+  ".html": "text/html",
+  ".ico": "image/x-icon",
+  ".jpeg": "image/jpeg",
+  ".jpg": "image/jpeg",
+  ".js": "application/javascript",
+  ".json": "application/json",
+  ".map": "application/json",
+  ".png": "image/png",
+  ".svg": "image/svg+xml",
+  ".txt": "text/plain",
+  ".webp": "image/webp"
+};
+function createControlPlaneHandler(options) {
+  return async (request, response) => {
+    try {
+      const method = request.method ?? "GET";
+      const url = new URL(request.url ?? "/", "http://127.0.0.1");
+      if (url.pathname === "/api/v1/refresh") {
+        await handleRefreshRequest(method, request, response, options);
+        return;
+      }
+      if (isDashboardRequest(url.pathname)) {
+        const resolved = await resolveDashboardResponse({
+          pathname: url.pathname,
+          method,
+          reader: options.reader
+        });
+        respondJson(response, resolved.status, resolved.payload);
+        return;
+      }
+      if (!isStaticRequestMethod(method)) {
+        respondJson(response, 405, { error: "Method not allowed" });
+        return;
+      }
+      const asset = await resolveStaticAsset(url.pathname);
+      if (!asset) {
+        respondJson(response, 404, { error: "Not found" });
+        return;
+      }
+      if (asset.kind === "error") {
+        respondJson(response, asset.status, { error: "Bad request" });
+        return;
+      }
+      await respondFile(response, asset.path, method, asset.fallback);
+    } catch (error) {
+      console.error("Control plane request failed.", error);
+      if (!response.headersSent) {
+        respondJson(response, 500, { error: "Internal server error" });
+      } else {
+        response.end();
+      }
+    }
+  };
+}
+async function startControlPlaneServer(options) {
+  const reader = new DashboardFsReader(options.runtimeRoot);
+  const handler9 = createControlPlaneHandler({
+    reader,
+    onRefreshRequest: options.onRefreshRequest
+  });
+  for (let port = options.port; port <= 65535; port += 1) {
+    const server = createServer2((request, response) => {
+      void handler9(request, response);
+    });
+    try {
+      await new Promise((resolveReady, rejectReady) => {
+        const cleanup = () => {
+          server.off("listening", handleListening);
+          server.off("error", handleError);
+        };
+        const handleListening = () => {
+          cleanup();
+          resolveReady();
+        };
+        const handleError = (error) => {
+          cleanup();
+          rejectReady(error);
+        };
+        server.once("listening", handleListening);
+        server.once("error", handleError);
+        server.listen(port, options.host);
+      });
+      const address = server.address();
+      const boundPort = address && typeof address !== "string" ? address.port : port;
+      return {
+        server,
+        port: boundPort,
+        url: formatBoundUrl(server)
+      };
+    } catch (error) {
+      await closeServer(server).catch(() => {
+      });
+      if (error.code === "EADDRINUSE") {
+        continue;
+      }
+      throw error;
+    }
+  }
+  throw new Error(
+    `Unable to bind control plane server starting from port ${options.port}`
+  );
+}
+async function handleRefreshRequest(method, request, response, options) {
+  if (method !== "POST") {
+    respondJson(response, 405, { error: "Method not allowed" });
+    return;
+  }
+  request.resume();
+  options.onRefreshRequest?.();
+  respondJson(response, 202, { ok: true });
+}
+function isDashboardRequest(pathname) {
+  return pathname === "/healthz" || pathname === "/api/v1/state" || pathname.startsWith("/api/v1/");
+}
+function isStaticRequestMethod(method) {
+  return method === "GET" || method === "HEAD";
+}
+async function resolveStaticAsset(pathname) {
+  const clientDistDir = await resolveClientDistDir();
+  if (!clientDistDir) {
+    return null;
+  }
+  const indexPath = join5(clientDistDir, "index.html");
+  if (pathname === "/") {
+    return await existsAsFile(indexPath) ? { kind: "asset", path: indexPath, fallback: true } : null;
+  }
+  let decodedPathname;
+  try {
+    decodedPathname = decodeURIComponent(pathname);
+  } catch {
+    return { kind: "error", status: 400 };
+  }
+  const resolvedPath = resolve4(clientDistDir, `.${decodedPathname}`);
+  if (!isPathInsideClientDist(clientDistDir, resolvedPath)) {
+    return null;
+  }
+  if (await existsAsFile(resolvedPath)) {
+    return { kind: "asset", path: resolvedPath, fallback: false };
+  }
+  if (hasFileExtension(decodedPathname)) {
+    return null;
+  }
+  return await existsAsFile(indexPath) ? { kind: "asset", path: indexPath, fallback: true } : null;
+}
+function isPathInsideClientDist(clientDistDir, path) {
+  return path === clientDistDir || path.startsWith(`${clientDistDir}${sep}`);
+}
+function hasFileExtension(pathname) {
+  const lastSegment = pathname.split("/").pop() ?? "";
+  return lastSegment.includes(".");
+}
+async function existsAsFile(path) {
+  try {
+    return (await stat2(path)).isFile();
+  } catch {
+    return false;
+  }
+}
+async function resolveClientDistDir() {
+  clientDistDirPromise ??= (async () => {
+    for (const candidate of CLIENT_DIST_DIR_CANDIDATES) {
+      try {
+        if ((await stat2(candidate)).isDirectory()) {
+          return candidate;
+        }
+      } catch {
+        continue;
+      }
+    }
+    return null;
+  })();
+  return clientDistDirPromise;
+}
+async function respondFile(response, path, method, fallback) {
+  const contentType = contentTypeForPath(path);
+  const body = method === "HEAD" ? void 0 : await readFile4(path);
+  const cacheControl = fallback || path.endsWith(`${sep}index.html`) ? "no-cache" : "public, max-age=31536000, immutable";
+  response.writeHead(200, {
+    "cache-control": cacheControl,
+    "content-type": contentType
+  });
+  response.end(body);
+}
+function contentTypeForPath(path) {
+  const contentType = CONTENT_TYPES[extname(path).toLowerCase()];
+  if (!contentType) {
+    return "application/octet-stream";
+  }
+  if (TEXT_CONTENT_TYPES.has(contentType)) {
+    return `${contentType}; charset=utf-8`;
+  }
+  return contentType;
+}
+function respondJson(response, status, payload) {
+  response.writeHead(status, {
+    "content-type": "application/json; charset=utf-8"
+  });
+  response.end(JSON.stringify(payload));
+}
+function formatBoundUrl(server) {
+  const address = server.address();
+  if (!address || typeof address === "string") {
+    return "http://localhost";
+  }
+  const host = address.address === "::" || address.address === "::1" || address.address === "0.0.0.0" || address.address === "127.0.0.1" ? "localhost" : address.address;
+  const urlHost = host.includes(":") ? `[${host}]` : host;
+  return `http://${urlHost}:${address.port}`;
+}
+async function closeServer(server) {
+  await new Promise((resolveClose, rejectClose) => {
+    server.close((error) => {
+      if (error) {
+        rejectClose(error);
+        return;
+      }
+      resolveClose();
+    });
+  });
+}
+
+// src/removed-project-id.ts
+var REMOVED_PROJECT_ID_MESSAGE = "--project-id has been removed. gh-symphony now uses the current repository directory; run the command from the target repo or pass --repo-dir where supported.";
+function rejectRemovedProjectId(args, options = { rejectProjectAlias: true }) {
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === "--project-id" || options.rejectProjectAlias !== false && arg === "--project") {
+      process.stderr.write(`${REMOVED_PROJECT_ID_MESSAGE}
+`);
+      process.exitCode = 2;
+      return true;
+    }
+    if (arg?.startsWith("--project-id=") || options.rejectProjectAlias !== false && arg?.startsWith("--project=")) {
+      process.stderr.write(`${REMOVED_PROJECT_ID_MESSAGE}
+`);
+      process.exitCode = 2;
+      return true;
+    }
+  }
+  return false;
+}
+
+// src/format/repository.ts
+function formatRepositoryDisplay(snapshot, fallback = "repository") {
+  if (snapshot.repository) {
+    return `${snapshot.repository.owner}/${snapshot.repository.name}`;
+  }
+  return snapshot.slug ?? fallback;
+}
+
+// src/commands/start.ts
+function timestamp() {
+  const now = /* @__PURE__ */ new Date();
+  const hh = String(now.getHours()).padStart(2, "0");
+  const mm = String(now.getMinutes()).padStart(2, "0");
+  const ss = String(now.getSeconds()).padStart(2, "0");
+  return dim(`${hh}:${mm}:${ss}`);
+}
+function logLine(icon, msg) {
+  process.stdout.write(`${timestamp()} ${icon} ${msg}
+`);
+}
+var DEFAULT_HTTP_PORT = 4680;
+var HTTP_HOST = "0.0.0.0";
+function parseStartArgs(args) {
+  const parsed = {
+    daemon: false,
+    once: false
+  };
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === "--daemon" || arg === "-d") {
+      parsed.daemon = true;
+      continue;
+    }
+    if (arg === "--once") {
+      parsed.once = true;
+      continue;
+    }
+    if (arg === "--http") {
+      const value = args[i + 1];
+      if (!value || value.startsWith("-")) {
+        parsed.httpPort = DEFAULT_HTTP_PORT;
+        continue;
+      }
+      parsed.httpPort = parsePort(value, arg);
+      i += 1;
+      continue;
+    }
+    if (arg === "--web") {
+      const value = args[i + 1];
+      if (!value || value.startsWith("-")) {
+        parsed.webPort = DEFAULT_HTTP_PORT;
+        continue;
+      }
+      parsed.webPort = parsePort(value, arg);
+      i += 1;
+      continue;
+    }
+    if (arg === "--log-level") {
+      const value = args[i + 1];
+      if (!value || value.startsWith("-")) {
+        parsed.error = `Option '${arg}' argument missing`;
+        return parsed;
+      }
+      parsed.logLevel = value;
+      i += 1;
+      continue;
+    }
+    if (arg?.startsWith("-")) {
+      parsed.error = `Unknown option '${arg}'`;
+      return parsed;
+    }
+  }
+  if (parsed.httpPort !== void 0 && parsed.webPort !== void 0) {
+    parsed.error = "Options '--http' and '--web' cannot be used together";
+  }
+  return parsed;
+}
+function logTickResult(snapshot, prevSnapshot, isFirst) {
+  if (isFirst) {
+    const healthColor = snapshot.health === "degraded" ? red : snapshot.health === "running" ? green : cyan;
+    logLine(
+      green("\u25CF"),
+      `Repository ${bold(formatRepositoryDisplay(snapshot))} connected ${dim(
+        "("
+      )}${healthColor(snapshot.health)}${dim(")")}`
+    );
+    if (snapshot.summary.activeRuns > 0) {
+      logLine(cyan("\u25B8"), `${snapshot.summary.activeRuns} active run(s)`);
+    }
+    return;
+  }
+  if (prevSnapshot && prevSnapshot.health !== snapshot.health) {
+    const icon = snapshot.health === "degraded" ? red("\u25CF") : green("\u25CF");
+    logLine(
+      icon,
+      `Health changed: ${prevSnapshot.health} \u2192 ${bold(snapshot.health)}`
+    );
+  }
+  if (snapshot.lastError && snapshot.lastError !== prevSnapshot?.lastError) {
+    logLine(red("\u2717"), red(snapshot.lastError));
+  }
+  if (!snapshot.lastError && prevSnapshot?.lastError) {
+    logLine(green("\u2713"), green("Error cleared"));
+  }
+  const prevDispatched = prevSnapshot?.summary.dispatched ?? 0;
+  if (snapshot.summary.dispatched > prevDispatched) {
+    const delta = snapshot.summary.dispatched - prevDispatched;
+    logLine(yellow("\u25B8"), `Dispatched ${bold(String(delta))} new run(s)`);
+  }
+  const prevRunIds = new Set(
+    prevSnapshot?.activeRuns.map((run) => run.runId) ?? []
+  );
+  for (const run of snapshot.activeRuns) {
+    if (!prevRunIds.has(run.runId)) {
+      logLine(
+        cyan("\u25B8"),
+        `Run started: ${bold(run.issueIdentifier)} ${dim("state=")}${run.issueState} ${dim("status=")}${run.status}`
+      );
+    }
+  }
+  const currentRunIds = new Set(snapshot.activeRuns.map((run) => run.runId));
+  for (const prevRun of prevSnapshot?.activeRuns ?? []) {
+    if (!currentRunIds.has(prevRun.runId)) {
+      logLine(
+        green("\u2713"),
+        `Run finished: ${bold(prevRun.issueIdentifier)} ${dim("(")}${prevRun.status}${dim(")")}`
+      );
+    }
+  }
+  const prevSuppressed = prevSnapshot?.summary.suppressed ?? 0;
+  if (snapshot.summary.suppressed > prevSuppressed) {
+    const delta = snapshot.summary.suppressed - prevSuppressed;
+    logLine(
+      dim("\u25CB"),
+      dim(`${delta} issue(s) suppressed (already running or at limit)`)
+    );
+  }
+  const prevRecovered = prevSnapshot?.summary.recovered ?? 0;
+  if (snapshot.summary.recovered > prevRecovered) {
+    const delta = snapshot.summary.recovered - prevRecovered;
+    logLine(
+      yellow("\u21BA"),
+      `Recovered ${bold(String(delta))} stalled run(s)`
+    );
+  }
+  const prevRetryCount = prevSnapshot?.retryQueue.length ?? 0;
+  if (snapshot.retryQueue.length > prevRetryCount) {
+    const delta = snapshot.retryQueue.length - prevRetryCount;
+    logLine(yellow("\u25CC"), `${delta} run(s) queued for retry`);
+  }
+  const changed = snapshot.health !== prevSnapshot?.health || snapshot.lastError !== prevSnapshot?.lastError || snapshot.summary.dispatched !== prevSnapshot?.summary.dispatched || snapshot.summary.suppressed !== prevSnapshot?.summary.suppressed || snapshot.summary.recovered !== prevSnapshot?.summary.recovered || snapshot.activeRuns.length !== (prevSnapshot?.activeRuns.length ?? 0) || snapshot.retryQueue.length !== (prevSnapshot?.retryQueue.length ?? 0);
+  if (!changed) {
+    logLine(
+      dim("\xB7"),
+      dim(
+        `tick \u2014 ${snapshot.summary.activeRuns} active, ${snapshot.health}`
+      )
+    );
+  }
+}
+function parsePort(value, optionName) {
+  if (!/^\d+$/.test(value)) {
+    throw new Error(`Option '${optionName}' must be an integer port number`);
+  }
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isSafeInteger(parsed) || parsed < 0 || parsed > 65535) {
+    throw new Error(
+      `Option '${optionName}' must be a port number between 0 and 65535`
+    );
+  }
+  return parsed;
+}
+function respondJson2(response, status, payload) {
+  response.writeHead(status, {
+    "content-type": "application/json"
+  });
+  response.end(JSON.stringify(payload));
+}
+function formatBoundUrl2(server) {
+  const address = server.address();
+  if (!address || typeof address === "string") {
+    return `http://${HTTP_HOST}`;
+  }
+  const host = address.address === "::" || address.address === "::1" || address.address === "0.0.0.0" || address.address === "127.0.0.1" ? "localhost" : address.address;
+  const urlHost = host.includes(":") ? `[${host}]` : host;
+  return `http://${urlHost}:${address.port}`;
+}
+function logHttpRequestError(error) {
+  const message = error instanceof Error ? error.stack ?? error.message : String(error);
+  process.stderr.write(`[start] HTTP request failed: ${message}
+`);
+}
+async function closeHttpServer(server) {
+  if (!server) {
+    return;
+  }
+  await new Promise((resolveClose, rejectClose) => {
+    server.close((error) => {
+      if (error) {
+        rejectClose(error);
+        return;
+      }
+      resolveClose();
+    });
+  });
+}
+async function writeHttpBindingState(configDir, projectId, binding) {
+  await writeJsonFile(httpStatusPath(configDir, projectId), binding);
+}
+async function removeHttpBindingState(configDir, projectId) {
+  await rm(httpStatusPath(configDir, projectId), { force: true });
+}
+async function startHttpServer(input) {
+  const reader = new DashboardFsReader(input.runtimeRoot);
+  for (let port = input.initialPort; port <= 65535; port += 1) {
+    const server = createServer3((request, response) => {
+      void (async () => {
+        try {
+          const url = new URL(request.url ?? "/", `http://${HTTP_HOST}`);
+          if (request.method === "POST" && url.pathname === "/api/v1/refresh") {
+            request.resume();
+            input.service.requestReconcile();
+            respondJson2(response, 202, { ok: true });
+            return;
+          }
+          const resolved = await resolveDashboardResponse({
+            pathname: url.pathname,
+            method: request.method ?? "GET",
+            reader
+          });
+          respondJson2(response, resolved.status, resolved.payload);
+        } catch (error) {
+          logHttpRequestError(error);
+          if (!response.headersSent) {
+            respondJson2(response, 500, {
+              error: "Internal server error"
+            });
+          } else {
+            response.end();
+          }
+        }
+      })();
+    });
+    try {
+      await new Promise((resolveReady, rejectReady) => {
+        const handleListening = () => {
+          cleanup();
+          resolveReady();
+        };
+        const handleError = (error) => {
+          cleanup();
+          rejectReady(error);
+        };
+        const cleanup = () => {
+          server.off("listening", handleListening);
+          server.off("error", handleError);
+        };
+        server.once("listening", handleListening);
+        server.once("error", handleError);
+        server.listen(port, HTTP_HOST);
+      });
+      return {
+        server,
+        port,
+        url: formatBoundUrl2(server)
+      };
+    } catch (error) {
+      await closeHttpServer(server).catch(() => {
+      });
+      if (error?.code === "EADDRINUSE") {
+        continue;
+      }
+      throw error;
+    }
+  }
+  throw new Error(
+    `Unable to bind HTTP server starting from port ${input.initialPort}`
+  );
+}
+var handler5 = async (args, options) => {
+  setNoColor(options.noColor);
+  let parsed;
+  try {
+    if (rejectRemovedProjectId(args)) {
+      return;
+    }
+    parsed = parseStartArgs(args);
+  } catch (error) {
+    process.stderr.write(
+      `${error instanceof Error ? error.message : "Invalid arguments"}
+`
+    );
+    process.exitCode = 2;
+    return;
+  }
+  if (parsed.error) {
+    process.stderr.write(`${parsed.error}
+`);
+    process.stderr.write(
+      "Usage: gh-symphony repo start [--daemon] [--once] [--http [port]] [--web [port]]\n"
+    );
+    process.exitCode = 2;
+    return;
+  }
+  if (parsed.daemon && parsed.once) {
+    process.stderr.write(
+      "Options '--daemon' and '--once' cannot be used together\n"
+    );
+    process.exitCode = 2;
+    return;
+  }
+  const projectConfig = await resolveManagedProjectConfig({
+    configDir: options.configDir,
+    requestedProjectId: void 0
+  });
+  if (!projectConfig) {
+    handleMissingManagedProjectConfig();
+    return;
+  }
+  if (!hasConfiguredRepository(projectConfig)) {
+    process.stderr.write(
+      "No repository is configured in this project. Run 'gh-symphony repo init' from the target repository first.\n"
+    );
+    process.exitCode = 1;
+    return;
+  }
+  const runtimeRoot = resolveRuntimeRoot(options.configDir);
+  const projectId = projectConfig.projectId;
+  let logLevel;
+  try {
+    logLevel = resolveOrchestratorLogLevel(
+      parsed.logLevel ?? process.env.SYMPHONY_LOG_LEVEL
+    );
+  } catch (error) {
+    process.stderr.write(
+      `${error instanceof Error ? error.message : "Unsupported log level"}
+`
+    );
+    process.exitCode = 2;
+    return;
+  }
+  if (parsed.daemon) {
+    await startDaemon(
+      options,
+      projectId,
+      parsed.logLevel,
+      parsed.httpPort,
+      parsed.webPort
+    );
+    return;
+  }
+  if (!process.env.GITHUB_GRAPHQL_TOKEN) {
+    try {
+      process.env.GITHUB_GRAPHQL_TOKEN = getGhToken();
+    } catch {
+    }
+  }
+  let projectLock = null;
+  try {
+    projectLock = await acquireProjectLock({
+      runtimeRoot,
+      projectId
+    });
+    await removeHttpBindingState(options.configDir, projectId);
+    const store = createStore(runtimeRoot);
+    let prevSnapshot = null;
+    let isFirst = true;
+    const service = new OrchestratorService(store, projectConfig, {
+      logLevel,
+      onTick: async (snapshot) => {
+        try {
+          logTickResult(snapshot, prevSnapshot, isFirst);
+          if (!isFirst) {
+            const currentRunIds = new Set(
+              snapshot.activeRuns.map((run) => run.runId)
+            );
+            for (const prevRun of prevSnapshot?.activeRuns ?? []) {
+              if (!currentRunIds.has(prevRun.runId)) {
+                await tailWorkerLog(
+                  runtimeRoot,
+                  projectId,
+                  prevRun.runId,
+                  prevRun.issueIdentifier
+                );
+              }
+            }
+          }
+          prevSnapshot = snapshot;
+          isFirst = false;
+        } catch (error) {
+          logLine(
+            red("\u2717"),
+            red(
+              `Tick error: ${error instanceof Error ? error.message : "Unknown error"}`
+            )
+          );
+        }
+      }
+    });
+    let shuttingDown = false;
+    let shutdownPromise = null;
+    let keepHttpAliveResolve = null;
+    let httpServer = null;
+    const shutdown = async () => {
+      if (shuttingDown) {
+        return shutdownPromise;
+      }
+      shuttingDown = true;
+      keepHttpAliveResolve?.();
+      keepHttpAliveResolve = null;
+      const heldLock = projectLock;
+      projectLock = null;
+      shutdownPromise = shutdownForegroundOrchestrator({
+        configDir: options.configDir,
+        projectId,
+        httpServer: httpServer?.server,
+        projectLock: heldLock,
+        service
+      });
+      return shutdownPromise;
+    };
+    const handleSigint = () => {
+      void shutdown();
+    };
+    const handleSigterm = () => {
+      void shutdown();
+    };
+    process.on("SIGINT", handleSigint);
+    process.on("SIGTERM", handleSigterm);
+    try {
+      httpServer = parsed.webPort !== void 0 ? await startControlPlaneServer({
+        host: HTTP_HOST,
+        port: parsed.webPort,
+        runtimeRoot,
+        onRefreshRequest: () => service.requestReconcile()
+      }) : parsed.httpPort !== void 0 ? await startHttpServer({
+        runtimeRoot,
+        projectId,
+        initialPort: parsed.httpPort,
+        service
+      }) : null;
+      if (httpServer) {
+        try {
+          await writeHttpBindingState(options.configDir, projectId, {
+            host: HTTP_HOST,
+            port: httpServer.port,
+            endpoint: httpServer.url
+          });
+        } catch (error) {
+          logLine(
+            yellow("\u26A0"),
+            yellow(
+              `Failed to persist HTTP binding state (http.json): ${error instanceof Error ? error.message : "Unknown error"}`
+            )
+          );
+        }
+      }
+      logLine(
+        green("\u25B2"),
+        `Starting orchestrator for project: ${bold(projectId)}`
+      );
+      if (httpServer) {
+        logLine(
+          cyan("\u25A1"),
+          parsed.webPort !== void 0 ? `Web dashboard listening on ${httpServer.url}` : `HTTP dashboard listening on ${httpServer.url}`
+        );
+      }
+      logLine(
+        dim("\xB7"),
+        dim(
+          parsed.once ? "Running one orchestration tick" : "Press Ctrl+C to stop"
+        )
+      );
+      while (!shuttingDown) {
+        try {
+          await service.run({ once: parsed.once });
+          if (shuttingDown) {
+            break;
+          }
+          if (parsed.once) {
+            if (httpServer) {
+              logLine(
+                cyan("\u25A1"),
+                parsed.webPort !== void 0 ? "One-shot tick completed; web dashboard remains available until Ctrl+C" : "One-shot tick completed; HTTP dashboard remains available until Ctrl+C"
+              );
+              if (shuttingDown) {
+                break;
+              }
+              await new Promise((resolve5) => {
+                keepHttpAliveResolve = resolve5;
+              });
+            } else {
+              await shutdown();
+            }
+          }
+          break;
+        } catch (error) {
+          if (shuttingDown) {
+            break;
+          }
+          logLine(
+            red("\u2717"),
+            red(
+              `${parsed.once ? "One-shot run failed" : "Run loop error"}: ${error instanceof Error ? error.message : "Unknown error"}`
+            )
+          );
+          if (parsed.once) {
+            process.exitCode = 1;
+            await closeHttpServer(httpServer?.server).catch((closeError) => {
+              logLine(
+                yellow("\u26A0"),
+                `Failed to stop HTTP server: ${closeError instanceof Error ? closeError.message : "Unknown error"}`
+              );
+            });
+            await removeHttpBindingState(options.configDir, projectId).catch(
+              (removeError) => {
+                logLine(
+                  yellow("\u26A0"),
+                  `Failed to remove HTTP state: ${removeError instanceof Error ? removeError.message : "Unknown error"}`
+                );
+              }
+            );
+            return;
+          }
+        }
+      }
+    } finally {
+      process.off("SIGINT", handleSigint);
+      process.off("SIGTERM", handleSigterm);
+      if (shutdownPromise) {
+        await shutdownPromise;
+      }
+    }
+  } finally {
+    await releaseProjectLock(projectLock);
+  }
+};
+async function shutdownForegroundOrchestrator(input) {
+  logLine(yellow("\u25BC"), "Shutting down...");
+  if (input.service) {
+    try {
+      await input.service.shutdown();
+    } catch (error) {
+      logLine(
+        red("\u2717"),
+        red(
+          `Failed to shut down workers: ${error instanceof Error ? error.message : "Unknown error"}`
+        )
+      );
+    }
+  }
+  try {
+    await closeHttpServer(input.httpServer);
+  } catch (error) {
+    logLine(
+      yellow("\u26A0"),
+      `Failed to stop HTTP server: ${error instanceof Error ? error.message : "Unknown error"}`
+    );
+  }
+  try {
+    await removeHttpBindingState(input.configDir, input.projectId);
+  } catch (error) {
+    logLine(
+      yellow("\u26A0"),
+      `Failed to remove HTTP state: ${error instanceof Error ? error.message : "Unknown error"}`
+    );
+  }
+  try {
+    await (input.releaseLock ?? releaseProjectLock)(input.projectLock);
+  } catch (error) {
+    logLine(
+      yellow("\u26A0"),
+      `Failed to release project lock: ${error instanceof Error ? error.message : "Unknown error"}`
+    );
+  }
+  return (input.exit ?? process.exit)(0);
+}
+function hasConfiguredRepository(config) {
+  return Boolean(config.repository?.owner && config.repository.name);
+}
+async function tailWorkerLog(runtimeRoot, projectId, runId, issueIdentifier) {
+  for (const logPath of [
+    join6(runtimeRoot, "runs", runId, "worker.log"),
+    join6(runtimeRoot, "projects", projectId, "runs", runId, "worker.log")
+  ]) {
+    try {
+      const content = await readFile5(logPath, "utf8");
+      const lines = content.split("\n").filter((l) => l.trim());
+      if (lines.length === 0) return;
+      const tail = lines.slice(-30);
+      logLine(red("\u2717"), red(`Worker stderr (${issueIdentifier}):`));
+      for (const line of tail) {
+        process.stdout.write(`  ${dim(line)}
+`);
+      }
+      return;
+    } catch {
+    }
+  }
+}
+var start_default = handler5;
+async function startDaemon(options, projectId, logLevel, httpPort, webPort) {
+  const logPath = orchestratorLogPath(options.configDir, projectId);
+  await mkdir(dirname2(logPath), { recursive: true });
+  const { openSync } = await import("fs");
+  const logFd = openSync(logPath, "a");
+  const child = spawn(
+    process.execPath,
+    [
+      process.argv[1],
+      "repo",
+      "start",
+      ...httpPort !== void 0 ? ["--http", String(httpPort)] : [],
+      ...webPort !== void 0 ? ["--web", String(webPort)] : [],
+      ...logLevel ? ["--log-level", logLevel] : []
+    ],
+    {
+      cwd: process.cwd(),
+      env: {
+        ...process.env,
+        GH_SYMPHONY_CONFIG_DIR: options.configDir
+      },
+      detached: true,
+      stdio: ["ignore", logFd, logFd]
+    }
+  );
+  const pidPath = daemonPidPath(options.configDir, projectId);
+  await mkdir(dirname2(pidPath), { recursive: true });
+  await writeFile(pidPath, String(child.pid), "utf8");
+  child.unref();
+  const { closeSync } = await import("fs");
+  closeSync(logFd);
+  process.stdout.write(
+    `Orchestrator started in background (PID: ${child.pid}).
+Logs: ${logPath}
+Stop with: gh-symphony repo stop
+`
+  );
+}
+
+// src/commands/status.ts
+import { readFile as readFile6 } from "fs/promises";
+import { join as join7 } from "path";
+
+// src/dashboard/renderer.ts
+var COL_ID = 24;
+var COL_STATUS = 14;
+var COL_PID = 8;
+var COL_AGE_TURN = 12;
+var COL_TOKENS = 17;
+var COL_SESSION = 14;
+var COL_ID_HEADER = COL_ID + 2;
+var identity = (s) => s;
+function makeColors(noColor) {
+  if (noColor) {
+    return {
+      bold: identity,
+      dim: identity,
+      green: identity,
+      red: identity,
+      yellow: identity,
+      cyan: identity,
+      magenta: identity,
+      blue: identity
+    };
+  }
+  return { bold, dim, green, red, yellow, cyan, magenta, blue };
+}
+function pad(s, width, align = "left") {
+  const visible = stripAnsi(s);
+  if (visible.length >= width) return visible.slice(0, width);
+  const padding = " ".repeat(width - visible.length);
+  return align === "right" ? padding + s : s + padding;
+}
+function compactSessionId(id) {
+  if (!id) return "\u2014";
+  if (id.length <= 10) return id;
+  return `${id.slice(0, 4)}...${id.slice(-6)}`;
+}
+function fmtTokens(n) {
+  return n.toLocaleString("en-US");
+}
+function fmtTokenPair(delta, cumulative) {
+  const left = fmtTokens(delta ?? 0);
+  const right = fmtTokens(cumulative ?? delta ?? 0);
+  return `${left} / ${right}`;
+}
+function fmtAge(startedAt, now) {
+  if (!startedAt) return "0m";
+  const diffMs = now - new Date(startedAt).getTime();
+  if (diffMs < 0) return "0m";
+  const totalMin = Math.floor(diffMs / 6e4);
+  if (totalMin < 60) return `${totalMin}m`;
+  const h = Math.floor(totalMin / 60);
+  const m = totalMin % 60;
+  return `${h}h ${m}m`;
+}
+function fmtRuntime(ms) {
+  if (ms <= 0) return "0h 0m";
+  const totalMin = Math.floor(ms / 6e4);
+  const h = Math.floor(totalMin / 60);
+  const m = totalMin % 60;
+  return `${h}h ${m}m`;
+}
+function fmtRetryTime(nextRetryAt, now) {
+  if (!nextRetryAt) return "\u2014";
+  const diffMs = new Date(nextRetryAt).getTime() - now;
+  if (diffMs <= 0) return "now";
+  const totalSec = Math.ceil(diffMs / 1e3);
+  if (totalSec < 60) return `${totalSec}s`;
+  const m = Math.floor(totalSec / 60);
+  const s = totalSec % 60;
+  return s > 0 ? `${m}m ${s}s` : `${m}m`;
+}
+var COL_SEPARATORS = 6;
+function eventColWidth(termWidth) {
+  const fixed = 2 + COL_ID_HEADER + COL_STATUS + COL_PID + COL_AGE_TURN + COL_TOKENS + COL_SESSION + COL_SEPARATORS;
+  return Math.max(5, termWidth - fixed);
+}
+function statusDot(run, c) {
+  const event = run.lastEvent;
+  if (event === null || event === void 0 || run.status === "failed")
+    return c.red("\u25CF");
+  if (event === "token_count") return c.yellow("\u25CF");
+  if (event === "task_started") return c.green("\u25CF");
+  if (event === "turn_completed") return c.magenta("\u25CF");
+  return c.blue("\u25CF");
+}
+function titleBar(width, c) {
+  const title = " gh-symphony ";
+  const side = Math.max(0, Math.floor((width - title.length) / 2));
+  const right = Math.max(0, width - side - title.length);
+  return c.bold("\u2550".repeat(side) + title + "\u2550".repeat(right));
+}
+function sectionDivider(label, width, c) {
+  const prefix = `\u2500\u2500 ${label} `;
+  const fill = "\u2500".repeat(Math.max(0, width - prefix.length));
+  return c.dim(prefix + fill);
+}
+function buildSummaryLines(snapshots, options, c) {
+  const now = options.now ?? Date.now();
+  const lines = [];
+  const totalActive = snapshots.reduce(
+    (sum, s) => sum + s.summary.activeRuns,
+    0
+  );
+  const agentStr = options.maxAgents != null ? `${totalActive}/${options.maxAgents}` : `${totalActive}`;
+  const totIn = snapshots.reduce(
+    (sum, s) => sum + (s.codexTotals?.inputTokens ?? 0),
+    0
+  );
+  const totOut = snapshots.reduce(
+    (sum, s) => sum + (s.codexTotals?.outputTokens ?? 0),
+    0
+  );
+  const totAll = snapshots.reduce(
+    (sum, s) => sum + (s.codexTotals?.totalTokens ?? 0),
+    0
+  );
+  const allStarts = snapshots.flatMap((s) => s.activeRuns).map((r) => r.startedAt).filter((t) => t != null).map((t) => new Date(t).getTime());
+  const runtimeMs = allStarts.length > 0 ? now - Math.min(...allStarts) : 0;
+  const runtime = fmtRuntime(runtimeMs);
+  lines.push(
+    `  ${c.dim("Agents")}  ${c.bold(agentStr)}     ${c.dim("Runtime")}  ${c.bold(runtime)}    ${c.dim("Tokens")}  ${fmtTokens(totIn)} in / ${fmtTokens(totOut)} out / ${c.bold(fmtTokens(totAll))} total`
+  );
+  const hasLimits = snapshots.some((s) => s.rateLimits != null);
+  const limitStr = hasLimits ? "active" : "standard";
+  lines.push(`  ${c.dim("Rate Limits")}  ${limitStr}`);
+  return lines;
+}
+function tableHeaderRow(c) {
+  const cols = [
+    pad("ID", COL_ID_HEADER),
+    pad("STATUS", COL_STATUS),
+    pad("PID", COL_PID),
+    pad("AGE/TURN", COL_AGE_TURN),
+    pad("TOKENS", COL_TOKENS),
+    pad("SESSION", COL_SESSION),
+    "EVENT"
+  ].join(" ");
+  return `  ${c.dim(cols)}`;
+}
+function activeRunRow(run, now, evtWidth, c) {
+  const dot = statusDot(run, c);
+  const id = pad(run.issueIdentifier, COL_ID);
+  const status = pad(
+    run.issueState ?? run.executionPhase ?? "\u2014",
+    COL_STATUS
+  );
+  const pid = pad(
+    run.processId != null ? String(run.processId) : "\u2014",
+    COL_PID
+  );
+  const age = fmtAge(run.startedAt, now);
+  const turn = run.turnCount ?? 0;
+  const ageTurn = pad(`${age}/${turn}`, COL_AGE_TURN);
+  const tokens = pad(
+    fmtTokenPair(
+      run.tokenUsage?.totalTokens,
+      run.tokenUsage?.cumulativeTotalTokens
+    ),
+    COL_TOKENS,
+    "right"
+  );
+  const sessionId = run.runtimeSession?.sessionId ?? run.runtimeSession?.threadId ?? null;
+  const session = pad(compactSessionId(sessionId), COL_SESSION);
+  const event = pad(run.lastEvent ?? "\u2014", evtWidth);
+  const columns = [id, status, pid, ageTurn, tokens, session, event].join(" ");
+  return `  ${dot} ${columns}`;
+}
+function retryRow(entry, snapshot, now, c) {
+  const id = entry.issueIdentifier;
+  const kind = entry.retryKind;
+  const timeStr = fmtRetryTime(entry.nextRetryAt, now);
+  const matchingRun = snapshot.activeRuns.find((r) => r.runId === entry.runId);
+  const errorHint = matchingRun?.lastEvent ?? "";
+  return `  ${c.yellow("\u21BB")} ${id}  ${kind}  retrying in ${timeStr}${errorHint ? "  " + errorHint : ""}`;
+}
+function renderDashboard(snapshots, options) {
+  const width = options.terminalWidth || 115;
+  const now = options.now ?? Date.now();
+  const c = makeColors(options.noColor);
+  const evtWidth = eventColWidth(width);
+  const lines = [];
+  lines.push(titleBar(width, c));
+  lines.push(...buildSummaryLines(snapshots, options, c));
+  lines.push("");
+  for (const snap of snapshots) {
+    const hasActiveRuns = snap.activeRuns.length > 0;
+    const hasRetries = snap.retryQueue.length > 0;
+    if (!hasActiveRuns && !hasRetries) continue;
+    lines.push(
+      sectionDivider(formatRepositoryDisplay(snap), width, c)
+    );
+    if (hasActiveRuns) {
+      lines.push(tableHeaderRow(c));
+      for (const rawRun of snap.activeRuns) {
+        const run = rawRun;
+        lines.push(activeRunRow(run, now, evtWidth, c));
+      }
+    }
+    lines.push("");
+  }
+  const allRetries = [];
+  for (const snap of snapshots) {
+    for (const entry of snap.retryQueue) {
+      allRetries.push({ entry, snapshot: snap });
+    }
+  }
+  if (allRetries.length > 0) {
+    lines.push(sectionDivider("Backoff Queue", width, c));
+    for (const { entry, snapshot } of allRetries) {
+      lines.push(retryRow(entry, snapshot, now, c));
+    }
+    lines.push("");
+  }
+  const result = lines.map((line) => {
+    const visible = stripAnsi(line);
+    if (visible.length <= width) return line;
+    return visible.slice(0, width);
+  });
+  return result.join("\n");
+}
+
+// src/commands/status.ts
+function healthIcon(health) {
+  switch (health) {
+    case "idle":
+    case "running":
+      return green("\u25CF");
+    case "degraded":
+      return red("\u25CF");
+  }
+}
+function relativeTime(isoString) {
+  const now = /* @__PURE__ */ new Date();
+  const then = new Date(isoString);
+  const diffMs = now.getTime() - then.getTime();
+  const diffS = Math.floor(diffMs / 1e3);
+  const diffM = Math.floor(diffS / 60);
+  const diffH = Math.floor(diffM / 60);
+  if (diffS < 60) return `${diffS}s ago`;
+  if (diffM < 60) return `${diffM}m ago`;
+  return `${diffH}h ago`;
+}
+function truncate(s, len) {
+  if (s.length <= len) return s;
+  return s.slice(0, len - 3) + "...";
+}
+function formatTokenPair(delta, cumulative) {
+  return `${delta.toLocaleString("en-US")} / ${cumulative.toLocaleString("en-US")}`;
+}
+function resolveProjectTokenDelta(snapshot) {
+  return snapshot.activeRuns.reduce(
+    (sum, run) => sum + (run.tokenUsage?.totalTokens ?? 0),
+    0
+  );
+}
+function renderLegacyStatus(snapshot, noColor) {
+  const apply = noColor ? (s) => stripAnsi(s) : (s) => s;
+  const lines = [];
+  const headerTitle = `gh-symphony \u2219 ${formatRepositoryDisplay(snapshot)}`;
+  const headerWidth = 45;
+  const headerPadding = Math.max(
+    0,
+    headerWidth - stripAnsi(headerTitle).length
+  );
+  lines.push("\u256D" + "\u2500".repeat(headerWidth) + "\u256E");
+  lines.push(
+    "\u2502  " + apply(bold(headerTitle)) + " ".repeat(headerPadding) + "\u2502"
+  );
+  lines.push("\u2570" + "\u2500".repeat(headerWidth) + "\u256F");
+  lines.push("");
+  const healthStr = apply(
+    `${healthIcon(snapshot.health)} Health    ${snapshot.health}`
+  );
+  const lastTickStr = apply(`Last tick  ${relativeTime(snapshot.lastTickAt)}`);
+  lines.push(
+    `  ${healthStr}${" ".repeat(Math.max(0, 30 - stripAnsi(healthStr).length))}${lastTickStr}`
+  );
+  lines.push("");
+  const dispatchedStr = apply(`Dispatched   ${snapshot.summary.dispatched}`);
+  const activeRunsStr = apply(`Active Runs  ${snapshot.summary.activeRuns}`);
+  const suppressedStr = apply(`Suppressed   ${snapshot.summary.suppressed}`);
+  const recoveredStr = apply(`Recovered    ${snapshot.summary.recovered}`);
+  lines.push(
+    `  ${dispatchedStr}${" ".repeat(Math.max(0, 20 - stripAnsi(dispatchedStr).length))}${activeRunsStr}`
+  );
+  lines.push(
+    `  ${suppressedStr}${" ".repeat(Math.max(0, 20 - stripAnsi(suppressedStr).length))}${recoveredStr}`
+  );
+  lines.push("");
+  if (snapshot.activeRuns.length > 0) {
+    lines.push("  Active Runs:");
+    for (const run of snapshot.activeRuns) {
+      const runIdDisplay = truncate(run.runId, 12);
+      const stateStr = apply(cyan(run.issueState));
+      const statusColor = run.status === "running" ? green : run.status === "failed" ? red : run.status === "succeeded" ? green : dim;
+      const statusStr = apply(statusColor(run.status));
+      lines.push(
+        `    ${runIdDisplay}  ${run.issueIdentifier}  ${stateStr}  ${statusStr}`
+      );
+    }
+    lines.push("");
+  } else {
+    lines.push("  No active runs.");
+    lines.push("");
+  }
+  if (snapshot.retryQueue.length > 0) {
+    lines.push("  Retry Queue:");
+    for (const retry of snapshot.retryQueue) {
+      const runIdDisplay = truncate(retry.runId, 12);
+      const nextRetryDisplay = retry.nextRetryAt ? relativeTime(retry.nextRetryAt) : "pending";
+      lines.push(
+        `    ${runIdDisplay}  ${retry.issueIdentifier}  ${apply(yellow(retry.retryKind))}  ${nextRetryDisplay}`
+      );
+    }
+    lines.push("");
+  }
+  if (snapshot.lastError) {
+    lines.push(apply(red(`  \u2717 ${snapshot.lastError}`)));
+    lines.push("");
+  }
+  if (snapshot.codexTotals) {
+    const tokenDelta = resolveProjectTokenDelta(snapshot);
+    const tokenStr = apply(
+      `Tokens: ${formatTokenPair(tokenDelta, snapshot.codexTotals.totalTokens)} total`
+    );
+    lines.push(`  ${tokenStr}`);
+  } else {
+    lines.push("  Tokens: 0 / 0 total");
+  }
+  return lines.join("\n");
+}
+function parseStatusArgs(args) {
+  const parsed = {
+    watch: false
+  };
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === "--watch" || arg === "-w") {
+      parsed.watch = true;
+      continue;
+    }
+    if (arg?.startsWith("-")) {
+      parsed.error = `Unknown option '${arg}'`;
+      return parsed;
+    }
+  }
+  return parsed;
+}
+async function readStatusSnapshot(runtimeRoot, projectId) {
+  for (const statusPath of [
+    join7(runtimeRoot, "status.json"),
+    join7(runtimeRoot, "projects", projectId, "status.json")
+  ]) {
+    try {
+      const content = await readFile6(statusPath, "utf-8");
+      return JSON.parse(content);
+    } catch {
+    }
+  }
+  return null;
+}
+var handler6 = async (args, options) => {
+  if (rejectRemovedProjectId(args)) {
+    return;
+  }
+  const parsed = parseStatusArgs(args);
+  if (parsed.error) {
+    process.stderr.write(`${parsed.error}
+`);
+    process.stderr.write("Usage: gh-symphony repo status [--watch]\n");
+    process.exitCode = 2;
+    return;
+  }
+  const projectConfig = await resolveManagedProjectConfig({
+    configDir: options.configDir,
+    requestedProjectId: void 0
+  });
+  if (!projectConfig) {
+    handleMissingManagedProjectConfig();
+    return;
+  }
+  const runtimeRoot = resolveRuntimeRoot(options.configDir);
+  const projectId = projectConfig.projectId;
+  if (parsed.watch) {
+    const isTTY = process.stdout.isTTY === true;
+    let terminalWidth = process.stdout.columns ?? 115;
+    let runPromise = null;
+    const run = async () => {
+      const snapshot2 = await readStatusSnapshot(runtimeRoot, projectId);
+      if (options.json || !isTTY) {
+        process.stdout.write(JSON.stringify(snapshot2, null, 2) + "\n");
+      } else {
+        if (!snapshot2) {
+          process.stdout.write(
+            clearScreen() + "Unable to read status snapshot.\n"
+          );
+          return;
+        }
+        process.stdout.write(
+          clearScreen() + renderDashboard([snapshot2], {
+            terminalWidth,
+            noColor: options.noColor
+          }) + "\n"
+        );
+      }
+    };
+    const tick = () => {
+      if (runPromise) {
+        return;
+      }
+      runPromise = run().finally(() => {
+        runPromise = null;
+      });
+    };
+    if (isTTY) {
+      process.stdout.write(hideCursor());
+    }
+    tick();
+    await runPromise;
+    const interval = setInterval(tick, 2e3);
+    process.on("SIGWINCH", () => {
+      terminalWidth = process.stdout.columns ?? terminalWidth;
+    });
+    const shutdown = () => {
+      clearInterval(interval);
+      process.stdout.write(showCursor() + "\n");
+      process.exit(0);
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+    await new Promise(() => {
+    });
+  }
+  const snapshot = await readStatusSnapshot(runtimeRoot, projectId);
+  if (snapshot) {
+    if (options.json) {
+      process.stdout.write(JSON.stringify(snapshot, null, 2) + "\n");
+    } else {
+      process.stdout.write(
+        renderLegacyStatus(snapshot, options.noColor) + "\n"
+      );
+    }
+  } else {
+    process.stderr.write("Unable to read status snapshot.\n");
+    process.exitCode = 1;
+  }
+};
+var status_default = handler6;
+
+// src/commands/stop.ts
+import { readFile as readFile7, rm as rm2 } from "fs/promises";
+function parseStopArgs(args) {
+  const parsed = {
+    force: false
+  };
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === "--force") {
+      parsed.force = true;
+      continue;
+    }
+    if (arg?.startsWith("-")) {
+      parsed.error = `Unknown option '${arg}'`;
+      return parsed;
+    }
+  }
+  return parsed;
+}
+var handler7 = async (args, options) => {
+  if (rejectRemovedProjectId(args)) {
+    return;
+  }
+  const parsed = parseStopArgs(args);
+  if (parsed.error) {
+    process.stderr.write(`${parsed.error}
+`);
+    process.stderr.write("Usage: gh-symphony repo stop [--force]\n");
+    process.exitCode = 2;
+    return;
+  }
+  const resolvedForce = parsed.force;
+  const projectConfig = await resolveManagedProjectConfig({
+    configDir: options.configDir,
+    requestedProjectId: void 0
+  });
+  if (!projectConfig) {
+    handleMissingManagedProjectConfig();
+    return;
+  }
+  const resolvedProjectId = projectConfig.projectId;
+  const pidPath = daemonPidPath(options.configDir, resolvedProjectId);
+  let pidStr;
+  try {
+    pidStr = await readFile7(pidPath, "utf8");
+  } catch {
+    process.stderr.write(
+      `No running daemon found for project "${resolvedProjectId}" (PID file missing).
+`
+    );
+    process.exitCode = 1;
+    return;
+  }
+  const pid = Number.parseInt(pidStr.trim(), 10);
+  if (!Number.isFinite(pid)) {
+    process.stderr.write(`Invalid PID in ${pidPath}: ${pidStr}
+`);
+    process.exitCode = 1;
+    return;
+  }
+  try {
+    process.kill(pid, 0);
+  } catch {
+    process.stdout.write(
+      `Daemon for project "${resolvedProjectId}" (PID ${pid}) is not running. Cleaning up PID file.
+`
+    );
+    await rm2(pidPath, { force: true });
+    return;
+  }
+  const signal = resolvedForce ? "SIGKILL" : "SIGTERM";
+  try {
+    process.kill(pid, signal);
+    process.stdout.write(`Sent ${signal} to orchestrator (PID ${pid}).
+`);
+  } catch (error) {
+    process.stderr.write(
+      `Failed to stop process ${pid}: ${error instanceof Error ? error.message : "Unknown error"}
+`
+    );
+    process.exitCode = 1;
+    return;
+  }
+  await rm2(pidPath, { force: true });
+  process.stdout.write("Daemon stopped.\n");
+};
+var stop_default = handler7;
+
+// src/commands/repo.ts
+var handler8 = async (args, options) => {
+  const [subcommand, ...rest] = args;
+  switch (subcommand) {
+    case "init":
+      await repoInit(rest, options);
+      break;
+    case "start":
+      if (rejectRemovedProjectId(rest)) return;
+      await start_default(rest, repoOptions(options));
+      break;
+    case "run":
+      if (rejectRemovedProjectId(rest)) return;
+      await run_default(rest, repoOptions(options));
+      break;
+    case "recover":
+      if (rejectRemovedProjectId(rest)) return;
+      await recover_default(rest, repoOptions(options));
+      break;
+    case "logs":
+      if (rejectRemovedProjectId(rest)) return;
+      await logs_default(rest, repoOptions(options));
+      break;
+    case "explain":
+      if (rejectRemovedProjectId(rest)) return;
+      await repo_explain_default(rest, repoOptions(options));
+      break;
+    case "status":
+      if (rejectRemovedProjectId(rest)) return;
+      await status_default(rest, repoOptions(options));
+      break;
+    case "stop":
+      if (rejectRemovedProjectId(rest)) return;
+      await stop_default(rest, repoOptions(options));
+      break;
+    default:
+      process.stderr.write(
+        "Usage: gh-symphony repo <init|start|status|stop|run|recover|logs|explain> [repo]\n"
+      );
+      process.exitCode = 2;
+  }
+};
+var repo_default = handler8;
+function repoOptions(options) {
+  return {
+    ...options,
+    configDir: resolveRepoRuntimeRoot()
+  };
+}
+async function repoInit(args, options) {
+  if (rejectRemovedProjectId(args)) {
+    return;
+  }
+  let flags;
+  try {
+    flags = parseRepoRuntimeFlags(args);
+  } catch (error) {
+    process.stderr.write(
+      `${error instanceof Error ? error.message : "Invalid arguments"}
+`
+    );
+    process.stderr.write(
+      "Usage: gh-symphony repo init [--repo-dir <path>] [--workflow-file <path>]\n"
+    );
+    process.exitCode = 2;
+    return;
+  }
+  try {
+    const result = await initRepoRuntime(flags);
+    if (options.json) {
+      process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+      return;
+    }
+    process.stdout.write(
+      [
+        `Repository initialized: ${formatRepoSpec(result.repository)}`,
+        `Runtime: ${result.configDir}`,
+        `Workflow: ${result.workflowPath}`
+      ].join("\n") + "\n"
+    );
+  } catch (error) {
+    process.stderr.write(
+      `${error instanceof Error ? error.message : "Repository initialization failed."}
+`
+    );
+    process.exitCode = 1;
+  }
+}
+function formatRepoSpec(repo) {
+  return `${repo.owner}/${repo.name}`;
+}
+export {
+  repo_default as default
+};