@gh-symphony/cli 0.0.1

package/dist/commands/project.js

@@ -0,0 +1,101 @@
+import * as p from "@clack/prompts";
+import { loadGlobalConfig, saveGlobalConfig, loadWorkspaceConfig, } from "../config.js";
+const handler = async (args, options) => {
+    const [subcommand] = args;
+    switch (subcommand) {
+        case "list":
+            await projectList(options);
+            break;
+        case "switch":
+            await projectSwitch(options);
+            break;
+        case "status":
+            await projectStatus(options);
+            break;
+        default:
+            process.stderr.write("Usage: gh-symphony project <list|switch|status>\n");
+            process.exitCode = 2;
+    }
+};
+export default handler;
+// ── 6.1: project list ────────────────────────────────────────────────────────
+async function projectList(options) {
+    const global = await loadGlobalConfig(options.configDir);
+    if (!global || global.workspaces.length === 0) {
+        process.stdout.write("No workspaces configured. Run 'gh-symphony init'.\n");
+        return;
+    }
+    if (options.json) {
+        const configs = [];
+        for (const wsId of global.workspaces) {
+            const ws = await loadWorkspaceConfig(options.configDir, wsId);
+            configs.push({
+                id: wsId,
+                active: wsId === global.activeWorkspace,
+                repos: ws?.repositories.length ?? 0,
+            });
+        }
+        process.stdout.write(JSON.stringify(configs, null, 2) + "\n");
+        return;
+    }
+    process.stdout.write("Workspaces:\n\n");
+    for (const wsId of global.workspaces) {
+        const ws = await loadWorkspaceConfig(options.configDir, wsId);
+        const active = wsId === global.activeWorkspace ? " (active)" : "";
+        const repos = ws?.repositories.length ?? 0;
+        process.stdout.write(`  ${wsId}${active} — ${repos} repo${repos === 1 ? "" : "s"}\n`);
+    }
+}
+// ── 6.2: project switch ──────────────────────────────────────────────────────
+async function projectSwitch(options) {
+    const global = await loadGlobalConfig(options.configDir);
+    if (!global || global.workspaces.length === 0) {
+        process.stderr.write("No workspaces configured. Run 'gh-symphony init'.\n");
+        process.exitCode = 1;
+        return;
+    }
+    if (global.workspaces.length === 1) {
+        process.stdout.write(`Only one workspace exists: ${global.workspaces[0]}\n`);
+        return;
+    }
+    const selected = await p.select({
+        message: "Select workspace to activate:",
+        options: global.workspaces.map((wsId) => ({
+            value: wsId,
+            label: wsId,
+            hint: wsId === global.activeWorkspace ? "current" : undefined,
+        })),
+    });
+    if (p.isCancel(selected)) {
+        p.cancel("Cancelled.");
+        return;
+    }
+    global.activeWorkspace = selected;
+    await saveGlobalConfig(options.configDir, global);
+    process.stdout.write(`Switched to workspace: ${selected}\n`);
+}
+// ── 6.3: project status ──────────────────────────────────────────────────────
+async function projectStatus(options) {
+    const global = await loadGlobalConfig(options.configDir);
+    if (!global?.activeWorkspace) {
+        process.stderr.write("No active workspace.\n");
+        process.exitCode = 1;
+        return;
+    }
+    const ws = await loadWorkspaceConfig(options.configDir, global.activeWorkspace);
+    if (!ws) {
+        process.stderr.write(`Workspace config missing: ${global.activeWorkspace}\n`);
+        process.exitCode = 1;
+        return;
+    }
+    if (options.json) {
+        process.stdout.write(JSON.stringify(ws, null, 2) + "\n");
+        return;
+    }
+    process.stdout.write(`Workspace:   ${ws.workspaceId}\n`);
+    process.stdout.write(`Tracker:     ${ws.tracker.adapter} (${ws.tracker.bindingId})\n`);
+    process.stdout.write(`Repositories:\n`);
+    for (const repo of ws.repositories) {
+        process.stdout.write(`  - ${repo.owner}/${repo.name}\n`);
+    }
+}

package/dist/commands/recover.d.ts

@@ -0,0 +1,3 @@
+import type { GlobalOptions } from "../index.js";
+declare const handler: (args: string[], options: GlobalOptions) => Promise<void>;
+export default handler;

