@gh-symphony/cli 0.0.20 → 0.0.22

package/dist/{chunk-EKKT5USP.js → chunk-E7HYEEZD.js}

@@ -5,7 +5,10 @@ import {
   createStore,
   releaseProjectLock,
   resolveOrchestratorLogLevel
-} from "./chunk-HZVDTAPS.js";
+} from "./chunk-PUDXVBSN.js";
+import {
+  getGhToken
+} from "./chunk-C67H3OUL.js";
 import {
   deriveIssueWorkspaceKeyFromIdentifier,
   isFileMissing,
@@ -14,40 +17,41 @@ import {
   parseRecentEvents,
   readJsonFile,
   safeReadDir
-} from "./chunk-M3IFVLQS.js";
-import {
-  getGhToken
-} from "./chunk-TILHWBP6.js";
+} from "./chunk-EEQQWTXS.js";
 import {
   bold,
   cyan,
   dim,
+  formatRepositoryDisplay,
   green,
   red,
   setNoColor,
   yellow
-} from "./chunk-MVRF7BES.js";
+} from "./chunk-36KYEDEO.js";
 import {
   resolveRuntimeRoot
-} from "./chunk-5NV3LSAJ.js";
+} from "./chunk-IWFX2FMA.js";
+import {
+  rejectRemovedProjectId
+} from "./chunk-GDE6FYN4.js";
 import {
   handleMissingManagedProjectConfig,
   resolveManagedProjectConfig
-} from "./chunk-C7G7RJ4G.js";
+} from "./chunk-DDL4BWSL.js";
 import {
   daemonPidPath,
   httpStatusPath,
   orchestratorLogPath,
   writeJsonFile
-} from "./chunk-ROGRTUFI.js";
+} from "./chunk-QIRE2VXS.js";
 
 // src/commands/start.ts
-import { writeFile, mkdir, readFile, rm } from "fs/promises";
-import { dirname, join as join2 } from "path";
+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 createServer2 } from "http";
+import { createServer as createServer3 } from "http";
 
-// ../dashboard/dist/store.js
+// ../dashboard/src/store.ts
 import { open } from "fs/promises";
 import { join, resolve } from "path";
 var DEFAULT_RECENT_EVENT_LIMIT = 20;
@@ -55,24 +59,30 @@ 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) {
+  constructor(runtimeRoot) {
     this.runtimeRoot = runtimeRoot;
-    this.projectId = projectId;
-    assertValidDashboardProjectId(projectId);
     this.resolvedRuntimeRoot = resolve(runtimeRoot);
   }
+  resolvedRuntimeRoot;
   projectDir() {
-    return join(this.resolvedRuntimeRoot, "projects", this.projectId);
+    return this.resolvedRuntimeRoot;
   }
   runDir(runId) {
     assertValidDashboardRunId(runId);
-    return join(this.projectDir(), "runs", runId);
+    return join(this.resolvedRuntimeRoot, "runs", runId);
   }
   async loadProjectStatus() {
-    return readJsonFile(join(this.projectDir(), "status.json"));
+    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();
@@ -87,7 +97,9 @@ var DashboardFsReader = class {
     };
   }
   async loadProjectIssueOrchestrations() {
-    const issues = await readJsonFile(join(this.projectDir(), "issues.json"));
+    const issues = await readJsonFile(
+      join(this.projectDir(), "issues.json")
+    );
     if (issues) {
       return issues.map((issue) => ({
         ...issue,
@@ -99,7 +111,9 @@ var DashboardFsReader = class {
     return legacyLeases.map((lease) => ({
       issueId: lease.issueId,
       identifier: lease.issueIdentifier,
-      workspaceKey: deriveIssueWorkspaceKeyFromIdentifier(lease.issueIdentifier),
+      workspaceKey: deriveIssueWorkspaceKeyFromIdentifier(
+        lease.issueIdentifier
+      ),
       completedOnce: false,
       failureRetryCount: 0,
       state: lease.status === "active" ? "claimed" : "released",
@@ -109,29 +123,39 @@ var DashboardFsReader = class {
     }));
   }
   async loadRun(runId) {
-    return readJsonFile(join(this.runDir(runId), "run.json"));
+    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));
+    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)) {
+    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 null;
       }
-    });
+    );
     return runs.filter((run) => Boolean(run));
   }
   async loadRecentRunEvents(runId, limit = DEFAULT_RECENT_EVENT_LIMIT) {
@@ -148,7 +172,11 @@ var DashboardFsReader = class {
         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);
+          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);
@@ -160,9 +188,13 @@ var DashboardFsReader = class {
           bytesScanned += bytesRead;
           newlineCount += countNewlines(populatedChunk);
         }
