@gr8ful/spf 0.8.0 → 0.8.2

package/dist/chains/steps.d.ts

@@ -316,6 +316,23 @@ export declare function refine(opts?: {
     retries?: number;
     extraGates?: string[];
 }): Step;
+/**
+ * `cli/commands/watch.ts`'s `runRefine()` reads BOTH `refine_publish.json`
+ * and `refine_questions.json` back, unconditionally, after this chain
+ * exits — it has no other way to learn what THIS run did, since a chain's
+ * return value is just an exit code. A resumed spec (`continue-refinement`)
+ * reruns this entire chain from `request` on, into the SAME deterministic
+ * `context_handoff_dir` a PRIOR round already wrote into. Without clearing
+ * the file this run is NOT about to write, a stale `refine_questions.json`
+ * from an earlier escalation round survives a LATER round's successful
+ * publish — `runRefine` then reports those old questions as if raised
+ * again THIS round, so `runSpec` escalates a second time even though real
+ * issues were already created on the tracker seconds earlier. Called
+ * before EITHER branch writes, so exactly one of the two files reflects
+ * this run when the phase returns, never a leftover from a previous one.
+ * `force: true` — a first-ever run has neither file yet, which is fine.
+ */
+export declare function clearStaleRefineOutputFiles(contextHandoffDir: string): void;
 export declare function publishIssues(opts?: {
     description?: string;
 }): Step;

package/dist/chains/steps.js

@@ -40,7 +40,7 @@
  *    chain is a load-time problem the loader can report against a file and a
  *    line, never a phase that blows up ten minutes into an unattended run.
  */
-import { writeFileSync } from "node:fs";
+import { rmSync, writeFileSync } from "node:fs";
 import path from "node:path";
 import * as changesLib from "../core/changes.js";
 import * as gates from "../core/gates.js";
@@ -723,6 +723,27 @@ function parsePriorityOption(raw) {
     }
     return raw;
 }
+/**
+ * `cli/commands/watch.ts`'s `runRefine()` reads BOTH `refine_publish.json`
+ * and `refine_questions.json` back, unconditionally, after this chain
+ * exits — it has no other way to learn what THIS run did, since a chain's
+ * return value is just an exit code. A resumed spec (`continue-refinement`)
+ * reruns this entire chain from `request` on, into the SAME deterministic
+ * `context_handoff_dir` a PRIOR round already wrote into. Without clearing
+ * the file this run is NOT about to write, a stale `refine_questions.json`
+ * from an earlier escalation round survives a LATER round's successful
+ * publish — `runRefine` then reports those old questions as if raised
+ * again THIS round, so `runSpec` escalates a second time even though real
+ * issues were already created on the tracker seconds earlier. Called
+ * before EITHER branch writes, so exactly one of the two files reflects
+ * this run when the phase returns, never a leftover from a previous one.
+ * `force: true` — a first-ever run has neither file yet, which is fine.
+ */
+export function clearStaleRefineOutputFiles(contextHandoffDir) {
+    for (const name of ["refine_questions.json", "refine_publish.json"]) {
+        rmSync(path.join(contextHandoffDir, name), { force: true });
+    }
+}
 export function publishIssues(opts = {}) {
     preflightDescription("publish", opts.description);
     const fn = async (run, state) => {
@@ -738,6 +759,7 @@ export function publishIssues(opts = {}) {
             owner: "tracker",
             description: opts.description ?? "Create the feature/story tree on the tracker, in dependency order, and link each to its parent",
         }), async (ph) => {
+            clearStaleRefineOutputFiles(run.context_handoff_dir);
             if (questions.length > 0) {
                 writeFileSync(path.join(run.context_handoff_dir, "refine_questions.json"), JSON.stringify(questions, null, 2));
                 ph.log({ escalated: questions.length });

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/dist/cli/commands/watch.js

@@ -457,6 +457,18 @@ export async function watchCommand(argv) {
         catch {
             // best-effort, same as above — no questions file means this run wasn't an escalation
         }
+        // Defense in depth: `steps.publishIssues()` now clears whichever of
+        // these two files it's NOT about to write, so both should never be
+        // non-empty here — but if some future change (or an older worktree's
+        // leftover files, before that fix existed) ever produces both, a real
+        // completed publish must never be silently overridden by a stale
+        // question. `runSpec` checks `questions.length > 0` first, so without
+        // this it would re-escalate over issues that already landed on the
+        // tracker seconds earlier.
+        if (created.length > 0 && questions.length > 0) {
+            console.error(`watch: ${opts.adwId}: refine_publish.json AND refine_questions.json both had content — treating the ${created.length} published issue(s) as authoritative and discarding the stale question(s)`);
+            questions = [];
+        }
         return { accepted: true, adwId: opts.adwId, detail: "", created, questions };
     };
     // `IssueAuthoringProvider`'s read-back half — `isAuthoringProvider()` is a

package/package.json

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