@gr8ful/spf 0.8.0 → 0.8.1

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/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.1",
   "description": "Super Portable Factory — a global CLI for repeatable agents-plus-code workflows (ADWs)",
   "type": "module",
   "license": "MIT",