-        return parseRecentEvents(Buffer.concat(chunks).toString("utf8"), limit, {
-          allowPartialFirstLine: position > 0
-        });
+        return parseRecentEvents(
+          Buffer.concat(chunks).toString("utf8"),
+          limit,
+          {
+            allowPartialFirstLine: position > 0
+          }
+        );
       } finally {
         await handle.close();
       }
@@ -185,12 +217,18 @@ function countNewlines(chunk) {
 }
 async function statusForIssue(reader, issueIdentifier) {
   const issueRecords = await reader.loadProjectIssueOrchestrations();
-  const issueRecord = issueRecords.find((record) => record.identifier === issueIdentifier);
+  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 : 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);
@@ -252,30 +290,39 @@ async function statusForIssue(reader, issueIdentifier) {
   };
 }
 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
-  });
+  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());
+  const sortedRuns = [...matchingRuns].sort(
+    (left, right) => new Date(right.updatedAt).getTime() - new Date(left.updatedAt).getTime()
+  );
   return sortedRuns[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.`);
+    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;
@@ -291,8 +338,10 @@ async function mapWithConcurrency(items, concurrency, mapper) {
   return results;
 }
 
-// ../dashboard/dist/server.js
-import { createServer } from "http";
+// ../dashboard/src/server.ts
+import {
+  createServer
+} from "http";
 async function resolveDashboardResponse(options) {
   const method = options.method ?? "GET";
   if (options.pathname === "/healthz") {
@@ -371,6 +420,267 @@ async function resolveDashboardResponse(options) {
   };
 }
 
+// ../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();
@@ -410,13 +720,13 @@ function parseStartArgs(args) {
       i += 1;
       continue;
     }
-    if (arg === "--project" || arg === "--project-id") {
+    if (arg === "--web") {
       const value = args[i + 1];
       if (!value || value.startsWith("-")) {
-        parsed.error = `Option '${arg}' argument missing`;
-        return parsed;
+        parsed.webPort = DEFAULT_HTTP_PORT;
+        continue;
       }
-      parsed.projectId = value;
+      parsed.webPort = parsePort(value, arg);
       i += 1;
       continue;
     }
@@ -435,6 +745,9 @@ function parseStartArgs(args) {
       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) {
@@ -442,7 +755,9 @@ function logTickResult(snapshot, prevSnapshot, 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(")")}`
+      `Repository ${bold(formatRepositoryDisplay(snapshot))} connected ${dim(
+        "("
+      )}${healthColor(snapshot.health)}${dim(")")}`
     );
     if (snapshot.summary.activeRuns > 0) {
       logLine(cyan("\u25B8"), `${snapshot.summary.activeRuns} active run(s)`);
@@ -530,13 +845,13 @@ function parsePort(value, optionName) {
   }
   return parsed;
 }
