@gh-symphony/cli 0.0.22 → 0.1.2

package/dist/{doctor-EJUMPBMW.js → doctor-EEPNFCGF.js}

@@ -1,4 +1,18 @@
 #!/usr/bin/env node
+import {
+  parseIssueReference,
+  readGitHubProjectBinding,
+  renderIssueWorkflowPreview
+} from "./chunk-B4ZJMAZL.js";
+import "./chunk-WM2B6BJ7.js";
+import {
+  fetchGithubProjectIssueByRepositoryAndNumber,
+  fetchGithubProjectIssues,
+  inspectManagedProjectSelection
+} from "./chunk-DLZAJXZL.js";
+import {
+  resolveRuntimeRoot
+} from "./chunk-6I753NYO.js";
 import {
   GitHubApiError,
   REQUIRED_GH_SCOPES,
@@ -6,27 +20,22 @@ import {
   checkGhInstalled,
   checkGhScopes,
   createClient,
+  findLinkedRepository,
   getEnvGitHubToken,
   getGhToken,
   getProjectDetail,
   runGhAuthLogin,
   runGhAuthRefresh,
   validateGitHubToken
-} from "./chunk-C67H3OUL.js";
+} from "./chunk-Z3NZOPLZ.js";
 import {
   isClaudeRuntimeCommand,
   parseWorkflowMarkdown,
   resolveClaudeCommandBinary,
   resolveRuntimeCommandBinary,
   runClaudePreflight
-} from "./chunk-EEQQWTXS.js";
-import {
-  resolveRuntimeRoot
-} from "./chunk-IWFX2FMA.js";
-import {
-  inspectManagedProjectSelection
-} from "./chunk-DDL4BWSL.js";
-import "./chunk-QIRE2VXS.js";
+} from "./chunk-GPRCOJDJ.js";
+import "./chunk-WOVNN5NW.js";
 
 // src/commands/doctor.ts
 import { constants } from "fs";
