@gh-symphony/cli 0.0.21 → 0.1.2

package/dist/worker-entry.js

@@ -6,20 +6,21 @@ import {
   normalizeCodexRuntimeEvents,
   prepareCodexRuntimePlan,
   resolveLocalRuntimeLaunchConfig
-} from "./chunk-A67CMOYE.js";
+} from "./chunk-VFHMHHZW.js";
 import {
   DEFAULT_AGENT_INPUT_REQUIRED_REASON,
   classifySessionExit,
+  createClaudePrintRuntimeAdapter,
+  extractEnvForClaude,
   formatClaudePreflightText,
-  isClaudeRuntimeCommand,
   parseWorkflowMarkdown,
   resolveClaudeCommandBinary,
   resolveWorkflowRuntimeCommand,
   runClaudePreflight
-} from "./chunk-QEONJ5DZ.js";
+} from "./chunk-GPRCOJDJ.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 +125,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 +286,18 @@ 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";
+}
+function resolveClaudePreflightAuthMode(workflow) {
+  return workflow.runtime?.isolation.bare === true ? "api-key-required" : "local-or-api-key";
+}
+
 // ../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 +457,7 @@ console.log(
   )
 );
 var childProcess = null;
+var runtimeAdapter = null;
 var shutdownPromise = null;
 var orchestratorChannelDrainPending = false;
 var pendingOrchestratorChannelPayloads = [];
@@ -328,6 +488,7 @@ function shutdown(signal) {
       } catch {
       }
     }
+    await runtimeAdapter?.cancel(`worker received ${signal}`);
     stopOrchestratorHeartbeatTimer();
     emitOrchestratorHeartbeat();
     await persistSessionTokenUsageArtifact(launcherEnv);
@@ -569,12 +730,16 @@ async function startAssignedRun() {
       await readFile(workflowPath, "utf8"),
       launcherEnv
     );
