wogiflow 2.26.0 → 2.26.1

package/.claude/docs/phases/05-complete.md

@@ -33,7 +33,7 @@ Reflection: "Have I introduced any bugs or regressions?"
 
 1. Reflection: "Does this match what the user asked for?"
 2. Close out all TodoWrite items for this task
-3. Move task to recentlyCompleted in ready.json
+3. **Run `node node_modules/wogiflow/scripts/flow-done.js <taskId>`** — this is the ONLY supported way to complete a task. It runs quality gates, moves the task from `inProgress` → `recentlyCompleted`, writes the gate latch, and fires the task-boundary-restart Phase 1 marker. **Do NOT hand-edit `ready.json` to move the task** — that bypasses the CLI and silently disables: quality-gate verification, gate latch, and the task-boundary session restart. If `flow` is not on PATH in this environment, invoke it as `node node_modules/wogiflow/scripts/flow-done.js <taskId>` directly.
 4. Registry maps auto-updated by `registryUpdate` quality gate (runs `flow registry-manager scan` on all active registries — app-map, function-map, api-map, schema-map, service-map)
 5. If `config.webmcp.enabled` and UI files created: run `node node_modules/wogiflow/scripts/flow-webmcp-generator.js scan`
 6. Commit: `feat: Complete wf-XXXXXXXX - [title]`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wogiflow",
