wogiflow 2.22.0 → 2.22.2

package/scripts/flow-story.js

@@ -39,6 +39,9 @@ try {
 // Import parallel execution detection
 const { findParallelizable, getParallelConfig } = require('./flow-parallel');
 
+// wf-63c0f4cc — specification-quality gates
+const storyGates = require('./flow-story-gates');
+
 const CHANGES_DIR = PATHS.changes;
 const READY_PATH = PATHS.ready;
 
@@ -81,6 +84,85 @@ function getProductContextForStory() {
   }
 }
 
+/**
+ * Build additional story sections from gate results (wf-63c0f4cc).
+ * Returns a markdown string or null if nothing to append.
+ *
+ * @param {Object} gateResults
+ * @returns {string|null}
+ */
+function buildGateSections(gateResults) {
+  const parts = [];
+
+  const items = gateResults?.itemReconciliation;
+  if (items?.active && items.items.length > 0) {
+    parts.push(
+      '## Item Manifest (zero-loss)',
+      `Detected ${items.count} discrete items in the original request. ALL must map to a criterion or sub-task (anti-deferral rule).`,
+      '',
+      ...items.items.map((it, i) => `${i + 1}. ${it}`),
+      ''
+    );
+  }
+
+  const ci = gateResults?.consumerImpact;
+  if (ci?.active && Array.isArray(ci.matches)) {
+    const byFile = new Map();
+    for (const m of ci.matches) {
+      if (!byFile.has(m.file)) byFile.set(m.file, { kinds: new Set(), seeds: new Set() });
+      byFile.get(m.file).kinds.add(m.kind);
+      byFile.get(m.file).seeds.add(m.seed);
+    }
+    parts.push(
+      '## Consumer Impact',
+      `Refactoring-keyword detected in input; grepped codebase for consumers of: ${(ci.seeds || []).join(', ') || '(no seeds extracted)'}`,
+      '',
+      `Files matched: ${byFile.size} (breaking: ${ci.breakingCount || 0})`
+    );
+    if (byFile.size > 0) {
+      parts.push('', '| File | Kind | Via |', '|------|------|-----|');
+      for (const [file, info] of byFile) {
+        parts.push(`| \`${file}\` | ${[...info.kinds].join(', ')} | ${[...info.seeds].join(', ')} |`);
+      }
+    }
+    if (ci.phasedMigrationRecommended) {
+      parts.push(
+        '',
+        `**Phased migration strategy recommended** — ${ci.breakingCount} breaking consumers exceeds the threshold. Consider Phase 1 (new alongside old) → Phase 2 (migrate consumers) → Phase 3 (remove old) rather than a big-bang rewrite.`
+      );
+    }
+    parts.push('');
+  }
+
+  const sc = gateResults?.scopeConfidence;
+  if (sc?.active && sc.assumptions.length > 0) {
+    const bad = sc.assumptions.filter(a => a.status === 'UNVERIFIED' || a.status === 'CONTRADICTED');
+    if (bad.length > 0) {
+      parts.push(
+        '## Pending Clarifications',
+        'Scope-confidence audit found assumptions that do not match the codebase. Resolve before implementation (or /wogi-start Step 1.45 will).',
+        ''
+      );
+      for (const a of sc.assumptions) {
+        const icon = a.status === 'VERIFIED' ? '✓' : a.status === 'CONTRADICTED' ? '✗' : '?';
+        parts.push(`- ${icon} **${a.status}** — "${a.label} ${a.phrase}"`);
+      }
+      parts.push('');
+    }
+  }
+
+  const ib = gateResults?.intentBootstrap;
+  if (ib?.scheduled) {
+    parts.push(
+      '## IGR Bootstrap Scheduled',
+      'Intent-Grounded Reasoning artifacts are missing. Bootstrap has been scheduled for `/wogi-session-end` (Option C [2]). No action needed now.',
+      ''
+    );
+  }
+
+  return parts.length > 0 ? parts.join('\n') : null;
+}
+
 /**
  * Generate story template content
  */
