@gr8ful/spf 0.8.1 → 0.8.2

package/dist/cli/commands/doctor.js

@@ -53,6 +53,33 @@ async function withProbeStatus(label, run) {
  * a plain `✓` so a real negative finding (e.g. "unreachable", a `/v1`
  * double-path warning) can't be mistaken for a pass at a glance.
  */
+/**
+ * Cross-check ONE chain's own `requiredAgents`/`requiredSuites` (derived
+ * from what it actually does — `resolveRequiredAgents`/`resolveRequiredSuites`,
+ * same as `spf list`/a real dispatch would resolve) against what `cfg`
+ * actually has. Shared by the repo-chain loop below (every `.spf/chains/
+ * *.yaml` chain) and `watch.chain`/`watch.refine.chain` — the two chains
+ * `spf watch` will ACTUALLY dispatch, built-in or not. Extracted specifically
+ * because the repo-chain loop used to be the ONLY place this ran, and it
+ * skips every built-in chain by construction (`.filter((c) => c.source !==
+ * undefined)`) — so a `watch.chain` naming a built-in like `plan-build-test`
+ * never went through it at all: `spf doctor` could report clean while `spf
+ * watch`'s very first claimed issue failed at runtime on a missing
+ * `quality.suites` entry doctor never actually looked for.
+ */
+function checkChainRequirements(report, label, chain, cfg) {
+    const owners = resolveRequiredAgents(chain, {});
+    const missingOwners = owners.filter((o) => !cfg.agents.some((a) => a.name === o));
+    check(report, `${label} owners`, missingOwners.length === 0, missingOwners.length === 0 ? owners.join(", ") || "(none)" : `unknown agent(s): ${missingOwners.join(", ")} — not in cfg.agents`);
+    const suiteNames = resolveRequiredSuites(chain, {});
+    const missingSuites = suiteNames.filter((s) => !(s in cfg.quality.suites));
+    const missingChecks = missingSuites.length === 0 ? suiteNames.flatMap((s) => cfg.quality.suites[s].filter((n) => !cfg.quality.checks.some((c) => c.name === n))) : [];
+    check(report, `${label} suites`, missingSuites.length === 0 && missingChecks.length === 0, missingSuites.length > 0
+        ? `unknown suite(s): ${missingSuites.join(", ")} — not in cfg.quality.suites`
+        : missingChecks.length > 0
+            ? `suite(s) name unknown check(s): ${missingChecks.join(", ")}`
+            : suiteNames.join(", ") || "(none)");
+}
 function check(report, name, ok, detail, severity) {
     report.checks.push({ name, ok, detail, severity });
     if (!ok)
@@ -468,17 +495,7 @@ export async function doctorCommand(argv) {
         check(report, `repo chain ${problem.file}`, false, problem.message);
     }
     for (const chain of allChains().filter((c) => c.source !== undefined)) {
-        const owners = resolveRequiredAgents(chain, {});
-        const missingOwners = owners.filter((o) => !cfg.agents.some((a) => a.name === o));
-        check(report, `repo chain "${chain.name}" owners`, missingOwners.length === 0, missingOwners.length === 0 ? owners.join(", ") || "(none)" : `unknown agent(s): ${missingOwners.join(", ")} — not in cfg.agents`);
-        const suiteNames = resolveRequiredSuites(chain, {});
-        const missingSuites = suiteNames.filter((s) => !(s in cfg.quality.suites));
-        const missingChecks = missingSuites.length === 0 ? suiteNames.flatMap((s) => cfg.quality.suites[s].filter((n) => !cfg.quality.checks.some((c) => c.name === n))) : [];
-        check(report, `repo chain "${chain.name}" suites`, missingSuites.length === 0 && missingChecks.length === 0, missingSuites.length > 0
-            ? `unknown suite(s): ${missingSuites.join(", ")} — not in cfg.quality.suites`
-            : missingChecks.length > 0
-                ? `suite(s) name unknown check(s): ${missingChecks.join(", ")}`
-                : suiteNames.join(", ") || "(none)");
+        checkChainRequirements(report, `repo chain "${chain.name}"`, chain, cfg);
         // Informational: the derived sequence itself, same string `spf list`
         // shows — printed here so the chain's author can eyeball what they
         // actually wrote without a second command.
@@ -537,6 +554,19 @@ export async function doctorCommand(argv) {
         // same way it would for `spf watch` itself, no special-casing needed.
         const watchChain = findChain(cfg.watch.chain);
         check(report, "watch.chain", Boolean(watchChain), watchChain ? `${cfg.watch.chain}${watchChain.source ? ` (repo: ${repoChainLabel(watchChain.source)})` : ""}` : `"${cfg.watch.chain}" is not a registered chain`);
+        // The "repo chain X suites/owners" loop above only covers chains with a
+        // `.source` (loaded from `.spf/chains/*.yaml`) — a BUILT-IN chain named
+        // by `watch.chain` (the common case: `plan-build-test`, etc.) never went
+        // through that check, and the "roster + suites validate" call earlier
+        // only validates suites already present in `cfg.quality.suites`, not
+        // whether `watch.chain` actually NEEDS one that's missing entirely. That
+        // gap is exactly how `spf doctor` can report clean while `spf watch`'s
+        // very first claimed issue fails at runtime with "quality.suites.\"test\"
+        // is not configured" — this closes it by checking the chain `spf watch`
+        // will ACTUALLY dispatch, the same way the repo-chain loop already does.
+        if (watchChain) {
+            checkChainRequirements(report, `watch.chain "${cfg.watch.chain}"`, watchChain, cfg);
+        }
         // Informational only, never a failure: a chain that skips review and/or
         // never commits is a legitimate choice (e.g. `scout`, `plan`) — this is
         // here so an unattended `spf watch` posture is a visible fact, not a
@@ -558,6 +588,9 @@ export async function doctorCommand(argv) {
         if (cfg.watch.refine.enabled) {
             const refineChain = findChain(cfg.watch.refine.chain);
             check(report, "watch.refine.chain", Boolean(refineChain), refineChain ? `${cfg.watch.refine.chain}${refineChain.source ? ` (repo: ${repoChainLabel(refineChain.source)})` : ""}` : `"${cfg.watch.refine.chain}" is not a registered chain`);
+            if (refineChain) {
+                checkChainRequirements(report, `watch.refine.chain "${cfg.watch.refine.chain}"`, refineChain, cfg);
+            }
             check(report, "watch.refine issue authoring", cfg.watch.issue_provider === "github" || cfg.watch.issue_provider === "jira", cfg.watch.issue_provider === "github"
                 ? "github supports issue authoring (createIssue/sub-issues)"
                 : cfg.watch.issue_provider === "jira"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gr8ful/spf",
-  "version": "0.8.1",
+  "version": "0.8.2",
   "description": "Super Portable Factory — a global CLI for repeatable agents-plus-code workflows (ADWs)",
   "type": "module",
   "license": "MIT",