@@ -43,6 +52,8 @@ var DEFAULT_DEPENDENCIES = {
   inspectManagedProjectSelection,
   createClient,
   getProjectDetail,
+  fetchProjectIssues: fetchGithubProjectIssues,
+  fetchProjectIssue: fetchGithubProjectIssueByRepositoryAndNumber,
   readFile,
   access,
   mkdir,
@@ -64,8 +75,9 @@ var DEFAULT_DEPENDENCIES = {
 };
 var MINIMUM_NODE_MAJOR = 24;
 var MINIMUM_NODE_VERSION = `v${MINIMUM_NODE_MAJOR}.0.0`;
+var DOCTOR_USAGE = "Usage: gh-symphony doctor [--project-id <project-id>] [--fix] [--smoke] [--issue <owner/repo#number>]";
 function parseDoctorArgs(args) {
-  const parsed = { fix: false };
+  const parsed = { fix: false, smoke: false };
   for (let i = 0; i < args.length; i += 1) {
     const arg = args[i];
     if (arg === "--project" || arg === "--project-id") {
@@ -82,11 +94,28 @@ function parseDoctorArgs(args) {
       parsed.fix = true;
       continue;
     }
+    if (arg === "--smoke") {
+      parsed.smoke = true;
+      continue;
+    }
+    if (arg === "--issue") {
+      const value = args[i + 1];
+      if (!value || value.startsWith("-")) {
+        parsed.error = "Option '--issue' argument missing";
+        return parsed;
+      }
+      parsed.issue = value;
+      i += 1;
+      continue;
+    }
     if (arg?.startsWith("-")) {
       parsed.error = `Unknown option '${arg}'`;
       return parsed;
     }
   }
+  if (parsed.issue && !parsed.smoke) {
+    parsed.error = "Option '--issue' requires '--smoke'";
+  }
   return parsed;
 }
 function passCheck(id, title, summary, details) {
@@ -310,7 +339,7 @@ async function checkWorkflow(repoRoot, deps) {
       reason: "missing",
       workflowPath,
       summary: "WORKFLOW.md was not found in the repository root.",
-      remediation: "Run 'gh-symphony init' in this repository or add a valid WORKFLOW.md at the repo root."
+      remediation: "Run 'gh-symphony workflow init' in this repository or add a valid WORKFLOW.md at the repo root."
     };
   }
   try {
@@ -319,7 +348,8 @@ async function checkWorkflow(repoRoot, deps) {
       status: "pass",
       command: parsed.agentCommand,
       workflowPath,
-      format: parsed.format
+      format: parsed.format,
+      workflow: parsed
     };
   } catch (error) {
     return {
@@ -327,20 +357,394 @@ async function checkWorkflow(repoRoot, deps) {
       reason: "invalid",
       workflowPath,
       summary: "WORKFLOW.md could not be parsed.",
-      remediation: "Fix the WORKFLOW.md front matter or re-run 'gh-symphony init' to regenerate it.",
+      remediation: "Fix the WORKFLOW.md front matter or re-run 'gh-symphony workflow init' to regenerate it.",
       error: error instanceof Error ? error.message : "Unknown workflow parse error."
     };
   }
 }
+function buildGithubTrackerConfig(input) {
+  const settings = input.projectConfig.projectConfig.tracker.settings;
+  return {
+    projectId: input.bindingId,
+    token: input.token,
+    apiUrl: input.projectConfig.projectConfig.tracker.apiUrl,
+    lifecycle: input.workflow.lifecycle,
+    assignedOnly: settings?.assignedOnly === true,
+    priorityFieldName: typeof settings?.priorityFieldName === "string" ? settings.priorityFieldName : void 0,
+    timeoutMs: typeof settings?.timeoutMs === "number" ? settings.timeoutMs : void 0
+  };
+}
+function isActiveSmokeIssue(issue, workflow) {
+  const normalized = issue.state.trim().toLowerCase();
+  return workflow.lifecycle.activeStates.some(
+    (state) => state.trim().toLowerCase() === normalized
+  );
+}
+function selectRepresentativeIssue(issues, workflow) {
+  const activeIssues = issues.filter(
+    (issue) => isActiveSmokeIssue(issue, workflow)
+  );
+  activeIssues.sort((a, b) => {
+    const left = a.updatedAt ?? a.createdAt ?? "";
+    const right = b.updatedAt ?? b.createdAt ?? "";
+    return right.localeCompare(left);
+  });
+  return activeIssues[0] ?? null;
+}
+function isRepositoryConfigured(projectConfig, owner, name) {
+  const repositories = [projectConfig.projectConfig.repository].filter(
+    (repository) => Boolean(repository?.owner && repository.name)
+  );
+  const normalizedOwner = owner.trim().toLowerCase();
+  const normalizedName = name.trim().toLowerCase();
+  return repositories.some(
+    (repo) => repo.owner.trim().toLowerCase() === normalizedOwner && repo.name.trim().toLowerCase() === normalizedName
+  );
+}
+function isHookPathLike(command) {
+  const trimmed = command.trim();
+  return trimmed.length > 0 && !trimmed.includes("\n") && !/\s/.test(trimmed) && (trimmed.startsWith("/") || trimmed.startsWith("./") || trimmed.startsWith("../") || trimmed.includes("/") || trimmed.includes("\\"));
+}
+async function buildHookChecks(repoRoot, workflow, deps) {
+  const hooks = [
+    ["after_create", workflow.hooks.afterCreate],
+    ["before_run", workflow.hooks.beforeRun],
+    ["after_run", workflow.hooks.afterRun],
+    ["before_remove", workflow.hooks.beforeRemove]
+  ];
+  const configured = hooks.filter(([, command]) => command);
+  if (configured.length === 0) {
+    return [
+      passCheck(
+        "workflow_hooks",
+        "Workflow hook paths",
+        "No WORKFLOW.md hooks are configured.",
+        { configured: 0 }
+      )
+    ];
+  }
+  const unresolved = [];
+  const checked = [];
+  let inline = 0;
+  for (const [hook, command] of configured) {
+    if (!command || !isHookPathLike(command)) {
+      inline += 1;
+      continue;
+    }
+    const path = isAbsolute(command) ? command : resolve(repoRoot, command);
+    try {
+      await deps.access(path, constants.F_OK);
+      checked.push({ hook, command, path });
+    } catch {
+      unresolved.push({ hook, command, path });
+    }
+  }
+  if (unresolved.length > 0) {
+    return [
+      failCheck(
+        "workflow_hooks",
+        "Workflow hook paths",
+        `Unresolved WORKFLOW.md hook path${unresolved.length === 1 ? "" : "s"}: ${unresolved.map((entry) => `${entry.hook}=${entry.command}`).join(", ")}.`,
+        "Create the referenced hook script(s), fix the hook path(s), or replace them with inline commands.",
+        { configured: configured.length, pathsChecked: checked.length, inline, unresolved, checked }
+      )
+    ];
+  }
+  const pathSummary = checked.length === 0 ? "No hook paths required filesystem validation." : `Resolved ${checked.length} WORKFLOW.md hook path${checked.length === 1 ? "" : "s"}.`;
+  const inlineSummary = inline === 0 ? "" : ` Treated ${inline} hook${inline === 1 ? "" : "s"} as inline command${inline === 1 ? "" : "s"}.`;
+  return [
+    passCheck(
+      "workflow_hooks",
+      "Workflow hook paths",
+      `${pathSummary}${inlineSummary}`,
+      { configured: configured.length, pathsChecked: checked.length, inline, checked }
+    )
+  ];
+}
+function formatSmokeError(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+async function buildDoctorSmokeChecks(input) {
+  const checks = [];
+  if (input.selection.kind !== "resolved") {
+    checks.push(
+      failCheck(
+        "smoke_issue",
+        "Smoke target issue",
+        "Smoke check could not choose an issue because managed project selection failed.",
+        "Fix the managed project selection check first, then re-run 'gh-symphony doctor --smoke'.",
+        { blockedBy: "managed_project" }
+      )
+    );
+    return checks;
+  }
+  if (!input.auth) {
+    checks.push(
+      failCheck(
+        "smoke_issue",
+        "Smoke target issue",
+        "Smoke check could not read live issues because GitHub authentication failed.",
+        "Fix GitHub authentication first, then re-run 'gh-symphony doctor --smoke'.",
+        { blockedBy: "gh_authentication" }
+      )
+    );
+    return checks;
+  }
+  if (input.workflow.status !== "pass") {
+    checks.push(
+      failCheck(
+        "smoke_issue",
+        "Smoke target issue",
+        "Smoke check could not read a live issue because WORKFLOW.md is missing or invalid.",
+        "Fix WORKFLOW.md first, then re-run 'gh-symphony doctor --smoke'.",
+        { blockedBy: "workflow_file" }
+      )
+    );
+    return checks;
+  }
+  if (!input.projectBindingId || !input.projectDetail) {
+    checks.push(
+      failCheck(
+        "smoke_issue",
+        "Smoke target issue",
+        "Smoke check could not read live issues because the GitHub Project binding did not resolve.",
+        "Fix the GitHub project resolution check first, then re-run 'gh-symphony doctor --smoke'.",
+        { blockedBy: "github_project_resolution" }
+      )
+    );
+    return checks;
+  }
+  const trackerConfig = buildGithubTrackerConfig({
+    projectConfig: input.selection,
+    bindingId: input.projectBindingId,
+    token: input.auth.token,
+    workflow: input.workflow.workflow
+  });
+  let issue = null;
+  if (input.parsedArgs.issue) {
+    let issueRef;
+    try {
+      issueRef = parseIssueReference(input.parsedArgs.issue);
+    } catch (error) {
+      checks.push(
+        failCheck(
+          "smoke_issue",
+          "Smoke target issue",
+          `Smoke check issue reference is invalid: ${input.parsedArgs.issue}.`,
+          "Use the expected '--issue owner/repo#number' format and re-run the smoke check.",
+          {
+            issue: input.parsedArgs.issue,
+            expectedFormat: "owner/repo#number",
+            error: formatSmokeError(error)
+          }
+        )
+      );
+      return checks;
+    }
+    if (!findLinkedRepository(input.projectDetail, issueRef.owner, issueRef.name)) {
+      checks.push(
+        failCheck(
+          "project_repository_link",
+          "Project repository link",
+          `Repository ${issueRef.owner}/${issueRef.name} is not linked to GitHub Project "${input.projectDetail.title}".`,
+          "Run 'gh-symphony setup' from inside the target repository, or run 'gh-symphony workflow init' followed by 'gh-symphony repo init'.",
+          {
+            repository: `${issueRef.owner}/${issueRef.name}`,
+            projectTitle: input.projectDetail.title
+          }
+        )
+      );
+    } else if (!isRepositoryConfigured(input.selection, issueRef.owner, issueRef.name)) {
+      checks.push(
+        failCheck(
+          "project_repository_link",
+          "Project repository link",
+          `Repository ${issueRef.owner}/${issueRef.name} is linked to the GitHub Project but is not configured locally.`,
+          "Run 'gh-symphony repo init' from the target repository before running start.",
+          { repository: `${issueRef.owner}/${issueRef.name}` }
+        )
+      );
+    } else {
+      checks.push(
+        passCheck(
+          "project_repository_link",
+          "Project repository link",
+          `Repository ${issueRef.owner}/${issueRef.name} is linked to the GitHub Project and configured locally.`,
+          { repository: `${issueRef.owner}/${issueRef.name}` }
+        )
+      );
+    }
+    try {
+      issue = await input.deps.fetchProjectIssue(
+        trackerConfig,
+        { owner: issueRef.owner, name: issueRef.name },
+        issueRef.number
+      );
+    } catch (error) {
+      checks.push(
+        failCheck(
+          "smoke_issue",
+          "Smoke target issue",
+          `Smoke check could not read issue ${issueRef.identifier}.`,
+          "Confirm GitHub token scopes, project visibility, and network access, then re-run the smoke check.",
+          { issue: issueRef.identifier, error: formatSmokeError(error) }
+        )
+      );
+      return checks;
+    }
+    if (!issue) {
+      checks.push(
+        failCheck(
+          "smoke_issue",
+          "Smoke target issue",
+          `Issue ${issueRef.identifier} is not in the configured GitHub Project or is not readable.`,
+          "Add the issue to the project, confirm the token can read it, and re-run the smoke check.",
+          { issue: issueRef.identifier }
+        )
+      );
+      return checks;
+    }
+  } else {
+    let issues;
+    try {
+      issues = await input.deps.fetchProjectIssues(trackerConfig);
+    } catch (error) {
+      checks.push(
+        failCheck(
+          "smoke_issue",
+          "Smoke target issue",
+          `Smoke check could not read live issues from GitHub Project "${input.projectDetail.title}".`,
+          "Confirm GitHub token scopes, project visibility, and network access, then re-run the smoke check.",
+          {
+            projectTitle: input.projectDetail.title,
+            error: formatSmokeError(error)
+          }
+        )
+      );
+      return checks;
+    }
+    issue = selectRepresentativeIssue(issues, input.workflow.workflow);
+    if (!issue) {
+      checks.push(
+        failCheck(
+          "smoke_issue",
+          "Smoke target issue",
+          `No active live issue was found in GitHub Project "${input.projectDetail.title}".`,
+          `Move one issue into an active state (${input.workflow.workflow.lifecycle.activeStates.join(", ")}) or re-run with '--issue owner/repo#number'.`,
+          {
+            projectTitle: input.projectDetail.title,
+            activeStates: input.workflow.workflow.lifecycle.activeStates
+          }
+        )
+      );
+      return checks;
+    }
+  }
+  const repositoryName = `${issue.repository.owner}/${issue.repository.name}`;
+  if (!checks.some((check) => check.id === "project_repository_link")) {
+    if (!findLinkedRepository(
+      input.projectDetail,
+      issue.repository.owner,
+      issue.repository.name
+    )) {
+      checks.push(
+        failCheck(
+          "project_repository_link",
+          "Project repository link",
+          `Repository ${repositoryName} is not linked to GitHub Project "${input.projectDetail.title}".`,
+          "Run 'gh-symphony setup' from inside the target repository, or run 'gh-symphony workflow init' followed by 'gh-symphony repo init'.",
+          {
+            repository: repositoryName,
+            projectTitle: input.projectDetail.title
+          }
+        )
+      );
+    } else if (!isRepositoryConfigured(
+      input.selection,
+      issue.repository.owner,
+      issue.repository.name
+    )) {
+      checks.push(
+        failCheck(
+          "project_repository_link",
+          "Project repository link",
+          `Repository ${repositoryName} is linked to the GitHub Project but is not configured locally.`,
+          "Run 'gh-symphony repo init' from the target repository before running start.",
+          { repository: repositoryName }
+        )
+      );
+    } else {
+      checks.push(
+        passCheck(
+          "project_repository_link",
+          "Project repository link",
+          `Repository ${repositoryName} is linked to the GitHub Project and configured locally.`,
+          { repository: repositoryName }
+        )
+      );
+    }
+  }
+  checks.push(
+    passCheck(
+      "smoke_issue",
+      "Smoke target issue",
+      `Using live issue ${issue.identifier} (${issue.state}).`,
+      {
+        issue: issue.identifier,
+        state: issue.state,
+        source: input.parsedArgs.issue ? "explicit" : "auto"
+      }
+    )
+  );
+  try {
+    const renderedPrompt = renderIssueWorkflowPreview({
+      workflow: input.workflow.workflow,
+      issue,
+      attempt: null
+    });
+    checks.push(
+      passCheck(
+        "workflow_prompt_render",
+        "Workflow prompt render",
+        `WORKFLOW.md rendered successfully for ${issue.identifier}.`,
+        {
+          issue: issue.identifier,
+          promptLength: renderedPrompt.length,
+          workflowPath: input.workflow.workflowPath
+        }
+      )
+    );
+  } catch (error) {
+    checks.push(
+      failCheck(
+        "workflow_prompt_render",
+        "Workflow prompt render",
+        `WORKFLOW.md failed to render for ${issue.identifier}.`,
+        "Fix the prompt template variables or run 'gh-symphony workflow preview --issue ...' for a detailed preview error.",
+        {
+          issue: issue.identifier,
+          error: error instanceof Error ? error.message : String(error)
+        }
+      )
+    );
+  }
+  checks.push(
+    ...await buildHookChecks(
+      input.repoRoot,
+      input.workflow.workflow,
+      input.deps
+    )
+  );
+  return checks;
+}
 async function runDoctorDiagnostics(options, args, dependencies = {}) {
   const deps = { ...DEFAULT_DEPENDENCIES, ...dependencies };
   const parsedArgs = parseDoctorArgs(args);
   if (parsedArgs.error) {
-    throw new Error(
-      `${parsedArgs.error}
-Usage: gh-symphony doctor [--project-id <project-id>] [--fix]`
-    );
+    throw new Error(`${parsedArgs.error}
+${DOCTOR_USAGE}`);
   }
+  const repoRoot = process.cwd();
   const checks = [];
   let auth = null;
   let tokenError = null;
@@ -349,6 +753,8 @@ Usage: gh-symphony doctor [--project-id <project-id>] [--fix]`
   let envTokenError = null;
   let resolvedProjectId = null;
   let resolvedProjectConfig = null;
+  let resolvedGithubProjectDetail = null;
+  let resolvedGithubProjectBindingId = null;
   const envToken = deps.getEnvGitHubToken();
   const currentNodeVersion = deps.processVersion;
   const currentNodeMajor = parseMajorNodeVersion(currentNodeVersion);
@@ -529,7 +935,7 @@ Usage: gh-symphony doctor [--project-id <project-id>] [--fix]`
         "managed_project",
         "Managed project selection",
         resolvedProjectConfig.message,
-        "Run 'gh-symphony project add' to register a project, or select one with 'gh-symphony project switch' / '--project-id'.",
+        "Run 'gh-symphony repo init' from the target repository.",
         {
           reason: resolvedProjectConfig.kind,
           ...resolvedProjectConfig.projectId ? { projectId: resolvedProjectConfig.projectId } : {}
@@ -550,33 +956,38 @@ Usage: gh-symphony doctor [--project-id <project-id>] [--fix]`
         } : void 0
       )
     );
-  } else if (resolvedProjectConfig.kind === "resolved" && !resolvedProjectConfig.projectConfig.tracker.bindingId) {
+  } else if (resolvedProjectConfig.kind === "resolved" && !readGitHubProjectBinding(resolvedProjectConfig.projectConfig)) {
     checks.push(
       failCheck(
         "github_project_resolution",
         "GitHub project resolution",
         `Managed project "${resolvedProjectConfig.projectId}" is not bound to a GitHub Project.`,
-        "Re-run 'gh-symphony project add' and select a valid GitHub Project binding, then run the doctor command again.",
+        "Run 'gh-symphony workflow init' to select a valid GitHub Project binding, then run 'gh-symphony repo init' again.",
         {
           reason: "missing_binding",
           projectId: resolvedProjectConfig.projectId
         }
       )
     );
-  } else if (auth && resolvedProjectConfig.kind === "resolved" && resolvedProjectConfig.projectConfig.tracker.bindingId) {
+  } else if (auth && resolvedProjectConfig.kind === "resolved" && readGitHubProjectBinding(resolvedProjectConfig.projectConfig)) {
     try {
-      const client = deps.createClient(auth.token);
-      const detail = await deps.getProjectDetail(
-        client,
-        resolvedProjectConfig.projectConfig.tracker.bindingId
+      const bindingId = readGitHubProjectBinding(
+        resolvedProjectConfig.projectConfig
       );
+      if (!bindingId) {
+        throw new Error("Managed project is not bound to a GitHub Project.");
+      }
+      resolvedGithubProjectBindingId = bindingId;
+      const client = deps.createClient(auth.token);
+      const detail = await deps.getProjectDetail(client, bindingId);
+      resolvedGithubProjectDetail = detail;
       checks.push(
         passCheck(
           "github_project_resolution",
           "GitHub project resolution",
           `Resolved GitHub Project "${detail.title}".`,
           {
-            bindingId: resolvedProjectConfig.projectConfig.tracker.bindingId,
+            bindingId: resolvedGithubProjectBindingId,
             url: detail.url
           }
         )
@@ -587,11 +998,11 @@ Usage: gh-symphony doctor [--project-id <project-id>] [--fix]`
         failCheck(
           "github_project_resolution",
           "GitHub project resolution",
-          `Failed to resolve configured project binding '${resolvedProjectConfig.projectConfig.tracker.bindingId}'.`,
-          "Re-run 'gh-symphony project add' and select a valid GitHub Project, then run the doctor command again.",
+          `Failed to resolve configured project binding '${resolvedGithubProjectBindingId}'.`,
+          "Run 'gh-symphony workflow init' to select a valid GitHub Project, then run 'gh-symphony repo init' again.",
           {
             reason: "api_error",
-            bindingId: resolvedProjectConfig.projectConfig.tracker.bindingId,
+            bindingId: resolvedGithubProjectBindingId,
             error: message
           }
         )
@@ -733,6 +1144,21 @@ Usage: gh-symphony doctor [--project-id <project-id>] [--fix]`
       )
     );
   }
+  if (parsedArgs.smoke) {
+    checks.push(
+      ...await buildDoctorSmokeChecks({
+        auth,
+        selection: resolvedProjectConfig,
+        workflow,
+        projectDetail: resolvedGithubProjectDetail,
+        projectBindingId: resolvedGithubProjectBindingId,
+        repoRoot,
+        options,
+        parsedArgs,
+        deps
+      })
+    );
+  }
   return {
     ok: checks.every((check) => check.status !== "fail"),
     checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -963,9 +1389,9 @@ async function runDoctorFixes(report, deps, options) {
         if (check.details?.reason === "multiple_projects_require_selection") {
           steps.push(
             runCliRemediation(
-              "Managed project selection",
+              "Repository runtime setup",
               check.id,
-              ["project", "switch"],
+              ["repo", "init"],
               deps,
               options,
               interactive,
@@ -976,9 +1402,9 @@ async function runDoctorFixes(report, deps, options) {
         }
         steps.push(
           runCliRemediation(
-            "Managed project setup",
+            "Repository runtime setup",
             check.id,
-            ["project", "add"],
+            ["repo", "init"],
             deps,
             options,
             interactive,
@@ -1005,7 +1431,7 @@ async function runDoctorFixes(report, deps, options) {
             runCliRemediation(
               "GitHub project binding setup",
               check.id,
-              ["project", "add"],
+              ["setup"],
               deps,
               options,
               interactive,
@@ -1021,7 +1447,7 @@ async function runDoctorFixes(report, deps, options) {
             check.title,
             "manual",
             check.remediation ?? "Resolve the GitHub Project binding manually.",
-            formatGhSymphonyCommand(["project", "add"], deps, options),
+            formatGhSymphonyCommand(["setup"], deps, options),
             check.details
           )
         );
@@ -1051,7 +1477,7 @@ async function runDoctorFixes(report, deps, options) {
           runCliRemediation(
             title,
             check.id,
-            ["init"],
+            ["workflow", "init"],
             deps,
             options,
             interactive,
@@ -1142,10 +1568,8 @@ async function runDoctorCommand(args, options, dependencies = {}) {
     const deps = { ...DEFAULT_DEPENDENCIES, ...dependencies };
     const parsedArgs = parseDoctorArgs(args);
     if (parsedArgs.error) {
-      throw new Error(
-        `${parsedArgs.error}
-Usage: gh-symphony doctor [--project-id <project-id>] [--fix]`
-      );
+      throw new Error(`${parsedArgs.error}
+${DOCTOR_USAGE}`);
     }
     const initialReport = await runDoctorDiagnostics(options, args, deps);
     if (parsedArgs.fix) {