@@ -136,6 +218,8 @@ ${productSection}
 - **Triggered by**: [onClick on table row / button click / route navigation]
 - **Verification**: [Component is imported AND rendered when trigger fires]
 
+**Enforcement**: this section is verified during \`/wogi-start\` Step 3.7 (Wiring Check). If wiring is broken at runtime, the task will fail verification.
+
 *Delete this section if no new UI components are created.*
 
 ## Technical Notes
@@ -304,6 +388,54 @@ async function createStory(title, options = {}) {
   const decompositionConfig = config.storyDecomposition || {};
   const dryRun = options.dryRun || false;
 
+  // wf-63c0f4cc — specification-quality gates.
+  // The "input" for gate purposes is either the explicit fullInput option
+  // (when a long multi-item payload was passed programmatically) or the
+  // title (typical CLI / single-request path).
+  const gateInput = options.fullInput || title;
+  const gateResults = {};
+
+  // Gate 1: Long Input — route oversized inputs to /wogi-extract-review.
+  // The `bypassLongInput` flag prevents re-routing when /wogi-start already
+  // handled long-input detection and forwarded to /wogi-story for a single
+  // extracted story.
+  if (!options.skipGates) {
+    gateResults.longInput = storyGates.checkLongInput(gateInput, {
+      bypassLongInput: options.bypassLongInput
+    });
+    if (gateResults.longInput.route) {
+      return {
+        taskId: null,
+        title,
+        gateResults,
+        routed: '/wogi-extract-review',
+        message: 'Input is large — routing to /wogi-extract-review for zero-loss capture.'
+      };
+    }
+  }
+
+  // Gate 2: Item Reconciliation — BEFORE decomposition, so enumerated items
+  // drive sub-task generation.
+  if (!options.skipGates) {
+    gateResults.itemReconciliation = storyGates.reconcileItems(gateInput);
+  }
+
+  // Gate 3: Consumer Impact Analysis (refactoring-keyword triggered)
+  if (!options.skipGates) {
+    gateResults.consumerImpact = storyGates.analyzeConsumerImpact(gateInput);
+  }
+
+  // Gate 4: Scope-Confidence Audit — writes a "Pending Clarifications" block
+  // to the story (non-interactive; resolved later by user or /wogi-start).
+  if (!options.skipGates) {
+    gateResults.scopeConfidence = storyGates.auditScopeConfidence(gateInput);
+  }
+
+  // Gate 5: Intent Bootstrap coordination (no UI prompt — background scheduling)
+  if (!options.skipGates) {
+    gateResults.intentBootstrap = storyGates.coordinateIntentBootstrap();
+  }
+
   // Get priority from options or config
   const defaultPriority = getConfigValue('priorities.defaultPriority', 'P2');
   const priority = options.priority || defaultPriority;
@@ -342,7 +474,13 @@ async function createStory(title, options = {}) {
   }
 
   // Create main story file (or just compute path in dry-run mode)
-  const storyContent = generateStoryTemplate(taskId, title);
+  let storyContent = generateStoryTemplate(taskId, title);
+
+  // Append gate-derived sections (Consumer Impact, Pending Clarifications,
+  // Item Manifest). These are additive — the base template is unchanged.
+  const gateSections = buildGateSections(gateResults);
+  if (gateSections) storyContent += '\n' + gateSections;
+
   const storyFile = path.join(targetDir, `${taskId}.md`);
   if (!dryRun) {
     fs.writeFileSync(storyFile, storyContent);
@@ -355,7 +493,8 @@ async function createStory(title, options = {}) {
     storyFile,
     featureFolder,  // null for flat, folder name for decomposed
     subTasks: [],
-    dryRun  // Include dry-run flag in result
+    dryRun,  // Include dry-run flag in result
+    gateResults  // wf-63c0f4cc — specification-quality gate findings
   };
 
   const shouldSuggest = !options.deep &&
@@ -493,6 +632,22 @@ async function createStory(title, options = {}) {
 
     result.decomposed = true;
 
+    // wf-63c0f4cc scenario 4 — item-coverage reconciliation check.
+    // After the template is populated, verify each enumerated item appears
+    // in at least one criterion / sub-task objective. Unmapped items are
+    // surfaced (non-blocking) for the user to address.
+    if (gateResults.itemReconciliation?.active) {
+      const criteriaTexts = result.subTasks.map(s => s.objective);
+      const coverage = storyGates.verifyItemCoverage(
+        gateResults.itemReconciliation.items,
+        criteriaTexts
+      );
+      gateResults.itemReconciliation.coverage = coverage;
+      if (!coverage.allMapped) {
+        result.unmappedItems = coverage.unmapped;
+      }
+    }
+
     // Check if sub-tasks can run in parallel
     try {
       const parallelConfig = getParallelConfig();
@@ -540,10 +695,13 @@ Usage:
   flow story "<title>" --deep --json   All options
 
 Options:
-  --deep           Automatically decompose into sub-tasks
-  --priority <P>   Priority P0-P4 (default: from config, usually P2)
-  --dry-run        Preview what would be created without writing files
-  --json           Output JSON instead of human-readable
+  --deep              Automatically decompose into sub-tasks
+  --priority <P>      Priority P0-P4 (default: from config, usually P2)
+  --dry-run           Preview what would be created without writing files
+  --json              Output JSON instead of human-readable
+  --skip-gates        Skip all P0 spec-quality gates (wf-63c0f4cc)
+  --bypass-long-input Skip Gate 1 (when /wogi-start already handled it)
+  --full-input <txt>  Full user input for gates (when title is a summary)
 
 Storage:
   - Simple stories: flat in .workflow/changes/
@@ -585,9 +743,22 @@ Examples:
   const result = await createStory(title, {
     deep: flags.deep,
     priority,
-    dryRun: flags['dry-run'] || flags.dryRun
+    dryRun: flags['dry-run'] || flags.dryRun,
+    skipGates: flags['skip-gates'] || flags.skipGates,
+    bypassLongInput: flags['bypass-long-input'] || flags.bypassLongInput,
+    fullInput: flags['full-input'] || flags.fullInput
   });
 
+  // If Gate 1 routed the input to /wogi-extract-review, print guidance + exit.
+  if (result.routed === '/wogi-extract-review') {
+    console.log('');
+    warn(result.message);
+    log('yellow', `   Run: /wogi-extract-review "<your input>"`);
+    console.log('');
+    if (flags.json) outputJson({ success: true, ...result });
+    process.exit(0);
+  }
+
   // JSON output
   if (flags.json) {
     outputJson({
@@ -646,6 +817,33 @@ Examples:
     log('dim', `   Run: flow story "${title}" --deep`);
   }
 
+  // wf-63c0f4cc — gate results summary
+  const gr = result.gateResults || {};
+  if (gr.itemReconciliation?.active) {
+    console.log('');
+    const items = gr.itemReconciliation;
+    log('cyan', `Item Reconciliation: ${items.count} items detected`);
+    if (items.coverage && !items.coverage.allMapped) {
+      log('yellow', `   ⚠ Unmapped: ${items.coverage.unmapped.length} — review story for completeness`);
+    } else if (result.decomposed) {
+      log('green', `   ✓ All ${items.count} items mapped to sub-tasks`);
+    }
+  }
+  if (gr.consumerImpact?.active && gr.consumerImpact.breakingCount > 0) {
+    console.log('');
+    log('cyan', `Consumer Impact: ${gr.consumerImpact.breakingCount} potentially-breaking consumers found`);
+    if (gr.consumerImpact.phasedMigrationRecommended) {
+      log('yellow', `   ⚠ Phased migration recommended — see story "Consumer Impact" section`);
+    }
+  }
+  if (gr.scopeConfidence?.active) {
+    const bad = gr.scopeConfidence.assumptions.filter(a => a.status !== 'VERIFIED');
+    if (bad.length > 0) {
+      console.log('');
+      log('yellow', `Scope-Confidence: ${bad.length} unverified/contradicted assumptions — see "Pending Clarifications"`);
+    }
+  }
+
   // Simple (non-decomposed) story ready.json status — wf-b5cff650 fix
   if (!result.decomposed) {
     if (result.addedToReady) {

package/scripts/hooks/adapters/claude-code.js

@@ -421,46 +421,27 @@ Run: /wogi-start ${coreResult.nextTaskId}`;
       };
     }
 
