@gh-symphony/cli 0.0.11 → 0.0.12

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/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.12",
   "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.12",
+    "@gh-symphony/tracker-github": "0.0.12",
+    "@gh-symphony/worker": "0.0.12",
+    "@gh-symphony/orchestrator": "0.0.12"
   },
   "scripts": {
     "build": "tsc -p tsconfig.json",