-    if (isClaudeRuntimeCommand(workflow.codex.command)) {
+    const route = resolveWorkerRuntimeRoute(workflow);
+    const runtimeCommand = resolveWorkflowRuntimeCommand(workflow);
+    const claudeCommand = resolveClaudeCommandBinary(runtimeCommand);
+    if (route === "runtime-adapter" && workflow.runtime?.kind === "claude-print" && claudeCommand) {
       const hasGitHubGraphqlToken = typeof launcherEnv.GITHUB_GRAPHQL_TOKEN === "string" && launcherEnv.GITHUB_GRAPHQL_TOKEN.trim().length > 0;
       const preflight = await runClaudePreflight({
         cwd: launcherEnv.WORKING_DIRECTORY,
         env: launcherEnv,
-        command: resolveClaudeCommandBinary(workflow.codex.command) ?? void 0,
+        command: claudeCommand,
+        authMode: resolveClaudePreflightAuthMode(workflow),
         includeGhAuth: !hasGitHubGraphqlToken
       });
       process.stderr.write(
@@ -587,19 +752,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 +805,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 +1689,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 +1844,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-26QNZZWH.js

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+import {
+  parseIssueReference,
+  readGitHubProjectBinding,
+  renderIssueWorkflowPreview,
+  resetWorkflowCommandDependenciesForTest,
+  setWorkflowCommandDependenciesForTest,
+  workflow_default
+} from "./chunk-B4ZJMAZL.js";
+import "./chunk-WM2B6BJ7.js";
+import "./chunk-DLZAJXZL.js";
+import "./chunk-Z3NZOPLZ.js";
+import "./chunk-GPRCOJDJ.js";
+import "./chunk-WOVNN5NW.js";
+export {
+  workflow_default as default,
+  parseIssueReference,
+  readGitHubProjectBinding,
+  renderIssueWorkflowPreview,
+  resetWorkflowCommandDependenciesForTest,
+  setWorkflowCommandDependenciesForTest
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gh-symphony/cli",
-  "version": "0.0.21",
+  "version": "0.1.2",
   "license": "MIT",
   "author": "hojinzs",
   "description": "Interactive CLI for GitHub Symphony orchestration",
@@ -41,13 +41,13 @@
   },
   "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/dashboard": "0.0.14",
+    "@gh-symphony/control-plane": "0.0.15",
+    "@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"
+    "@gh-symphony/worker": "0.0.14",
+    "@gh-symphony/tracker-github": "0.0.14"
   },
   "scripts": {
     "build": "tsup",

package/dist/chunk-5NV3LSAJ.js

@@ -1,11 +0,0 @@
-#!/usr/bin/env node
-
-// src/orchestrator-runtime.ts
-import { resolve } from "path";
-function resolveRuntimeRoot(configDir) {
-  return resolve(configDir);
-}
-
-export {
-  resolveRuntimeRoot
-};

package/dist/chunk-C7G7RJ4G.js

@@ -1,146 +0,0 @@
-#!/usr/bin/env node
-import {
-  loadGlobalConfig,
-  loadProjectConfig
-} from "./chunk-ROGRTUFI.js";
-
-// src/project-selection.ts
-import * as p from "@clack/prompts";
-function isInteractiveTerminal() {
-  return process.stdin.isTTY === true && process.stdout.isTTY === true;
-}
-function explicitProjectRequiredMessage() {
-  return "Multiple projects are configured. Re-run with --project-id in non-interactive environments.\n";
-}
-async function inspectManagedProjectSelection(input) {
-  if (input.requestedProjectId) {
-    const projectConfig = await loadProjectConfig(
-      input.configDir,
-      input.requestedProjectId
-    );
-    if (!projectConfig) {
-      return {
-        kind: "requested_project_missing",
-        projectId: input.requestedProjectId,
-        message: `Project "${input.requestedProjectId}" is not configured. Run 'gh-symphony project add' or choose an existing project.`
-      };
-    }
-    return {
-      kind: "resolved",
-      projectId: input.requestedProjectId,
-      projectConfig
-    };
-  }
-  const global = await loadGlobalConfig(input.configDir);
-  if (!global) {
-    return {
-      kind: "missing_global_config",
-      message: "No CLI configuration found. Run 'gh-symphony project add' first."
-    };
-  }
-  const projectIds = global.projects ?? [];
-  if (projectIds.length === 0) {
-    return {
-      kind: "no_projects",
-      message: "No managed projects are configured. Run 'gh-symphony project add' first."
-    };
-  }
-  if (projectIds.length > 1 && !isInteractiveTerminal()) {
-    return {
-      kind: "multiple_projects_require_selection",
-      message: explicitProjectRequiredMessage().trimEnd()
-    };
-  }
-  if (global.activeProject) {
-    const projectConfig = await loadProjectConfig(
-      input.configDir,
-      global.activeProject
-    );
-    if (!projectConfig) {
-      return {
-        kind: "active_project_missing",
-        projectId: global.activeProject,
-        message: `Active project "${global.activeProject}" is configured in config.json but its project config is missing. Re-run 'gh-symphony project add' or 'gh-symphony project switch'.`
-      };
-    }
-    return {
-      kind: "resolved",
-      projectId: global.activeProject,
-      projectConfig
-    };
-  }
-  if (projectIds.length === 1) {
-    const projectId = projectIds[0];
-    const projectConfig = await loadProjectConfig(input.configDir, projectId);
-    if (!projectConfig) {
-      return {
-        kind: "configured_project_missing",
-        projectId,
-        message: `Configured project "${projectId}" is missing its project config file. Re-run 'gh-symphony project add'.`
-      };
-    }
-    return {
-      kind: "resolved",
-      projectId,
-      projectConfig
-    };
-  }
-  return {
-    kind: "multiple_projects_require_selection",
-    message: "Multiple projects are configured and no active project is set. Run 'gh-symphony project switch' or re-run with --project-id."
-  };
-}
-async function resolveManagedProjectConfig(input) {
-  if (input.requestedProjectId) {
-    return loadProjectConfig(input.configDir, input.requestedProjectId);
-  }
-  const global = await loadGlobalConfig(input.configDir);
-  const projectIds = global?.projects ?? [];
-  if (projectIds.length === 0) {
-    return null;
-  }
-  if (projectIds.length === 1) {
-    return loadProjectConfig(input.configDir, projectIds[0]);
-  }
-  if (!isInteractiveTerminal()) {
-    process.stderr.write(explicitProjectRequiredMessage());
-    process.exitCode = 1;
-    return null;
-  }
-  const projects = await Promise.all(
-    projectIds.map(async (projectId) => ({
-      projectId,
-      config: await loadProjectConfig(input.configDir, projectId)
-    }))
-  );
-  const selected = await p.select({
-    message: "Select a project:",
-    options: projects.map(({ projectId, config }) => ({
-      value: projectId,
-      label: config?.displayName ?? config?.slug ?? projectId,
-      hint: projectId === global?.activeProject ? "current" : config && config.displayName && config.displayName !== projectId ? projectId : void 0
-    })),
-    maxItems: 10
-  });
-  if (p.isCancel(selected)) {
-    p.cancel("Cancelled.");
-    process.exitCode = 130;
-    return null;
-  }
-  return loadProjectConfig(input.configDir, selected);
-}
-function handleMissingManagedProjectConfig() {
-  if (process.exitCode) {
-    return;
-  }
-  process.stderr.write(
-    "No project configured. Run 'gh-symphony project add' first.\n"
-  );
-  process.exitCode = 1;
-}
-
-export {
-  inspectManagedProjectSelection,
-  resolveManagedProjectConfig,
-  handleMissingManagedProjectConfig
-};