@gh-symphony/cli 0.0.21 → 0.0.22

package/dist/{run-XJQ6BF7U.js → run-IHN3ZL35.js}

@@ -1,18 +1,18 @@
 #!/usr/bin/env node
 import {
   runCli
-} from "./chunk-MYVJ6HK4.js";
-import "./chunk-A67CMOYE.js";
-import "./chunk-SXGT7LOF.js";
-import "./chunk-QEONJ5DZ.js";
+} from "./chunk-PUDXVBSN.js";
+import "./chunk-2UW7NQLX.js";
+import "./chunk-2TSM3INR.js";
+import "./chunk-EEQQWTXS.js";
 import {
   resolveRuntimeRoot
-} from "./chunk-5NV3LSAJ.js";
+} from "./chunk-IWFX2FMA.js";
 import {
   handleMissingManagedProjectConfig,
   resolveManagedProjectConfig
-} from "./chunk-C7G7RJ4G.js";
-import "./chunk-ROGRTUFI.js";
+} from "./chunk-DDL4BWSL.js";
+import "./chunk-QIRE2VXS.js";
 
 // src/commands/run.ts
 function parseRunArgs(args) {
@@ -72,10 +72,22 @@ var handler = async (args, options) => {
   const runtimeRoot = resolveRuntimeRoot(options.configDir);
   const projectId = projectConfig.projectId;
   const [repoSpec] = parsed.issue.split("#");
-  if (repoSpec && !projectConfig.repositories.some((r) => `${r.owner}/${r.name}` === repoSpec)) {
+  const configuredRepos = [
+    ...projectConfig.repository ? [projectConfig.repository] : [],
+    ...projectConfig.repositories ?? []
+  ].filter((repository) => repository.owner && repository.name).map((repository) => `${repository.owner}/${repository.name}`);
+  const configuredRepoSet = new Set(configuredRepos);
+  if (configuredRepoSet.size === 0) {
+    process.stderr.write(
+      "No repository is configured in this project. Run 'gh-symphony repo add owner/name' first.\n"
+    );
+    process.exitCode = 1;
+    return;
+  }
+  if (repoSpec && !configuredRepoSet.has(repoSpec)) {
     process.stderr.write(
       `Repository "${repoSpec}" is not configured in this project.
-Configured repos: ${projectConfig.repositories.map((r) => `${r.owner}/${r.name}`).join(", ")}
+Configured repo: ${configuredRepos.join(", ")}
 `
     );
     process.exitCode = 1;

package/dist/{setup-B2SVLW2R.js → setup-TZJSM3QV.js}

@@ -2,7 +2,7 @@
 import {
   promptProjectRegistrationOptions,
   renderProjectRegistrationSummary
-} from "./chunk-S6VIK4FF.js";
+} from "./chunk-ZHOKYUO3.js";
 import {
   abortIfCancelled,
   buildAutomaticStateMappings,
@@ -16,11 +16,11 @@ import {
   writeConfig,
   writeEcosystem,
   writeWorkflowPlan
-} from "./chunk-JN3TQVFV.js";
-import "./chunk-KY6WKH66.js";
-import "./chunk-MYVJ6HK4.js";
-import "./chunk-A67CMOYE.js";
-import "./chunk-SXGT7LOF.js";
+} from "./chunk-HMLBBZNY.js";
+import "./chunk-E7HYEEZD.js";
+import "./chunk-PUDXVBSN.js";
+import "./chunk-2UW7NQLX.js";
+import "./chunk-2TSM3INR.js";
 import {
   GhAuthError,
   GitHubScopeError,
@@ -32,13 +32,14 @@ import {
   listUserProjects,
   validateToken
 } from "./chunk-C67H3OUL.js";
-import "./chunk-QEONJ5DZ.js";
-import "./chunk-XN5ABWZ6.js";
-import "./chunk-MVRF7BES.js";
-import "./chunk-5NV3LSAJ.js";
-import "./chunk-Y6TYJMNT.js";
-import "./chunk-C7G7RJ4G.js";
-import "./chunk-ROGRTUFI.js";
+import "./chunk-EEQQWTXS.js";
+import "./chunk-DFLXHNYQ.js";
+import "./chunk-36KYEDEO.js";
+import "./chunk-IWFX2FMA.js";
+import "./chunk-GSX2FV3M.js";
+import "./chunk-GDE6FYN4.js";
+import "./chunk-DDL4BWSL.js";
+import "./chunk-QIRE2VXS.js";
 
 // src/commands/setup.ts
 import * as p from "@clack/prompts";

package/dist/start-RTAHQMR2.js

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+import {
+  shutdownForegroundOrchestrator,
+  start_default
+} from "./chunk-E7HYEEZD.js";
+import "./chunk-PUDXVBSN.js";
+import "./chunk-2UW7NQLX.js";
+import "./chunk-2TSM3INR.js";
+import "./chunk-C67H3OUL.js";
+import "./chunk-EEQQWTXS.js";
+import "./chunk-36KYEDEO.js";
+import "./chunk-IWFX2FMA.js";
+import "./chunk-GDE6FYN4.js";
+import "./chunk-DDL4BWSL.js";
+import "./chunk-QIRE2VXS.js";
+export {
+  start_default as default,
+  shutdownForegroundOrchestrator
+};

package/dist/status-F4D52OVK.js

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+import {
+  status_default
+} from "./chunk-DFLXHNYQ.js";
+import "./chunk-36KYEDEO.js";
+import "./chunk-IWFX2FMA.js";
+import "./chunk-GDE6FYN4.js";
+import "./chunk-DDL4BWSL.js";
+import "./chunk-QIRE2VXS.js";
+export {
+  status_default as default
+};

package/dist/stop-MDKMJPVR.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import {
+  stop_default
+} from "./chunk-GSX2FV3M.js";
+import "./chunk-GDE6FYN4.js";
+import "./chunk-DDL4BWSL.js";
+import "./chunk-QIRE2VXS.js";
+export {
+  stop_default as default
+};

package/dist/{upgrade-OJXPZRYE.js → upgrade-O33S2SJK.js}

@@ -16,8 +16,8 @@ function execFileAsync(file, args, execFileImpl = execFileCallback) {
   });
 }
 function resolveCurrentCliVersion() {
-  if ("0.0.21".length > 0) {
-    return "0.0.21";
+  if ("0.0.22".length > 0) {
+    return "0.0.22";
   }
   const pkg = JSON.parse(
     readFileSync(new URL("../../package.json", import.meta.url), "utf8")

package/dist/{version-TBDCTKDO.js → version-CW54Q7BK.js}

@@ -2,7 +2,7 @@
 
 // src/commands/version.ts
 var handler = async (_args, options) => {
-  const version = "0.0.21";
+  const version = "0.0.22";
   if (options.json) {
     process.stdout.write(JSON.stringify({ version }) + "\n");
   } else {

package/dist/worker-entry.js

@@ -6,20 +6,22 @@ import {
   normalizeCodexRuntimeEvents,
   prepareCodexRuntimePlan,
   resolveLocalRuntimeLaunchConfig
-} from "./chunk-A67CMOYE.js";
+} from "./chunk-2UW7NQLX.js";
 import {
   DEFAULT_AGENT_INPUT_REQUIRED_REASON,
   classifySessionExit,
+  createClaudePrintRuntimeAdapter,
+  extractEnvForClaude,
   formatClaudePreflightText,
   isClaudeRuntimeCommand,
   parseWorkflowMarkdown,
   resolveClaudeCommandBinary,
   resolveWorkflowRuntimeCommand,
   runClaudePreflight
-} from "./chunk-QEONJ5DZ.js";
+} from "./chunk-EEQQWTXS.js";
 
 // ../worker/src/index.ts
-import { spawn } from "child_process";
+import { spawn as spawn2 } from "child_process";
 import { readFile } from "fs/promises";
 import { join as join2 } from "path";
 
@@ -124,6 +126,152 @@ function normalizeError(value) {
   return normalized.length > 0 ? normalized : null;
 }
 
+// ../worker/src/non-codex-runtime.ts
+import {
+  spawn
+} from "child_process";
+import { finished } from "stream/promises";
+var CustomCommandWorkerRuntimeAdapter = class {
+  constructor(config, dependencies = {}) {
+    this.config = config;
+    this.dependencies = dependencies;
+  }
+  activeChild = null;
+  prepare() {
+  }
+  async spawnTurn(input) {
+    const command = this.config.command;
+    const args = [...this.config.args];
+    const cwd = input.cwd ?? this.config.workingDirectory;
+    const child = (this.dependencies.spawnImpl ?? spawn)(command, args, {
+      cwd,
+      env: {
+        ...this.config.env,
+        ...input.env,
+        SYMPHONY_RENDERED_PROMPT: input.prompt
+      },
+      stdio: "pipe"
+    });
+    this.activeChild = child;
+    this.config.onSpawned?.(child);
+    let stdout = "";
+    let stderr = "";
+    let spawnError;
+    child.stdout?.setEncoding("utf8");
+    child.stderr?.setEncoding("utf8");
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk;
+    });
+    child.stderr?.on("data", (chunk) => {
+      stderr += chunk;
+    });
+    child.once("error", (error) => {
+      spawnError = error.message;
+    });
+    if (child.stdin && !child.stdin.destroyed) {
+      child.stdin.end(input.prompt);
+    }
+    const { exitCode, signal } = await waitForChildExit(child);
+    await Promise.all([
+      child.stdout ? finished(child.stdout).catch(() => void 0) : void 0,
+      child.stderr ? finished(child.stderr).catch(() => void 0) : void 0
+    ]);
+    this.activeChild = null;
+    const result = exitCode === 0 && signal === null && !spawnError ? "success" : "process-error";
+    return {
+      command,
+      args,
+      cwd,
+      stdout,
+      stderr,
+      exitCode,
+      signal,
+      result,
+      errorMessage: spawnError
+    };
+  }
+  onEvent(_handler) {
+    return () => {
+    };
+  }
+  resolveCredentials(brokerResponse) {
+    if (!this.config.authEnvKey) {
+      return {};
+    }
+    return extractEnvForClaude(brokerResponse.env, this.config.authEnvKey);
+  }
+  shutdown() {
+    this.stopActiveChild();
+  }
+  cancel() {
+    this.stopActiveChild();
+  }
+  stopActiveChild() {
+    if (!this.activeChild || this.activeChild.killed) {
+      this.activeChild = null;
+      return;
+    }
+    this.activeChild.kill("SIGTERM");
+    this.activeChild = null;
+  }
+};
+function createWorkerNonCodexRuntimeAdapter(workflow, context) {
+  const runtime = workflow.runtime;
+  if (!runtime || runtime.kind === "codex-app-server") {
+    throw new Error(
+      "Worker non-Codex runtime adapter requested for a Codex runtime."
+    );
+  }
+  switch (runtime.kind) {
+    case "claude-print":
+      return createClaudePrintRuntimeAdapter(
+        {
+          workingDirectory: context.workingDirectory,
+          runtimeRoot: context.runtimeRoot,
+          runtimeDirectory: context.runtimeDirectory,
+          command: runtime.command,
+          args: runtime.args,
+          env: context.env,
+          authEnvKey: runtime.auth.env ?? void 0,
+          isolation: {
+            bare: runtime.isolation.bare,
+            strictMcpConfig: runtime.isolation.strictMcpConfig
+          }
+        },
+        {
+          ...context.claudeDependencies,
+          onSpawned: context.onSpawned
+        }
+      );
+    case "custom":
+      return new CustomCommandWorkerRuntimeAdapter(
+        {
+          workingDirectory: context.workingDirectory,
+          command: runtime.command,
+          args: runtime.args,
+          env: context.env,
+          authEnvKey: runtime.auth.env ?? void 0,
+          onSpawned: context.onSpawned
+        },
+        context.customDependencies
+      );
+  }
+}
+function waitForChildExit(child) {
+  return new Promise((resolve) => {
+    let settled = false;
+    const settle = (exitCode, signal) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      resolve({ exitCode, signal });
+    };
+    child.once("exit", settle);
+    child.once("error", () => settle(1, null));
+  });
+}
+
 // ../worker/src/run-phase.ts
 var TERMINAL_RUN_PHASES = /* @__PURE__ */ new Set([
   "succeeded",
@@ -139,6 +287,15 @@ function resolveExitRunPhase(currentRunPhase, exit) {
   return exit.code === 0 && !exit.signal ? "succeeded" : "failed";
 }
 
+// ../worker/src/runtime-routing.ts
+function resolveWorkerRuntimeRoute(workflow) {
+  const kind = workflow.runtime?.kind;
+  if (!kind || kind === "codex-app-server") {
+    return "codex-app-server";
+  }
+  return "runtime-adapter";
+}
+
 // ../worker/src/thread-resume.ts
 var DEFAULT_CONTINUATION_GUIDANCE = "Continue working on the issue. Review your progress and complete any remaining tasks.";
 function parseNonNegativeInteger(value) {
@@ -298,6 +455,7 @@ console.log(
   )
 );
 var childProcess = null;
+var runtimeAdapter = null;
 var shutdownPromise = null;
 var orchestratorChannelDrainPending = false;
 var pendingOrchestratorChannelPayloads = [];
@@ -328,6 +486,7 @@ function shutdown(signal) {
       } catch {
       }
     }
+    await runtimeAdapter?.cancel(`worker received ${signal}`);
     stopOrchestratorHeartbeatTimer();
     emitOrchestratorHeartbeat();
     await persistSessionTokenUsageArtifact(launcherEnv);
@@ -569,7 +728,8 @@ async function startAssignedRun() {
       await readFile(workflowPath, "utf8"),
       launcherEnv
     );
-    if (isClaudeRuntimeCommand(workflow.codex.command)) {
+    const route = resolveWorkerRuntimeRoute(workflow);
+    if (route === "runtime-adapter" && workflow.runtime?.kind === "claude-print" && isClaudeRuntimeCommand(resolveWorkflowRuntimeCommand(workflow))) {
       const hasGitHubGraphqlToken = typeof launcherEnv.GITHUB_GRAPHQL_TOKEN === "string" && launcherEnv.GITHUB_GRAPHQL_TOKEN.trim().length > 0;
       const preflight = await runClaudePreflight({
         cwd: launcherEnv.WORKING_DIRECTORY,
@@ -587,19 +747,19 @@ async function startAssignedRun() {
         );
         return;
       }
-      await exitWorkerStartupFailure(
-        "Claude runtime worker launch is not yet implemented in this branch."
-      );
-      return;
     }
     runtimeState.executionPhase = resolveInitialExecutionPhase({
       issueState: runtimeState.run?.state,
       blockerCheckStates: workflow.lifecycle.blockerCheckStates,
       activeStates: workflow.lifecycle.activeStates
     });
+    runtimeState.runPhase = "launching_agent";
+    if (route === "runtime-adapter") {
+      await runNonCodexRuntimeAdapterLifecycle(workflow, launcherEnv);
+      return;
+    }
     const config = resolveLocalRuntimeLaunchConfig(launcherEnv);
     config.agentCommand = resolveWorkflowRuntimeCommand(workflow);
-    runtimeState.runPhase = "launching_agent";
     const plan = await prepareCodexRuntimePlan(config);
     childProcess = launchCodexAppServer(plan);
     runtimeState.status = "running";
@@ -640,14 +800,210 @@ async function startAssignedRun() {
       void persistSessionTokenUsageArtifact(launcherEnv);
     });
   } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown worker startup error";
     runtimeState.status = "failed";
     runtimeState.runPhase = "failed";
     if (runtimeState.run) {
-      runtimeState.run.lastError = error instanceof Error ? error.message : "Unknown worker startup error";
+      runtimeState.run.lastError = message;
     }
+    process.stderr.write(`[worker] startup failed: ${message}
+`);
     await persistSessionTokenUsageArtifact(launcherEnv);
   }
 }
+async function runNonCodexRuntimeAdapterLifecycle(workflow, env) {
+  const renderedPrompt = env.SYMPHONY_RENDERED_PROMPT;
+  if (!renderedPrompt) {
+    await exitWorkerStartupFailure(
+      "SYMPHONY_RENDERED_PROMPT not set; cannot run runtime adapter lifecycle."
+    );
+    return;
+  }
+  const runId = env.SYMPHONY_RUN_ID;
+  if (!runId) {
+    await exitWorkerStartupFailure(
+      "SYMPHONY_RUN_ID not set; cannot prepare runtime adapter lifecycle."
+    );
+    return;
+  }
+  const runtimeKind = workflow.runtime?.kind;
+  if (runtimeKind !== "claude-print" && runtimeKind !== "custom") {
+    await exitWorkerStartupFailure(
+      "Runtime adapter lifecycle requested for an unsupported runtime kind."
+    );
+    return;
+  }
+  const adapter = createWorkerNonCodexRuntimeAdapter(workflow, {
+    workingDirectory: env.WORKING_DIRECTORY,
+    env,
+    runtimeRoot: env.WORKSPACE_RUNTIME_DIR,
+    runtimeDirectory: env.WORKSPACE_RUNTIME_DIR,
+    onSpawned: (child) => {
+      childProcess = child;
+      if (runtimeState.run) {
+        runtimeState.run.processId = child.pid ?? null;
+      }
+    }
+  });
+  runtimeAdapter = adapter;
+  let terminalFailure = null;
+  const unsubscribe = adapter.onEvent((event) => {
+    const agentEvent = event;
+    handleNonCodexRuntimeEvent(agentEvent);
+    if (agentEvent.name === "agent.inputRequired") {
+      terminalFailure = agentEvent.payload.reason;
+    }
+    if (agentEvent.name === "agent.turnFailed" || agentEvent.name === "agent.error") {
+      terminalFailure = agentEvent.name === "agent.error" ? agentEvent.payload.error : JSON.stringify(agentEvent.payload.params);
+    }
+  });
+  const turnTelemetry = {
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    threadId: null,
+    turnId: `${runId}-turn-1`,
+    turnCount: 1,
+    sessionId: runId,
+    tokenUsageBaseline: cloneTokenUsageSnapshot()
+  };
+  try {
+    await adapter.prepare({
+      runId
+    });
+    runtimeState.status = "running";
+    runtimeState.runPhase = "streaming_turn";
+    runtimeState.sessionInfo = {
+      threadId: turnTelemetry.threadId,
+      turnId: turnTelemetry.turnId,
+      turnCount: turnTelemetry.turnCount,
+      sessionId: turnTelemetry.sessionId,
+      exitClassification: null
+    };
+    runtimeState.sessionId = turnTelemetry.sessionId;
+    emitTurnStartedEvent(turnTelemetry);
+    const result = await spawnNonCodexRuntimeTurn(
+      adapter,
+      runtimeKind,
+      renderedPrompt,
+      env
+    );
+    if (isNonCodexTurnFailure(result)) {
+      terminalFailure = describeNonCodexTurnFailure(result);
+    }
+    runtimeState.status = terminalFailure ? "failed" : "completed";
+    runtimeState.runPhase = terminalFailure ? "failed" : "succeeded";
+    if (runtimeState.run) {
+      runtimeState.run.lastError = terminalFailure;
+    }
+    runtimeState.sessionInfo.exitClassification = classifySessionExit({
+      runPhase: runtimeState.runPhase,
+      userInputRequired: terminalFailure === DEFAULT_AGENT_INPUT_REQUIRED_REASON || terminalFailure?.startsWith("turn_input_required:") === true,
+      budgetExceeded: false,
+      convergenceDetected: false,
+      maxTurnsReached: false
+    });
+    if (terminalFailure) {
+      emitTurnFailedEvent(turnTelemetry, terminalFailure);
+    } else {
+      emitTurnCompletedEvent(turnTelemetry);
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown runtime adapter lifecycle error";
+    runtimeState.status = "failed";
+    runtimeState.runPhase = "failed";
+    if (runtimeState.run) {
+      runtimeState.run.lastError = message;
+    }
+    runtimeState.sessionInfo.exitClassification = classifySessionExit({
+      runPhase: runtimeState.runPhase,
+      userInputRequired: false,
+      budgetExceeded: false,
+      convergenceDetected: false,
+      maxTurnsReached: false
+    });
+    emitTurnFailedEvent(turnTelemetry, message);
+  } finally {
+    unsubscribe();
+    await adapter.shutdown();
+    runtimeAdapter = null;
+    childProcess = null;
+    runtimeState.runPhase = runtimeState.runPhase ?? "failed";
+    stopOrchestratorHeartbeatTimer();
+    emitOrchestratorHeartbeat();
+    await persistSessionTokenUsageArtifact(env);
+    await waitForPendingOrchestratorChannelFlush(
+      resolveTerminalOrchestratorChannelFlushTimeoutMs()
+    );
+    setTimeout(() => {
+      process.exit(runtimeState.status === "completed" ? 0 : 1);
+    }, 1500);
+  }
+}
+async function spawnNonCodexRuntimeTurn(adapter, runtimeKind, renderedPrompt, env) {
+  if (runtimeKind === "claude-print") {
+    return await adapter.spawnTurn({
+      messages: [{ type: "user", text: renderedPrompt }],
+      cwd: env.WORKING_DIRECTORY,
+      env
+    });
+  }
+  return await adapter.spawnTurn({
+    prompt: renderedPrompt,
+    cwd: env.WORKING_DIRECTORY,
+    env
+  });
+}
+function handleNonCodexRuntimeEvent(event) {
+  if (event.payload.suppressUpdate) {
+    return;
+  }
+  runtimeState.lastEventAt = (/* @__PURE__ */ new Date()).toISOString();
+  switch (event.name) {
+    case "agent.tokenUsageUpdated": {
+      const tokenUsage = extractAbsoluteTokenUsage(event.payload.params);
+      if (tokenUsage) {
+        applyTokenUsageUpdate(
+          event.payload.observabilityEvent ?? event.name,
+          tokenUsage
+        );
+      }
+      break;
+    }
+    case "agent.rateLimit": {
+      const rateLimits = extractRateLimitPayload(event.payload.params);
+      if (rateLimits) {
+        applyRateLimitUpdate(
+          event.payload.observabilityEvent ?? event.name,
+          rateLimits,
+          "runtime-adapter"
+        );
+      }
+      break;
+    }
+    case "agent.inputRequired":
+      runtimeState.status = "failed";
+      if (runtimeState.run) {
+        runtimeState.run.lastError = event.payload.reason;
+      }
+      break;
+    case "agent.turnFailed":
+    case "agent.turnCancelled":
+    case "agent.error":
+      runtimeState.status = "failed";
+      if (runtimeState.run) {
+        runtimeState.run.lastError = event.name === "agent.error" ? event.payload.error : JSON.stringify(event.payload.params);
+      }
+      break;
+    default:
+      break;
+  }
+  emitOrchestratorChannelEvent(event.payload.observabilityEvent ?? event.name);
+}
+function isNonCodexTurnFailure(result) {
+  return result.result !== "success";
+}
+function describeNonCodexTurnFailure(result) {
+  return result.errorMessage ?? `${result.command} exited with ${result.signal ?? result.exitCode ?? "unknown"}`;
+}
 async function exitWorkerStartupFailure(message) {
   runtimeState.status = "failed";
   runtimeState.runPhase = "failed";
@@ -1328,10 +1684,10 @@ function applyTokenUsageUpdate(source, tokenUsage) {
 `
   );
 }
-function applyRateLimitUpdate(source, rateLimits) {
+function applyRateLimitUpdate(source, rateLimits, runtimeSource = "codex") {
   runtimeState.rateLimits = {
     ...rateLimits,
-    source: "codex"
+    source: runtimeSource
   };
   process.stderr.write(
     `[worker] rate_limits source=${source} payload=${JSON.stringify(runtimeState.rateLimits).slice(0, 300)}
@@ -1483,7 +1839,7 @@ function runToolProcess(toolDef, inputJson) {
       ...process.env,
       ...toolDef.env
     };
-    const toolProc = spawn(toolDef.command, toolDef.args, {
+    const toolProc = spawn2(toolDef.command, toolDef.args, {
       env: toolEnv,
       stdio: "pipe"
     });

package/dist/{workflow-BLJH2HC3.js → workflow-L3KT6HB7.js}

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 import {
   init_default
-} from "./chunk-JN3TQVFV.js";
+} from "./chunk-HMLBBZNY.js";
 import {
   fetchGithubProjectIssueByRepositoryAndNumber
-} from "./chunk-SXGT7LOF.js";
+} from "./chunk-2TSM3INR.js";
 import {
   GitHubApiError,
   createClient,
@@ -17,11 +17,11 @@ import {
   buildPromptVariables,
   parseWorkflowMarkdown,
   renderPrompt
-} from "./chunk-QEONJ5DZ.js";
+} from "./chunk-EEQQWTXS.js";
 import {
   inspectManagedProjectSelection
-} from "./chunk-C7G7RJ4G.js";
-import "./chunk-ROGRTUFI.js";
+} from "./chunk-DDL4BWSL.js";
+import "./chunk-QIRE2VXS.js";
 
 // src/commands/workflow.ts
 import { readFile } from "fs/promises";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gh-symphony/cli",
-  "version": "0.0.21",
+  "version": "0.0.22",
   "license": "MIT",
   "author": "hojinzs",
   "description": "Interactive CLI for GitHub Symphony orchestration",
@@ -41,10 +41,10 @@
   },
   "devDependencies": {
     "tsup": "^8.5.1",
-    "@gh-symphony/control-plane": "0.0.14",
     "@gh-symphony/core": "0.0.14",
-    "@gh-symphony/orchestrator": "0.0.14",
+    "@gh-symphony/control-plane": "0.0.15",
     "@gh-symphony/dashboard": "0.0.14",
+    "@gh-symphony/orchestrator": "0.0.14",
     "@gh-symphony/runtime-claude": "0.0.14",
     "@gh-symphony/tracker-github": "0.0.14",
     "@gh-symphony/worker": "0.0.14"