@gh-symphony/cli 0.0.22 → 0.1.3

package/dist/{chunk-EEQQWTXS.js → chunk-WCOIVNHH.js}

@@ -25,6 +25,7 @@ function normalizeWorkflowState(state) {
 var DEFAULT_CODEX_COMMAND = "codex app-server";
 var DEFAULT_CLAUDE_COMMAND = "claude";
 var DEFAULT_AGENT_COMMAND = DEFAULT_CODEX_COMMAND;
+var DEFAULT_LINEAR_GRAPHQL_URL = "https://api.linear.app/graphql";
 var DEFAULT_HOOK_TIMEOUT_MS = 6e4;
 var DEFAULT_POLL_INTERVAL_MS = 3e4;
 var DEFAULT_MAX_RETRY_BACKOFF_MS = 3e5;
@@ -129,6 +130,7 @@ function parseWorkflowMarkdown(markdown, env = process.env, options = {}) {
   const hasRuntime = runtimeNode !== null;
   const codex = hasRuntime ? readObject(frontMatter, "codex") : readRequiredObject(frontMatter, "codex");
   const trackerKind = readRequiredString(tracker, "kind", env);
+  validateTrackerConfig(tracker, trackerKind, env);
   const activeStates = readStringList(tracker, "active_states") ?? DEFAULT_WORKFLOW_TRACKER.activeStates;
   const terminalStates = readStringList(tracker, "terminal_states") ?? DEFAULT_WORKFLOW_TRACKER.terminalStates;
   const blockerCheckStates = readStringList(tracker, "blocker_check_states") ?? DEFAULT_WORKFLOW_TRACKER.blockerCheckStates;
@@ -160,7 +162,7 @@ function parseWorkflowMarkdown(markdown, env = process.env, options = {}) {
     ),
     tracker: {
       kind: trackerKind,
-      endpoint: readOptionalString(tracker, "endpoint", env),
+      endpoint: readOptionalString(tracker, "endpoint", env) ?? (trackerKind === "linear" ? DEFAULT_LINEAR_GRAPHQL_URL : null),
       apiKey: readOptionalString(tracker, "api_key", env),
       projectSlug: readOptionalString(tracker, "project_slug", env),
       activeStates,
@@ -207,6 +209,32 @@ function parseWorkflowMarkdown(markdown, env = process.env, options = {}) {
   };
   return parsed;
 }
+function validateTrackerConfig(tracker, trackerKind, env) {
+  if (trackerKind !== "linear") {
+    return;
+  }
+  for (const key of ["project_id", "projectId", "teamId", "team_id"]) {
+    if (key in tracker) {
+      throw new Error(
+        `Workflow front matter field "tracker.${key}" is not supported for tracker.kind "linear"; use "tracker.project_slug".`
+      );
+    }
+  }
+  const projectSlug = readOptionalString(tracker, "project_slug", env);
+  if (!projectSlug || projectSlug.trim().length === 0) {
+    throw new Error(
+      'Workflow front matter field "tracker.project_slug" is required for tracker.kind "linear".'
+    );
+  }
+  if ("endpoint" in tracker) {
+    const endpoint = readOptionalString(tracker, "endpoint", env);
+    if (!endpoint || endpoint.trim().length === 0) {
+      throw new Error(
+        'Workflow front matter field "tracker.endpoint" must be a non-empty string when provided for tracker.kind "linear".'
+      );
+    }
+  }
+}
 function parseLegacyWorkflowMarkdown(markdown) {
   const promptGuidelines = matchOptionalSection(markdown, "Prompt Guidelines") ?? "";
   return {
@@ -372,7 +400,9 @@ function splitInlineArrayEntries(inner) {
     current += char;
   }
   if (quote) {
-    throw new Error("Workflow front matter inline array has an unterminated string.");
+    throw new Error(
+      "Workflow front matter inline array has an unterminated string."
+    );
   }
   pushInlineArrayEntry(entries, current, "end");
   return entries;
@@ -564,6 +594,16 @@ function resolveEnvironmentValue(value, env) {
     }
     return resolved;
   }
+  const dollarEnvTokenMatch = value.match(/^\$([A-Z0-9_]+)$/);
+  if (dollarEnvTokenMatch) {
+    const resolved = env[dollarEnvTokenMatch[1]];
+    if (!resolved) {
+      throw new Error(
+        `Workflow front matter requires environment variable ${dollarEnvTokenMatch[1]}.`
+      );
+    }
+    return resolved;
+  }
   return value.replace(/\$\{([A-Z0-9_]+)\}/g, (_, name) => {
     const resolved = env[name];
     if (!resolved) {
@@ -583,73 +623,6 @@ function matchOptionalSection(markdown, heading) {
   return match?.[1]?.trim() ?? null;
 }
 
-// ../core/src/workflow/loader.ts
-import { createHash } from "crypto";
-import { access, readFile, stat } from "fs/promises";
-import { constants } from "fs";
-var WorkflowConfigStore = class {
-  cache = /* @__PURE__ */ new Map();
-  async load(workflowPath, env = process.env) {
-    await access(workflowPath, constants.R_OK);
-    const fileStat = await stat(workflowPath);
-    const cached = this.cache.get(workflowPath);
-    const markdown = await readFile(workflowPath, "utf8");
-    const fingerprint = `${fileStat.mtimeMs}:${fileStat.size}:${createHash("sha256").update(markdown).digest("hex")}`;
-    if (cached && cached.fingerprint === fingerprint) {
-      return toWorkflowResolution(workflowPath, cached.workflow, {
-        isValid: true,
-        usedLastKnownGood: false,
-        validationError: null
-      });
-    }
-    try {
-      const workflow = parseWorkflowMarkdown(markdown, env);
-      this.cache.set(workflowPath, {
-        fingerprint,
-        workflow,
-        loadedAt: (/* @__PURE__ */ new Date()).toISOString()
-      });
-      return toWorkflowResolution(workflowPath, workflow, {
-        isValid: true,
-        usedLastKnownGood: false,
-        validationError: null
-      });
-    } catch (error) {
-      if (cached) {
-        return toWorkflowResolution(workflowPath, cached.workflow, {
-          isValid: false,
-          usedLastKnownGood: true,
-          validationError: error instanceof Error ? error.message : "Invalid workflow definition."
-        });
-      }
-      throw error;
-    }
-  }
-};
-function createDefaultWorkflowResolution() {
-  return createInvalidWorkflowResolution(null, "missing_workflow_file");
-}
-function createInvalidWorkflowResolution(workflowPath, validationError) {
-  return toWorkflowResolution(workflowPath, DEFAULT_WORKFLOW_DEFINITION, {
-    isValid: false,
-    usedLastKnownGood: false,
-    validationError
-  });
-}
-function toWorkflowResolution(workflowPath, workflow, metadata) {
-  return {
-    workflowPath,
-    workflow,
-    lifecycle: workflow.lifecycle,
-    promptTemplate: workflow.promptTemplate,
-    agentCommand: workflow.agentCommand,
-    hookPath: workflow.hookPath ?? "",
-    isValid: metadata.isValid,
-    usedLastKnownGood: metadata.usedLastKnownGood,
-    validationError: metadata.validationError
-  };
-}
-
 // ../core/src/workflow/render.ts
 import {
   Liquid,
@@ -659,6 +632,17 @@ import {
   UndefinedVariableError
 } from "liquidjs";
 function buildPromptVariables(issue, options) {
+  const contentType = issue.metadata.contentType ?? "Issue";
+  const linkedPullRequests = Array.isArray(issue.metadata.linkedPullRequests) ? issue.metadata.linkedPullRequests.map(normalizePullRequestContext) : [];
+  const primaryPullRequest = contentType === "PullRequest" ? normalizePullRequestContext(
+    issue.metadata.pullRequest ?? linkedPullRequests[0] ?? buildPullRequestContextFromIssue(issue)
+  ) : linkedPullRequests[0] ?? null;
+  const pullRequestContext = buildPullRequestVariables({
+    contentType,
+    linkedPullRequests,
+    primaryPullRequest,
+    issueBranchName: issue.branchName
+  });
   return {
     issue: {
       id: issue.id,
@@ -672,13 +656,61 @@ function buildPromptVariables(issue, options) {
       labels: issue.labels,
       blocked_by: issue.blockedBy,
       branch_name: issue.branchName,
+      content_type: contentType,
+      linked_pull_requests: linkedPullRequests,
+      primary_pull_request: primaryPullRequest,
+      has_linked_pr: linkedPullRequests.length > 0,
       created_at: issue.createdAt,
       updated_at: issue.updatedAt,
       repository: `${issue.repository.owner}/${issue.repository.name}`
     },
+    pull_request_context: pullRequestContext,
     attempt: options.attempt
   };
 }
+function normalizePullRequestContext(pullRequest) {
+  return {
+    ...pullRequest,
+    state: pullRequest.state ?? null,
+    projectState: pullRequest.projectState ?? null,
+    isDraft: pullRequest.isDraft ?? null,
+    merged: pullRequest.merged ?? null,
+    headRefName: pullRequest.headRefName ?? null,
+    baseRefName: pullRequest.baseRefName ?? null
+  };
+}
+function buildPullRequestVariables(options) {
+  const checkoutBranch = options.primaryPullRequest?.headRefName ?? (options.contentType === "PullRequest" ? options.issueBranchName : null);
+  const hasPrimaryPr = options.primaryPullRequest !== null;
+  return {
+    subject_type: options.contentType,
+    linked_pull_requests: options.linkedPullRequests,
+    primary_pull_request: options.primaryPullRequest,
+    has_linked_pr: options.linkedPullRequests.length > 0,
+    has_primary_pr: hasPrimaryPr,
+    checkout_branch: checkoutBranch,
+    // Policy flag for prompt templates: any primary PR means the worker must
+    // inspect review threads and checks before editing code.
+    review_first: hasPrimaryPr
+  };
+}
+function buildPullRequestContextFromIssue(issue) {
+  return {
+    id: issue.id,
+    number: issue.number,
+    identifier: issue.identifier,
+    url: issue.url,
+    state: null,
+    projectState: issue.state,
+    headRefName: issue.branchName,
+    repository: {
+      owner: issue.repository.owner,
+      name: issue.repository.name,
+      url: issue.repository.url ?? "",
+      cloneUrl: issue.repository.cloneUrl
+    }
+  };
+}
 var STRICT_LIQUID_ENGINE = new Liquid({
   strictVariables: true,
   strictFilters: true,
@@ -873,6 +905,73 @@ function isOrchestratorChannelEvent(value) {
   return false;
 }
 
+// ../core/src/workflow/loader.ts
+import { createHash } from "crypto";
+import { access, readFile, stat } from "fs/promises";
+import { constants } from "fs";
+var WorkflowConfigStore = class {
+  cache = /* @__PURE__ */ new Map();
+  async load(workflowPath, env = process.env) {
+    await access(workflowPath, constants.R_OK);
+    const fileStat = await stat(workflowPath);
+    const cached = this.cache.get(workflowPath);
+    const markdown = await readFile(workflowPath, "utf8");
+    const fingerprint = `${fileStat.mtimeMs}:${fileStat.size}:${createHash("sha256").update(markdown).digest("hex")}`;
+    if (cached && cached.fingerprint === fingerprint) {
+      return toWorkflowResolution(workflowPath, cached.workflow, {
+        isValid: true,
+        usedLastKnownGood: false,
+        validationError: null
+      });
+    }
+    try {
+      const workflow = parseWorkflowMarkdown(markdown, env);
+      this.cache.set(workflowPath, {
+        fingerprint,
+        workflow,
+        loadedAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      return toWorkflowResolution(workflowPath, workflow, {
+        isValid: true,
+        usedLastKnownGood: false,
+        validationError: null
+      });
+    } catch (error) {
+      if (cached) {
+        return toWorkflowResolution(workflowPath, cached.workflow, {
+          isValid: false,
+          usedLastKnownGood: true,
+          validationError: error instanceof Error ? error.message : "Invalid workflow definition."
+        });
+      }
+      throw error;
+    }
+  }
+};
+function createDefaultWorkflowResolution() {
+  return createInvalidWorkflowResolution(null, "missing_workflow_file");
+}
+function createInvalidWorkflowResolution(workflowPath, validationError) {
+  return toWorkflowResolution(workflowPath, DEFAULT_WORKFLOW_DEFINITION, {
+    isValid: false,
+    usedLastKnownGood: false,
+    validationError
+  });
+}
+function toWorkflowResolution(workflowPath, workflow, metadata) {
+  return {
+    workflowPath,
+    workflow,
+    lifecycle: workflow.lifecycle,
+    promptTemplate: workflow.promptTemplate,
+    agentCommand: workflow.agentCommand,
+    hookPath: workflow.hookPath ?? "",
+    isValid: metadata.isValid,
+    usedLastKnownGood: metadata.usedLastKnownGood,
+    validationError: metadata.validationError
+  };
+}
+
 // ../core/src/workflow/exit-classification.ts
 function classifySessionExit(params) {
   if (params.userInputRequired) {
@@ -1471,7 +1570,7 @@ async function runClaudePreflight(options, dependencies = {}) {
   const command = resolveRuntimeCommandBinary(options.command) ?? "claude";
   const checks = [];
   checks.push(checkClaudeBinary(command, options.cwd, deps));
-  checks.push(await checkAnthropicApiKey(env, options, deps));
+  checks.push(await checkClaudeAuthentication(env, options, deps));
   checks.push(await checkWorkspaceMcpConfig(options.cwd, deps));
   if (options.includeGhAuth) {
     checks.push(checkGhAuthentication(options.cwd, deps));
@@ -1573,11 +1672,12 @@ function checkGhAuthentication(cwd, deps) {
     );
   }
 }
-async function checkAnthropicApiKey(env, options, deps) {
+async function checkClaudeAuthentication(env, options, deps) {
+  const authMode = options.authMode ?? "api-key-required";
   if (env.ANTHROPIC_API_KEY?.trim()) {
     return pass(
       "anthropic_api_key",
-      "Anthropic API key",
+      "Claude authentication",
       "ANTHROPIC_API_KEY is configured in the environment.",
       { source: "env" }
     );
@@ -1585,9 +1685,32 @@ async function checkAnthropicApiKey(env, options, deps) {
   const brokerUrl = env.AGENT_CREDENTIAL_BROKER_URL?.trim();
   const brokerSecret = env.AGENT_CREDENTIAL_BROKER_SECRET?.trim();
   if (!brokerUrl || !brokerSecret) {
+    if (authMode === "local-or-api-key" && !brokerUrl && !brokerSecret) {
+      return warn(
+        "anthropic_api_key",
+        "Claude authentication",
+        "ANTHROPIC_API_KEY and agent credential broker are not configured; Claude Code local login may be used for this non-bare runtime.",
+        "If this runtime will run headlessly or with runtime.isolation.bare: true, set ANTHROPIC_API_KEY or configure AGENT_CREDENTIAL_BROKER_URL and AGENT_CREDENTIAL_BROKER_SECRET.",
+        { source: "local" }
+      );
+    }
+    if (brokerUrl || brokerSecret) {
+      const missingName = brokerUrl ? "AGENT_CREDENTIAL_BROKER_SECRET" : "AGENT_CREDENTIAL_BROKER_URL";
+      return fail(
+        "anthropic_api_key",
+        "Claude authentication",
+        `Agent credential broker configuration is incomplete: ${missingName} is not configured.`,
+        `Set ${missingName} or remove the partial broker configuration and use ANTHROPIC_API_KEY instead.`,
+        {
+          source: "broker",
+          brokerUrl: brokerUrl ?? null,
+          missing: missingName
+        }
+      );
+    }
     return fail(
       "anthropic_api_key",
-      "Anthropic API key",
+      "Claude authentication",
       "Neither ANTHROPIC_API_KEY nor an agent credential broker is configured.",
       "Set ANTHROPIC_API_KEY or configure AGENT_CREDENTIAL_BROKER_URL and AGENT_CREDENTIAL_BROKER_SECRET.",
       { source: "missing" }
@@ -1596,7 +1719,7 @@ async function checkAnthropicApiKey(env, options, deps) {
   if (options.probeCredentialBroker === false) {
     return pass(
       "anthropic_api_key",
-      "Anthropic API key",
+      "Claude authentication",
       "Agent credential broker configuration is present.",
       { source: "broker", brokerUrl }
     );
@@ -1614,14 +1737,14 @@ async function checkAnthropicApiKey(env, options, deps) {
     if (response.ok && payload.env?.ANTHROPIC_API_KEY?.trim()) {
       return pass(
         "anthropic_api_key",
-        "Anthropic API key",
+        "Claude authentication",
         "Agent credential broker is reachable and returned ANTHROPIC_API_KEY.",
         { source: "broker", brokerUrl }
       );
     }
     return fail(
       "anthropic_api_key",
-      "Anthropic API key",
+      "Claude authentication",
       payload.error ? `Agent credential broker did not return ANTHROPIC_API_KEY: ${payload.error}.` : "Agent credential broker did not return ANTHROPIC_API_KEY.",
       "Set ANTHROPIC_API_KEY or configure the credential broker to return ANTHROPIC_API_KEY.",
       { source: "broker", brokerUrl, status: response.status }
@@ -1629,7 +1752,7 @@ async function checkAnthropicApiKey(env, options, deps) {
   } catch (error) {
     return fail(
       "anthropic_api_key",
-      "Anthropic API key",
+      "Claude authentication",
       "Agent credential broker could not be reached.",
       "Set ANTHROPIC_API_KEY or fix AGENT_CREDENTIAL_BROKER_URL and AGENT_CREDENTIAL_BROKER_SECRET.",
       {
@@ -2105,15 +2228,18 @@ function createGitHubGraphQLMcpServerEntry(options = {}) {
 // ../runtime-claude/src/mcp-compose.ts
 async function composeClaudeMcpConfig(workspaceRoot, strictMode, symphonyTokenEnv = {}) {
   const workspaceMcpPath = join3(workspaceRoot, ".mcp.json");
-  const finalPath = strictMode ? resolveStrictMcpConfigPath(workspaceRoot, symphonyTokenEnv) : workspaceMcpPath;
+  const finalPath = resolveRuntimeMcpConfigPath(
+    workspaceRoot,
+    symphonyTokenEnv
+  );
   const baseConfig = await readBaseMcpConfig(workspaceMcpPath);
   const mergedConfig = mergeGitHubGraphQLMcpServer(baseConfig, symphonyTokenEnv);
   await mkdir(dirname(finalPath), { recursive: true });
   await writeFile3(finalPath, JSON.stringify(mergedConfig, null, 2) + "\n", "utf8");
   return {
     finalPath,
-    extraArgv: strictMode ? ["--strict-mcp-config", "--mcp-config", finalPath] : [],
-    ...strictMode ? { cleanupPath: finalPath } : {}
+    extraArgv: strictMode ? ["--strict-mcp-config", "--mcp-config", finalPath] : ["--mcp-config", finalPath],
+    cleanupPath: finalPath
   };
 }
 async function readBaseMcpConfig(workspaceMcpPath) {
@@ -2145,9 +2271,13 @@ function mergeGitHubGraphQLMcpServer(baseConfig, env) {
     }
   };
 }
-function resolveStrictMcpConfigPath(workspaceRoot, env) {
+function resolveRuntimeMcpConfigPath(workspaceRoot, env) {
   const normalizedWorkspaceRoot = resolve4(workspaceRoot);
-  const runtimeDir = env.WORKSPACE_RUNTIME_DIR ?? join3(normalizedWorkspaceRoot, ".runtime", basename(normalizedWorkspaceRoot));
+  const runtimeDir = env.WORKSPACE_RUNTIME_DIR ?? join3(
+    dirname(normalizedWorkspaceRoot),
+    ".runtime",
+    basename(normalizedWorkspaceRoot)
+  );
   return join3(runtimeDir, "mcp.json");
 }
 function isRecord3(value) {
@@ -3214,6 +3344,7 @@ export {
   isStateActive,
   isStateTerminal,
   matchesWorkflowState,
+  DEFAULT_LINEAR_GRAPHQL_URL,
   DEFAULT_MAX_FAILURE_RETRIES,
   resolveWorkflowRuntimeCommand,
   resolveWorkflowRuntimeTimeouts,

package/dist/{chunk-QIRE2VXS.js → chunk-WOVNN5NW.js}

@@ -1,16 +1,28 @@
 #!/usr/bin/env node
 
 // src/config.ts
+import { existsSync } from "fs";
 import { readFile, writeFile, mkdir } from "fs/promises";
-import { dirname, join } from "path";
+import { dirname, join, resolve } from "path";
 import { homedir } from "os";
 var DEFAULT_CONFIG_DIR = join(homedir(), ".gh-symphony");
 var CONFIG_FILE = "config.json";
 var DAEMON_PID_FILE = "daemon.pid";
 var ORCHESTRATOR_LOG_FILE = "orchestrator.log";
 var HTTP_STATUS_FILE = "http.json";
+var REPO_RUNTIME_DIR = join(".runtime", "orchestrator");
 function resolveConfigDir(override) {
-  return override ?? process.env.GH_SYMPHONY_CONFIG_DIR ?? DEFAULT_CONFIG_DIR;
+  if (override) {
+    return override;
+  }
+  if (process.env.GH_SYMPHONY_CONFIG_DIR) {
+    return process.env.GH_SYMPHONY_CONFIG_DIR;
+  }
+  const repoRuntimeDir = resolve(process.cwd(), REPO_RUNTIME_DIR);
+  if (existsSync(configFilePath(repoRuntimeDir))) {
+    return repoRuntimeDir;
+  }
+  return DEFAULT_CONFIG_DIR;
 }
 function configFilePath(configDir) {
   return join(configDir, CONFIG_FILE);
@@ -54,15 +66,7 @@ async function saveGlobalConfig(configDir, config) {
   await writeJsonFile(configFilePath(configDir), config);
 }
 async function loadProjectConfig(configDir, projectId) {
-  const config = await readJsonFile(projectConfigPath(configDir, projectId));
-  if (!config) {
-    return null;
-  }
-  const repository = config.repository ?? firstConfiguredRepository(config);
-  return {
-    ...config,
-    ...repository ? { repository } : {}
-  };
+  return readJsonFile(projectConfigPath(configDir, projectId));
 }
 async function saveProjectConfig(configDir, projectId, config) {
   await writeJsonFile(projectConfigPath(configDir, projectId), config);
@@ -97,16 +101,11 @@ function isFileMissing(error) {
     error && typeof error === "object" && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR")
   );
 }
-function firstConfiguredRepository(config) {
-  return config.repositories?.find(
-    (repository) => typeof repository.owner === "string" && repository.owner.length > 0 && typeof repository.name === "string" && repository.name.length > 0
-  );
-}
 
 export {
+  REPO_RUNTIME_DIR,
   resolveConfigDir,
   configFilePath,
-  projectConfigDir,
   daemonPidPath,
   orchestratorLogPath,
   httpStatusPath,

package/dist/{chunk-C67H3OUL.js → chunk-Z3NZOPLZ.js}

@@ -25,14 +25,6 @@ var GitHubScopeError = class extends GitHubApiError {
     this.name = "GitHubScopeError";
   }
 };
-var GitHubRepositoryLookupError = class extends GitHubApiError {
-  constructor(reason, message, remediation, status) {
-    super(message, status);
-    this.reason = reason;
-    this.remediation = remediation;
-    this.name = "GitHubRepositoryLookupError";
-  }
-};
 function createClient(token, options) {
   return {
     token,
@@ -40,77 +32,6 @@ function createClient(token, options) {
     fetchImpl: options?.fetchImpl ?? fetch
   };
 }
-async function getRepositoryMetadata(client, owner, name) {
-  const restUrl = client.apiUrl.replace("/graphql", "");
-  const baseUrl = restUrl === client.apiUrl ? REST_API_URL : restUrl;
-  const repoPath = `/repos/${encodeURIComponent(owner)}/${encodeURIComponent(name)}`;
-  let response;
-  try {
-    response = await client.fetchImpl(`${baseUrl}${repoPath}`, {
-      headers: {
-        authorization: `Bearer ${client.token}`,
-        accept: "application/vnd.github+json"
-      }
-    });
-  } catch (error) {
-    const detail = error instanceof Error && error.message.length > 0 ? ` ${error.message}` : "";
-    throw new GitHubRepositoryLookupError(
-      "offline",
-      `GitHub repository validation could not reach the API.${detail}`.trim(),
-      "Check your network connection and re-run the command to validate before saving."
-    );
-  }
-  if (!response.ok) {
-    const payload = await response.json().catch(() => null);
-    const message = payload?.message?.trim() || response.statusText;
-    if (response.status === 403 && (response.headers.get("x-ratelimit-remaining") === "0" || /rate limit/i.test(message))) {
-      throw new GitHubRepositoryLookupError(
-        "rate_limited",
-        "GitHub API rate limit blocked repository validation.",
-        "Wait for the rate limit window to reset, then re-run 'gh-symphony repo add owner/name'.",
-        response.status
-      );
-    }
-    if (response.status === 401) {
-      throw new GitHubRepositoryLookupError(
-        "invalid_token",
-        "GitHub token is invalid or expired.",
-        "Run 'gh auth login --scopes repo,read:org,project' or refresh GITHUB_GRAPHQL_TOKEN, then retry.",
-        response.status
-      );
-    }
-    if (response.status === 403 || /resource not accessible|saml|single sign-on|access denied/i.test(message)) {
-      throw new GitHubRepositoryLookupError(
-        "no_access",
-        `GitHub denied access to ${owner}/${name}.`,
-        "Confirm that the authenticated user can read this repository and that the token has the required access.",
-        response.status
-      );
-    }
-    if (response.status === 404) {
-      throw new GitHubRepositoryLookupError(
-        "not_found",
-        `Repository ${owner}/${name} was not found.`,
-        "Check the owner/name spelling. If the repository is private, confirm the current token can access it.",
-        response.status
-      );
-    }
-    throw new GitHubRepositoryLookupError(
-      "unknown",
-      `GitHub repository validation failed: ${response.status} ${message}`.trim(),
-      "Retry the command. If the problem continues, verify GitHub API access separately.",
-      response.status
-    );
-  }
-  const repo = await response.json();
-  return {
-    owner: repo.owner.login,
-    name: repo.name,
-    url: repo.html_url,
-    cloneUrl: repo.clone_url,
-    visibility: repo.visibility ?? (repo.private === true ? "private" : "public")
-  };
-}
 async function validateToken(client) {
   const restUrl = client.apiUrl.replace("/graphql", "");
   const baseUrl = restUrl === client.apiUrl ? REST_API_URL : restUrl;
@@ -817,9 +738,7 @@ export {
   findLinkedRepository,
   GitHubApiError,
   GitHubScopeError,
-  GitHubRepositoryLookupError,
   createClient,
-  getRepositoryMetadata,
   validateToken,
   checkRequiredScopes,
   discoverUserProjects,

package/dist/{config-cmd-Z3A7V6NC.js → config-cmd-2ADPUYWA.js}

@@ -3,7 +3,7 @@ import {
   configFilePath,
   loadGlobalConfig,
   saveGlobalConfig
-} from "./chunk-QIRE2VXS.js";
+} from "./chunk-WOVNN5NW.js";
 
 // src/commands/config-cmd.ts
 import { spawn } from "child_process";