@gh-symphony/cli 0.0.6 → 0.0.7

package/dist/commands/recover.js

@@ -1,7 +1,7 @@
 import { readFile, readdir } from "node:fs/promises";
 import { join } from "node:path";
 import { runCli as orchestratorRunCli } from "@gh-symphony/orchestrator";
-import { resolveRuntimeRoot, resolveTenantConfig, syncTenantToRuntime, } from "../orchestrator-runtime.js";
+import { resolveRuntimeRoot, resolveProjectConfig, syncProjectToRuntime, } from "../orchestrator-runtime.js";
 function parseRecoverArgs(args) {
     const parsed = { dryRun: false };
     for (let i = 0; i < args.length; i += 1) {
@@ -9,8 +9,8 @@ function parseRecoverArgs(args) {
         if (arg === "--dry-run") {
             parsed.dryRun = true;
         }
-        if (arg === "--tenant" || arg === "--tenant-id") {
-            parsed.tenantId = args[i + 1];
+        if (arg === "--project" || arg === "--project-id") {
+            parsed.projectId = args[i + 1];
             i += 1;
         }
     }
@@ -18,18 +18,18 @@ function parseRecoverArgs(args) {
 }
 const handler = async (args, options) => {
     const parsed = parseRecoverArgs(args);
-    const tenantConfig = await resolveTenantConfig(options.configDir, parsed.tenantId);
-    if (!tenantConfig) {
-        process.stderr.write("No tenant configured. Run 'gh-symphony init' first.\n");
+    const projectConfig = await resolveProjectConfig(options.configDir, parsed.projectId);
+    if (!projectConfig) {
+        process.stderr.write("No project configured. Run 'gh-symphony project add' first.\n");
         process.exitCode = 1;
         return;
     }
     const runtimeRoot = resolveRuntimeRoot(options.configDir);
-    const tenantId = tenantConfig.tenantId;
-    await syncTenantToRuntime(options.configDir, tenantConfig);
+    const projectId = projectConfig.projectId;
+    await syncProjectToRuntime(options.configDir, projectConfig);
     if (parsed.dryRun) {
         process.stdout.write("Dry run — scanning for stalled runs...\n");
-        const candidates = await listRecoverCandidates(runtimeRoot, tenantId);
+        const candidates = await listRecoverCandidates(runtimeRoot, projectId);
         if (options.json) {
             process.stdout.write(JSON.stringify(candidates, null, 2) + "\n");
             return;
@@ -48,12 +48,12 @@ const handler = async (args, options) => {
         "recover",
         "--runtime-root",
         runtimeRoot,
-        "--tenant-id",
-        tenantId,
+        "--project-id",
+        projectId,
     ]);
 };
 export default handler;
-async function listRecoverCandidates(runtimeRoot, tenantId) {
+async function listRecoverCandidates(runtimeRoot, projectId) {
     const runsDir = join(runtimeRoot, "orchestrator", "runs");
     const candidates = [];
     let entries = [];
@@ -68,7 +68,7 @@ async function listRecoverCandidates(runtimeRoot, tenantId) {
         try {
             const raw = await readFile(runPath, "utf8");
             const run = JSON.parse(raw);
-            if (run.tenantId !== tenantId) {
+            if (run.projectId !== projectId) {
                 continue;
             }
             const reason = detectRecoveryReason(run);

package/dist/commands/repo.js

@@ -1,4 +1,4 @@
-import { loadActiveTenantConfig, loadGlobalConfig, saveTenantConfig, } from "../config.js";
+import { loadActiveProjectConfig, loadGlobalConfig, saveProjectConfig, } from "../config.js";
 const handler = async (args, options) => {
     const [subcommand, ...rest] = args;
     switch (subcommand) {
@@ -19,9 +19,9 @@ const handler = async (args, options) => {
 export default handler;
 // ── 6.4: repo list / add / remove ────────────────────────────────────────────
 async function repoList(options) {
-    const ws = await loadActiveTenantConfig(options.configDir);
+    const ws = await loadActiveProjectConfig(options.configDir);
     if (!ws) {
-        process.stderr.write("No tenant configured.\n");
+        process.stderr.write("No project configured.\n");
         process.exitCode = 1;
         return;
     }
@@ -42,14 +42,14 @@ async function repoAdd(args, options) {
         return;
     }
     const global = await loadGlobalConfig(options.configDir);
-    if (!global?.activeTenant) {
-        process.stderr.write("No active tenant.\n");
+    if (!global?.activeProject) {
+        process.stderr.write("No active project.\n");
         process.exitCode = 1;
         return;
     }
-    const ws = await loadActiveTenantConfig(options.configDir);
+    const ws = await loadActiveProjectConfig(options.configDir);
     if (!ws) {
-        process.stderr.write("Tenant config missing.\n");
+        process.stderr.write("Project config missing.\n");
         process.exitCode = 1;
         return;
     }
@@ -68,7 +68,7 @@ async function repoAdd(args, options) {
         name,
         cloneUrl: `https://github.com/${owner}/${name}.git`,
     });
-    await saveTenantConfig(options.configDir, global.activeTenant, ws);
+    await saveProjectConfig(options.configDir, global.activeProject, ws);
     process.stdout.write(`Added repository: ${repoSpec}\n`);
 }
 async function repoRemove(args, options) {
@@ -79,14 +79,14 @@ async function repoRemove(args, options) {
         return;
     }
     const global = await loadGlobalConfig(options.configDir);
-    if (!global?.activeTenant) {
-        process.stderr.write("No active tenant.\n");
+    if (!global?.activeProject) {
+        process.stderr.write("No active project.\n");
         process.exitCode = 1;
         return;
     }
-    const ws = await loadActiveTenantConfig(options.configDir);
+    const ws = await loadActiveProjectConfig(options.configDir);
     if (!ws) {
-        process.stderr.write("Tenant config missing.\n");
+        process.stderr.write("Project config missing.\n");
         process.exitCode = 1;
         return;
     }
@@ -98,6 +98,6 @@ async function repoRemove(args, options) {
         return;
     }
     ws.repositories.splice(idx, 1);
-    await saveTenantConfig(options.configDir, global.activeTenant, ws);
+    await saveProjectConfig(options.configDir, global.activeProject, ws);
     process.stdout.write(`Removed repository: ${repoSpec}\n`);
 }

package/dist/commands/run.js

@@ -1,5 +1,5 @@
 import { runCli as orchestratorRunCli } from "@gh-symphony/orchestrator";
-import { resolveRuntimeRoot, resolveTenantConfig, syncTenantToRuntime, } from "../orchestrator-runtime.js";
+import { resolveRuntimeRoot, resolveProjectConfig, syncProjectToRuntime, } from "../orchestrator-runtime.js";
 function parseRunArgs(args) {
     const parsed = {
         watch: false,
@@ -9,8 +9,8 @@ function parseRunArgs(args) {
         if (arg === "--watch" || arg === "-w") {
             parsed.watch = true;
         }
-        else if (arg === "--tenant" || arg === "--tenant-id") {
-            parsed.tenantId = args[i + 1];
+        else if (arg === "--project" || arg === "--project-id") {
+            parsed.projectId = args[i + 1];
             i += 1;
         }
         else if (!arg?.startsWith("--")) {
@@ -27,21 +27,21 @@ const handler = async (args, options) => {
         process.exitCode = 2;
         return;
     }
-    const tenantConfig = await resolveTenantConfig(options.configDir, parsed.tenantId);
-    if (!tenantConfig) {
-        process.stderr.write("No tenant configured. Run 'gh-symphony init' first.\n");
+    const projectConfig = await resolveProjectConfig(options.configDir, parsed.projectId);
+    if (!projectConfig) {
+        process.stderr.write("No project configured. Run 'gh-symphony project add' first.\n");
         process.exitCode = 1;
         return;
     }
     const runtimeRoot = resolveRuntimeRoot(options.configDir);
-    const tenantId = tenantConfig.tenantId;
-    await syncTenantToRuntime(options.configDir, tenantConfig);
+    const projectId = projectConfig.projectId;
+    await syncProjectToRuntime(options.configDir, projectConfig);
     // Validate the issue identifier belongs to a configured repo
     const [repoSpec] = parsed.issue.split("#");
     if (repoSpec &&
-        !tenantConfig.repositories.some((r) => `${r.owner}/${r.name}` === repoSpec)) {
-        process.stderr.write(`Repository "${repoSpec}" is not configured in this tenant.\n` +
-            `Configured repos: ${tenantConfig.repositories.map((r) => `${r.owner}/${r.name}`).join(", ")}\n`);
+        !projectConfig.repositories.some((r) => `${r.owner}/${r.name}` === repoSpec)) {
+        process.stderr.write(`Repository "${repoSpec}" is not configured in this project.\n` +
+            `Configured repos: ${projectConfig.repositories.map((r) => `${r.owner}/${r.name}`).join(", ")}\n`);
         process.exitCode = 1;
         return;
     }
@@ -50,8 +50,8 @@ const handler = async (args, options) => {
         "run-issue",
         "--runtime-root",
         runtimeRoot,
-        "--tenant-id",
-        tenantId,
+        "--project-id",
+        projectId,
         "--issue",
         parsed.issue,
     ]);
@@ -61,8 +61,8 @@ const handler = async (args, options) => {
             "status",
             "--runtime-root",
             runtimeRoot,
-            "--tenant-id",
-            tenantId,
+            "--project-id",
+            projectId,
         ]);
     }
 };

package/dist/commands/start.d.ts

@@ -1,3 +1,14 @@
+import { rm } from "node:fs/promises";
 import type { GlobalOptions } from "../index.js";
+type ForegroundShutdownOptions = {
+    configDir: string;
+    projectId: string;
+    statusServer: {
+        close(): void;
+    };
+    exit?: (code?: number) => never;
+    removePortFile?: typeof rm;
+};
 declare const handler: (args: string[], options: GlobalOptions) => Promise<void>;
+export declare function shutdownForegroundOrchestrator(input: ForegroundShutdownOptions): Promise<never>;
 export default handler;

package/dist/commands/start.js

@@ -1,9 +1,11 @@
-import { writeFile, mkdir, readFile } from "node:fs/promises";
+import { writeFile, mkdir, readFile, rm } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { spawn } from "node:child_process";
-import { daemonPidPath, orchestratorLogPath, logsDir } from "../config.js";
+import { once } from "node:events";
+import { parseCliArgs } from "./parse-cli-args.js";
+import { daemonPidPath, orchestratorLogPath, orchestratorPortPath, } from "../config.js";
 import { OrchestratorService, createStore, startOrchestratorStatusServer, } from "@gh-symphony/orchestrator";
-import { resolveTenantConfig, resolveRuntimeRoot, syncTenantToRuntime, } from "../orchestrator-runtime.js";
+import { resolveProjectConfig, resolveRuntimeRoot, syncProjectToRuntime, } from "../orchestrator-runtime.js";
 import { bold, dim, green, red, yellow, cyan, setNoColor } from "../ansi.js";
 import { getGhToken } from "../github/gh-auth.js";
 function timestamp() {
@@ -18,114 +20,112 @@ function logLine(icon, msg) {
 }
 // ── Arg parsing ───────────────────────────────────────────────────────────────
 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;
-        }
-        if (arg === "--tenant" || arg === "--tenant-id") {
-            parsed.tenantId = args[i + 1];
-            i += 1;
-        }
+    const parsed = parseCliArgs(args, {
+        daemon: { type: "boolean", short: "d" },
+        project: { type: "string" },
+        "project-id": { type: "string" },
+    });
+    if ("error" in parsed) {
+        return { daemon: false, error: parsed.error };
     }
-    return parsed;
+    return {
+        daemon: Boolean(parsed.values.daemon),
+        projectId: (parsed.values["project-id"] ?? parsed.values.project),
+    };
 }
 // ── Tick logging ──────────────────────────────────────────────────────────────
-function logTickResult(snapshots, prevSnapshots, isFirst) {
-    for (const snap of snapshots) {
-        const prev = prevSnapshots.find((p) => p.tenantId === snap.tenantId);
-        if (isFirst) {
-            const healthColor = snap.health === "degraded"
-                ? red
-                : snap.health === "running"
-                    ? green
-                    : cyan;
-            logLine(green("\u25CF"), `Tenant ${bold(snap.slug)} connected ${dim("(")}${healthColor(snap.health)}${dim(")")}`);
-            if (snap.summary.activeRuns > 0) {
-                logLine(cyan("\u25B8"), `${snap.summary.activeRuns} active run(s)`);
-            }
-            continue;
-        }
-        // Health changes
-        if (prev && prev.health !== snap.health) {
-            const icon = snap.health === "degraded" ? red("\u25CF") : green("\u25CF");
-            logLine(icon, `Health changed: ${prev.health} \u2192 ${bold(snap.health)}`);
+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)`);
         }
-        // New error
-        if (snap.lastError && snap.lastError !== prev?.lastError) {
-            logLine(red("\u2717"), red(snap.lastError));
-        }
-        // Error cleared
-        if (!snap.lastError && prev?.lastError) {
-            logLine(green("\u2713"), green("Error cleared"));
-        }
-        // Dispatched delta
-        const prevDispatched = prev?.summary.dispatched ?? 0;
-        if (snap.summary.dispatched > prevDispatched) {
-            const delta = snap.summary.dispatched - prevDispatched;
-            logLine(yellow("\u25B8"), `Dispatched ${bold(String(delta))} new run(s)`);
-        }
-        // Active run changes
-        const prevRunIds = new Set(prev?.activeRuns.map((r) => r.runId) ?? []);
-        for (const run of snap.activeRuns) {
-            if (!prevRunIds.has(run.runId)) {
-                logLine(cyan("\u25B8"), `Run started: ${bold(run.issueIdentifier)} ${dim("state=")}${run.issueState} ${dim("status=")}${run.status}`);
-            }
-        }
-        // Completed runs (were active, now gone)
-        const currentRunIds = new Set(snap.activeRuns.map((r) => r.runId));
-        for (const prevRun of prev?.activeRuns ?? []) {
-            if (!currentRunIds.has(prevRun.runId)) {
-                logLine(green("\u2713"), `Run finished: ${bold(prevRun.issueIdentifier)} ${dim("(")}${prevRun.status}${dim(")")}`);
-            }
-        }
-        // Suppressed delta
-        const prevSuppressed = prev?.summary.suppressed ?? 0;
-        if (snap.summary.suppressed > prevSuppressed) {
-            const delta = snap.summary.suppressed - prevSuppressed;
-            logLine(dim("\u25CB"), dim(`${delta} issue(s) suppressed (already running or at limit)`));
-        }
-        // Recovered delta
-        const prevRecovered = prev?.summary.recovered ?? 0;
-        if (snap.summary.recovered > prevRecovered) {
-            const delta = snap.summary.recovered - prevRecovered;
-            logLine(yellow("\u21BA"), `Recovered ${bold(String(delta))} stalled run(s)`);
-        }
-        // Retry queue changes
-        const prevRetryCount = prev?.retryQueue.length ?? 0;
-        if (snap.retryQueue.length > prevRetryCount) {
-            const delta = snap.retryQueue.length - prevRetryCount;
-            logLine(yellow("\u25CC"), `${delta} run(s) queued for retry`);
+        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}`);
         }
-        // Quiet tick — no changes
-        const changed = snap.health !== prev?.health ||
-            snap.lastError !== prev?.lastError ||
-            snap.summary.dispatched !== prev?.summary.dispatched ||
-            snap.summary.suppressed !== prev?.summary.suppressed ||
-            snap.summary.recovered !== prev?.summary.recovered ||
-            snap.activeRuns.length !== (prev?.activeRuns.length ?? 0) ||
-            snap.retryQueue.length !== (prev?.retryQueue.length ?? 0);
-        if (!changed) {
-            logLine(dim("\u00B7"), dim(`tick \u2014 ${snap.summary.activeRuns} active, ${snap.health}`));
+    }
+    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("\u00B7"), dim(`tick \u2014 ${snapshot.summary.activeRuns} active, ${snapshot.health}`));
+    }
 }
 // ── Handler ───────────────────────────────────────────────────────────────────
 const handler = async (args, options) => {
     setNoColor(options.noColor);
     const parsed = parseStartArgs(args);
-    const tenantConfig = await resolveTenantConfig(options.configDir, parsed.tenantId);
-    if (!tenantConfig) {
-        process.stderr.write("No tenant configured. Run 'gh-symphony init' first.\n");
+    if (parsed.error) {
+        process.stderr.write(`${parsed.error}\n`);
+        process.stderr.write("Usage: gh-symphony start --project-id <project-id> [--daemon]\n");
+        process.exitCode = 2;
+        return;
+    }
+    if (!parsed.projectId) {
+        process.stderr.write("Usage: gh-symphony start --project-id <project-id> [--daemon]\n");
+        process.exitCode = 2;
+        return;
+    }
+    const projectConfig = await resolveProjectConfig(options.configDir, parsed.projectId);
+    if (!projectConfig) {
+        process.stderr.write("No project configured. Run 'gh-symphony project add' first.\n");
         process.exitCode = 1;
         return;
     }
     const runtimeRoot = resolveRuntimeRoot(options.configDir);
-    const tenantId = tenantConfig.tenantId;
-    await syncTenantToRuntime(options.configDir, tenantConfig);
+    const projectId = projectConfig.projectId;
+    await syncProjectToRuntime(options.configDir, projectConfig);
     if (parsed.daemon) {
-        await startDaemon(options, tenantId);
+        await startDaemon(options, projectId);
         return;
     }
     // ── 5.1: Foreground mode with live logging ────────────────────────────────
@@ -139,50 +139,53 @@ const handler = async (args, options) => {
         }
     }
     const store = createStore(runtimeRoot);
-    const service = new OrchestratorService(store);
-    // Start status server
-    startOrchestratorStatusServer({
+    const service = new OrchestratorService(store, projectConfig);
+    const statusServer = startOrchestratorStatusServer({
         host: "127.0.0.1",
-        port: 4680,
-        getTenantStatus: {
-            all: () => service.status(),
-            byTenantId: async (id) => {
-                const [snapshot] = await service.status(id);
-                return snapshot ?? null;
-            },
-        },
+        port: 0,
+        getProjectStatus: () => service.status(),
         onRefresh: async () => {
-            await service.runOnce({ tenantId });
+            await service.runOnce();
         },
     });
-    logLine(green("\u25B2"), `Starting orchestrator for tenant: ${bold(tenantId)}`);
+    await persistStatusServerPort(options.configDir, projectId, statusServer);
+    logLine(green("\u25B2"), `Starting orchestrator for project: ${bold(projectId)}`);
     logLine(dim("\u00B7"), dim("Press Ctrl+C to stop"));
     let running = true;
-    const shutdown = () => {
+    let shuttingDown = false;
+    const shutdown = async () => {
+        if (shuttingDown) {
+            return;
+        }
+        shuttingDown = true;
         running = false;
-        logLine(yellow("\u25BC"), "Shutting down...");
-        process.exit(0);
+        await shutdownForegroundOrchestrator({
+            configDir: options.configDir,
+            projectId,
+            statusServer,
+        });
     };
-    process.on("SIGINT", shutdown);
-    process.on("SIGTERM", shutdown);
-    let prevSnapshots = [];
+    process.on("SIGINT", () => {
+        void shutdown();
+    });
+    process.on("SIGTERM", () => {
+        void shutdown();
+    });
+    let prevSnapshot = null;
     let isFirst = true;
     while (running) {
         try {
-            const snapshots = await service.runOnce({ tenantId });
-            logTickResult(snapshots, prevSnapshots, isFirst);
+            const snapshot = await service.runOnce();
+            logTickResult(snapshot, prevSnapshot, isFirst);
             if (!isFirst) {
-                for (const snap of snapshots) {
-                    const prev = prevSnapshots.find((p) => p.tenantId === snap.tenantId);
-                    const currentRunIds = new Set(snap.activeRuns.map((r) => r.runId));
-                    for (const prevRun of prev?.activeRuns ?? []) {
-                        if (!currentRunIds.has(prevRun.runId)) {
-                            await tailWorkerLog(runtimeRoot, prevRun.runId, prevRun.issueIdentifier);
-                        }
+                const currentRunIds = new Set(snapshot.activeRuns.map((run) => run.runId));
+                for (const prevRun of prevSnapshot?.activeRuns ?? []) {
+                    if (!currentRunIds.has(prevRun.runId)) {
+                        await tailWorkerLog(runtimeRoot, prevRun.runId, prevRun.issueIdentifier);
                     }
                 }
             }
-            prevSnapshots = snapshots;
+            prevSnapshot = snapshot;
             isFirst = false;
         }
         catch (error) {
@@ -192,6 +195,24 @@ const handler = async (args, options) => {
         await new Promise((r) => setTimeout(r, 30_000));
     }
 };
+export async function shutdownForegroundOrchestrator(input) {
+    logLine(yellow("\u25BC"), "Shutting down...");
+    try {
+        input.statusServer.close();
+    }
+    catch (error) {
+        logLine(red("\u2717"), red(`Failed to close status server: ${error instanceof Error ? error.message : "Unknown error"}`));
+    }
+    try {
+        await (input.removePortFile ?? rm)(orchestratorPortPath(input.configDir, input.projectId), {
+            force: true,
+        });
+    }
+    catch (error) {
+        logLine(yellow("\u26A0"), `Failed to remove persisted status port: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+    return (input.exit ?? process.exit)(0);
+}
 async function tailWorkerLog(runtimeRoot, runId, issueIdentifier) {
     try {
         const logPath = join(runtimeRoot, "orchestrator", "runs", runId, "worker.log");
@@ -211,12 +232,12 @@ async function tailWorkerLog(runtimeRoot, runId, issueIdentifier) {
 }
 export default handler;
 // ── 5.2: Daemon mode ─────────────────────────────────────────────────────────
-async function startDaemon(options, tenantId) {
-    const logPath = orchestratorLogPath(options.configDir);
-    await mkdir(logsDir(options.configDir), { recursive: true });
+async function startDaemon(options, projectId) {
+    const logPath = orchestratorLogPath(options.configDir, projectId);
+    await mkdir(dirname(logPath), { recursive: true });
     const { openSync } = await import("node:fs");
     const logFd = openSync(logPath, "a");
-    const child = spawn(process.execPath, [process.argv[1], "start", "--tenant", tenantId], {
+    const child = spawn(process.execPath, [process.argv[1], "start", "--project", projectId], {
         cwd: process.cwd(),
         env: {
             ...process.env,
@@ -225,7 +246,7 @@ async function startDaemon(options, tenantId) {
         detached: true,
         stdio: ["ignore", logFd, logFd],
     });
-    const pidPath = daemonPidPath(options.configDir);
+    const pidPath = daemonPidPath(options.configDir, projectId);
     await mkdir(dirname(pidPath), { recursive: true });
     await writeFile(pidPath, String(child.pid), "utf8");
     child.unref();
@@ -233,5 +254,17 @@ async function startDaemon(options, tenantId) {
     closeSync(logFd);
     process.stdout.write(`Orchestrator started in background (PID: ${child.pid}).\n` +
         `Logs: ${logPath}\n` +
-        `Stop with: gh-symphony stop\n`);
+        `Stop with: gh-symphony project stop --project-id ${projectId}\n`);
+}
+async function persistStatusServerPort(configDir, projectId, statusServer) {
+    if (!statusServer.listening) {
+        await once(statusServer, "listening");
+    }
+    const address = statusServer.address();
+    if (!address || typeof address !== "object") {
+        return;
+    }
+    const portPath = orchestratorPortPath(configDir, projectId);
+    await mkdir(dirname(portPath), { recursive: true });
+    await writeFile(portPath, `${address.port}\n`, "utf8");
 }

package/dist/commands/status-refresh.d.ts

@@ -2,6 +2,7 @@ type RefreshRequestOptions = {
     fetchImpl?: typeof fetch;
     timeoutMs?: number;
     env?: NodeJS.ProcessEnv;
+    baseUrl?: string | null;
 };
 export declare function resolveOrchestratorStatusBaseUrl(env?: NodeJS.ProcessEnv): string;
 export declare function requestOrchestratorRefresh(options?: RefreshRequestOptions): Promise<boolean>;

package/dist/commands/status-refresh.js

@@ -8,8 +8,14 @@ export async function requestOrchestratorRefresh(options = {}) {
     const fetchImpl = options.fetchImpl ?? fetch;
     const timeoutMs = options.timeoutMs ?? 5_000;
     const signal = AbortSignal.timeout(timeoutMs);
+    const baseUrl = "baseUrl" in options
+        ? options.baseUrl
+        : resolveOrchestratorStatusBaseUrl(options.env);
+    if (!baseUrl) {
+        return false;
+    }
     try {
-        const response = await fetchImpl(`${resolveOrchestratorStatusBaseUrl(options.env)}/api/v1/refresh`, {
+        const response = await fetchImpl(`${baseUrl}/api/v1/refresh`, {
             method: "POST",
             signal,
         });