-    // Research protocol triggered - inject protocol steps as additional context
-    if (coreResult.systemReminder) {
-      // Append phase prompt if present
-      const context = coreResult.phasePrompt
-        ? `${coreResult.systemReminder}\n\n${coreResult.phasePrompt}`
-        : coreResult.systemReminder;
-      return {
-        hookSpecificOutput: {
-          hookEventName: 'UserPromptSubmit',
-          additionalContext: context
-        }
-      };
-    }
+    // Compose additionalContext from up to four pieces:
+    //   1. systemReminder (research protocol) OR message (warning)
+    //   2. phasePrompt (phase-specific context)
+    //   3. overduePrompt (wf-d3e67abe — silent-halt surfacing, manager-only)
+    const pieces = [];
+    if (coreResult.systemReminder) pieces.push(coreResult.systemReminder);
+    else if (coreResult.message) pieces.push(coreResult.message);
+    if (coreResult.phasePrompt) pieces.push(coreResult.phasePrompt);
+    if (coreResult.overduePrompt) pieces.push(coreResult.overduePrompt);
 
-    // Warning - allow but inject context with the warning message
-    if (coreResult.message && !coreResult.blocked) {
-      // Append phase prompt if present
-      const context = coreResult.phasePrompt
-        ? `${coreResult.message}\n\n${coreResult.phasePrompt}`
-        : coreResult.message;
-      return {
-        hookSpecificOutput: {
-          hookEventName: 'UserPromptSubmit',
-          additionalContext: context
-        }
-      };
+    if (pieces.length === 0) {
+      // Allowed - empty response means allow
+      return {};
     }
 
-    // Phase prompt only (no other context to inject)
-    if (coreResult.phasePrompt) {
-      return {
-        hookSpecificOutput: {
-          hookEventName: 'UserPromptSubmit',
-          additionalContext: coreResult.phasePrompt
-        }
-      };
-    }
-
-    // Allowed - empty response means allow
-    return {};
+    return {
+      hookSpecificOutput: {
+        hookEventName: 'UserPromptSubmit',
+        additionalContext: pieces.join('\n\n')
+      }
+    };
   }
 
   /**

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

@@ -0,0 +1,291 @@
+/**
+ * Wogi Flow — Overdue Dispatch Detection (wf-d3e67abe)
+ *
+ * Computes overdue workspace dispatches for manager sessions and
+ * returns an additionalContext string to inject into UserPromptSubmit,
+ * surfacing silent worker deaths to the model before it processes the
+ * next prompt.
+ *
+ * Manager-scoped: returns null for worker sessions and when
+ * WOGI_WORKSPACE_ROOT is unset.
+ */
+
+const path = require('node:path');
+
+/**
+ * Returns true when this process is a workspace manager session
+ * (i.e., NOT a worker). A session counts as manager when:
+ *   - WOGI_WORKSPACE_ROOT is set (we have a workspace to inspect), AND
+ *   - WOGI_REPO_NAME is 'manager' OR unset (not a worker name).
+ */
+function isManagerSession() {
+  if (!process.env.WOGI_WORKSPACE_ROOT) return false;
+  const repo = process.env.WOGI_REPO_NAME;
+  return !repo || repo === 'manager';
+}
+
+function formatDuration(ms) {
+  const totalMin = Math.max(0, Math.floor(ms / 60000));
+  const hours = Math.floor(totalMin / 60);
+  const min = totalMin % 60;
+  if (hours === 0) return `${min}m`;
+  return `${hours}h${min}m`;
+}
+
+function formatLine(record, now) {
+  const dispatched = Date.parse(record.dispatchedAt || '');
+  const deadline = Date.parse(record.expectedDeadline || '');
+  const sinceDispatch = Number.isFinite(dispatched) ? formatDuration(now - dispatched) : '?';
+  const pastDeadline = Number.isFinite(deadline) ? formatDuration(now - deadline) : '?';
+  const budget = record.expectedDurationMs
+    ? formatDuration(record.expectedDurationMs)
+    : '?';
+  return `• ${record.taskId} → ${record.repoName}  | dispatched ${sinceDispatch} ago (${pastDeadline} past ${budget} deadline) | no task-complete / worker-stopped message`;
+}
+
+/**
+ * Reconcile any pending dispatches against `task-complete` or `worker-stopped`
+ * messages in the workspace message bus. Called before overdue computation so
+ * records that matched an incoming message don't get flagged as silent deaths.
+ *
+ * @param {string} workspaceRoot
+ * @returns {number} count of reconciled records
+ */
+function sweepAndReconcile(workspaceRoot) {
+  let reconciled = 0;
+  let readMessages, reconcileDispatch, readDispatches;
+  try {
+    const libMessages = path.resolve(__dirname, '..', '..', '..', 'lib', 'workspace-messages.js');
+    const libTracking = path.resolve(__dirname, '..', '..', '..', 'lib', 'workspace-dispatch-tracking.js');
+    readMessages = require(libMessages).readMessages;
+    const tracking = require(libTracking);
+    reconcileDispatch = tracking.reconcileDispatch;
+    readDispatches = tracking.readDispatches;
+  } catch (_err) {
+    return 0; // Fail-open
+  }
+
+  let dispatches;
+  try {
+    dispatches = readDispatches(workspaceRoot).filter(r => r && r.status === 'pending');
+  } catch (_err) {
+    return 0;
+  }
+  if (dispatches.length === 0) return 0;
+
+  const byTaskId = new Map();
+  for (const r of dispatches) {
+    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.
+  let messages = [];
+  try {
+    const completes = readMessages(workspaceRoot, { type: 'task-complete' });
+    const stops = readMessages(workspaceRoot, { type: 'worker-stopped' });
+    messages = completes.concat(stops);
+  } catch (_err) {
+    return 0;
+  }
+
+  for (const msg of messages) {
+    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;
+      const result = reconcileDispatch(workspaceRoot, taskId, status, reason);
+      if (result) {
+        reconciled++;
+        byTaskId.delete(taskId); // Don't double-reconcile
+      }
+    } catch (_err) {
+      // Per-record failure must not poison the sweep.
+    }
+  }
+
+  return reconciled;
+}
+
+/**
+ * Reconcile pending `worker-ready` messages (2.22.2 restart-handoff).
+ *
+ * A worker-ready message signals that a worker session started with an
+ * empty queue — possibly because a prior dispatch was lost during the
+ * wrapper's restart window. For each pending worker-ready:
+ *   - Find pending dispatches to that repo in dispatched-tasks.json
+ *   - If any found: they're likely the lost dispatches. Collect as
+ *     `lostDispatches` for surface to the manager.
+ *   - Mark the worker-ready message as acknowledged regardless — once
+ *     the manager has seen it, there's nothing more to do with the
+ *     same message. If another restart happens, a fresh worker-ready
+ *     will be written.
+ *
+ * @param {string} workspaceRoot
+ * @param {Object} [opts]
+ * @param {number} [opts.staleGraceMs=30000] — ignore dispatches newer than this
+ *   (to avoid flagging just-sent dispatches still in flight).
+ * @returns {{acknowledged: number, lostDispatches: Array}}
+ */
+function reconcileWorkerReady(workspaceRoot, opts = {}) {
+  const staleGraceMs = Number.isFinite(opts.staleGraceMs) ? opts.staleGraceMs : 30000;
+  const now = Number.isFinite(opts.now) ? opts.now : Date.now();
+
+  let readMessages, updateMessageStatus, readDispatches;
+  try {
+    const libMessages = path.resolve(__dirname, '..', '..', '..', 'lib', 'workspace-messages.js');
+    const libTracking = path.resolve(__dirname, '..', '..', '..', 'lib', 'workspace-dispatch-tracking.js');
+    const bus = require(libMessages);
+    readMessages = bus.readMessages;
+    updateMessageStatus = bus.updateMessageStatus;
+    const tracking = require(libTracking);
+    readDispatches = tracking.readDispatches;
+  } catch (_err) {
+    return { acknowledged: 0, lostDispatches: [] };
+  }
+
+  let pendingReady = [];
+  try {
+    pendingReady = readMessages(workspaceRoot, { type: 'worker-ready', status: 'pending' });
+  } catch (_err) {
+    return { acknowledged: 0, lostDispatches: [] };
+  }
+  if (pendingReady.length === 0) return { acknowledged: 0, lostDispatches: [] };
+
+  let dispatches = [];
+  try {
+    dispatches = readDispatches(workspaceRoot).filter(r => r && r.status === 'pending');
+  } catch (_err) {
+    dispatches = [];
+  }
+
+  const lostDispatches = [];
+  let acknowledged = 0;
+
+  for (const msg of pendingReady) {
+    const repoName = msg.from;
+    if (!repoName) continue;
+
+    // Find pending dispatches to this repo that are older than the grace
+    // period (avoid race conditions with just-sent dispatches).
+    const candidates = dispatches.filter(r => {
+      if (r.repoName !== repoName) return false;
+      const dispatched = Date.parse(r.dispatchedAt || '');
+      if (!Number.isFinite(dispatched)) return false;
+      return (now - dispatched) > staleGraceMs;
+    });
+
+    for (const c of candidates) {
+      lostDispatches.push({ ...c, workerReadyMsgId: msg.id });
+    }
+
+    // Acknowledge the worker-ready message — we've processed it once.
+    // If the restart-loss recurs, a fresh worker-ready will be written.
+    try {
+      if (updateMessageStatus) {
+        updateMessageStatus(workspaceRoot, msg.id, 'acknowledged');
+        acknowledged++;
+      }
+    } catch (_err) { /* non-fatal */ }
+  }
+
+  return { acknowledged, lostDispatches };
+}
+
+/**
+ * Format the lost-dispatches block for manager additionalContext.
+ *
+ * @param {Array} lost
+ * @returns {string|null}
+ */
+function formatLostDispatchesContext(lost) {
+  if (!Array.isArray(lost) || lost.length === 0) return null;
+  const lines = lost.map(r => {
+    const dispatchedAt = r.dispatchedAt || '?';
+    return `• ${r.taskId} → ${r.repoName}  | dispatched ${dispatchedAt} | still pending after worker restart`;
+  });
+  return [
+    `━━━ LOST DISPATCHES — WORKER RESTARTED WITH EMPTY QUEUE (${lost.length}) ━━━`,
+    ...lines,
+    '',
+    'A worker announced fresh readiness but these dispatches are still',
+    'pending. Likely lost during the wrapper\'s restart window. Re-dispatch',
+    'them now via dispatchToChannel(workspaceRoot, repoName, taskId).',
+    '━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'
+  ].join('\n');
+}
+
+/**
+ * Build the overdue-dispatches additionalContext block, or return null
+ * when nothing to surface (non-manager, no workspace root, no overdue).
+ *
+ * Also handles worker-ready reconciliation (2.22.2) — if workers announced
+ * readiness and there are matching pending dispatches, include a lost-dispatch
+ * section so the manager can re-dispatch.
+ *
+ * @param {Object} [opts]
+ * @param {string} [opts.workspaceRoot] — override (primarily for tests)
+ * @param {number} [opts.now=Date.now()]
+ * @returns {string|null}
+ */
+function buildOverdueContext(opts = {}) {
+  const workspaceRoot = opts.workspaceRoot || process.env.WOGI_WORKSPACE_ROOT;
+  if (!workspaceRoot) return null;
+  if (!opts.workspaceRoot && !isManagerSession()) return null;
+
+  // Sweep: reconcile any pending records that match incoming messages
+  // before computing overdue. This prevents false positives for workers
+  // whose completion/stop message arrived while the manager was idle.
+  try { sweepAndReconcile(workspaceRoot); }
+  catch (_err) { /* fail-open */ }
+
+  // Reconcile worker-ready announcements. Surface any lost dispatches
+  // the manager should re-send.
+  let lostBlock = null;
+  try {
+    const { lostDispatches } = reconcileWorkerReady(workspaceRoot, { now: opts.now });
+    lostBlock = formatLostDispatchesContext(lostDispatches);
+  } catch (_err) { /* fail-open */ }
+
+  let overdue;
+  try {
+    const libPath = path.resolve(__dirname, '..', '..', '..', 'lib', 'workspace-dispatch-tracking.js');
+    const { getOverdueDispatches } = require(libPath);
+    overdue = getOverdueDispatches(workspaceRoot, opts.now);
+  } catch (_err) {
+    // If dispatch-tracking is missing but we have lost-dispatches from
+    // worker-ready, still surface those.
+    return lostBlock;
+  }
+
+  if ((!Array.isArray(overdue) || overdue.length === 0) && !lostBlock) return null;
+
+  const sections = [];
+
+  if (lostBlock) sections.push(lostBlock);
+
+  if (Array.isArray(overdue) && overdue.length > 0) {
+    const now = Number.isFinite(opts.now) ? opts.now : Date.now();
+    const lines = overdue.map(r => formatLine(r, now));
+    sections.push([
+      `━━━ OVERDUE WORKSPACE DISPATCHES (${overdue.length}) ━━━`,
+      ...lines,
+      '',
+      'These workers may have died silently. Check worker terminals;',
+      'if dead, re-dispatch or mark failed. Records:',
+      '  .workspace/state/dispatched-tasks.json',
+      '━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'
+    ].join('\n'));
+  }
+
+  return sections.length > 0 ? sections.join('\n\n') : null;
+}
+
+module.exports = {
+  isManagerSession,
+  buildOverdueContext,
+  sweepAndReconcile,
+  reconcileWorkerReady,
+  formatLostDispatchesContext
+};

package/scripts/hooks/core/session-context.js

@@ -871,6 +871,23 @@ function formatContextForInjection(context) {
     // Non-critical — history file may not exist; continue with normal context
   }
 
+  // Workspace worker auto-resume (wf-restart-handoff / 2.22.2).
+  // CRITICAL priority — shown at the top so the model acts on it before
+  // anything else. Fires when a worker session starts with queued channel
+  // dispatches that were inherited from the prior (restarted) session.
+  if (ctx.workerAutoResume) {
+    output += `### Workspace Worker Auto-Resume\n`;
+    output += ctx.workerAutoResume + '\n\n';
+  }
+
+  // Workspace worker readiness announcement (wf-restart-handoff / 2.22.2).
+  // Informational — worker started idle, announced readiness to manager.
+  // Manager will reconcile async; no immediate action required from the worker.
+  if (ctx.workerReadyAnnounce) {
+    output += `### Workspace Worker Ready\n`;
+    output += ctx.workerReadyAnnounce + '\n\n';
+  }
+
   // CRITICAL: CLAUDE_CODE_SIMPLE mode warning (highest priority)
   if (ctx.simpleModeWarning && ctx.simpleModeWarning.active) {
     output += `### CLAUDE_CODE_SIMPLE Mode Detected\n`;