wogiflow 2.33.0 → 2.34.1

package/scripts/hooks/core/git-safety-gate.js

@@ -108,14 +108,19 @@ function getAffectedFileCount(targetRef) {
 
 /**
  * Create a backup branch at current HEAD.
+ *
+ * Uses `execFileSync` (no shell) per `security-patterns.md §8` — the branch
+ * name is timestamp-derived and currently safe, but going through the shell
+ * with template-string interpolation is the wrong-by-default pattern.
+ *
  * @returns {string|null} Branch name or null on failure.
  */
 function createBackupBranch() {
-  const { execSync } = require('node:child_process');
+  const { execFileSync } = require('node:child_process');
   const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
   const branchName = `backup/pre-reset-${timestamp}`;
   try {
-    execSync(`git branch "${branchName}"`, {
+    execFileSync('git', ['branch', branchName], {
       encoding: 'utf-8', cwd: PATHS.root, stdio: ['pipe', 'pipe', 'pipe']
     });
     return branchName;
@@ -126,20 +131,27 @@ function createBackupBranch() {
 
 /**
  * Clean up old backup branches, keeping only the most recent N.
+ *
+ * Uses `execFileSync` (no shell) per `security-patterns.md §8`. Branch names
+ * pulled from `git branch --list` output and passed back to `git branch -D`
+ * never touch a shell.
+ *
  * @param {number} keep
  */
 function rotateBackupBranches(keep) {
-  const { execSync } = require('node:child_process');
+  const { execFileSync } = require('node:child_process');
   try {
-    const branches = execSync('git branch --list "backup/pre-reset-*" --sort=-creatordate', {
-      encoding: 'utf-8', cwd: PATHS.root, stdio: ['pipe', 'pipe', 'pipe']
-    }).trim().split('\n').map(b => b.trim()).filter(Boolean);
+    const branches = execFileSync(
+      'git',
+      ['branch', '--list', 'backup/pre-reset-*', '--sort=-creatordate'],
+      { encoding: 'utf-8', cwd: PATHS.root, stdio: ['pipe', 'pipe', 'pipe'] }
+    ).trim().split('\n').map(b => b.trim()).filter(Boolean);
 
     if (branches.length > keep) {
       const toDelete = branches.slice(keep);
       for (const branch of toDelete) {
         try {
-          execSync(`git branch -D "${branch}"`, {
+          execFileSync('git', ['branch', '-D', branch], {
             cwd: PATHS.root, stdio: ['pipe', 'pipe', 'pipe']
           });
         } catch (_err) {
@@ -170,27 +182,34 @@ function rotateBackupBranches(keep) {
  * `git checkout .` / `git restore .` through either way. This was BUG-1.
  *
  * @param {Object} [opts]
- * @param {Function} [opts.exec] - execSync replacement for testing (string cmd → string stdout, throws on error).
+ * @param {Function} [opts.exec] - execFileSync-shaped replacement for testing.
+ *   Signature: `(file, args, opts) → stdout`. Throws on non-zero exit. Default
+ *   uses `child_process.execFileSync` so no shell layer is involved — closes
+ *   the security-patterns.md §8 violation that earlier versions had.
  * @returns {{ status: 'no-changes' | 'stashed' | 'failed', error?: string, stashRef?: string }}
  */
 function autoStash(opts = {}) {
-  const exec = opts.exec || require('node:child_process').execSync;
+  const exec = opts.exec || require('node:child_process').execFileSync;
   const runOpts = { encoding: 'utf-8', cwd: PATHS.root, stdio: ['pipe', 'pipe', 'pipe'] };
 
   // 1. Anything to stash?
   let status;
   try {
-    status = exec('git status --porcelain', runOpts).trim();
+    status = exec('git', ['status', '--porcelain'], runOpts).trim();
   } catch (err) {
     return { status: 'failed', error: `git status failed: ${err.message || err}` };
   }
   if (!status) return { status: 'no-changes' };
 
-  // 2. Attempt the stash.
+  // 2. Attempt the stash. TOCTOU-resistant message (F18): include a random
+  //    UUID-style suffix so two parallel runs can't collide on the stash@{0}
+  //    verification step and so substring matches can't be forged by an
+  //    attacker-controlled stash with the same timestamp prefix.
   const timestamp = new Date().toISOString().slice(0, 19);
-  const stashMessage = `auto-backup-${timestamp}`;
+  const nonce = require('node:crypto').randomBytes(6).toString('hex');
+  const stashMessage = `auto-backup-${timestamp}-${nonce}`;
   try {
-    exec(`git stash push -m "${stashMessage}"`, runOpts);
+    exec('git', ['stash', 'push', '-m', stashMessage], runOpts);
   } catch (err) {
     return { status: 'failed', error: `git stash push failed: ${err.message || err}` };
   }
@@ -198,11 +217,11 @@ function autoStash(opts = {}) {
   // 3. VERIFY the stash actually saved (BUG-1 / wf-2d3d09b8). A zero exit code
   //    from `git stash push` is NOT proof: lock contention, broken hooks, or
   //    edge cases can leave the working tree unchanged with status 0. Confirm
-  //    by reading `git stash list` and matching our timestamped message at
+  //    by reading `git stash list` and matching our nonce-suffixed message at
   //    stash@{0}.
   let stashList;
   try {
-    stashList = exec('git stash list', runOpts);
+    stashList = exec('git', ['stash', 'list'], runOpts);
   } catch (err) {
     return { status: 'failed', error: `stash verification (git stash list) failed: ${err.message || err}` };
   }

package/scripts/hooks/core/overdue-dispatches.js

@@ -53,7 +53,7 @@ function formatLine(record, now) {
  */
 function sweepAndReconcile(workspaceRoot) {
   let reconciled = 0;
-  let readMessages, reconcileDispatch, readDispatches;
+  let readMessages, reconcileDispatch, readDispatches, refreshDispatchDeadline;
   try {
     const libMessages = path.resolve(__dirname, '..', '..', '..', 'lib', 'workspace-messages.js');
     const libTracking = path.resolve(__dirname, '..', '..', '..', 'lib', 'workspace-dispatch-tracking.js');
@@ -61,6 +61,7 @@ function sweepAndReconcile(workspaceRoot) {
     const tracking = require(libTracking);
     reconcileDispatch = tracking.reconcileDispatch;
     readDispatches = tracking.readDispatches;
+    refreshDispatchDeadline = tracking.refreshDispatchDeadline;
   } catch (_err) {
     return 0; // Fail-open
   }
@@ -78,13 +79,32 @@ function sweepAndReconcile(workspaceRoot) {
     if (r.taskId && !byTaskId.has(r.taskId)) byTaskId.set(r.taskId, r);
   }
 
-  // Pull both message types. readMessages throws on missing dir internally
-  // but guards with existsSync, so it's safe.
+  // S3 (wf-d3ae1717): heartbeats refresh the deadline (work ongoing, NOT a
+  // silent halt); terminal types resolve the dispatch. worker-progress is
+  // applied FIRST so a heartbeat that arrived before a terminal doesn't keep a
+  // since-resolved dispatch alive.
+  try {
+    const heartbeats = readMessages(workspaceRoot, { type: 'worker-progress' });
+    if (refreshDispatchDeadline) {
+      for (const hb of heartbeats) {
+        const taskId = hb.taskId;
+        if (!taskId || !byTaskId.has(taskId)) continue;
+        try { refreshDispatchDeadline(workspaceRoot, taskId); } catch (_err) { /* per-record */ }
+      }
+    }
+  } catch (_err) { /* heartbeats are best-effort */ }
+
+  // Pull terminal message types. readMessages throws on missing dir internally
+  // but guards with existsSync, so it's safe. worker-blocked / worker-idle /
+  // worker-awaiting-approval are terminal stops alongside the legacy pair.
   let messages = [];
   try {
     const completes = readMessages(workspaceRoot, { type: 'task-complete' });
     const stops = readMessages(workspaceRoot, { type: 'worker-stopped' });
-    messages = completes.concat(stops);
+    const blocked = readMessages(workspaceRoot, { type: 'worker-blocked' });
+    const idle = readMessages(workspaceRoot, { type: 'worker-idle' });
+    const awaiting = readMessages(workspaceRoot, { type: 'worker-awaiting-approval' });
+    messages = completes.concat(stops, blocked, idle, awaiting);
   } catch (_err) {
     return 0;
   }
@@ -93,8 +113,10 @@ function sweepAndReconcile(workspaceRoot) {
     const taskId = msg.taskId || (msg.type === 'task-complete' ? msg.subject : null);
     if (!taskId || !byTaskId.has(taskId)) continue;
     try {
-      const status = msg.type === 'worker-stopped' ? 'graceful-stop' : 'completed';
-      const reason = msg.type === 'worker-stopped' ? (msg.reason || 'graceful') : null;
+      // task-complete → completed; everything else is a non-overdue graceful
+      // stop (the reason field distinguishes blocked / awaiting / idle / graceful).
+      const status = msg.type === 'task-complete' ? 'completed' : 'graceful-stop';
+      const reason = msg.type === 'task-complete' ? null : (msg.reason || msg.type);
       const result = reconcileDispatch(workspaceRoot, taskId, status, reason);
       if (result) {
         reconciled++;

package/scripts/hooks/core/session-start-worker.js

@@ -40,6 +40,58 @@ function handleWorkerSessionStart() {
     const { isWorker, shouldAnnounceReady, announceWorkerReady } = require(WORKER_READY_LIB);
     if (!isWorker()) return { branch: 'skip', reason: 'not-worker' };
 
+    // S5 (wf-ee87a24e): RESUME-IN-PROGRESS. If this restarted session has a task
+    // still in `inProgress` with sub-tasks remaining (durable S1 ledger), resume
+    // THAT task — do NOT fall through to "announce idle" (which would orphan it)
+    // or pick a different next task. The durable ledger means completed sub-tasks
+    // are NOT redone. Also post a worker-ready ack so the manager actively
+    // re-triggers if the resume wake-up was missed.
+    try {
+      const { PATHS, safeJsonParse } = require('../../flow-utils');
+      const ready = safeJsonParse(path.join(PATHS.state, 'ready.json'), { inProgress: [] });
+      const inProgress = (ready.inProgress || [])[0] || null;
+      if (inProgress && inProgress.id) {
+        let remaining = null, total = null;
+        try {
+          const subtaskState = require(path.join(__dirname, '..', '..', '..', 'lib', 'workspace-subtask-state.js'));
+          const summary = subtaskState.summary(inProgress.id);
+          remaining = summary.remaining; total = summary.total;
+        } catch (_err) { /* ledger optional */ }
+        // Only treat as resumable if there is remaining decomposed work, OR no
+        // ledger exists at all (single-step task interrupted mid-flight).
+        if (remaining === null || remaining > 0) {
+          // Best-effort ack so the manager knows the worker is back on this task.
+          // Bypass shouldAnnounceReady's empty-queue gating (it returns
+          // 'in-progress-not-empty' here by design) — for a resume we WANT the
+          // manager pinged. announceWorkerReady dedups via hasPendingAnnounce.
+          try {
+            const wr = require(WORKER_READY_LIB);
+            const wsRoot = process.env.WOGI_WORKSPACE_ROOT;
+            const repoName = process.env.WOGI_REPO_NAME;
+            if (wsRoot && repoName && repoName !== 'manager') {
+              wr.announceWorkerReady(wsRoot, repoName);
+            }
+          } catch (_err) { /* ack is best-effort */ }
+          const ctx = [
+            `⚡ WORKSPACE SESSION START — RESUMING IN-PROGRESS TASK`,
+            '',
+            `This worker restarted with task ${inProgress.id} still in progress${total != null ? ` (${remaining} of ${total} sub-task(s) remaining)` : ''}.`,
+            `Durable sub-task state is on disk — completed sub-tasks are recorded and must NOT be redone.`,
+            '',
+            'AUTONOMOUS MODE CONTRACT (workspace worker):',
+            '  • Resume the SAME task — do not pick a different one, do not go idle.',
+            '  • Read .workflow/state/subtask-state.json to see which sub-tasks remain.',
+            '  • Grind to completion; only stop when done (flow done) or genuinely blocked.',
+            '',
+            `ACT NOW: Invoke Skill(skill="wogi-start", args="${inProgress.id}")`
+          ].join('\n');
+          return { branch: 'resume-in-progress', context: ctx, taskId: inProgress.id, remaining, total };
+        }
+      }
+    } catch (err) {
+      if (process.env.DEBUG) console.error(`[session-start-worker] resume-in-progress check failed (fail-open): ${err.message}`);
+    }
+
     // Check for queued work first — if any, tell the model to pick it up
     // instead of announcing idle readiness.
     let pickup;

package/scripts/hooks/core/stop-orchestrator.js

@@ -87,8 +87,12 @@ async function orchestrateStop({ parsedInput }) {
     };
   }
 
+  // S3 (wf-d3ae1717): the worker-stopped emission used to fire HERE,
+  // unconditionally, before any gate decided to continue — so the manager saw
+  // "stopped mid-work" on every turn boundary. It now fires only at a genuine
+  // stop (end of this function) with a precise terminal type, and a
+  // worker-progress heartbeat fires from the continuation gate instead.
   const workspaceNotify = require('./workspace-stop-notify');
-  await workspaceNotify.notifyWorkerStopped();
 
   const restartCoordinator = require('./task-boundary-restart-coordinator');
   const restartResult = await restartCoordinator.handleTaskBoundaryRestart({ parsedInput });
@@ -120,7 +124,18 @@ async function orchestrateStop({ parsedInput }) {
   const wsResult = await workspaceGates.checkWorkspaceStopGates({ parsedInput });
   if (wsResult?.shouldReturn) return wsResult.result;
 
-  return await checkLoopExit();
+  // Genuine stop path: no gate forced continuation. Emit a precise terminal
+  // worker signal ONLY when we're actually allowing the turn to end (canExit).
+  // continueToNext / blocked-continue are not terminal stops.
+  const loopResult = await checkLoopExit();
+  try {
+    if (loopResult?.canExit === true) {
+      await workspaceNotify.notifyWorkerTerminal();
+    }
+  } catch (err) {
+    if (process.env.DEBUG) console.error(`[Stop] terminal notify error (fail-open): ${err.message}`);
+  }
+  return loopResult;
 }
 
 module.exports = { orchestrateStop };

package/scripts/hooks/core/validation.js

@@ -222,6 +222,14 @@ async function runValidation(options = {}) {
 
   return {
     passed: allPassed,
+    // F6 (R-379): signal `blocked` so the adapter's `decision: 'block'` path
+    // actually fires when validation fails. Without this, the `continueOnBlock`
+    // wiring in transformPostToolUse is inert (decision is always undefined).
+    // With it, lint/typecheck failure after Edit/Write feeds back to Claude
+    // and (per the continueOnBlock setting) the turn continues so Claude can
+    // fix the error in-loop — which is what CLAUDE.md's "validate after every
+    // file edit" rule needs.
+    blocked: !allPassed,
     skipped: false,
     results,
     summary: generateValidationSummary(results, filePath)

package/scripts/hooks/core/worker-continuation-gate.js

@@ -0,0 +1,326 @@
+'use strict';
+
+/**
+ * Worker In-Progress Continuation Gate
+ * (epic-workspace-sustained-exec / S2, wf-aee4a4fa)
+ *
+ * THE core fix for "channel-dispatched workers stall after one turn." The
+ * existing "Gap B" gate (workspace-stop-gates.js) only forces continuation when
+ * a dispatch is queued but NOT started (inProgressCount===0). When a decomposed
+ * task is already in-progress and the worker stops mid-way, nothing keeps it
+ * going. This gate fills that hole.
+ *
+ * On a worker Stop, if a task is in-progress in an active-work phase with
+ * sub-tasks remaining (durable ledger from S1) and no escalation is pending and
+ * the per-task cap isn't exhausted, it returns {continue:true} so Claude Code
+ * does NOT stop — keeping the SAME session alive (preserving in-context
+ * decomposition, sidestepping the flaky channel wake-up). The proven mechanism
+ * is the same one the routing-gate / research-required-gate / tool-first-gate
+ * already use.
+ *
+ * Termination (no infinite loop):
+ *   - Task leaves inProgress (done) ⇒ remaining()=0 / no inProgress ⇒ gate stops.
+ *   - Per-task iteration cap = total*perSubtaskTurns + capBuffer (≤ maxContinuations).
+ *   - No-progress detector: a "progress fingerprint" = hash(git status --porcelain)
+ *     + remaining-count. If it doesn't change across noProgressK consecutive
+ *     continuations, the worker isn't doing anything ⇒ escalate ## BLOCKED + stop.
+ *     Any file edit OR completed sub-task changes the fingerprint, so legitimately
+ *     long multi-turn refactors (no commits yet) are NOT false-killed, and a
+ *     failing `flow done` that the worker keeps editing around still counts as
+ *     progress.
+ *
+ * Phase-gating: fires only in active-work phases (coding/validating). In
+ * spec_review / exploring the worker is legitimately waiting on the manager's
+ * approval, so the gate stays out of the way.
+ *
+ * Worker-mode only. Fail-open: any error returns null (normal Stop flow).
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+const childProcess = require('node:child_process');
+const crypto = require('node:crypto');
+
+const COUNTER_FILE = 'worker-continuation.json';
+const PHASE_FILE = 'workflow-phase.json';
+
+const DEFAULTS = {
+  enabled: true,
+  activePhases: ['coding', 'validating'],
+  perSubtaskTurns: 6,
+  capBuffer: 4,
+  maxContinuations: 60,
+  noProgressK: 4
+};
+
+function getCfg(config) {
+  const ws = (config && config.workspace && config.workspace.continuationGate) || {};
+  return {
+    enabled: ws.enabled !== false,
+    activePhases: Array.isArray(ws.activePhases) && ws.activePhases.length ? ws.activePhases : DEFAULTS.activePhases,
+    perSubtaskTurns: Number.isFinite(ws.perSubtaskTurns) ? ws.perSubtaskTurns : DEFAULTS.perSubtaskTurns,
+    capBuffer: Number.isFinite(ws.capBuffer) ? ws.capBuffer : DEFAULTS.capBuffer,
+    maxContinuations: Number.isFinite(ws.maxContinuations) ? ws.maxContinuations : DEFAULTS.maxContinuations,
+    noProgressK: Number.isFinite(ws.noProgressK) ? ws.noProgressK : DEFAULTS.noProgressK
+  };
+}
+
+function isWorkerMode(env = process.env) {
+  return Boolean(env.WOGI_WORKSPACE_ROOT && env.WOGI_REPO_NAME && env.WOGI_REPO_NAME !== 'manager');
+}
+
+function getCounterPath(stateDir) {
+  return path.join(stateDir, COUNTER_FILE);
+}
+
+function readCounter(stateDir) {
+  try {
+    const raw = fs.readFileSync(getCounterPath(stateDir), 'utf-8');
+    const data = JSON.parse(raw);
+    if (data && typeof data === 'object') return data;
+  } catch (_err) { /* absent or unreadable */ }
+  return null;
+}
+
+function writeCounter(stateDir, state) {
+  try {
+    const p = getCounterPath(stateDir);
+    fs.mkdirSync(path.dirname(p), { recursive: true });
+    const tmp = `${p}.tmp.${process.pid}.${Math.random().toString(36).slice(2, 8)}`;
+    fs.writeFileSync(tmp, JSON.stringify(state, null, 2));
+    fs.renameSync(tmp, p);
+  } catch (_err) { /* best effort */ }
+}
+
+function clearCounter(stateDir) {
+  try { fs.unlinkSync(getCounterPath(stateDir)); } catch (_err) { /* fine */ }
+}
+
+function readPhase(stateDir) {
+  try {
+    const raw = fs.readFileSync(path.join(stateDir, PHASE_FILE), 'utf-8');
+    const data = JSON.parse(raw);
+    return data && typeof data.phase === 'string' ? data.phase : null;
+  } catch (_err) {
+    return null;
+  }
+}
+
+/**
+ * Progress fingerprint: working-tree state (uncommitted edits count too) plus the
+ * remaining sub-task count. Changes whenever a file is touched OR a sub-task
+ * completes. Used to detect "doing nothing" without false-killing long refactors.
+ */
+function defaultProgressFingerprint(root, remainingCount) {
+  let porcelain = '';
+  try {
+    porcelain = childProcess.execSync('git status --porcelain 2>/dev/null || true', {
+      cwd: root, encoding: 'utf-8', timeout: 3000
+    });
+  } catch (_err) { /* non-fatal */ }
+  let sha = '';
+  try {
+    sha = childProcess.execSync('git rev-parse --short HEAD 2>/dev/null || true', {
+      cwd: root, encoding: 'utf-8', timeout: 2000
+    }).trim();
+  } catch (_err) { /* non-fatal */ }
+  return crypto.createHash('sha1').update(`${sha}\n${remainingCount}\n${porcelain}`).digest('hex');
+}
+
+function derivedCap(total, cfg) {
+  const base = (total > 0 ? total : 1) * cfg.perSubtaskTurns + cfg.capBuffer;
+  return Math.min(base, cfg.maxContinuations);
+}
+
+function buildContinueDirective({ taskId, remaining, total, attempt, cap }) {
+  return [
+    `SUSTAINED EXECUTION — task ${taskId} is in progress with ${remaining} of ${total} sub-task(s) remaining.`,
+    `You are a workspace worker. A dispatched task runs to COMPLETION across turns — do NOT stop to "report progress" mid-task.`,
+    '',
+    `Do the next sub-task NOW (one tool call to start). Keep going until ALL sub-tasks are done.`,
+    '',
+    'Exit conditions (only these):',
+    `  • DONE → run \`flow done ${taskId}\` (quality gates run). When the task leaves inProgress, this gate stops automatically.`,
+    `  • BLOCKED on something only the manager/user can resolve, OR the next step is DESTRUCTIVE / IRREVERSIBLE /`,
+    `    touches PRODUCTION / needs external credentials → do NOT proceed. Escalate instead:`,
+    `      curl -s -X POST http://127.0.0.1:${process.env.WOGI_MANAGER_PORT || '8800'} \\`,
+    `        -H "X-Wogi-From: ${process.env.WOGI_REPO_NAME || 'worker'}" \\`,
+    `        --data-binary "## QUESTION: <blocker>"  (then end the turn)`,
+    '',
+    `(continuation ${attempt}/${cap} — make real progress this turn or escalate; idle turns are detected and will be stopped.)`
+  ].join('\n');
+}
+
+/**
+ * Best-effort escalation to the manager when the gate gives up (cap / no-progress).
+ * Writes a worker-blocked message to the bus AND POSTs to the manager port.
+ */
+function escalateBlocked({ workspaceRoot, repoName, taskId, reason, managerPort }) {
+  const summary = `## BLOCKED: ${reason} (task ${taskId})`;
+  try {
+    if (workspaceRoot) {
+      const libMessages = path.resolve(__dirname, '..', '..', '..', 'lib', 'workspace-messages');
+      const { createMessage, saveMessage } = require(libMessages);
+      const msg = createMessage({
+        from: repoName, to: 'manager', type: 'worker-blocked',
+        subject: `Worker ${repoName} blocked on ${taskId}`,
+        body: summary, priority: 'high', actionRequired: true
+      });
+      msg.taskId = taskId;
+      msg.reason = reason;
+      saveMessage(workspaceRoot, msg);
+    }
+  } catch (_err) { /* best effort */ }
+  try {
+    if (managerPort) {
+      const http = require('node:http');
+      const buf = Buffer.from(summary, 'utf-8');
+      const req = http.request({
+        hostname: '127.0.0.1', port: parseInt(managerPort, 10), path: '/', method: 'POST',
+        headers: { 'Content-Type': 'text/plain', 'Content-Length': buf.byteLength, 'X-Wogi-From': repoName }
+      });
+      req.on('error', () => {});
+      req.write(buf); req.end();
+    }
+  } catch (_err) { /* best effort */ }
+}
+
+/**
+ * Main gate. Returns one of:
+ *   { continue: true, stopReason }              — force continuation
+ *   null                                        — allow normal stop (no fire)
+ * plus a `decision` field for diagnostics/tests: 'continue' | 'allow' with reason.
+ *
+ * @param {Object} opts
+ * @param {Object} opts.config
+ * @param {string} [opts.stateDir]  default PATHS.state
+ * @param {string} [opts.root]      repo root for git probe (default PATHS.root)
+ * @param {Object} [opts.env]       default process.env
+ * @param {Function} [opts.fingerprintFn]  (root, remaining) => string  (injectable for tests)
+ * @param {Object}  [opts.subtaskState]    injectable S1 module (tests)
+ */
+function checkWorkerContinuation(opts = {}) {
+  try {
+    const env = opts.env || process.env;
+    if (!isWorkerMode(env)) return { fired: false, decision: 'allow', reason: 'not-worker' };
+
+    const cfg = getCfg(opts.config);
+    if (!cfg.enabled) return { fired: false, decision: 'allow', reason: 'disabled' };
+
+    const { PATHS, safeJsonParse } = require('../../flow-utils');
+    const stateDir = opts.stateDir || PATHS.state;
+    const root = opts.root || PATHS.root;
+
+    // Active task?
+    const ready = safeJsonParse(path.join(stateDir, 'ready.json'), { inProgress: [] });
+    const task = (ready.inProgress || [])[0];
+    const taskId = task && task.id;
+    if (!taskId) {
+      clearCounter(stateDir); // nothing in progress — reset for next task
+      return { fired: false, decision: 'allow', reason: 'no-in-progress' };
+    }
+
+    // Active-work phase only (respect spec-approval / exploration waits).
+    const phase = readPhase(stateDir);
+    if (!cfg.activePhases.includes(phase)) {
+      return { fired: false, decision: 'allow', reason: `phase-not-active:${phase || 'none'}` };
+    }
+
+    // Remaining decomposed work?
+    const subtaskState = opts.subtaskState || require('../../../lib/workspace-subtask-state');
+    const summary = subtaskState.summary(taskId);
+    const remaining = summary.remaining;
+    if (remaining <= 0) {
+      return { fired: false, decision: 'allow', reason: 'no-remaining-subtasks' };
+    }
+
+    // Per-task counter (reset when the task changes).
+    let counter = readCounter(stateDir);
+    if (!counter || counter.taskId !== taskId) {
+      counter = { taskId, count: 0, noProgressStreak: 0, fingerprint: null, escalated: false };
+    }
+
+    // Already escalated for this task ⇒ allow stop (don't re-fire). Manager
+    // re-dispatch / restart resets the counter (taskId match but escalated flag);
+    // we clear the escalation only when progress resumes (fingerprint changes).
+    const fingerprintFn = opts.fingerprintFn || defaultProgressFingerprint;
+    const fingerprint = fingerprintFn(root, remaining);
+
+    if (counter.escalated) {
+      if (counter.fingerprint && fingerprint !== counter.fingerprint) {
+        // Work resumed since we escalated — clear and continue.
+        counter.escalated = false;
+        counter.noProgressStreak = 0;
+      } else {
+        return { fired: false, decision: 'allow', reason: 'already-escalated' };
+      }
+    }
+
+    const cap = derivedCap(summary.total, cfg);
+
+    // No-progress detection.
+    if (counter.fingerprint !== null && fingerprint === counter.fingerprint) {
+      counter.noProgressStreak = (counter.noProgressStreak || 0) + 1;
+    } else {
+      counter.noProgressStreak = 0;
+    }
+    counter.fingerprint = fingerprint;
+
+    if (counter.noProgressStreak >= cfg.noProgressK) {
+      counter.escalated = true;
+      writeCounter(stateDir, counter);
+      escalateBlocked({
+        workspaceRoot: env.WOGI_WORKSPACE_ROOT, repoName: env.WOGI_REPO_NAME,
+        taskId, reason: `no progress across ${counter.noProgressStreak} continuations`,
+        managerPort: env.WOGI_MANAGER_PORT
+      });
+      return { fired: false, decision: 'allow', reason: 'no-progress-escalated', escalated: true };
+    }
+
+    if (counter.count >= cap) {
+      counter.escalated = true;
+      writeCounter(stateDir, counter);
+      escalateBlocked({
+        workspaceRoot: env.WOGI_WORKSPACE_ROOT, repoName: env.WOGI_REPO_NAME,
+        taskId, reason: `iteration cap (${cap}) reached`,
+        managerPort: env.WOGI_MANAGER_PORT
+      });
+      return { fired: false, decision: 'allow', reason: 'cap-escalated', escalated: true };
+    }
+
+    // Fire continuation.
+    counter.count += 1;
+    writeCounter(stateDir, counter);
+    const directive = buildContinueDirective({
+      taskId, remaining, total: summary.total, attempt: counter.count, cap
+    });
+    return {
+      fired: true,
+      decision: 'continue',
+      reason: 'remaining-subtasks',
+      taskId,
+      remaining,
+      total: summary.total,
+      attempt: counter.count,
+      cap,
+      stopReason: directive
+    };
+  } catch (err) {
+    if (process.env.DEBUG) console.error(`[worker-continuation-gate] fail-open: ${err.message}`);
+    return { fired: false, decision: 'allow', reason: `error:${err.message}` };
+  }
+}
+
+module.exports = {
+  checkWorkerContinuation,
+  isWorkerMode,
+  getCfg,
+  derivedCap,
+  buildContinueDirective,
+  readCounter,
+  writeCounter,
+  clearCounter,
+  getCounterPath,
+  readPhase,
+  DEFAULTS
+};

package/scripts/hooks/core/workspace-stop-gates.js

@@ -60,6 +60,27 @@ async function checkWorkspaceStopGates({ parsedInput }) {
     if (process.env.DEBUG) console.error(`[Stop] Workspace autopickup gate error (fail-open): ${err.message}`);
   }
 
+  // In-Progress Continuation Gate (S2 / wf-aee4a4fa) — the core sustained-
+  // execution fix. Gap B (above) handles NOT-STARTED dispatches; this handles
+  // an IN-PROGRESS decomposed task with sub-tasks remaining. Keeps the SAME
+  // session grinding via {continue:true} instead of going idle after one turn.
+  try {
+    const { checkWorkerContinuation } = require('./worker-continuation-gate');
+    const { getConfig } = require('../../flow-utils');
+    const result = checkWorkerContinuation({ config: getConfig() });
+    if (result?.fired && result.stopReason) {
+      // S3: emit a worker-progress heartbeat (NOT a terminal stop) so the
+      // manager sees ongoing work and refreshes the dispatch deadline.
+      try {
+        const { notifyWorkerProgress } = require('./workspace-stop-notify');
+        await notifyWorkerProgress({ taskId: result.taskId, remaining: result.remaining, total: result.total, attempt: result.attempt });
+      } catch (_err) { /* best effort */ }
+      return { shouldReturn: true, result: { __raw: true, continue: true, stopReason: result.stopReason } };
+    }
+  } catch (err) {
+    if (process.env.DEBUG) console.error(`[Stop] Worker continuation gate error (fail-open): ${err.message}`);
+  }
+
   // Worker Tool-First Turn Gate
   try {
     const { isWorkerMode, checkWorkerToolFirstTurn, renderBlockMessage } = require('./worker-tool-first-gate');