@gh-symphony/cli 0.0.11 → 0.0.13

package/README.md

@@ -62,6 +62,38 @@ You can further customize the agent's behavior by editing `WORKFLOW.md` — this
 
 > Currently supported runtimes: **Codex**, **Claude Code**
 
+### Project `.env` Mapping
+
+If your hooks or worker runs need staging hosts, database URLs, Playwright base URLs, or other runtime-only values, store them in the project runtime directory instead of hardcoding them in `WORKFLOW.md`.
+
+1. Find the project id from `gh-symphony project list`.
+2. Create the runtime env file:
+
+```bash
+mkdir -p ~/.gh-symphony/projects/<project-id>
+cat > ~/.gh-symphony/projects/<project-id>/.env <<'EOF'
+STAGING_API_HOST=https://staging.example.com
+DATABASE_URL=postgres://user:pass@staging-db:5432/app
+PLAYWRIGHT_BASE_URL=http://localhost:3000
+EOF
+```
+
+3. Reference those variables from `WORKFLOW.md` hooks or repository setup scripts:
+
+```yaml
+hooks:
+  after_create: 'echo "API_HOST=$STAGING_API_HOST" >> .env.development'
+  before_run: 'echo "BASE_URL=$PLAYWRIGHT_BASE_URL" > playwright.env'
+```
+
+Env precedence during hook execution and worker spawn is:
+
+- `project .env` as the base
+- system env as the override layer
+- Symphony context vars such as `SYMPHONY_*` as the highest-priority layer
+
+If you use `--config <dir>`, replace `~/.gh-symphony` with that directory.
+
 ## 3. Set Orchestrator Runner (Project)
 
 On the machine where you want the orchestrator to run, register a project:

package/dist/commands/logs.js

@@ -1,4 +1,4 @@
-import { readFile, readdir } from "node:fs/promises";
+import { readFile, readdir, stat } from "node:fs/promises";
 import { join, resolve } from "node:path";
 import { createReadStream } from "node:fs";
 import { createInterface } from "node:readline";
