@gh-symphony/cli 0.2.0 → 0.2.3

package/dist/{doctor-JPNA7OCD.js → doctor-GIJAH7MA.js}

@@ -1,19 +1,21 @@
 #!/usr/bin/env node
 import {
+  buildPriorityConfigDiagnostics,
+  buildPriorityDriftDiagnostics,
   parseIssueReference,
   readGitHubProjectBinding,
   renderIssueWorkflowPreview
-} from "./chunk-JU3WSGMZ.js";
-import "./chunk-F46FTZJE.js";
+} from "./chunk-AA3T5AAJ.js";
+import "./chunk-PLBG7TZA.js";
 import {
   fetchGithubProjectIssueByRepositoryAndNumber,
   fetchGithubProjectIssues,
   inspectManagedProjectSelection
-} from "./chunk-CTTFIZYG.js";
-import "./chunk-B6OHDUSH.js";
+} from "./chunk-ZGNAAHLD.js";
+import "./chunk-FAU72YC2.js";
 import {
   resolveRuntimeRoot
-} from "./chunk-6I753NYO.js";
+} from "./chunk-RZ3WO7OV.js";
 import {
   GitHubApiError,
   REQUIRED_GH_SCOPES,
@@ -25,24 +27,397 @@ import {
   getEnvGitHubToken,
   getGhToken,
   getProjectDetail,
+  listRepositoryLabels,
   runGhAuthLogin,
   runGhAuthRefresh,
   validateGitHubToken
-} from "./chunk-Z3NZOPLZ.js";
+} from "./chunk-BOM2BYZQ.js";
 import {
   isClaudeRuntimeCommand,
   parseWorkflowMarkdown,
+  redactObservabilityDiagnosticsWithStats,
+  redactObservabilityTextWithStats,
   resolveClaudeCommandBinary,
   resolveRuntimeCommandBinary,
   runClaudePreflight
-} from "./chunk-Q3UEPUE3.js";
-import "./chunk-WOVNN5NW.js";
+} from "./chunk-3SKN5L3I.js";
+import {
+  configFilePath,
+  orchestratorLogPath,
+  projectConfigPath
+} from "./chunk-4ICDSQCJ.js";
 
 // src/commands/doctor.ts
-import { constants } from "fs";
+import { constants as constants2 } from "fs";
 import { execFileSync, spawnSync } from "child_process";