package/dist/commands/recover.js

@@ -0,0 +1,117 @@
+import { readFile, readdir } from "node:fs/promises";
+import { join } from "node:path";
+import { runCli as orchestratorRunCli } from "@hojinzs/gh-symphony-orchestrator";
+import { resolveRuntimeRoot, resolveWorkspaceConfig, syncWorkspaceToRuntime, } from "../orchestrator-runtime.js";
+function parseRecoverArgs(args) {
+    const parsed = { dryRun: false };
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if (arg === "--dry-run") {
+            parsed.dryRun = true;
+        }
+        if (arg === "--workspace" || arg === "--workspace-id") {
+            parsed.workspaceId = args[i + 1];
+            i += 1;
+        }
+    }
+    return parsed;
+}
+const handler = async (args, options) => {
+    const parsed = parseRecoverArgs(args);
+    const wsConfig = await resolveWorkspaceConfig(options.configDir, parsed.workspaceId);
+    if (!wsConfig) {
+        process.stderr.write("No workspace configured. Run 'gh-symphony init' first.\n");
+        process.exitCode = 1;
+        return;
+    }
+    const runtimeRoot = resolveRuntimeRoot(options.configDir);
+    const workspaceId = wsConfig.workspaceId;
+    await syncWorkspaceToRuntime(options.configDir, wsConfig);
+    if (parsed.dryRun) {
+        process.stdout.write("Dry run — scanning for stalled runs...\n");
+        const candidates = await listRecoverCandidates(runtimeRoot, workspaceId);
+        if (options.json) {
+            process.stdout.write(JSON.stringify(candidates, null, 2) + "\n");
+            return;
+        }
+        if (candidates.length === 0) {
+            process.stdout.write("No recoverable runs found.\n");
+            return;
+        }
+        for (const candidate of candidates) {
+            process.stdout.write(`${candidate.issueIdentifier} (${candidate.runId}) — ${candidate.reason}\n`);
+        }
+        return;
+    }
+    process.stdout.write("Recovering stalled runs...\n");
+    await orchestratorRunCli([
+        "recover",
+        "--runtime-root",
+        runtimeRoot,
+        "--workspace-id",
+        workspaceId,
+    ]);
+};
+export default handler;
+async function listRecoverCandidates(runtimeRoot, workspaceId) {
+    const runsDir = join(runtimeRoot, "orchestrator", "runs");
+    const candidates = [];
+    let entries = [];
+    try {
+        entries = await readdir(runsDir);
+    }
+    catch {
+        return candidates;
+    }
+    for (const entry of entries) {
+        const runPath = join(runsDir, entry, "run.json");
+        try {
+            const raw = await readFile(runPath, "utf8");
+            const run = JSON.parse(raw);
+            if (run.workspaceId !== workspaceId) {
+                continue;
+            }
+            const reason = detectRecoveryReason(run);
+            if (!reason) {
+                continue;
+            }
+            candidates.push({
+                runId: run.runId,
+                issueIdentifier: run.issueIdentifier,
+                status: run.status,
+                reason,
+            });
+        }
+        catch {
+            // Skip malformed or partial run records.
+        }
+    }
+    return candidates;
+}
+function detectRecoveryReason(run) {
+    if (run.processId) {
+        const startedAt = run.startedAt ? new Date(run.startedAt).getTime() : 0;
+        const runningForMs = Date.now() - startedAt;
+        if (isProcessRunning(run.processId) && runningForMs > 30 * 60 * 1000) {
+            return "worker appears stuck";
+        }
+        if (!isProcessRunning(run.processId)) {
+            return "worker process is no longer running";
+        }
+    }
+    if (run.status === "retrying" &&
+        run.nextRetryAt &&
+        new Date(run.nextRetryAt).getTime() <= Date.now()) {
+        return "retry window has elapsed";
+    }
+    return null;
+}
+function isProcessRunning(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/commands/repo.d.ts

@@ -0,0 +1,3 @@
+import type { GlobalOptions } from "../index.js";
+declare const handler: (args: string[], options: GlobalOptions) => Promise<void>;
+export default handler;

package/dist/commands/repo.js

@@ -0,0 +1,103 @@
+import { loadActiveWorkspaceConfig, loadGlobalConfig, saveWorkspaceConfig, } from "../config.js";
+const handler = async (args, options) => {
+    const [subcommand, ...rest] = args;
+    switch (subcommand) {
+        case "list":
+            await repoList(options);
+            break;
+        case "add":
+            await repoAdd(rest, options);
+            break;
+        case "remove":
+            await repoRemove(rest, options);
+            break;
+        default:
+            process.stderr.write("Usage: gh-symphony repo <list|add|remove> [repo]\n");
+            process.exitCode = 2;
+    }
+};
+export default handler;
+// ── 6.4: repo list / add / remove ────────────────────────────────────────────
+async function repoList(options) {
+    const ws = await loadActiveWorkspaceConfig(options.configDir);
+    if (!ws) {
+        process.stderr.write("No workspace configured.\n");
+        process.exitCode = 1;
+        return;
+    }
+    if (options.json) {
+        process.stdout.write(JSON.stringify(ws.repositories, null, 2) + "\n");
+        return;
+    }
+    process.stdout.write("Repositories:\n");
+    for (const repo of ws.repositories) {
+        process.stdout.write(`  ${repo.owner}/${repo.name}\n`);
+    }
+}
+async function repoAdd(args, options) {
+    const [repoSpec] = args;
+    if (!repoSpec || !repoSpec.includes("/")) {
+        process.stderr.write("Usage: gh-symphony repo add <owner/name>\n");
+        process.exitCode = 2;
+        return;
+    }
+    const global = await loadGlobalConfig(options.configDir);
+    if (!global?.activeWorkspace) {
+        process.stderr.write("No active workspace.\n");
+        process.exitCode = 1;
+        return;
+    }
+    const ws = await loadActiveWorkspaceConfig(options.configDir);
+    if (!ws) {
+        process.stderr.write("Workspace config missing.\n");
+        process.exitCode = 1;
+        return;
+    }
+    const [owner, name] = repoSpec.split("/");
+    if (!owner || !name) {
+        process.stderr.write("Invalid repo format. Use: owner/name\n");
+        process.exitCode = 2;
+        return;
+    }
+    if (ws.repositories.some((r) => r.owner === owner && r.name === name)) {
+        process.stdout.write(`Repository ${repoSpec} is already configured.\n`);
+        return;
+    }
+    ws.repositories.push({
+        owner,
+        name,
+        cloneUrl: `https://github.com/${owner}/${name}.git`,
+    });
+    await saveWorkspaceConfig(options.configDir, global.activeWorkspace, ws);
+    process.stdout.write(`Added repository: ${repoSpec}\n`);
+}
+async function repoRemove(args, options) {
+    const [repoSpec] = args;
+    if (!repoSpec || !repoSpec.includes("/")) {
+        process.stderr.write("Usage: gh-symphony repo remove <owner/name>\n");
+        process.exitCode = 2;
+        return;
+    }
+    const global = await loadGlobalConfig(options.configDir);
+    if (!global?.activeWorkspace) {
+        process.stderr.write("No active workspace.\n");
+        process.exitCode = 1;
+        return;
+    }
+    const ws = await loadActiveWorkspaceConfig(options.configDir);
+    if (!ws) {
+        process.stderr.write("Workspace config missing.\n");
+        process.exitCode = 1;
+        return;
+    }
+    const [owner, name] = repoSpec.split("/");
+    const idx = ws.repositories.findIndex((r) => r.owner === owner && r.name === name);
+    if (idx === -1) {
+        process.stderr.write(`Repository ${repoSpec} is not configured.\n`);
+        process.exitCode = 1;
+        return;
+    }
+    ws.repositories.splice(idx, 1);
+    await saveWorkspaceConfig(options.configDir, global.activeWorkspace, ws);
+    process.stdout.write(`Removed repository: ${repoSpec}\n`);
+}

package/dist/commands/run.d.ts

@@ -0,0 +1,3 @@
+import type { GlobalOptions } from "../index.js";
+declare const handler: (args: string[], options: GlobalOptions) => Promise<void>;
+export default handler;

package/dist/commands/run.js

@@ -0,0 +1,69 @@
+import { runCli as orchestratorRunCli } from "@hojinzs/gh-symphony-orchestrator";
+import { resolveRuntimeRoot, resolveWorkspaceConfig, syncWorkspaceToRuntime, } from "../orchestrator-runtime.js";
+function parseRunArgs(args) {
+    const parsed = {
+        watch: false,
+    };
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if (arg === "--watch" || arg === "-w") {
+            parsed.watch = true;
+        }
+        else if (arg === "--workspace" || arg === "--workspace-id") {
+            parsed.workspaceId = args[i + 1];
+            i += 1;
+        }
+        else if (!arg?.startsWith("--")) {
+            // Positional arg = issue identifier
+            parsed.issue = arg;
+        }
+    }
+    return parsed;
+}
+const handler = async (args, options) => {
+    const parsed = parseRunArgs(args);
+    if (!parsed.issue) {
+        process.stderr.write("Usage: gh-symphony run <owner/repo#number>\n");
+        process.exitCode = 2;
+        return;
+    }
+    const wsConfig = await resolveWorkspaceConfig(options.configDir, parsed.workspaceId);
+    if (!wsConfig) {
+        process.stderr.write("No workspace configured. Run 'gh-symphony init' first.\n");
+        process.exitCode = 1;
+        return;
+    }
+    const runtimeRoot = resolveRuntimeRoot(options.configDir);
+    const workspaceId = wsConfig.workspaceId;
+    await syncWorkspaceToRuntime(options.configDir, wsConfig);
+    // Validate the issue identifier belongs to a configured repo
+    const [repoSpec] = parsed.issue.split("#");
+    if (repoSpec &&
+        !wsConfig.repositories.some((r) => `${r.owner}/${r.name}` === repoSpec)) {
+        process.stderr.write(`Repository "${repoSpec}" is not configured in this workspace.\n` +
+            `Configured repos: ${wsConfig.repositories.map((r) => `${r.owner}/${r.name}`).join(", ")}\n`);
+        process.exitCode = 1;
+        return;
+    }
+    process.stdout.write(`Dispatching issue: ${parsed.issue}\n`);
+    await orchestratorRunCli([
+        "run-issue",
+        "--runtime-root",
+        runtimeRoot,
+        "--workspace-id",
+        workspaceId,
+        "--issue",
+        parsed.issue,
+    ]);
+    if (parsed.watch) {
+        process.stdout.write("\nWatching for status changes...\n");
+        await orchestratorRunCli([
+            "status",
+            "--runtime-root",
+            runtimeRoot,
+            "--workspace-id",
+            workspaceId,
+        ]);
+    }
+};
+export default handler;