-  "version": "2.26.0",
+  "version": "2.26.1",
   "description": "AI-powered development workflow management system with multi-model support",
   "main": "lib/index.js",
   "bin": {

package/scripts/hooks/core/task-boundary-reset.js

@@ -50,6 +50,12 @@ const { getConfig, PATHS } = require('../../flow-utils');
 const { safeJsonParse } = require('../../flow-io');
 
 const PENDING_MARKER_FILE = 'task-just-completed';
+const LAST_TRIGGERED_FILE = 'task-boundary-last-triggered';
+// Window during which a recentlyCompleted[0] entry is considered "fresh
+// enough" to retro-mark Phase 1 from the Stop hook. Large enough to cover
+// a slow quality-gate run; small enough that a session opened hours later
+// doesn't trigger a bogus restart.
+const FRESHNESS_WINDOW_MS = 5 * 60 * 1000;
 
 /**
  * Locate the pending-marker file path inside .workflow/state/.
@@ -59,6 +65,26 @@ function getPendingMarkerPath() {
   return path.join(PATHS.state, PENDING_MARKER_FILE);
 }
 
+function getLastTriggeredPath() {
+  return path.join(PATHS.state, LAST_TRIGGERED_FILE);
+}
+
+function readLastTriggered() {
+  try {
+    return safeJsonParse(getLastTriggeredPath(), null);
+  } catch (_err) {
+    return null;
+  }
+}
+
+function writeLastTriggered(taskId) {
+  try {
+    const p = getLastTriggeredPath();
+    fs.mkdirSync(path.dirname(p), { recursive: true });
+    fs.writeFileSync(p, JSON.stringify({ taskId, at: new Date().toISOString() }));
+  } catch (_err) { /* best effort — anti-replay is defense-in-depth */ }
+}
+
 /**
  * Phase 1 — mark that a task just completed and a restart is desired at the
  * next Stop-hook boundary. Safe to call even when the feature is disabled;
@@ -196,6 +222,13 @@ function consumeAndTriggerRestart() {
     return { triggered: false, reason: `sigterm-failed: ${err.message}` };
   }
 
+  // Record anti-replay sentinel so the Stop-hook fallback in the NEW session
+  // (post-restart) doesn't retro-mark the same recentlyCompleted[0] and
+  // trigger a second restart.
+  if (markerPayload?.taskId) {
+    writeLastTriggered(markerPayload.taskId);
+  }
+
   return {
     triggered: true,
     flagPath: pre.flagPath,
@@ -203,6 +236,72 @@ function consumeAndTriggerRestart() {
   };
 }
 
+/**
+ * Phase 1 fallback — called from the Stop hook BEFORE
+ * consumeAndTriggerRestart. Detects a freshly-completed task in
+ * recentlyCompleted and writes the pending marker if neither of the primary
+ * Phase 1 paths fired.
+ *
+ * Why this exists: the primary Phase 1 writers are (a) flow-done.js:604 when
+ * `flow done <taskId>` runs, and (b) task-completed.js:522 driven by Claude
+ * Code's TaskCompleted hook. Path (b) does not fire for /wogi-start workflow
+ * completions (TaskCompleted fires for Task-tool sub-agents only — the reason
+ * for the two-phase redesign above). Path (a) only fires if the agent runs
+ * `flow done`. Older phase docs quietly encouraged "move task to
+ * recentlyCompleted in ready.json" as a substitute for `flow done`, which
+ * silently disables the restart. This fallback catches that case: if a fresh
+ * completion is visible in ready.json but no marker exists, we write one so
+ * Phase 2 can do its job.
+ *
+ * Anti-replay: recentlyCompleted[0] survives the SIGTERM + wrapper restart
+ * cycle, so without a guard the Stop hook in the NEW session would see the
+ * same fresh completion and trigger a second restart. The
+ * task-boundary-last-triggered sentinel prevents that — it records the last
+ * taskId we triggered on, and we skip if the current fresh completion
+ * matches.
+ *
+ * @returns {{ marked: boolean, taskId?: string, reason?: string }}
+ */
+function ensurePhase1MarkedIfRecentlyCompleted() {
+  try {
+    if (hasPendingMarker()) {
+      return { marked: false, reason: 'marker-already-present' };
+    }
+
+    const readyPath = path.join(PATHS.state, 'ready.json');
+    const ready = safeJsonParse(readyPath, null);
+    const recent = ready && Array.isArray(ready.recentlyCompleted)
+      ? ready.recentlyCompleted[0]
+      : null;
+    if (!recent || typeof recent !== 'object' || !recent.id || !recent.completedAt) {
+      return { marked: false, reason: 'no-fresh-completion' };
+    }
+
+    const completedTs = new Date(recent.completedAt).getTime();
+    if (!Number.isFinite(completedTs)) {
+      return { marked: false, reason: 'unparseable-completedAt' };
+    }
+    const ageMs = Date.now() - completedTs;
+    if (ageMs < 0 || ageMs > FRESHNESS_WINDOW_MS) {
+      return { marked: false, reason: 'stale-completion' };
+    }
+
+    const lastTriggered = readLastTriggered();
+    if (lastTriggered?.taskId === recent.id) {
+      return { marked: false, reason: 'already-triggered-for-this-task' };
+    }
+
+    const result = markRestartPending({
+      taskId: recent.id,
+      taskTitle: recent.title,
+      source: 'stop-hook-fallback'
+    });
+    return { marked: result.marked, taskId: recent.id, reason: result.reason };
+  } catch (err) {
+    return { marked: false, reason: `fallback-error: ${err.message}` };
+  }
+}
+
 /**
  * Convenience: whether a pending marker currently exists. Diagnostic only.
  * @returns {boolean}
@@ -219,6 +318,10 @@ module.exports = {
   // Phase 1 — called from task-completion code paths
   markRestartPending,
 
+  // Phase 1 fallback — called from the Stop hook entry BEFORE Phase 2,
+  // catches the case where flow-done didn't run and TaskCompleted didn't fire
+  ensurePhase1MarkedIfRecentlyCompleted,
+
   // Phase 2 — called from the Stop hook entry
   consumeAndTriggerRestart,
 

package/scripts/hooks/entry/claude-code/stop.js

@@ -155,7 +155,33 @@ runHook('Stop', async ({ parsedInput }) => {
   // No-op unless task-just-completed marker exists AND feature is enabled
   // AND wogi-claude wrapper env is present.
   try {
-    const { consumeAndTriggerRestart, hasPendingMarker } = require('../../core/task-boundary-reset');
+    const {
+      consumeAndTriggerRestart,
+      hasPendingMarker,
+      ensurePhase1MarkedIfRecentlyCompleted
+    } = require('../../core/task-boundary-reset');
+
+    // Phase 1 fallback: if the task completed via a path that didn't write the
+    // marker (e.g., agent edited ready.json directly instead of running
+    // `flow done`, or TaskCompleted hook didn't fire), retro-mark here so
+    // Phase 2 below can consume it. Anti-replay sentinel prevents double-firing
+    // across the SIGTERM + wrapper restart cycle.
+    try {
+      const fallback = ensurePhase1MarkedIfRecentlyCompleted();
+      if (fallback.marked && process.env.DEBUG) {
+        console.error(`[Stop] Phase 1 fallback marked ${fallback.taskId}`);
+      } else if (!fallback.marked && fallback.reason !== 'marker-already-present' &&
+                 fallback.reason !== 'no-fresh-completion' &&
+                 fallback.reason !== 'stale-completion' &&
+                 fallback.reason !== 'already-triggered-for-this-task' &&
+                 process.env.DEBUG) {
+        console.error(`[Stop] Phase 1 fallback skipped: ${fallback.reason}`);
+      }
+    } catch (err) {
+      if (process.env.DEBUG) {
+        console.error(`[Stop] Phase 1 fallback error (fail-open): ${err.message}`);
+      }
+    }
 
     // If we're about to restart, record the session in history FIRST so the
     // new session can find the prior session's resume token. Use parsedInput