-import { access, mkdir, readFile, stat } from "fs/promises";
-import { delimiter, isAbsolute, join, resolve } from "path";
+import { access as access2, mkdir as mkdir2, readFile as readFile2, stat as stat2 } from "fs/promises";
+import { delimiter, isAbsolute, join as join2, resolve as resolve2 } from "path";
+
+// src/support/bundle.ts
+import { constants } from "fs";
+import { open } from "fs/promises";
+import {
+  access,
+  mkdir,
+  readdir,
+  readFile,
+  stat,
+  writeFile
+} from "fs/promises";
+import { dirname, join, relative, resolve, sep } from "path";
+var SUPPORT_BUNDLE_LIMITS = {
+  maxRuns: 3,
+  maxLogBytes: 64 * 1024,
+  maxLogLines: 500,
+  maxBundleBytes: 5 * 1024 * 1024
+};
+async function createSupportBundle(input) {
+  const createdAt = (input.now ?? /* @__PURE__ */ new Date()).toISOString();
+  const root = resolveBundleRoot(input.outputPath, input.repoRoot, createdAt);
+  await ensureWritableBundleRoot(root);
+  const state = {
+    root,
+    writtenBytes: 0,
+    manifest: {
+      version: 1,
+      createdAt,
+      projectId: input.projectId,
+      configDir: resolve(input.configDir),
+      included: [],
+      missing: [],
+      redactions: [],
+      truncations: [],
+      limits: SUPPORT_BUNDLE_LIMITS,
+      bundleBytes: {
+        written: 0,
+        softMax: SUPPORT_BUNDLE_LIMITS.maxBundleBytes,
+        exceeded: false
+      }
+    }
+  };
+  await writeJsonArtifact(state, "doctor.json", input.doctorReport);
+  await copyJsonArtifact(
+    state,
+    configFilePath(input.configDir),
+    "config/config.json"
+  );
+  await copyJsonArtifact(
+    state,
+    projectConfigPath(input.configDir, input.projectId),
+    "config/project.json"
+  );
+  await copyTextArtifact(
+    state,
+    join(input.repoRoot, "WORKFLOW.md"),
+    "repo/WORKFLOW.md",
+    { bounded: false }
+  );
+  const runtimeRoot = await resolveRuntimeArtifactRoot(
+    input.configDir,
+    input.projectId
+  );
+  await copyJsonArtifact(
+    state,
+    join(runtimeRoot, "status.json"),
+    "runtime/status.json"
+  );
+  await copyJsonArtifact(
+    state,
+    join(runtimeRoot, "issues.json"),
+    "runtime/issues.json"
+  );
+  await copyTextArtifact(
+    state,
+    orchestratorLogPath(input.configDir, input.projectId),
+    "runtime/orchestrator.log.tail",
+    { bounded: true }
+  );
+  const recentRuns = await listRecentRuns(input.configDir, input.projectId);
+  if (recentRuns.length === 0) {
+    state.manifest.missing.push({
+      path: "runs",
+      reason: "No run records were found for the selected project."
+    });
+  }
+  for (const recentRun of recentRuns) {
+    const destinationDir = `runs/${sanitizePathSegment(recentRun.runId)}`;
+    if (recentRun.run) {
+      await writeJsonArtifact(
+        state,
+        `${destinationDir}/run.json`,
+        recentRun.run
+      );
+    } else {
+      state.manifest.missing.push({
+        path: `${destinationDir}/run.json`,
+        reason: "Run metadata is missing or unreadable."
+      });
+    }
+    await copyTextArtifact(
+      state,
+      join(recentRun.runDir, "events.ndjson"),
+      `${destinationDir}/events.ndjson.tail`,
+      { bounded: true }
+    );
+    await copyTextArtifact(
+      state,
+      join(recentRun.runDir, "worker.log"),
+      `${destinationDir}/worker.log.tail`,
+      { bounded: true }
+    );
+  }
+  await writeManifest(state);
+  return buildSummary(state);
+}
+function resolveBundleRoot(outputPath, repoRoot, createdAt) {
+  if (outputPath) {
+    return resolve(repoRoot, outputPath);
+  }
+  const timestamp = createdAt.replace(/[:.]/g, "").replace("T", "-");
+  return resolve(repoRoot, `gh-symphony-support-bundle-${timestamp}`);
+}
+async function ensureWritableBundleRoot(root) {
+  await mkdir(root, { recursive: true });
+  const target = await stat(root);
+  if (!target.isDirectory()) {
+    throw new Error(`Bundle output path is not a directory: ${root}`);
+  }
+  await access(root, constants.W_OK);
+}
+async function writeJsonArtifact(state, relativePath, value) {
+  const redacted = redactObservabilityDiagnosticsWithStats(value);
+  addRedactions(state, redacted.redactions);
+  await writeBundleFile(
+    state,
+    relativePath,
+    JSON.stringify(redacted.value, null, 2) + "\n"
+  );
+}
+async function copyJsonArtifact(state, sourcePath, destinationPath) {
+  let raw;
+  try {
+    raw = await readFile(sourcePath, "utf8");
+  } catch (error) {
+    recordMissing(state, destinationPath, sourcePath, error);
+    return;
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    await writeJsonArtifact(state, destinationPath, parsed);
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      recordMissing(state, destinationPath, sourcePath, error);
+      return;
+    }
+    throw new Error(
+      `Failed to redact/write JSON artifact ${sourcePath}: ${formatError(error)}`
+    );
+  }
+}
+async function copyTextArtifact(state, sourcePath, destinationPath, options) {
+  let captured;
+  try {
+    captured = options.bounded ? await readBoundedTail(sourcePath) : { text: await readFile(sourcePath, "utf8"), truncated: false };
+  } catch (error) {
+    recordMissing(state, destinationPath, sourcePath, error);
+    return;
+  }
+  const redacted = redactObservabilityTextWithStats(captured.text);
+  addRedactions(state, redacted.redactions);
+  await writeBundleFile(state, destinationPath, redacted.value);
+  if (captured.truncated) {
+    state.manifest.truncations.push({
+      path: destinationPath,
+      originalBytes: captured.originalBytes,
+      writtenBytes: Buffer.byteLength(redacted.value, "utf8"),
+      maxBytes: SUPPORT_BUNDLE_LIMITS.maxLogBytes,
+      maxLines: SUPPORT_BUNDLE_LIMITS.maxLogLines,
+      reason: captured.reason ?? "bounded_tail"
+    });
+  }
+}
+async function readBoundedTail(sourcePath) {
+  const handle = await open(sourcePath, "r");
+  try {
+    const stats = await handle.stat();
+    const start = Math.max(0, stats.size - SUPPORT_BUNDLE_LIMITS.maxLogBytes);
+    const length = stats.size - start;
+    const buffer = Buffer.alloc(length);
+    if (length > 0) {
+      await handle.read(buffer, 0, length, start);
+    }
+    let text = buffer.toString("utf8");
+    let truncated = start > 0;
+    const reasons = [];
+    if (start > 0) {
+      reasons.push("maxLogBytes");
+      const firstNewline = text.indexOf("\n");
+      if (firstNewline >= 0) {
+        text = text.slice(firstNewline + 1);
+      } else {
+        reasons.push("partialLine");
+      }
+    }
+    const lines = text.split(/\r?\n/);
+    if (lines.length > SUPPORT_BUNDLE_LIMITS.maxLogLines) {
+      text = lines.slice(-SUPPORT_BUNDLE_LIMITS.maxLogLines).join("\n");
+      truncated = true;
+      reasons.push("maxLogLines");
+    }
+    return {
+      text,
+      truncated,
+      originalBytes: stats.size,
+      reason: reasons.join(",") || void 0
+    };
+  } finally {
+    await handle.close();
+  }
+}
+async function writeBundleFile(state, relativePath, content) {
+  const target = resolveBundlePath(state.root, relativePath);
+  await mkdir(dirname(target), { recursive: true });
+  await writeFile(target, content, "utf8");
+  state.writtenBytes += Buffer.byteLength(content, "utf8");
+  state.manifest.included.push(relativePath);
+}
+async function writeManifest(state) {
+  if (!state.manifest.included.includes("manifest.json")) {
+    state.manifest.included.push("manifest.json");
+  }
+  state.manifest.bundleBytes = {
+    written: state.writtenBytes,
+    softMax: SUPPORT_BUNDLE_LIMITS.maxBundleBytes,
+    exceeded: state.writtenBytes > SUPPORT_BUNDLE_LIMITS.maxBundleBytes
+  };
+  const target = resolveBundlePath(state.root, "manifest.json");
+  await writeFile(
+    target,
+    JSON.stringify(state.manifest, null, 2) + "\n",
+    "utf8"
+  );
+}
+function resolveBundlePath(root, relativePath) {
+  const target = resolve(root, relativePath);
+  const relativeTarget = relative(root, target);
+  if (relativeTarget === "" || relativeTarget.startsWith("..") || relativeTarget.includes(`..${sep}`)) {
+    throw new Error(`Refusing to write outside bundle root: ${relativePath}`);
+  }
+  return target;
+}
+function recordMissing(state, destinationPath, sourcePath, error) {
+  state.manifest.missing.push({
+    path: destinationPath,
+    reason: `${sourcePath}: ${formatError(error)}`
+  });
+}
+function addRedactions(state, redactions) {
+  const existing = new Map(
+    state.manifest.redactions.map((entry) => [entry.class, entry.count])
+  );
+  for (const redaction of redactions) {
+    existing.set(
+      redaction.class,
+      (existing.get(redaction.class) ?? 0) + redaction.count
+    );
+  }
+  state.manifest.redactions = Array.from(existing.entries()).map(([redactionClass, count]) => ({ class: redactionClass, count })).sort((left, right) => left.class.localeCompare(right.class));
+}
+async function resolveRuntimeArtifactRoot(configDir, projectId) {
+  const candidates = [
+    resolve(configDir),
+    resolve(configDir, "projects", projectId)
+  ];
+  for (const candidate of candidates) {
+    try {
+      await access(join(candidate, "status.json"), constants.R_OK);
+      return candidate;
+    } catch {
+      continue;
+    }
+  }
+  return candidates[0];
+}
+async function listRecentRuns(configDir, projectId) {
+  const runsDirs = [
+    resolve(configDir, "runs"),
+    resolve(configDir, "projects", projectId, "runs")
+  ];
+  const seen = /* @__PURE__ */ new Set();
+  const runs = [];
+  for (const runsDir of runsDirs) {
+    let entries;
+    try {
+      entries = await readdir(runsDir);
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const runId = sanitizePathSegment(entry);
+      if (seen.has(runId)) {
+        continue;
+      }
+      const runDir = join(runsDir, entry);
+      const runJsonPath = join(runDir, "run.json");
+      let run = null;
+      let updatedAt = "";
+      let active = false;
+      try {
+        const raw = await readFile(runJsonPath, "utf8");
+        run = JSON.parse(raw);
+        updatedAt = stringField(run, "updatedAt") ?? stringField(run, "endedAt") ?? stringField(run, "startedAt") ?? "";
+        const statusValue = stringField(run, "status");
+        active = statusValue === "running" || statusValue === "retrying";
+      } catch {
+        try {
+          const metadata = await stat(runDir);
+          updatedAt = metadata.mtime.toISOString();
+        } catch {
+          updatedAt = "";
+        }
+      }
+      seen.add(runId);
+      runs.push({ runId, runDir, run, updatedAt, active });
+    }
+  }
+  return runs.sort((left, right) => {
+    if (left.active !== right.active) {
+      return left.active ? -1 : 1;
+    }
+    return right.updatedAt.localeCompare(left.updatedAt);
+  }).slice(0, SUPPORT_BUNDLE_LIMITS.maxRuns);
+}
+function stringField(value, key) {
+  const field = value[key];
+  return typeof field === "string" ? field : null;
+}
+function sanitizePathSegment(value) {
+  return value.replace(/[^A-Za-z0-9._-]/g, "_");
+}
+function buildSummary(state) {
+  const redactionCount = state.manifest.redactions.reduce(
+    (sum, entry) => sum + entry.count,
+    0
+  );
+  return {
+    outputPath: state.root,
+    projectId: state.manifest.projectId,
+    includedCount: state.manifest.included.length,
+    missingCount: state.manifest.missing.length,
+    redactionCount,
+    redactionClasses: state.manifest.redactions,
+    truncationCount: state.manifest.truncations.length,
+    manifestPath: join(state.root, "manifest.json")
+  };
+}
+function formatError(error) {
+  if (error && typeof error === "object" && "code" in error && typeof error.code === "string") {
+    return error.code;
+  }
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/commands/doctor.ts
 var DEFAULT_DEPENDENCIES = {
   checkGhInstalled,
   checkGhAuthenticated,
@@ -53,12 +428,13 @@ var DEFAULT_DEPENDENCIES = {
   inspectManagedProjectSelection,
   createClient,
   getProjectDetail,
+  listRepositoryLabels,
   fetchProjectIssues: fetchGithubProjectIssues,
   fetchProjectIssue: fetchGithubProjectIssueByRepositoryAndNumber,
-  readFile,
-  access,
-  mkdir,
-  stat,
+  readFile: readFile2,
+  access: access2,
+  mkdir: mkdir2,
+  stat: stat2,
   parseWorkflowMarkdown,
   execFileSync,
   runGhAuthLogin,
@@ -76,9 +452,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>]";
+var DOCTOR_USAGE = "Usage: gh-symphony doctor [--project-id <project-id>] [--fix] [--smoke] [--issue <owner/repo#number>] [--bundle [path]]";
 function parseDoctorArgs(args) {
-  const parsed = { fix: false, smoke: false };
+  const parsed = { fix: false, smoke: false, bundle: false };
   for (let i = 0; i < args.length; i += 1) {
     const arg = args[i];
     if (arg === "--project" || arg === "--project-id") {
@@ -99,6 +475,15 @@ function parseDoctorArgs(args) {
       parsed.smoke = true;
       continue;
     }
+    if (arg === "--bundle") {
+      parsed.bundle = true;
+      const value = args[i + 1];
+      if (value && !value.startsWith("-")) {
+        parsed.bundlePath = value;
+        i += 1;
+      }
+      continue;
+    }
     if (arg === "--issue") {
       const value = args[i + 1];
       if (!value || value.startsWith("-")) {
@@ -113,10 +498,15 @@ function parseDoctorArgs(args) {
       parsed.error = `Unknown option '${arg}'`;
       return parsed;
     }
+    parsed.error = `Unexpected argument '${arg}'`;
+    return parsed;
   }
   if (parsed.issue && !parsed.smoke) {
     parsed.error = "Option '--issue' requires '--smoke'";
   }
+  if (parsed.bundle && parsed.fix) {
+    parsed.error = "Option '--fix' cannot be used with '--bundle'";
+  }
   return parsed;
 }
 function passCheck(id, title, summary, details) {
@@ -161,7 +551,7 @@ async function inspectPathState(targetPath, deps) {
       };
     }
     try {
-      await deps.access(targetPath, constants.W_OK);
+      await deps.access(targetPath, constants2.W_OK);
       return {
         exists: true,
         isDirectory: true,
@@ -255,7 +645,7 @@ async function commandExistsOnPath(binary, deps) {
   if (isAbsolute(binary) || binary.includes("/") || binary.includes("\\")) {
     for (const candidate of candidates) {
       try {
-        await deps.access(resolve(candidate), constants.X_OK);
+        await deps.access(resolve2(candidate), constants2.X_OK);
         return true;
       } catch {
         continue;
@@ -268,9 +658,9 @@ async function commandExistsOnPath(binary, deps) {
       continue;
     }
     for (const command of candidates) {
-      const candidate = join(segment, command);
+      const candidate = join2(segment, command);
       try {
-        await deps.access(candidate, constants.X_OK);
+        await deps.access(candidate, constants2.X_OK);
         return true;
       } catch {
         continue;
@@ -330,7 +720,7 @@ async function checkGitInstallation(deps) {
   }
 }
 async function checkWorkflow(repoRoot, deps) {
-  const workflowPath = join(repoRoot, "WORKFLOW.md");
+  const workflowPath = join2(repoRoot, "WORKFLOW.md");
   let markdown;
   try {
     markdown = await deps.readFile(workflowPath, "utf8");
@@ -371,10 +761,140 @@ function buildGithubTrackerConfig(input) {
     apiUrl: input.projectConfig.projectConfig.tracker.apiUrl,
     lifecycle: input.workflow.lifecycle,
     assignedOnly: settings?.assignedOnly === true,
+    priority: input.workflow.tracker.priority,
     priorityFieldName: typeof settings?.priorityFieldName === "string" ? settings.priorityFieldName : void 0,
     timeoutMs: typeof settings?.timeoutMs === "number" ? settings.timeoutMs : void 0
   };
 }
+async function buildPriorityMappingChecks(input) {
+  if (input.workflow.status !== "pass") {
+    return [];
+  }
+  const configDiagnostics = buildPriorityConfigDiagnostics(
+    input.workflow.workflow
+  );
+  const checks = configDiagnostics.map(
+    (diagnostic) => warnCheck(
+      "priority_mapping",
+      diagnostic.title,
+      diagnostic.summary,
+      diagnostic.remediation,
+      diagnostic.details
+    )
+  );
+  const priority = input.workflow.workflow.tracker.priority;
+  const parsedWorkflow = input.workflow.workflow;
+  if (input.workflow.workflow.tracker.kind !== "github-project" || !priority || priority.source === "disabled") {
+    if (checks.length === 0) {
+      checks.push(
+        passCheck(
+          "priority_mapping",
+          "Priority mapping",
+          priority?.source === "disabled" ? "Explicit priority mapping is disabled; dispatch priority resolves to null." : "No explicit priority mapping drift checks are required.",
+          { source: priority?.source ?? null }
+        )
+      );
+    }
+    return checks;
+  }
+  if (!input.auth || !input.selection || input.selection.kind !== "resolved" || !input.projectDetail || !input.projectBindingId) {
+    checks.push(
+      warnCheck(
+        "priority_mapping",
+        "Priority mapping drift",
+        "Live priority mapping drift checks could not run because GitHub authentication, managed project selection, or project resolution is unavailable.",
+        "Fix the prerequisite doctor checks, then re-run 'gh-symphony doctor'.",
+        {
+          blockedBy: [
+            ...!input.auth ? ["gh_authentication"] : [],
+            ...!input.selection || input.selection.kind !== "resolved" ? ["managed_project"] : [],
+            ...!input.projectDetail || !input.projectBindingId ? ["github_project_resolution"] : []
+          ]
+        }
+      )
+    );
+    return checks;
+  }
+  const client = input.deps.createClient(input.auth.token, {
+    apiUrl: input.selection.projectConfig.tracker.apiUrl
+  });
+  let repositoryLabels = priority.source === "labels" ? [] : null;
+  if (priority.source === "labels") {
+    try {
+      repositoryLabels = await Promise.all(
+        input.projectDetail.linkedRepositories.map(async (repository) => ({
+          repository: `${repository.owner}/${repository.name}`,
+          labels: (await input.deps.listRepositoryLabels(
+            client,
+            repository.owner,
+            repository.name
+          )).map((label) => label.name)
+        }))
+      );
+    } catch (error) {
+      checks.push(
+        warnCheck(
+          "priority_mapping",
+          "Priority label drift",
+          "Live repository labels could not be read for priority mapping drift checks.",
+          "Confirm GitHub token repository access and re-run 'gh-symphony doctor'.",
+          { error: formatSmokeError(error) }
+        )
+      );
+      repositoryLabels = null;
+    }
+  }
+  let activeIssues = [];
+  try {
+    const trackerConfig = buildGithubTrackerConfig({
+      projectConfig: input.selection,
+      bindingId: input.projectBindingId,
+      token: input.auth.token,
+      workflow: input.workflow.workflow
+    });
+    activeIssues = (await input.deps.fetchProjectIssues(trackerConfig)).filter(
+      (issue) => isActiveSmokeIssue(issue, parsedWorkflow)
+    );
+  } catch (error) {
+    checks.push(
+      warnCheck(
+        "priority_mapping",
+        "Active priority drift",
+        "Active issues could not be read for priority mapping drift checks.",
+        "Confirm GitHub token scopes, project visibility, and network access, then re-run 'gh-symphony doctor'.",
+        { error: formatSmokeError(error) }
+      )
+    );
+  }
+  const driftDiagnostics = buildPriorityDriftDiagnostics({
+    workflow: parsedWorkflow,
+    projectDetail: input.projectDetail,
+    repositoryLabels,
+    activeIssues
+  });
+  checks.push(
+    ...driftDiagnostics.map(
+      (diagnostic) => warnCheck(
+        "priority_mapping",
+        diagnostic.title,
+        diagnostic.summary,
+        diagnostic.remediation,
+        diagnostic.details
+      )
+    )
+  );
+  if (checks.length === 0) {
+    checks.push(
+      passCheck(
+        "priority_mapping",
+        "Priority mapping",
+        "Explicit priority mapping matches the live Project/repository state inspected by doctor.",
+        { source: priority.source }
+      )
+    );
+  }
+  return checks;
+}
 function isActiveSmokeIssue(issue, workflow) {
   const normalized = issue.state.trim().toLowerCase();
   return workflow.lifecycle.activeStates.some(
@@ -432,9 +952,9 @@ async function buildHookChecks(repoRoot, workflow, deps) {
       inline += 1;
       continue;
     }
-    const path = isAbsolute(command) ? command : resolve(repoRoot, command);
+    const path = isAbsolute(command) ? command : resolve2(repoRoot, command);
     try {
-      await deps.access(path, constants.F_OK);
+      await deps.access(path, constants2.F_OK);
       checked.push({ hook, command, path });
     } catch {
       unresolved.push({ hook, command, path });
@@ -447,7 +967,13 @@ async function buildHookChecks(repoRoot, workflow, deps) {
         "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 }
+        {
+          configured: configured.length,
+          pathsChecked: checked.length,
+          inline,
+          unresolved,
+          checked
+        }
       )
     ];
   }
@@ -458,7 +984,12 @@ async function buildHookChecks(repoRoot, workflow, deps) {
       "workflow_hooks",
       "Workflow hook paths",
       `${pathSummary}${inlineSummary}`,
-      { configured: configured.length, pathsChecked: checked.length, inline, checked }
+      {
+        configured: configured.length,
+        pathsChecked: checked.length,
+        inline,
+        checked
+      }
     )
   ];
 }
@@ -1145,6 +1676,16 @@ ${DOCTOR_USAGE}`);
       )
     );
   }
+  checks.push(
+    ...await buildPriorityMappingChecks({
+      auth,
+      selection: resolvedProjectConfig,
+      workflow,
+      projectDetail: resolvedGithubProjectDetail,
+      projectBindingId: resolvedGithubProjectBindingId,
+      deps
+    })
+  );
   if (parsedArgs.smoke) {
     checks.push(
       ...await buildDoctorSmokeChecks({
@@ -1268,7 +1809,7 @@ async function ensureDirectoryRemediation(check, deps) {
   }
   try {
     await deps.mkdir(pathValue, { recursive: true });
-    await deps.access(pathValue, constants.W_OK);
+    await deps.access(pathValue, constants2.W_OK);
     const target = await deps.stat(pathValue);
     if (!target.isDirectory()) {
       return remediationStep(
@@ -1564,6 +2105,19 @@ function renderTextReport(report) {
   );
   return lines.join("\n");
 }
+function renderBundleSummary(summary) {
+  const redactionClasses = summary.redactionClasses.length === 0 ? "none" : summary.redactionClasses.map((entry) => `${entry.class}:${entry.count}`).join(", ");
+  return [
+    "gh-symphony doctor support bundle",
+    `Output path: ${summary.outputPath}`,
+    `Project: ${summary.projectId}`,
+    `Included artifacts: ${summary.includedCount}`,
+    `Missing artifacts: ${summary.missingCount}`,
+    `Redactions: ${summary.redactionCount} (${redactionClasses})`,
+    `Truncations: ${summary.truncationCount}`,
+    `Manifest: ${summary.manifestPath}`
+  ].join("\n");
+}
 async function runDoctorCommand(args, options, dependencies = {}) {
   try {
     const deps = { ...DEFAULT_DEPENDENCIES, ...dependencies };
@@ -1573,6 +2127,27 @@ async function runDoctorCommand(args, options, dependencies = {}) {
 ${DOCTOR_USAGE}`);
     }
     const initialReport = await runDoctorDiagnostics(options, args, deps);
+    if (parsedArgs.bundle) {
+      if (!initialReport.projectId) {
+        throw new Error(
+          "Cannot create a support bundle because no managed project was resolved."
+        );
+      }
+      const summary = await createSupportBundle({
+        configDir: options.configDir,
+        projectId: initialReport.projectId,
+        repoRoot: process.cwd(),
+        outputPath: parsedArgs.bundlePath,
+        doctorReport: initialReport
+      });
+      if (options.json) {
+        process.stdout.write(JSON.stringify(summary, null, 2) + "\n");
+      } else {
+        process.stdout.write(renderBundleSummary(summary) + "\n");
+      }
+      process.exitCode = initialReport.ok ? 0 : 1;
+      return;
+    }
     if (parsedArgs.fix) {
       const remediation = {
         attempted: true,