-function respondJson(response, status, payload) {
+function respondJson2(response, status, payload) {
   response.writeHead(status, {
     "content-type": "application/json"
   });
   response.end(JSON.stringify(payload));
 }
-function formatBoundUrl(server) {
+function formatBoundUrl2(server) {
   const address = server.address();
   if (!address || typeof address === "string") {
     return `http://${HTTP_HOST}`;
@@ -571,16 +886,16 @@ async function removeHttpBindingState(configDir, projectId) {
   await rm(httpStatusPath(configDir, projectId), { force: true });
 }
 async function startHttpServer(input) {
-  const reader = new DashboardFsReader(input.runtimeRoot, input.projectId);
+  const reader = new DashboardFsReader(input.runtimeRoot);
   for (let port = input.initialPort; port <= 65535; port += 1) {
-    const server = createServer2((request, response) => {
+    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();
-            respondJson(response, 202, { ok: true });
+            respondJson2(response, 202, { ok: true });
             return;
           }
           const resolved = await resolveDashboardResponse({
@@ -588,11 +903,11 @@ async function startHttpServer(input) {
             method: request.method ?? "GET",
             reader
           });
-          respondJson(response, resolved.status, resolved.payload);
+          respondJson2(response, resolved.status, resolved.payload);
         } catch (error) {
           logHttpRequestError(error);
           if (!response.headersSent) {
-            respondJson(response, 500, {
+            respondJson2(response, 500, {
               error: "Internal server error"
             });
           } else {
@@ -622,7 +937,7 @@ async function startHttpServer(input) {
       return {
         server,
         port,
-        url: formatBoundUrl(server)
+        url: formatBoundUrl2(server)
       };
     } catch (error) {
       await closeHttpServer(server).catch(() => {
@@ -641,6 +956,9 @@ var handler = async (args, options) => {
   setNoColor(options.noColor);
   let parsed;
   try {
+    if (rejectRemovedProjectId(args)) {
+      return;
+    }
     parsed = parseStartArgs(args);
   } catch (error) {
     process.stderr.write(
@@ -654,24 +972,33 @@ var handler = async (args, options) => {
     process.stderr.write(`${parsed.error}
 `);
     process.stderr.write(
-      "Usage: gh-symphony start --project-id <project-id> [--daemon] [--once] [--http [port]]\n"
+      "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.stderr.write(
+      "Options '--daemon' and '--once' cannot be used together\n"
+    );
     process.exitCode = 2;
     return;
   }
   const projectConfig = await resolveManagedProjectConfig({
     configDir: options.configDir,
-    requestedProjectId: parsed.projectId
+    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;
@@ -688,7 +1015,13 @@ var handler = async (args, options) => {
     return;
   }
   if (parsed.daemon) {
-    await startDaemon(options, projectId, parsed.logLevel, parsed.httpPort);
+    await startDaemon(
+      options,
+      projectId,
+      parsed.logLevel,
+      parsed.httpPort,
+      parsed.webPort
+    );
     return;
   }
   if (!process.env.GITHUB_GRAPHQL_TOKEN) {
@@ -739,45 +1072,10 @@ var handler = async (args, options) => {
         }
       }
     });
-    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(parsed.once ? "Running one orchestration tick" : "Press Ctrl+C to stop")
-    );
     let shuttingDown = false;
     let shutdownPromise = null;
     let keepHttpAliveResolve = null;
+    let httpServer = null;
     const shutdown = async () => {
       if (shuttingDown) {
         return shutdownPromise;
@@ -805,17 +1103,66 @@ var handler = async (args, options) => {
     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"),
-                "One-shot tick completed; HTTP dashboard remains available until Ctrl+C"
+                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"
               );
-              await new Promise((resolve2) => {
-                keepHttpAliveResolve = resolve2;
+              if (shuttingDown) {
+                break;
+              }
+              await new Promise((resolve3) => {
+                keepHttpAliveResolve = resolve3;
               });
             } else {
               await shutdown();
@@ -903,25 +1250,33 @@ async function shutdownForegroundOrchestrator(input) {
   }
   return (input.exit ?? process.exit)(0);
 }
+function hasConfiguredRepository(config) {
+  return Boolean(config.repository?.owner && config.repository.name);
+}
 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)}
+  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 {
     }
-  } catch {
   }
 }
 var start_default = handler;
-async function startDaemon(options, projectId, logLevel, httpPort) {
+async function startDaemon(options, projectId, logLevel, httpPort, webPort) {
   const logPath = orchestratorLogPath(options.configDir, projectId);
-  await mkdir(dirname(logPath), { recursive: true });
+  await mkdir(dirname2(logPath), { recursive: true });
   const { openSync } = await import("fs");
   const logFd = openSync(logPath, "a");
   const child = spawn(
@@ -929,9 +1284,8 @@ async function startDaemon(options, projectId, logLevel, httpPort) {
     [
       process.argv[1],
       "start",
-      "--project",
-      projectId,
       ...httpPort !== void 0 ? ["--http", String(httpPort)] : [],
+      ...webPort !== void 0 ? ["--web", String(webPort)] : [],
       ...logLevel ? ["--log-level", logLevel] : []
     ],
     {
@@ -945,7 +1299,7 @@ async function startDaemon(options, projectId, logLevel, httpPort) {
     }
   );
   const pidPath = daemonPidPath(options.configDir, projectId);
-  await mkdir(dirname(pidPath), { recursive: true });
+  await mkdir(dirname2(pidPath), { recursive: true });
   await writeFile(pidPath, String(child.pid), "utf8");
   child.unref();
   const { closeSync } = await import("fs");
@@ -953,7 +1307,7 @@ async function startDaemon(options, projectId, logLevel, httpPort) {
   process.stdout.write(
     `Orchestrator started in background (PID: ${child.pid}).
 Logs: ${logPath}
-Stop with: gh-symphony project stop --project-id ${projectId}
+Stop with: gh-symphony repo stop
 `
   );
 }