@gh-symphony/cli 0.0.22 → 0.1.3

package/dist/chunk-E7HYEEZD.js

@@ -1,1318 +0,0 @@
-#!/usr/bin/env node
-import {
-  OrchestratorService,
-  acquireProjectLock,
-  createStore,
-  releaseProjectLock,
-  resolveOrchestratorLogLevel
-} from "./chunk-PUDXVBSN.js";
-import {
-  getGhToken
-} from "./chunk-C67H3OUL.js";
-import {
-  deriveIssueWorkspaceKeyFromIdentifier,
-  isFileMissing,
-  isMatchingIssueRun,
-  mapIssueOrchestrationStateToStatus,
-  parseRecentEvents,
-  readJsonFile,
-  safeReadDir
-} from "./chunk-EEQQWTXS.js";
-import {
-  bold,
-  cyan,
-  dim,
-  formatRepositoryDisplay,
-  green,
-  red,
-  setNoColor,
-  yellow
-} from "./chunk-36KYEDEO.js";
-import {
-  resolveRuntimeRoot
-} from "./chunk-IWFX2FMA.js";
-import {
-  rejectRemovedProjectId
-} from "./chunk-GDE6FYN4.js";
-import {
-  handleMissingManagedProjectConfig,
-  resolveManagedProjectConfig
-} from "./chunk-DDL4BWSL.js";
-import {
-  daemonPidPath,
-  httpStatusPath,
-  orchestratorLogPath,
-  writeJsonFile
-} from "./chunk-QIRE2VXS.js";
-
-// src/commands/start.ts
-import { writeFile, mkdir, readFile as readFile2, rm } from "fs/promises";
-import { dirname as dirname2, join as join3 } from "path";
-import { spawn } from "child_process";
-import { createServer as createServer3 } from "http";
-
-// ../dashboard/src/store.ts
-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 {
-  constructor(runtimeRoot) {
-    this.runtimeRoot = runtimeRoot;
-    this.resolvedRuntimeRoot = resolve(runtimeRoot);
-  }
-  resolvedRuntimeRoot;
-  projectDir() {
-    return this.resolvedRuntimeRoot;
-  }
-  runDir(runId) {
-    assertValidDashboardRunId(runId);
-    return join(this.resolvedRuntimeRoot, "runs", runId);
-  }
-  async loadProjectStatus() {
-    const snapshot = await readJsonFile(join(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(
-      join(this.projectDir(), "issues.json")
-    );
-    if (issues) {
-      return issues.map((issue) => ({
-        ...issue,
-        completedOnce: issue.completedOnce ?? false,
-        failureRetryCount: issue.failureRetryCount ?? 0
-      }));
-    }
-    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,
-      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(
-      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 loadRunsForIssue(issueId, issueIdentifier) {
-    const runIds = await safeReadDir(join(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 = 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,
-    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: join(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, stat } from "fs/promises";
-import { dirname, extname, join as join2, resolve as resolve2, sep } from "path";
-import { fileURLToPath } from "url";
-var CLIENT_DIST_DIR = join2(
-  dirname(fileURLToPath(import.meta.url)),
-  "../client/dist"
-);
-var BUNDLED_CLIENT_DIST_DIR = join2(
-  dirname(fileURLToPath(import.meta.url)),
-  "../../control-plane/client/dist"
-);
-var WORKSPACE_CLIENT_DIST_DIR = join2(
-  process.cwd(),
-  "packages/control-plane/client/dist"
-);
-var NODE_MODULES_CLIENT_DIST_DIR = join2(
-  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 handler2 = createControlPlaneHandler({
-    reader,
-    onRefreshRequest: options.onRefreshRequest
-  });
-  for (let port = options.port; port <= 65535; port += 1) {
-    const server = createServer2((request, response) => {
-      void handler2(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 = join2(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 = resolve2(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 stat(path)).isFile();
-  } catch {
-    return false;
-  }
-}
-async function resolveClientDistDir() {
-  clientDistDirPromise ??= (async () => {
-    for (const candidate of CLIENT_DIST_DIR_CANDIDATES) {
-      try {
-        if ((await stat(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 readFile(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/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 handler = 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 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 add owner/name' 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((resolve3) => {
-                keepHttpAliveResolve = resolve3;
-              });
-            } 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 [
-    join3(runtimeRoot, "runs", runId, "worker.log"),
-    join3(runtimeRoot, "projects", projectId, "runs", runId, "worker.log")
-  ]) {
-    try {
-      const content = await readFile2(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 = handler;
-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],
-      "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
-`
-  );
-}
-
-export {
-  shutdownForegroundOrchestrator,
-  start_default
-};