package/dist/commands/start.d.ts

@@ -0,0 +1,3 @@
+import type { GlobalOptions } from "../index.js";
+declare const handler: (args: string[], options: GlobalOptions) => Promise<void>;
+export default handler;

package/dist/commands/start.js

@@ -0,0 +1,210 @@
+import { writeFile, mkdir } from "node:fs/promises";
+import { dirname } from "node:path";
+import { spawn } from "node:child_process";
+import { daemonPidPath, orchestratorLogPath, logsDir } from "../config.js";
+import { OrchestratorService, createStore, startOrchestratorStatusServer, } from "@hojinzs/gh-symphony-orchestrator";
+import { resolveWorkspaceConfig, resolveRuntimeRoot, syncWorkspaceToRuntime, } from "../orchestrator-runtime.js";
+// ── ANSI helpers ──────────────────────────────────────────────────────────────
+const ESC = "\x1b[";
+const _bold = (s) => `${ESC}1m${s}${ESC}0m`;
+const _dim = (s) => `${ESC}2m${s}${ESC}0m`;
+const _green = (s) => `${ESC}32m${s}${ESC}0m`;
+const _red = (s) => `${ESC}31m${s}${ESC}0m`;
+const _yellow = (s) => `${ESC}33m${s}${ESC}0m`;
+const _cyan = (s) => `${ESC}36m${s}${ESC}0m`;
+let noColor = false;
+const bold = (s) => (noColor ? s : _bold(s));
+const dim = (s) => (noColor ? s : _dim(s));
+const green = (s) => (noColor ? s : _green(s));
+const red = (s) => (noColor ? s : _red(s));
+const yellow = (s) => (noColor ? s : _yellow(s));
+const cyan = (s) => (noColor ? s : _cyan(s));
+function timestamp() {
+    const now = 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}\n`);
+}
+// ── 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 === "--workspace" || arg === "--workspace-id") {
+            parsed.workspaceId = args[i + 1];
+            i += 1;
+        }
+    }
+    return parsed;
+}
+// ── Tick logging ──────────────────────────────────────────────────────────────
+function logTickResult(snapshots, prevSnapshots, isFirst) {
+    for (const snap of snapshots) {
+        const prev = prevSnapshots.find((p) => p.workspaceId === snap.workspaceId);
+        if (isFirst) {
+            const healthColor = snap.health === "degraded"
+                ? red
+                : snap.health === "running"
+                    ? green
+                    : cyan;
+            logLine(green("\u25CF"), `Workspace ${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)}`);
+        }
+        // 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("phase=")}${run.phase} ${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`);
+        }
+        // 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}`));
+        }
+    }
+}
+// ── Handler ───────────────────────────────────────────────────────────────────
+const handler = async (args, options) => {
+    noColor = options.noColor;
+    const parsed = parseStartArgs(args);
+    const wsConfig = await resolveWorkspaceConfig(options.configDir, parsed.workspaceId);
+    if (!wsConfig) {
+        process.stderr.write("No workspace configured. Run 'gh-symphony init' first.\n");
+        process.exitCode = 1;
+        return;
+    }
+    const runtimeRoot = resolveRuntimeRoot(options.configDir);
+    const workspaceId = wsConfig.workspaceId;
+    await syncWorkspaceToRuntime(options.configDir, wsConfig);
+    if (parsed.daemon) {
+        await startDaemon(options, workspaceId);
+        return;
+    }
+    // ── 5.1: Foreground mode with live logging ────────────────────────────────
+    const store = createStore(runtimeRoot);
+    const service = new OrchestratorService(store);
+    // Start status server
+    startOrchestratorStatusServer({
+        host: "127.0.0.1",
+        port: 4680,
+        getWorkspaceStatus: {
+            all: () => service.status(),
+            byWorkspaceId: async (id) => {
+                const [snapshot] = await service.status(id);
+                return snapshot ?? null;
+            },
+        },
+    });
+    logLine(green("\u25B2"), `Starting orchestrator for workspace: ${bold(workspaceId)}`);
+    logLine(dim("\u00B7"), dim("Press Ctrl+C to stop"));
+    let running = true;
+    const shutdown = () => {
+        running = false;
+        logLine(yellow("\u25BC"), "Shutting down...");
+        process.exit(0);
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+    let prevSnapshots = [];
+    let isFirst = true;
+    while (running) {
+        try {
+            const snapshots = await service.runOnce({ workspaceId });
+            logTickResult(snapshots, prevSnapshots, isFirst);
+            prevSnapshots = snapshots;
+            isFirst = false;
+        }
+        catch (error) {
+            logLine(red("\u2717"), red(`Tick error: ${error instanceof Error ? error.message : "Unknown error"}`));
+        }
+        // Poll interval: default 30s
+        await new Promise((r) => setTimeout(r, 30_000));
+    }
+};
+export default handler;
+// ── 5.2: Daemon mode ─────────────────────────────────────────────────────────
+async function startDaemon(options, workspaceId) {
+    const logPath = orchestratorLogPath(options.configDir);
+    await mkdir(logsDir(options.configDir), { recursive: true });
+    const { openSync } = await import("node:fs");
+    const logFd = openSync(logPath, "a");
+    const child = spawn(process.execPath, [process.argv[1], "start", "--workspace", workspaceId], {
+        cwd: process.cwd(),
+        env: {
+            ...process.env,
+            GH_SYMPHONY_CONFIG_DIR: options.configDir,
+        },
+        detached: true,
+        stdio: ["ignore", logFd, logFd],
+    });
+    const pidPath = daemonPidPath(options.configDir);
+    await mkdir(dirname(pidPath), { recursive: true });
+    await writeFile(pidPath, String(child.pid), "utf8");
+    child.unref();
+    const { closeSync } = await import("node:fs");
+    closeSync(logFd);
+    process.stdout.write(`Orchestrator started in background (PID: ${child.pid}).\n` +
+        `Logs: ${logPath}\n` +
+        `Stop with: gh-symphony stop\n`);
+}

package/dist/commands/status.d.ts

@@ -0,0 +1,3 @@
+import type { GlobalOptions } from "../index.js";
+declare const handler: (args: string[], options: GlobalOptions) => Promise<void>;
+export default handler;