@gh-symphony/cli 0.0.14 → 0.0.16

package/dist/chunk-MHIWAIVD.js

@@ -0,0 +1,876 @@
+#!/usr/bin/env node
+import {
+  getGhToken
+} from "./chunk-JO3AXHQI.js";
+import {
+  bold,
+  cyan,
+  dim,
+  green,
+  red,
+  setNoColor,
+  yellow
+} from "./chunk-MVRF7BES.js";
+import {
+  OrchestratorService,
+  acquireProjectLock,
+  createStore,
+  releaseProjectLock,
+  resolveOrchestratorLogLevel
+} from "./chunk-EFMFGOWM.js";
+import {
+  deriveIssueWorkspaceKeyFromIdentifier,
+  isFileMissing,
+  isMatchingIssueRun,
+  mapIssueOrchestrationStateToStatus,
+  parseRecentEvents,
+  readJsonFile,
+  safeReadDir
+} from "./chunk-TF3QNWNC.js";
+import {
+  resolveRuntimeRoot
+} from "./chunk-5NV3LSAJ.js";
+import {
+  handleMissingManagedProjectConfig,
+  resolveManagedProjectConfig
+} from "./chunk-TH5QPO3Y.js";
+import {
+  daemonPidPath,
+  httpStatusPath,
+  orchestratorLogPath,
+  writeJsonFile
+} from "./chunk-ROGRTUFI.js";
+
+// src/commands/start.ts
+import { writeFile, mkdir, readFile, rm } from "fs/promises";
+import { dirname, join as join2 } from "path";
+import { spawn } from "child_process";
+import { createServer as createServer2 } from "http";
+
+// ../dashboard/dist/store.js
+import { open } from "fs/promises";
+import { join, resolve } 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 {
+  runtimeRoot;
+  projectId;
+  resolvedRuntimeRoot;
+  constructor(runtimeRoot, projectId) {
+    this.runtimeRoot = runtimeRoot;
+    this.projectId = projectId;
+    assertValidDashboardProjectId(projectId);
+    this.resolvedRuntimeRoot = resolve(runtimeRoot);
+  }
+  projectDir() {
+    return join(this.resolvedRuntimeRoot, "projects", this.projectId);
+  }
+  runDir(runId) {
+    assertValidDashboardRunId(runId);
+    return join(this.projectDir(), "runs", runId);
+  }
+  async loadProjectStatus() {
+    return readJsonFile(join(this.projectDir(), "status.json"));
+  }
+  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(join(this.projectDir(), "issues.json"));
+    if (issues) {
+      return issues.map((issue) => ({
+        ...issue,
+        completedOnce: issue.completedOnce ?? false
+      }));
+    }
+    const legacyLeases = await readJsonFile(join(this.projectDir(), "leases.json")) ?? [];
+    return legacyLeases.map((lease) => ({
+      issueId: lease.issueId,
+      identifier: lease.issueIdentifier,
+      workspaceKey: deriveIssueWorkspaceKeyFromIdentifier(lease.issueIdentifier),
+      completedOnce: false,
+      state: lease.status === "active" ? "claimed" : "released",
+      currentRunId: lease.status === "active" ? lease.runId : null,
+      retryEntry: null,
+      updatedAt: lease.updatedAt
+    }));
+  }
+  async loadRun(runId) {
+    return readJsonFile(join(this.runDir(runId), "run.json"));
+  }
+  async loadAllRuns() {
+    const runIds = await safeReadDir(join(this.projectDir(), "runs"));
+    const runs = await mapWithConcurrency(runIds, RUN_RECORD_LOAD_CONCURRENCY, (runId) => this.loadRun(runId));
+    return runs.filter((run) => Boolean(run));
+  }
+  async loadRecentRunEvents(runId, limit = DEFAULT_RECENT_EVENT_LIMIT) {
+    if (limit <= 0) {
+      return [];
+    }
+    const path = join(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, reader.projectId, issueRecord.issueId, issueIdentifier) ? currentRunCandidate : await findLatestRunForIssue(reader, issueRecord.issueId, issueIdentifier);
+  const recentEvents = currentRun === null ? [] : await reader.loadRecentRunEvents(currentRun.runId);
+  const latestEventMessage = recentEvents[recentEvents.length - 1]?.message ?? null;
+  const currentAttempt = currentRun?.attempt ?? issueRecord.retryEntry?.attempt ?? 0;
+  return {
+    issue_identifier: issueRecord.identifier,
+    issue_id: issueRecord.issueId,
+    status: currentRun?.status ?? mapIssueOrchestrationStateToStatus(issueRecord.state),
+    workspace: {
+      path: currentRun?.workingDirectory ?? null
+    },
+    attempts: {
+      restart_count: Math.max(0, currentAttempt - 1),
+      current_retry_attempt: currentAttempt
+    },
+    running: currentRun === null ? null : {
+      session_id: currentRun.runtimeSession?.sessionId ?? null,
+      turn_count: currentRun.turnCount ?? null,
+      state: currentRun.issueState ?? null,
+      started_at: currentRun.startedAt ?? null,
+      last_event: currentRun.lastEvent ?? null,
+      last_message: latestEventMessage,
+      last_event_at: currentRun.lastEventAt ?? null,
+      tokens: currentRun.tokenUsage ? {
+        input_tokens: currentRun.tokenUsage.inputTokens,
+        output_tokens: currentRun.tokenUsage.outputTokens,
+        total_tokens: currentRun.tokenUsage.totalTokens
+      } : null
+    },
+    retry: currentRun?.nextRetryAt ?? issueRecord.retryEntry?.dueAt ? {
+      due_at: currentRun?.nextRetryAt ?? issueRecord.retryEntry?.dueAt ?? "",
+      kind: currentRun?.retryKind ?? null,
+      error: currentRun?.lastError ?? issueRecord.retryEntry?.error ?? null
+    } : null,
+    logs: {
+      codex_session_logs: currentRun === null ? [] : [
+        {
+          label: "worker",
+          path: join(reader.runDir(currentRun.runId), "worker.log"),
+          url: null
+        }
+      ]
+    },
+    recent_events: recentEvents,
+    last_error: currentRun?.lastError ?? issueRecord.retryEntry?.error ?? null,
+    tracked: {
+      issue_orchestration_state: issueRecord.state,
+      current_run_id: issueRecord.currentRunId,
+      workspace_key: issueRecord.workspaceKey,
+      completed_once: issueRecord.completedOnce,
+      run_phase: currentRun?.runPhase ?? null,
+      execution_phase: currentRun?.executionPhase ?? null
+    }
+  };
+}
+async function findLatestRunForIssue(reader, issueId, issueIdentifier) {
+  const matchingRuns = (await reader.loadAllRuns()).filter((run) => run.issueId === issueId || run.issueIdentifier === issueIdentifier).sort((left, right) => new Date(right.updatedAt).getTime() - new Date(left.updatedAt).getTime());
+  return matchingRuns[0] ?? null;
+}
+function assertValidDashboardProjectId(projectId) {
+  if (projectId.length === 0 || projectId === "." || projectId === ".." || projectId.includes("/") || projectId.includes("\\")) {
+    throw new Error(`Invalid project ID "${projectId}". Project IDs must not contain path separators or traversal segments.`);
+  }
+}
+function 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.`);
+  }
+}
+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/dist/server.js
+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" }
+  };
+}
+
+// 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
+  };
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === "--daemon" || arg === "-d") {
+      parsed.daemon = 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 === "--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;
+      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;
+    }
+  }
+  return parsed;
+}
+function logTickResult(snapshot, prevSnapshot, isFirst) {
+  if (isFirst) {
+    const healthColor = snapshot.health === "degraded" ? red : snapshot.health === "running" ? green : cyan;
+    logLine(
+      green("\u25CF"),
+      `Project ${bold(snapshot.slug)} 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 respondJson(response, status, payload) {
+  response.writeHead(status, {
+    "content-type": "application/json"
+  });
+  response.end(JSON.stringify(payload));
+}
+function formatBoundUrl(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, input.projectId);
+  for (let port = input.initialPort; port <= 65535; port += 1) {
+    const server = createServer2((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();
+            respondJson(response, 202, { ok: true });
+            return;
+          }
+          const resolved = await resolveDashboardResponse({
+            pathname: url.pathname,
+            method: request.method ?? "GET",
+            reader
+          });
+          respondJson(response, resolved.status, resolved.payload);
+        } catch (error) {
+          logHttpRequestError(error);
+          if (!response.headersSent) {
+            respondJson(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: formatBoundUrl(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 handler = async (args, options) => {
+  setNoColor(options.noColor);
+  let parsed;
+  try {
+    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 start --project-id <project-id> [--daemon] [--http [port]]\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;
+  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);
+    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"}`
+            )
+          );
+        }
+      }
+    });
+    const httpServer = 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"),
+        `HTTP dashboard listening on ${httpServer.url}`
+      );
+    }
+    logLine(dim("\xB7"), dim("Press Ctrl+C to stop"));
+    let shuttingDown = false;
+    let shutdownPromise = null;
+    const shutdown = async () => {
+      if (shuttingDown) {
+        return shutdownPromise;
+      }
+      shuttingDown = true;
+      const heldLock = projectLock;
+      projectLock = null;
+      shutdownPromise = shutdownForegroundOrchestrator({
+        configDir: options.configDir,
+        projectId,
+        httpServer: httpServer?.server,
+        projectLock: heldLock,
+        service
+      });
+      return shutdownPromise;
+    };
+    process.on("SIGINT", () => {
+      void shutdown();
+    });
+    process.on("SIGTERM", () => {
+      void shutdown();
+    });
+    try {
+      while (!shuttingDown) {
+        try {
+          await service.run();
+          break;
+        } catch (error) {
+          if (shuttingDown) {
+            break;
+          }
+          logLine(
+            red("\u2717"),
+            red(
+              `Run loop error: ${error instanceof Error ? error.message : "Unknown error"}`
+            )
+          );
+        }
+      }
+    } finally {
+      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);
+}
+async function tailWorkerLog(runtimeRoot, projectId, runId, issueIdentifier) {
+  try {
+    const logPath = join2(runtimeRoot, "projects", projectId, "runs", runId, "worker.log");
+    const content = await readFile(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)}
+`);
+    }
+  } catch {
+  }
+}
+var start_default = handler;
+async function startDaemon(options, projectId, logLevel, httpPort) {
+  const logPath = orchestratorLogPath(options.configDir, projectId);
+  await mkdir(dirname(logPath), { recursive: true });
+  const { openSync } = await import("fs");
+  const logFd = openSync(logPath, "a");
+  const child = spawn(
+    process.execPath,
+    [
+      process.argv[1],
+      "start",
+      "--project",
+      projectId,
+      ...httpPort !== void 0 ? ["--http", String(httpPort)] : [],
+      ...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(dirname(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 project stop --project-id ${projectId}
+`
+  );
+}
+
+export {
+  shutdownForegroundOrchestrator,
+  start_default
+};