wogiflow 2.22.0 → 2.22.1

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,159 @@
+/**
+ * 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;
+}
+
+/**
+ * Build the overdue-dispatches additionalContext block, or return null
+ * when nothing to surface (non-manager, no workspace root, no overdue).
+ *
+ * @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 */ }
+
+  let overdue;
+  try {
+    const libPath = path.resolve(__dirname, '..', '..', '..', 'lib', 'workspace-dispatch-tracking.js');
+    const { getOverdueDispatches } = require(libPath);
+    overdue = getOverdueDispatches(workspaceRoot, opts.now);
+  } catch (_err) {
+    return null; // Fail-open — tracking module missing or IO failure should never block the prompt.
+  }
+
+  if (!Array.isArray(overdue) || overdue.length === 0) return null;
+
+  const now = Number.isFinite(opts.now) ? opts.now : Date.now();
+  const lines = overdue.map(r => formatLine(r, now));
+  return [
+    `━━━ 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');
+}
+
+module.exports = {
+  isManagerSession,
+  buildOverdueContext,
+  sweepAndReconcile
+};

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

@@ -61,57 +61,84 @@ runHook('Stop', async ({ parsedInput }) => {
     };
   }
 
-  // Workspace worker: send results to manager via HTTP when stopping.
-  // Uses execFileSync with array args to avoid shell injection (finding-001).
-  if (process.env.WOGI_MANAGER_PORT && process.env.WOGI_REPO_NAME && process.env.WOGI_REPO_NAME !== 'manager') {
+  // Workspace worker: write a structured `worker-stopped` message to the
+  // workspace message bus when stopping. This is the graceful-stop half of
+  // silent-halt detection (wf-d3e67abe) — the manager's overdue check uses
+  // this (vs. task-complete vs. nothing) to tell "finished" from "gave up
+  // gracefully" from "died silently".
+  //
+  // Replaces the previous plain-text curl POST to the manager channel — that
+  // was fire-and-forget with no structure, so manager-side reconciliation
+  // couldn't distinguish graceful stops from silent deaths.
+  if (process.env.WOGI_REPO_NAME && process.env.WOGI_REPO_NAME !== 'manager') {
     try {
-      const { execFileSync, execSync } = require('node:child_process');
-      const path = require('node:path');
+      const nodePath = require('node:path');
+      const childProcess = require('node:child_process');
       const VALID_NAME = /^[a-zA-Z0-9_-]{1,64}$/;
       const repoName = process.env.WOGI_REPO_NAME;
-      const managerPort = parseInt(process.env.WOGI_MANAGER_PORT, 10);
 
-      // Validate inputs before using them (finding-001, finding-002)
-      if (!VALID_NAME.test(repoName) || !Number.isInteger(managerPort) || managerPort < 1024 || managerPort > 65535) {
-        throw new Error(`Invalid WOGI_REPO_NAME or WOGI_MANAGER_PORT`);
+      if (!VALID_NAME.test(repoName)) {
+        throw new Error(`Invalid WOGI_REPO_NAME`);
       }
 
-      // Build summary from available state
-      const summaryParts = [];
-      const { PATHS, safeJsonParse } = require('../../flow-utils');
+      const workspaceRoot = process.env.WOGI_WORKSPACE_ROOT;
+      if (workspaceRoot) {
+        const { PATHS, safeJsonParse } = require('../../flow-utils');
+        const ready = safeJsonParse(nodePath.join(PATHS.state, 'ready.json'), {});
+        const recentTask = (ready.recentlyCompleted || [])[0];
+        const inProgressTask = (ready.inProgress || [])[0];
+        const mostRecent = recentTask || inProgressTask;
 
-      const ready = safeJsonParse(path.join(PATHS.state, 'ready.json'), {});
-      const recentTask = (ready.recentlyCompleted || [])[0];
-      const inProgressTask = (ready.inProgress || [])[0];
-      const task = recentTask || inProgressTask;
+        // Determine worker state at stop-time
+        const hasInProgress = Boolean(inProgressTask);
+        const state = hasInProgress ? 'mid-work' : 'idle';
+        const taskInProgress = hasInProgress ? inProgressTask.id : null;
 
-      if (task) {
-        summaryParts.push(`**Task**: ${task.title || task.id}`);
-        if (task.type) summaryParts.push(`**Type**: ${task.type}`);
-      }
+        // Best-effort lastSha
+        let lastSha = null;
+        try {
+          lastSha = childProcess.execSync('git rev-parse --short HEAD 2>/dev/null || true', {
+            cwd: PATHS.root,
+            encoding: 'utf-8',
+            timeout: 2000
+          }).trim() || null;
+        } catch (_err) { /* non-critical */ }
 
-      try {
-        const diff = execSync('git diff --name-only HEAD 2>/dev/null || true', { cwd: PATHS.root, encoding: 'utf-8' }).trim();
-        const staged = execSync('git diff --name-only --staged 2>/dev/null || true', { cwd: PATHS.root, encoding: 'utf-8' }).trim();
-        const allChanged = [...new Set([...diff.split('\n'), ...staged.split('\n')].filter(Boolean))];
-        if (allChanged.length > 0) {
-          summaryParts.push(`**Files changed**: ${allChanged.join(', ')}`);
+        // Build structured message and persist via the workspace message bus.
+        // The worker-stopped type was added to MESSAGE_TYPES in
+        // workspace-messages.js (wf-d3e67abe).
+        try {
+          const libMessages = nodePath.resolve(__dirname, '..', '..', '..', '..', 'lib', 'workspace-messages');
+          const { createMessage, saveMessage } = require(libMessages);
+          const msg = createMessage({
+            from: repoName,
+            to: 'manager',
+            type: 'worker-stopped',
+            subject: hasInProgress
+              ? `Worker stopped mid-work on ${taskInProgress}`
+              : `Worker stopped (idle)`,
+            body: [
+              `Worker "${repoName}" is stopping.`,
+              `State: ${state}`,
+              taskInProgress ? `Task in progress: ${taskInProgress}` : null,
+              mostRecent?.title ? `Most recent task: ${mostRecent.title}` : null,
+              lastSha ? `Last commit: ${lastSha}` : null
+            ].filter(Boolean).join('\n'),
+            priority: hasInProgress ? 'high' : 'medium',
+            actionRequired: hasInProgress
+          });
+          // Attach structured fields the manager-side reconciler consumes.
+          msg.taskId = taskInProgress;
+          msg.reason = 'graceful';
+          msg.state = state;
+          msg.taskInProgress = taskInProgress;
+          msg.lastSha = lastSha;
+          saveMessage(workspaceRoot, msg);
+        } catch (err) {
+          if (process.env.DEBUG) {
+            console.error(`[Stop] Workspace message write failed: ${err.message}`);
+          }
         }
-      } catch (_err) { /* non-critical */ }
-
-      const body = summaryParts.join('\n') || `Work completed by ${repoName}.`;
-
-      // execFileSync with array args — no shell interpretation (finding-001 fix)
-      try {
-        execFileSync('curl', [
-          '-s', '-X', 'POST',
-          `http://127.0.0.1:${managerPort}`,
-          '-H', 'Content-Type: text/plain',
-          '-H', `X-Wogi-From: ${repoName}`,
-          '--data-binary', '@-'
-        ], { input: body, timeout: 5000, stdio: ['pipe', 'pipe', 'pipe'] });
-      } catch (_err) {
-        // Manager might be offline — that's OK
       }
     } catch (err) {
       if (process.env.DEBUG) {
@@ -168,14 +195,32 @@ runHook('Stop', async ({ parsedInput }) => {
     }
 
     const restartResult = consumeAndTriggerRestart();
-    if (restartResult.triggered && process.env.DEBUG) {
-      console.error(`[Stop] Task-boundary restart triggered — claude will exit, wrapper will relaunch`);
-    } else if (!restartResult.triggered && restartResult.reason !== 'no-pending-marker' && process.env.DEBUG) {
+    if (restartResult.triggered) {
+      if (process.env.DEBUG) {
+        console.error(`[Stop] Task-boundary restart triggered — claude will exit, wrapper will relaunch`);
+      }
+      // CRITICAL: return NOW, short-circuiting subsequent stop-blocking gates.
+      //
+      // Before this fix (observed 2026-04-17): Phase 2 would SIGTERM claude and
+      // write the restart flag, then fall through to the workspace autopickup
+      // gate (lines below). For a worker with queued dispatches (the common
+      // case), that gate returns `{ continue: true, stopReason: ... }` which
+      // Claude Code honours as "don't stop, pick up next dispatch." Result: the
+      // SIGTERM + restart flag became a no-op because claude was told to keep
+      // running in the SAME session. Symptom: single claude PID survives across
+      // N tasks, context accumulates, tokens burn — exactly the complaint this
+      // feature was supposed to solve.
+      //
+      // The restart is our stop path. The next session's SessionStart hook will
+      // inject queued-dispatch context, so the worker picks up the next task
+      // on RESTART rather than via the autopickup gate's continue-override.
+      // __raw skips the adapter transform — we want the literal {continue:false}
+      // wire format to reach claude unchanged.
+      return { __raw: true, continue: false };
+    }
+    if (restartResult.reason !== 'no-pending-marker' && process.env.DEBUG) {
       console.error(`[Stop] Task-boundary restart check: ${restartResult.reason}`);
     }
-    // If we SIGTERM'd our parent, the process will begin shutting down. Still
-    // return the normal Stop-hook result so any in-flight return value flows
-    // back to claude before the signal is handled.
   } catch (err) {
     if (process.env.DEBUG) {
       console.error(`[Stop] Task-boundary restart module error (fail-open): ${err.message}`);