@@ -32,9 +32,17 @@ function parseLogsArgs(args) {
 }
 const handler = async (args, options) => {
     const parsed = parseLogsArgs(args);
+    const runtimeRoot = resolve(options.configDir);
     // If --run is specified, read that run's events
     if (parsed.run) {
-        const eventsPath = join(resolve(options.configDir), "orchestrator", "runs", parsed.run, "events.ndjson");
+        const eventsPath = parsed.projectId
+            ? join(runtimeRoot, "projects", parsed.projectId, "runs", parsed.run, "events.ndjson")
+            : await resolveRunEventsPath(runtimeRoot, parsed.run);
+        if (!eventsPath) {
+            process.stderr.write(`No events found for run: ${parsed.run}\n`);
+            process.exitCode = 1;
+            return;
+        }
         try {
             const content = await readFile(eventsPath, "utf8");
             const lines = content.trim().split("\n").filter(Boolean);
@@ -96,31 +104,43 @@ const handler = async (args, options) => {
         return;
     }
     // Scan all run events
-    const runsDir = join(resolve(options.configDir), "orchestrator", "runs");
+    const runRoots = parsed.projectId
+        ? [join(runtimeRoot, "projects", parsed.projectId, "runs")]
+        : await listProjectRunRoots(runtimeRoot);
+    let foundRuns = false;
     try {
-        const entries = await readdir(runsDir);
-        for (const entry of entries) {
-            const eventsPath = join(runsDir, entry, "events.ndjson");
-            try {
-                const content = await readFile(eventsPath, "utf8");
-                const lines = content.trim().split("\n").filter(Boolean);
-                for (const line of lines) {
-                    const event = JSON.parse(line);
-                    if (parsed.projectId && event.projectId !== parsed.projectId)
-                        continue;
-                    if (parsed.level && event.level !== parsed.level)
-                        continue;
-                    if (parsed.issue && event.issueIdentifier !== parsed.issue)
-                        continue;
-                    process.stdout.write(formatEvent(event) + "\n");
-                }
+        for (const runsDir of runRoots) {
+            const entries = await safeReadDir(runsDir);
+            if (entries.length === 0) {
+                continue;
             }
-            catch {
-                // Skip runs without events
+            foundRuns = true;
+            for (const entry of entries) {
+                const eventsPath = join(runsDir, entry, "events.ndjson");
+                try {
+                    const content = await readFile(eventsPath, "utf8");
+                    const lines = content.trim().split("\n").filter(Boolean);
+                    for (const line of lines) {
+                        const event = JSON.parse(line);
+                        if (parsed.projectId && event.projectId !== parsed.projectId)
+                            continue;
+                        if (parsed.level && event.level !== parsed.level)
+                            continue;
+                        if (parsed.issue && event.issueIdentifier !== parsed.issue)
+                            continue;
+                        process.stdout.write(formatEvent(event) + "\n");
+                    }
+                }
+                catch {
+                    // Skip runs without events
+                }
             }
         }
     }
     catch {
+        // fall through to friendly error below
+    }
+    if (!foundRuns) {
         process.stderr.write("No runs found. Start the orchestrator first.\n");
     }
 };
@@ -132,3 +152,33 @@ function formatEvent(event) {
     const extra = event.error ? ` error=${event.error}` : "";
     return `[${at}] ${eventType} ${issue}${extra}`;
 }
+async function listProjectRunRoots(runtimeRoot) {
+    try {
+        const projectIds = await readdir(join(runtimeRoot, "projects"));
+        return projectIds.map((projectId) => join(runtimeRoot, "projects", projectId, "runs"));
+    }
+    catch {
+        return [];
+    }
+}
+async function resolveRunEventsPath(runtimeRoot, runId) {
+    for (const runsDir of await listProjectRunRoots(runtimeRoot)) {
+        const eventsPath = join(runsDir, runId, "events.ndjson");
+        try {
+            await stat(eventsPath);
+            return eventsPath;
+        }
+        catch {
+            // Continue searching.
+        }
+    }
+    return null;
+}
+async function safeReadDir(path) {
+    try {
+        return await readdir(path);
+    }
+    catch {
+        return [];
+    }
+}

package/dist/commands/project.js

@@ -174,7 +174,7 @@ function isProcessRunning(pid) {
 async function readPersistedSnapshot(configDir, projectId) {
     try {
         const runtimeRoot = resolveRuntimeRoot(configDir);
-        const content = await readFile(join(runtimeRoot, "orchestrator", "projects", projectId, "status.json"), "utf8");
+        const content = await readFile(join(runtimeRoot, "projects", projectId, "status.json"), "utf8");
         return JSON.parse(content);
     }
     catch {

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, syncProjectToRuntime, } from "../orchestrator-runtime.js";
+import { resolveRuntimeRoot, } from "../orchestrator-runtime.js";
 import { handleMissingManagedProjectConfig, resolveManagedProjectConfig, } from "../project-selection.js";
 function parseRecoverArgs(args) {
     const parsed = { dryRun: false };
@@ -29,7 +29,6 @@ const handler = async (args, options) => {
     }
     const runtimeRoot = resolveRuntimeRoot(options.configDir);
     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, projectId);
@@ -57,7 +56,7 @@ const handler = async (args, options) => {
 };
 export default handler;
 async function listRecoverCandidates(runtimeRoot, projectId) {
-    const runsDir = join(runtimeRoot, "orchestrator", "runs");
+    const runsDir = join(runtimeRoot, "projects", projectId, "runs");
     const candidates = [];
     let entries = [];
     try {

package/dist/commands/run.js

@@ -1,5 +1,5 @@
 import { runCli as orchestratorRunCli } from "@gh-symphony/orchestrator";
-import { resolveRuntimeRoot, syncProjectToRuntime, } from "../orchestrator-runtime.js";
+import { resolveRuntimeRoot, } from "../orchestrator-runtime.js";
 import { handleMissingManagedProjectConfig, resolveManagedProjectConfig, } from "../project-selection.js";
 function parseRunArgs(args) {
     const parsed = {
@@ -11,18 +11,41 @@ function parseRunArgs(args) {
             parsed.watch = true;
         }
         else if (arg === "--project" || arg === "--project-id") {
-            parsed.projectId = args[i + 1];
+            const value = args[i + 1];
+            if (!value || value.startsWith("-")) {
+                parsed.error = `Option '${arg}' argument missing`;
+                return parsed;
+            }
+            parsed.projectId = value;
             i += 1;
         }
-        else if (!arg?.startsWith("--")) {
+        else 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;
+        }
+        else if (!arg?.startsWith("-")) {
             // Positional arg = issue identifier
             parsed.issue = arg;
         }
+        else {
+            parsed.error = `Unknown option '${arg}'`;
+            return parsed;
+        }
     }
     return parsed;
 }
 const handler = async (args, options) => {
     const parsed = parseRunArgs(args);
+    if (parsed.error) {
+        process.stderr.write(`${parsed.error}\n`);
+        process.exitCode = 2;
+        return;
+    }
     if (!parsed.issue) {
         process.stderr.write("Usage: gh-symphony run <owner/repo#number>\n");
         process.exitCode = 2;
@@ -38,7 +61,6 @@ const handler = async (args, options) => {
     }
     const runtimeRoot = resolveRuntimeRoot(options.configDir);
     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 &&
@@ -57,6 +79,7 @@ const handler = async (args, options) => {
         projectId,
         "--issue",
         parsed.issue,
+        ...(parsed.logLevel ? ["--log-level", parsed.logLevel] : []),
     ]);
     if (parsed.watch) {
         process.stdout.write("\nWatching for status changes...\n");

package/dist/commands/start.d.ts

@@ -1,13 +1,19 @@
 import { rm } from "node:fs/promises";
 import type { GlobalOptions } from "../index.js";
+import { releaseProjectLock, type ProjectLockHandle } from "@gh-symphony/orchestrator";
 type ForegroundShutdownOptions = {
     configDir: string;
     projectId: string;
     statusServer: {
         close(): void;
     };
+    projectLock?: ProjectLockHandle | null;
+    service?: {
+        shutdown(): Promise<void>;
+    };
     exit?: (code?: number) => never;
     removePortFile?: typeof rm;
+    releaseLock?: typeof releaseProjectLock;
 };
 declare const handler: (args: string[], options: GlobalOptions) => Promise<void>;
 export declare function shutdownForegroundOrchestrator(input: ForegroundShutdownOptions): Promise<never>;

package/dist/commands/start.js

@@ -3,8 +3,8 @@ import { dirname, join } from "node:path";
 import { spawn } from "node:child_process";
 import { once } from "node:events";
 import { daemonPidPath, orchestratorLogPath, orchestratorPortPath, } from "../config.js";
-import { OrchestratorService, createStore, startOrchestratorStatusServer, } from "@gh-symphony/orchestrator";
-import { resolveRuntimeRoot, syncProjectToRuntime, } from "../orchestrator-runtime.js";
+import { OrchestratorService, acquireProjectLock, createStore, releaseProjectLock, resolveOrchestratorLogLevel, startOrchestratorStatusServer, } from "@gh-symphony/orchestrator";
+import { resolveRuntimeRoot, } from "../orchestrator-runtime.js";
 import { handleMissingManagedProjectConfig, resolveManagedProjectConfig, } from "../project-selection.js";
 import { bold, dim, green, red, yellow, cyan, setNoColor } from "../ansi.js";
 import { getGhToken } from "../github/gh-auth.js";
@@ -39,6 +39,16 @@ function parseStartArgs(args) {
             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;
@@ -133,9 +143,17 @@ const handler = async (args, options) => {
     }
     const runtimeRoot = resolveRuntimeRoot(options.configDir);
     const projectId = projectConfig.projectId;
-    await syncProjectToRuntime(options.configDir, projectConfig);
+    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"}\n`);
+        process.exitCode = 2;
+        return;
+    }
     if (parsed.daemon) {
-        await startDaemon(options, projectId);
+        await startDaemon(options, projectId, parsed.logLevel);
         return;
     }
     // ── 5.1: Foreground mode with live logging ────────────────────────────────
@@ -148,65 +166,99 @@ const handler = async (args, options) => {
             // Workers will fail if token is needed but not available
         }
     }
-    const store = createStore(runtimeRoot);
-    const service = new OrchestratorService(store, projectConfig);
-    const statusServer = startOrchestratorStatusServer({
-        host: "127.0.0.1",
-        port: 0,
-        getProjectStatus: () => service.status(),
-        onRefresh: async () => {
-            await service.runOnce();
-        },
-    });
-    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;
-    let shuttingDown = false;
-    const shutdown = async () => {
-        if (shuttingDown) {
-            return;
-        }
-        shuttingDown = true;
-        running = false;
-        await shutdownForegroundOrchestrator({
-            configDir: options.configDir,
+    let projectLock = null;
+    try {
+        projectLock = await acquireProjectLock({
+            runtimeRoot,
             projectId,
-            statusServer,
         });
-    };
-    process.on("SIGINT", () => {
-        void shutdown();
-    });
-    process.on("SIGTERM", () => {
-        void shutdown();
-    });
-    let prevSnapshot = null;
-    let isFirst = true;
-    while (running) {
-        try {
-            const snapshot = await service.runOnce();
-            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, prevRun.runId, prevRun.issueIdentifier);
+        const store = createStore(runtimeRoot);
+        const service = new OrchestratorService(store, projectConfig, {
+            logLevel,
+        });
+        const statusServer = startOrchestratorStatusServer({
+            host: "127.0.0.1",
+            port: 0,
+            getProjectStatus: () => service.status(),
+            onRefresh: async () => {
+                await service.runOnce();
+            },
+        });
+        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;
+        let shuttingDown = false;
+        let shutdownPromise = null;
+        const shutdown = async () => {
+            if (shuttingDown) {
+                return shutdownPromise;
+            }
+            shuttingDown = true;
+            running = false;
+            const heldLock = projectLock;
+            projectLock = null;
+            shutdownPromise = shutdownForegroundOrchestrator({
+                configDir: options.configDir,
+                projectId,
+                statusServer,
+                projectLock: heldLock,
+                service,
+            });
+            return shutdownPromise;
+        };
+        process.on("SIGINT", () => {
+            void shutdown();
+        });
+        process.on("SIGTERM", () => {
+            void shutdown();
+        });
+        let prevSnapshot = null;
+        let isFirst = true;
+        while (running) {
+            try {
+                const snapshot = await service.runOnce();
+                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;
             }
-            prevSnapshot = snapshot;
-            isFirst = false;
-        }
-        catch (error) {
-            logLine(red("\u2717"), red(`Tick error: ${error instanceof Error ? error.message : "Unknown error"}`));
+            catch (error) {
+                logLine(red("\u2717"), red(`Tick error: ${error instanceof Error ? error.message : "Unknown error"}`));
+            }
+            if (!running) {
+                if (shutdownPromise) {
+                    await shutdownPromise;
+                }
+                break;
+            }
+            // Poll interval: default 30s
+            await new Promise((r) => setTimeout(r, 30_000));
         }
-        // Poll interval: default 30s
-        await new Promise((r) => setTimeout(r, 30_000));
+    }
+    finally {
+        await releaseProjectLock(projectLock);
     }
 };
 export async function shutdownForegroundOrchestrator(input) {
     logLine(yellow("\u25BC"), "Shutting down...");
+    // Drain active workers before tearing down infrastructure so that child
+    // processes receive SIGTERM/SIGKILL and do not become orphans.
+    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 {
         input.statusServer.close();
     }
@@ -221,11 +273,17 @@ export async function shutdownForegroundOrchestrator(input) {
     catch (error) {
         logLine(yellow("\u26A0"), `Failed to remove persisted status port: ${error instanceof Error ? error.message : "Unknown error"}`);
     }
+    try {
+        await (input.releaseLock ?? releaseProjectLock)(input.projectLock);
+    }
+    catch (error) {
+        logLine(yellow("\u26A0"), `Failed to release project lock: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
     return (input.exit ?? process.exit)(0);
 }
-async function tailWorkerLog(runtimeRoot, runId, issueIdentifier) {
+async function tailWorkerLog(runtimeRoot, projectId, runId, issueIdentifier) {
     try {
-        const logPath = join(runtimeRoot, "orchestrator", "runs", runId, "worker.log");
+        const logPath = join(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)
@@ -242,12 +300,18 @@ async function tailWorkerLog(runtimeRoot, runId, issueIdentifier) {
 }
 export default handler;
 // ── 5.2: Daemon mode ─────────────────────────────────────────────────────────
-async function startDaemon(options, projectId) {
+async function startDaemon(options, projectId, logLevel) {
     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", "--project", projectId], {
+    const child = spawn(process.execPath, [
+        process.argv[1],
+        "start",
+        "--project",
+        projectId,
+        ...(logLevel ? ["--log-level", logLevel] : []),
+    ], {
         cwd: process.cwd(),
         env: {
             ...process.env,

package/dist/commands/status.js

@@ -1,6 +1,6 @@
 import { readFile } from "node:fs/promises";
 import { join } from "node:path";
-import { resolveRuntimeRoot, syncProjectToRuntime, } from "../orchestrator-runtime.js";
+import { resolveRuntimeRoot, } from "../orchestrator-runtime.js";
 import { handleMissingManagedProjectConfig, resolveManagedProjectConfig, } from "../project-selection.js";
 import { bold, dim, green, red, yellow, cyan, stripAnsi } from "../ansi.js";
 import { clearScreen, showCursor, hideCursor } from "../ansi.js";
@@ -137,7 +137,7 @@ function parseStatusArgs(args) {
 }
 async function readStatusSnapshot(runtimeRoot, projectId) {
     try {
-        const statusPath = join(runtimeRoot, "orchestrator", "projects", projectId, "status.json");
+        const statusPath = join(runtimeRoot, "projects", projectId, "status.json");
         const content = await readFile(statusPath, "utf-8");
         return JSON.parse(content);
     }
@@ -163,7 +163,6 @@ const handler = async (args, options) => {
     }
     const runtimeRoot = resolveRuntimeRoot(options.configDir);
     const projectId = projectConfig.projectId;
-    await syncProjectToRuntime(options.configDir, projectConfig);
     if (parsed.watch) {
         const isTTY = process.stdout.isTTY === true;
         let terminalWidth = process.stdout.columns ?? 115;

package/dist/config.d.ts

@@ -8,9 +8,10 @@ export type CliGlobalConfig = {
     activeProject: string | null;
     projects: string[];
 };
-export type CliProjectTrackerSettings = Record<string, string | boolean> & {
+export type CliProjectTrackerSettings = Record<string, string | number | boolean> & {
     projectId?: string;
     assignedOnly?: boolean;
+    timeoutMs?: number;
 };
 export type CliProjectConfig = Omit<OrchestratorProjectConfig, "tracker"> & {
     displayName?: string;

package/dist/index.js

@@ -103,6 +103,7 @@ function createProgram() {
         .command("start")
         .description("Start the orchestrator")
         .option("-d, --daemon", "Start in daemon mode")
+        .option("--log-level <level>", "Orchestrator lifecycle log level")
         .option("--project-id <projectId>", "Project identifier")
         .addOption(new Option("--project <projectId>").hideHelp())
         .allowExcessArguments(false)).action(async function () {
@@ -111,6 +112,7 @@ function createProgram() {
         const args = [];
         pushOption(args, "--project-id", resolveProjectId(values));
         pushOption(args, "--daemon", values.daemon);
+        pushOption(args, "--log-level", values.logLevel);
         await invokeHandler("start", args, values);
     });
     addGlobalOptions(program
@@ -145,6 +147,7 @@ function createProgram() {
         .command("run")
         .description("Dispatch a single issue")
         .argument("<issue>", "Issue identifier")
+        .option("--log-level <level>", "Orchestrator lifecycle log level")
         .option("-w, --watch", "Watch status after dispatch")
         .option("--project-id <projectId>", "Project identifier")
         .addOption(new Option("--project <projectId>").hideHelp())
@@ -153,6 +156,7 @@ function createProgram() {
         const values = this.optsWithGlobals();
         const args = [issue];
         pushOption(args, "--project-id", resolveProjectId(values));
+        pushOption(args, "--log-level", values.logLevel);
         pushOption(args, "--watch", values.watch);
         await invokeHandler("run", args, values);
     });
@@ -229,6 +233,7 @@ function createProgram() {
         .command("start")
         .description("Start a specific project")
         .option("-d, --daemon", "Start in daemon mode")
+        .option("--log-level <level>", "Orchestrator lifecycle log level")
         .option("--project-id <projectId>", "Project identifier")
         .addOption(new Option("--project <projectId>").hideHelp())
         .allowExcessArguments(false)).action(async function () {
@@ -237,6 +242,7 @@ function createProgram() {
         const args = ["start"];
         pushOption(args, "--project-id", resolveProjectId(values));
         pushOption(args, "--daemon", values.daemon);
+        pushOption(args, "--log-level", values.logLevel);
         await invokeHandler("project", args, values);
     });
     addGlobalOptions(project

package/dist/orchestrator-runtime.d.ts

@@ -1,5 +1 @@
-import { type CliProjectConfig } from "./config.js";
 export declare function resolveRuntimeRoot(configDir: string): string;
-export declare function resolveProjectConfig(configDir: string, requestedProjectId?: string): Promise<CliProjectConfig | null>;
-export declare function orchestratorProjectConfigPath(runtimeRoot: string, projectId: string): string;
-export declare function syncProjectToRuntime(configDir: string, projectConfig: CliProjectConfig): Promise<string>;

package/dist/orchestrator-runtime.js

@@ -1,26 +1,4 @@
-import { mkdir, writeFile } from "node:fs/promises";
-import { dirname, join, resolve } from "node:path";
-import { loadGlobalConfig, loadProjectConfig, } from "./config.js";
+import { resolve } from "node:path";
 export function resolveRuntimeRoot(configDir) {
     return resolve(configDir);
 }
-export async function resolveProjectConfig(configDir, requestedProjectId) {
-    if (requestedProjectId) {
-        return loadProjectConfig(configDir, requestedProjectId);
-    }
-    const global = await loadGlobalConfig(configDir);
-    if (!global?.activeProject) {
-        return null;
-    }
-    return loadProjectConfig(configDir, global.activeProject);
-}
-export function orchestratorProjectConfigPath(runtimeRoot, projectId) {
-    return join(runtimeRoot, "orchestrator", "projects", projectId, "config.json");
-}
-export async function syncProjectToRuntime(configDir, projectConfig) {
-    const runtimeRoot = resolveRuntimeRoot(configDir);
-    const configPath = orchestratorProjectConfigPath(runtimeRoot, projectConfig.projectId);
-    await mkdir(dirname(configPath), { recursive: true });
-    await writeFile(configPath, JSON.stringify(projectConfig, null, 2) + "\n");
-    return runtimeRoot;
-}

package/dist/skills/templates/gh-symphony.js

@@ -83,7 +83,7 @@ export function generateGhSymphonySkill(ctx) {
     lines.push("agent:");
     lines.push("  max_concurrent_agents: 10");
     lines.push("  max_retry_backoff_ms: 30000");
-    lines.push("  retry_base_delay_ms: 1000");
+    lines.push("  retry_base_delay_ms: 10000");
     lines.push("  max_turns: 20");
     lines.push("codex:");
     lines.push("  command: codex app-server");

package/dist/workflow/generate-reference-workflow.js

@@ -63,7 +63,7 @@ export function generateReferenceWorkflow(input) {
     lines.push("agent:");
     lines.push("  max_concurrent_agents: 10");
     lines.push("  max_retry_backoff_ms: 30000");
-    lines.push("  retry_base_delay_ms: 1000");
+    lines.push("  retry_base_delay_ms: 10000");
     lines.push("  max_turns: 20");
     lines.push("");
     lines.push("codex:");

package/dist/workflow/generate-workflow-md.js

@@ -37,7 +37,7 @@ function buildFrontMatter(input) {
     lines.push("agent:");
     lines.push("  max_concurrent_agents: 10");
     lines.push("  max_retry_backoff_ms: 30000");
-    lines.push("  retry_base_delay_ms: 1000");
+    lines.push("  retry_base_delay_ms: 10000");
     lines.push("codex:");
     lines.push(`  command: ${agentCommand}`);
     lines.push("  read_timeout_ms: 5000");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gh-symphony/cli",
-  "version": "0.0.11",
+  "version": "0.0.13",
   "license": "MIT",
   "author": "hojinzs",
   "description": "Interactive CLI for GitHub Symphony orchestration",
@@ -37,10 +37,10 @@
   "dependencies": {
     "@clack/prompts": "^0.9.1",
     "commander": "^14.0.1",
-    "@gh-symphony/orchestrator": "0.0.11",
-    "@gh-symphony/core": "0.0.11",
-    "@gh-symphony/tracker-github": "0.0.11",
-    "@gh-symphony/worker": "0.0.11"
+    "@gh-symphony/core": "0.0.13",
+    "@gh-symphony/orchestrator": "0.0.13",
+    "@gh-symphony/tracker-github": "0.0.13",
+    "@gh-symphony/worker": "0.0.13"
   },
   "scripts": {
     "build": "tsc -p tsconfig.json",

package/dist/commands/parse-cli-args.d.ts

@@ -1,6 +0,0 @@
-import { parseArgs, type ParseArgsOptionsConfig } from "node:util";
-type ParseCliArgsResult = ReturnType<typeof parseArgs> | {
-    error: string;
-};
-export declare function parseCliArgs(args: string[], options: ParseArgsOptionsConfig): ParseCliArgsResult;
-export {};

package/dist/commands/parse-cli-args.js

@@ -1,20 +0,0 @@
-import { parseArgs } from "node:util";
-export function parseCliArgs(args, options) {
-    try {
-        return parseArgs({
-            args,
-            options,
-            allowPositionals: false,
-            strict: true,
-        });
-    }
-    catch (error) {
-        return { error: formatParseArgsError(error) };
-    }
-}
-function formatParseArgsError(error) {
-    if (error instanceof Error) {
-        return error.message;
-    }
-    return "Invalid arguments";
-}

package/dist/commands/tenant.d.ts

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

package/dist/commands/tenant.js

@@ -1,348 +0,0 @@
-import * as p from "@clack/prompts";
-import { createClient, validateToken, checkRequiredScopes, listUserProjects, getProjectDetail, GitHubScopeError, } from "../github/client.js";
-import { ensureGhAuth, getGhToken, GhAuthError } from "../github/gh-auth.js";
-import { loadGlobalConfig, saveGlobalConfig, loadTenantConfig, tenantConfigDir, } from "../config.js";
-import { writeConfig, generateTenantId, abortIfCancelled } from "./init.js";
-// ── Scope error display ───────────────────────────────────────────────────────
-const KNOWN_REQUIRED_SCOPES = ["repo", "read:org", "project"];
-function displayScopeError(error, retryCommand) {
-    const plural = error.requiredScopes.length === 1 ? "" : "s";
-    p.log.error(`Token is missing required scope${plural}: ${error.requiredScopes.join(", ")}`);
-    const currentSet = new Set(error.currentScopes.map((s) => s.toLowerCase()));
-    const scopesToAdd = KNOWN_REQUIRED_SCOPES.filter((s) => !currentSet.has(s));
-    const scopeArg = scopesToAdd.length > 0
-        ? scopesToAdd.join(",")
-        : error.requiredScopes.join(",");
-    p.note(`gh auth refresh --scopes ${scopeArg}\n\nThen re-run: ${retryCommand}`, "Fix missing scope");
-}
-function parseTenantAddFlags(args) {
-    const flags = { nonInteractive: false, assignedOnly: false };
-    for (let i = 0; i < args.length; i += 1) {
-        const arg = args[i];
-        const next = args[i + 1];
-        switch (arg) {
-            case "--non-interactive":
-                flags.nonInteractive = true;
-                break;
-            case "--project":
-                flags.project = next;
-                i += 1;
-                break;
-            case "--workspace-dir":
-                flags.workspaceDir = next;
-                i += 1;
-                break;
-            case "--assigned-only":
-                flags.assignedOnly = true;
-                break;
-        }
-    }
-    return flags;
-}
-// ── Tenant command handler ────────────────────────────────────────────────────
-const handler = async (args, options) => {
-    const [subcommand, ...rest] = args;
-    switch (subcommand) {
-        case "add":
-            await tenantAdd(rest, options);
-            return;
-        case "list":
-            await tenantList(options);
-            return;
-        case "remove":
-            await tenantRemove(rest, options);
-            return;
-        default:
-            process.stdout.write("Usage: gh-symphony tenant <add|list|remove>\n");
-    }
-};
-export default handler;
-// ── tenant add ───────────────────────────────────────────────────────────────
-async function tenantAdd(args, options) {
-    const flags = parseTenantAddFlags(args);
-    if (flags.nonInteractive) {
-        await tenantAddNonInteractive(flags, options);
-        return;
-    }
-    await tenantAddInteractive(options);
-}
-// ── Non-interactive tenant add ───────────────────────────────────────────────
-async function tenantAddNonInteractive(flags, options) {
-    let token;
-    try {
-        token = getGhToken();
-    }
-    catch {
-        process.stderr.write("Error: GitHub token not found. Run 'gh auth login --scopes repo,read:org,project' or set GITHUB_GRAPHQL_TOKEN.\n");
-        process.exitCode = 1;
-        return;
-    }
-    const client = createClient(token);
-    // Validate token
-    let viewer;
-    try {
-        viewer = await validateToken(client);
-    }
-    catch {
-        process.stderr.write("Error: Invalid GitHub token.\n");
-        process.exitCode = 1;
-        return;
-    }
-    const scopeCheck = checkRequiredScopes(viewer.scopes);
-    if (!scopeCheck.valid) {
-        process.stderr.write(`Error: Missing required PAT scopes: ${scopeCheck.missing.join(", ")}\n`);
-        process.exitCode = 1;
-        return;
-    }
-    // Find project
-    const projects = await listUserProjects(client);
-    let project;
-    if (flags.project) {
-        const match = projects.find((p) => p.id === flags.project || p.url === flags.project);
-        if (!match) {
-            process.stderr.write(`Error: Project not found: ${flags.project}\n`);
-            process.exitCode = 1;
-            return;
-        }
-        project = await getProjectDetail(client, match.id);
-    }
-    else if (projects.length === 1) {
-        project = await getProjectDetail(client, projects[0].id);
-    }
-    else {
-        process.stderr.write("Error: --project is required when multiple projects exist.\n");
-        process.exitCode = 1;
-        return;
-    }
-    const tenantId = generateTenantId(project.title, project.id);
-    const workspaceDir = flags.workspaceDir ?? `${options.configDir}/workspaces`;
-    await writeConfig(options.configDir, {
-        tenantId,
-        project,
-        repos: project.linkedRepositories,
-        workspaceDir,
-        assignedOnly: flags.assignedOnly,
-    });
-    if (options.json) {
-        process.stdout.write(JSON.stringify({ tenantId, status: "created" }) + "\n");
-    }
-    else {
-        process.stdout.write(`Tenant created: ${tenantId}\n`);
-        process.stdout.write(`Run 'gh-symphony start' to begin orchestration.\n`);
-    }
-}
-// ── Interactive tenant add ───────────────────────────────────────────────────
-async function tenantAddInteractive(options) {
-    p.intro("gh-symphony — Tenant Setup");
-    // Detect existing config
-    const existingConfig = await loadGlobalConfig(options.configDir);
-    if (existingConfig) {
-        const action = await abortIfCancelled(p.select({
-            message: "Existing configuration detected. What would you like to do?",
-            options: [
-                { value: "add", label: "Add a new tenant" },
-                { value: "overwrite", label: "Start fresh (overwrite)" },
-            ],
-        }));
-        if (action === "overwrite") {
-            // Continue with fresh setup — will overwrite config
-        }
-        // "add" continues to create a new tenant alongside existing ones
-    }
-    // ── Step 1: gh CLI authentication ─────────────────────────────────────────────
-    const s1 = p.spinner();
-    s1.start("Checking gh CLI authentication...");
-    let login;
-    let client;
-    try {
-        const { login: ghLogin, token } = ensureGhAuth();
-        login = ghLogin;
-        client = createClient(token);
-        s1.stop(`Authenticated as ${login}`);
-    }
-    catch (error) {
-        s1.stop("Authentication failed.");
-        if (error instanceof GhAuthError) {
-            if (error.code === "not_installed") {
-                p.log.error("gh CLI가 설치되어 있지 않습니다. https://cli.github.com 에서 설치하세요.");
-            }
-            else if (error.code === "not_authenticated") {
-                p.log.error("gh auth login --scopes repo,read:org,project 를 실행하세요.");
-            }
-            else if (error.code === "missing_scopes") {
-                p.log.error("gh auth refresh --scopes repo,read:org,project 를 실행하세요.");
-            }
-            else {
-                p.log.error(error.message);
-            }
-        }
-        else {
-            p.log.error(error instanceof Error ? error.message : "Unknown error");
-        }
-        process.exitCode = 1;
-        return;
-    }
-    // ── Step 2: Project selection ───────────────────────────────────────────────
-    const s2 = p.spinner();
-    s2.start("Loading projects...");
-    let projects;
-    try {
-        projects = await listUserProjects(client);
-        s2.stop(`Found ${projects.length} project${projects.length === 1 ? "" : "s"}`);
-    }
-    catch (error) {
-        s2.stop("Failed to load projects.");
-        if (error instanceof GitHubScopeError) {
-            displayScopeError(error, "gh-symphony tenant add");
-        }
-        else {
-            p.log.error(error instanceof Error ? error.message : "Unknown error");
-        }
-        process.exitCode = 1;
-        return;
-    }
-    if (projects.length === 0) {
-        p.log.error("No GitHub Projects found. Create a project at https://github.com/orgs/YOUR_ORG/projects and re-run.");
-        process.exitCode = 1;
-        return;
-    }
-    const selectedProjectId = await abortIfCancelled(p.select({
-        message: "Step 1/4 — Select a GitHub Project:",
-        options: projects.map((proj) => ({
-            value: proj.id,
-            label: `${proj.owner.login}/${proj.title}`,
-            hint: `${proj.openItemCount} items`,
-        })),
-        maxItems: 15,
-    }));
-    const s2d = p.spinner();
-    s2d.start("Loading project details...");
-    let projectDetail;
-    try {
-        projectDetail = await getProjectDetail(client, selectedProjectId);
-        s2d.stop(`Loaded: ${projectDetail.title}`);
-    }
-    catch (error) {
-        s2d.stop("Failed to load project details.");
-        p.log.error(error instanceof Error ? error.message : "Unknown error");
-        process.exitCode = 1;
-        return;
-    }
-    // ── Step 2: Repository selection ────────────────────────────────────────────
-    if (projectDetail.linkedRepositories.length === 0) {
-        p.log.warn("No linked repositories found in this project. Add issues from repositories to the project first.");
-        process.exitCode = 1;
-        return;
-    }
-    const selectedRepos = await abortIfCancelled(p.multiselect({
-        message: "Step 2/4 — Select repositories to orchestrate:",
-        options: projectDetail.linkedRepositories.map((repo) => ({
-            value: repo,
-            label: `${repo.owner}/${repo.name}`,
-        })),
-        required: true,
-    }));
-    // ── Step 3: Assignment filter ────────────────────────────────────────────────
-    const assignedOnly = await abortIfCancelled(p.confirm({
-        message: "Step 3/4 — Only process issues assigned to the authenticated GitHub user?",
-        initialValue: false,
-    }));
-    const workspaceDir = await abortIfCancelled(p.text({
-        message: "Step 4/4 — Workspace root directory:",
-        placeholder: `${options.configDir}/workspaces`,
-        defaultValue: `${options.configDir}/workspaces`,
-        validate(value) {
-            return value.trim().length > 0
-                ? undefined
-                : "Workspace directory is required.";
-        },
-    }));
-    // ── Confirmation ─────────────────────────────────────────────────────────────
-    p.note([
-        `User:       ${login}`,
-        `Project:    ${projectDetail.title}`,
-        `Repos:      ${selectedRepos.map((r) => `${r.owner}/${r.name}`).join(", ")}`,
-        `Assigned:   ${assignedOnly ? `Only issues assigned to ${login}` : "All project issues"}`,
-        `Workspace:  ${workspaceDir}`,
-    ].join("\n"), "Configuration Summary");
-    const confirmed = await abortIfCancelled(p.confirm({ message: "Apply this configuration?" }));
-    if (!confirmed) {
-        p.cancel("Setup cancelled.");
-        process.exitCode = 130;
-        return;
-    }
-    // ── Write config files ────────────────────────────────────────────────────────
-    const tenantId = generateTenantId(projectDetail.title, projectDetail.id);
-    const s6 = p.spinner();
-    s6.start("Writing configuration...");
-    try {
-        await writeConfig(options.configDir, {
-            tenantId,
-            project: projectDetail,
-            repos: selectedRepos,
-            workspaceDir,
-            assignedOnly,
-        });
-        s6.stop("Configuration saved.");
-    }
-    catch (error) {
-        s6.stop("Failed to write configuration.");
-        p.log.error(error instanceof Error ? error.message : "Unknown error");
-        process.exitCode = 1;
-        return;
-    }
-    p.outro(`Tenant "${tenantId}" created!\n  Run 'gh-symphony start' to begin orchestration.`);
-}
-// ── tenant list ───────────────────────────────────────────────────────────────
-async function tenantList(options) {
-    const global = await loadGlobalConfig(options.configDir);
-    if (!global?.tenants?.length) {
-        process.stdout.write("No tenants configured.\n");
-        return;
-    }
-    process.stdout.write("Configured tenants:\n");
-    const configs = await Promise.all(global.tenants.map((id) => loadTenantConfig(options.configDir, id)));
-    for (let i = 0; i < global.tenants.length; i++) {
-        const tenantId = global.tenants[i];
-        const config = configs[i];
-        const active = global.activeTenant === tenantId ? " (active)" : "";
-        const slug = config?.slug ?? tenantId;
-        process.stdout.write(`  ${slug}${active}\n`);
-    }
-}
-// ── tenant remove ─────────────────────────────────────────────────────────────
-async function tenantRemove(args, options) {
-    const tenantId = args[0];
-    if (!tenantId) {
-        process.stderr.write("Usage: gh-symphony tenant remove <tenant-id>\n");
-        process.exitCode = 1;
-        return;
-    }
-    const global = await loadGlobalConfig(options.configDir);
-    if (!global) {
-        process.stderr.write("No configuration found.\n");
-        process.exitCode = 1;
-        return;
-    }
-    const updatedTenants = (global.tenants ?? []).filter((t) => t !== tenantId);
-    if (updatedTenants.length === global.tenants.length) {
-        process.stderr.write(`Tenant "${tenantId}" not found.\n`);
-        process.exitCode = 1;
-        return;
-    }
-    const updatedConfig = {
-        ...global,
-        tenants: updatedTenants,
-        activeTenant: global.activeTenant === tenantId ? null : global.activeTenant,
-    };
-    await saveGlobalConfig(options.configDir, updatedConfig);
-    const { rm } = await import("node:fs/promises");
-    const dir = tenantConfigDir(options.configDir, tenantId);
-    try {
-        await rm(dir, { recursive: true, force: true });
-    }
-    catch {
-        // Directory may not exist
-    }
-    process.stdout.write(`Tenant "${tenantId}" removed.\n`);
-}