wogiflow 2.26.2 → 2.29.0

package/scripts/flow-workspace-summary.js

@@ -0,0 +1,256 @@
+#!/usr/bin/env node
+
+/**
+ * Wogi Flow — Workspace Autonomous-Run Completion Summary (Story B / wf-ab59f0e4)
+ *
+ * Workers emit completion summaries to the manager via the channel-dispatch
+ * HTTP bus. The wire format is single-line:
+ *
+ *     ## COMPLETION-SUMMARY: <base64-JSON>
+ *
+ * Where <base64-JSON> is the same payload Story C produces locally, with a
+ * `workerId` field added for manager-side aggregation. Base64 was chosen
+ * over plain JSON because the channel-dispatch parser splits on `##`
+ * line-prefixes — multi-line raw JSON would split mid-payload (Blocker 5
+ * from the adversary critique).
+ *
+ * Chunked variant for >64KB payloads:
+ *
+ *     ## COMPLETION-SUMMARY-CHUNK-1/3: <base64-fragment>
+ *     ## COMPLETION-SUMMARY-CHUNK-2/3: <base64-fragment>
+ *     ## COMPLETION-SUMMARY-CHUNK-3/3: <base64-fragment>
+ *
+ * Programmatic:
+ *   const ws = require('./flow-workspace-summary');
+ *   const lines = ws.encodeMessage(payload);  // → ['## COMPLETION-SUMMARY: ...']
+ *   const r = ws.parseMessage(line);          // → { ok, payload?, error? }
+ *   const r = ws.parseChunked(lines);         // re-assemble chunks
+ *   const text = ws.renderMultiWorker(summaries);
+ */
+
+const SINGLE_LINE_PREFIX = '## COMPLETION-SUMMARY: ';
+const CHUNK_PREFIX_REGEX = /^## COMPLETION-SUMMARY-CHUNK-(\d+)\/(\d+):\s+/;
+// Channel-dispatch lines are typically capped well under 64KB; pick a
+// conservative single-line ceiling. Anything larger goes through chunking.
+const SINGLE_LINE_MAX_BYTES = 60 * 1024;
+
+const SEP = '━'.repeat(58);
+
+function encodeBase64(payload) {
+  return Buffer.from(JSON.stringify(payload), 'utf-8').toString('base64');
+}
+
+function decodeBase64(s) {
+  try {
+    const buf = Buffer.from(s, 'base64');
+    const text = buf.toString('utf-8');
+    return JSON.parse(text);
+  } catch (err) {
+    throw new Error(`base64-JSON decode failed: ${err.message}`);
+  }
+}
+
+/**
+ * Encode a completion-summary payload into one or more channel-dispatch
+ * message lines. Always returns at least one line; chunks when the payload
+ * exceeds SINGLE_LINE_MAX_BYTES.
+ */
+function encodeMessage(payload) {
+  if (!payload || typeof payload !== 'object') {
+    throw new Error('encodeMessage: payload must be an object');
+  }
+  const encoded = encodeBase64(payload);
+  if (encoded.length + SINGLE_LINE_PREFIX.length <= SINGLE_LINE_MAX_BYTES) {
+    return [`${SINGLE_LINE_PREFIX}${encoded}`];
+  }
+  const chunkSize = SINGLE_LINE_MAX_BYTES - 64;
+  const total = Math.ceil(encoded.length / chunkSize);
+  const lines = [];
+  for (let i = 0; i < total; i++) {
+    const fragment = encoded.slice(i * chunkSize, (i + 1) * chunkSize);
+    lines.push(`## COMPLETION-SUMMARY-CHUNK-${i + 1}/${total}: ${fragment}`);
+  }
+  return lines;
+}
+
+function isCompletionSummaryLine(line) {
+  if (typeof line !== 'string') return false;
+  if (line.startsWith(SINGLE_LINE_PREFIX)) return true;
+  return CHUNK_PREFIX_REGEX.test(line);
+}
+
+function parseMessage(line) {
+  if (typeof line !== 'string') {
+    return { ok: false, error: 'line must be a string' };
+  }
+  if (!line.startsWith(SINGLE_LINE_PREFIX)) {
+    return { ok: false, error: 'not a single-line COMPLETION-SUMMARY' };
+  }
+  const b64 = line.slice(SINGLE_LINE_PREFIX.length).trim();
+  try {
+    const payload = decodeBase64(b64);
+    return validatePayload(payload);
+  } catch (err) {
+    return { ok: false, error: err.message };
+  }
+}
+
+function parseChunked(lines) {
+  if (!Array.isArray(lines) || lines.length === 0) {
+    return { ok: false, error: 'lines must be a non-empty array' };
+  }
+  const fragments = [];
+  let total = null;
+  for (const line of lines) {
+    const m = CHUNK_PREFIX_REGEX.exec(line);
+    if (!m) return { ok: false, error: 'non-chunk line in chunked input' };
+    const n = parseInt(m[1], 10);
+    const t = parseInt(m[2], 10);
+    if (total === null) total = t;
+    if (t !== total) return { ok: false, error: 'mismatched chunk totals' };
+    if (!Number.isInteger(n) || n < 1 || n > total) {
+      return { ok: false, error: `invalid chunk index: ${m[1]}` };
+    }
+    fragments[n - 1] = line.replace(CHUNK_PREFIX_REGEX, '');
+  }
+  if (fragments.length !== total || fragments.some(f => f === undefined)) {
+    return { ok: false, error: `missing chunks (have ${fragments.filter(Boolean).length} of ${total})` };
+  }
+  try {
+    const payload = decodeBase64(fragments.join(''));
+    return validatePayload(payload);
+  } catch (err) {
+    return { ok: false, error: err.message };
+  }
+}
+
+/**
+ * Validate the shape of a completion-summary payload. Returns
+ * { ok: true, payload } or { ok: false, error }.
+ */
+function validatePayload(payload) {
+  if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
+    return { ok: false, error: 'payload must be a JSON object' };
+  }
+  if (typeof payload.runId !== 'string' || !payload.runId) {
+    return { ok: false, error: 'missing runId' };
+  }
+  for (const key of ['completed', 'queuedQuestions', 'skippedTasks']) {
+    if (!Array.isArray(payload[key])) {
+      return { ok: false, error: `${key} must be an array` };
+    }
+  }
+  return { ok: true, payload };
+}
+
+/**
+ * Render a multi-worker workspace summary block. `summaries` is an array
+ * of validated payloads (each may include `workerId`).
+ *
+ * Empty-collection rule (decisions.md 2026-04-23): all 3 sections always
+ * render per worker. Workers with no work still appear with empty-state
+ * placeholders so the user never wonders if a worker is missing.
+ */
+function renderMultiWorker(summaries) {
+  const list = Array.isArray(summaries) ? summaries : [];
+  const lines = [];
+  lines.push(SEP);
+  lines.push('WORKSPACE AUTONOMOUS RUN COMPLETE');
+  lines.push(SEP);
+  lines.push('');
+
+  if (list.length === 0) {
+    lines.push('[no worker summaries received]');
+    lines.push(SEP);
+    return lines.join('\n');
+  }
+
+  let totalCompleted = 0;
+  let totalQuestions = 0;
+  let totalSkipped = 0;
+  for (const s of list) {
+    const workerId = s.workerId || 'unknown';
+    const dur = formatDuration(s.startedAt, s.endedAt);
+    const completed = Array.isArray(s.completed) ? s.completed : [];
+    const queued = Array.isArray(s.queuedQuestions) ? s.queuedQuestions : [];
+    const skipped = Array.isArray(s.skippedTasks) ? s.skippedTasks : [];
+    totalCompleted += completed.length;
+    totalQuestions += queued.length;
+    totalSkipped += skipped.length;
+
+    lines.push(`Worker: ${workerId} (runId: ${s.runId}, duration: ${dur})`);
+    lines.push(`  ✓ Completed (${completed.length}):`);
+    if (completed.length === 0) {
+      lines.push('    [none]');
+    } else {
+      for (const t of completed) lines.push(`    - ${t.taskId}: ${t.title || '(no title)'}`);
+    }
+    lines.push(`  ? Queued questions (${queued.length}):`);
+    if (queued.length === 0) {
+      lines.push('    [none]');
+    } else {
+      for (const q of queued) {
+        const blockers = Array.isArray(q.dependencies) && q.dependencies.length
+          ? ` (blocks: ${q.dependencies.join(', ')})`
+          : '';
+        lines.push(`    - ${q.id}: ${q.text}${blockers}`);
+      }
+    }
+    lines.push(`  ⊘ Skipped tasks (${skipped.length}):`);
+    if (skipped.length === 0) {
+      lines.push('    [none]');
+    } else {
+      for (const sk of skipped) {
+        const ref = sk.blockingQuestionId ? ` (awaiting ${sk.blockingQuestionId})` : '';
+        lines.push(`    - ${sk.taskId}: ${sk.reason}${ref}`);
+      }
+    }
+    if (s.endReason && s.endReason !== 'queue-drained') {
+      lines.push(`  ⚠ endReason: ${s.endReason}`);
+    }
+    lines.push('');
+  }
+
+  lines.push(`Total: ${totalCompleted} completed, ${totalQuestions} questions queued, ${totalSkipped} skipped across ${list.length} worker${list.length === 1 ? '' : 's'}`);
+  lines.push(SEP);
+  return lines.join('\n');
+}
+
+function formatDuration(startedAt, endedAt) {
+  if (!startedAt || !endedAt) return '0:00';
+  const ms = new Date(endedAt).getTime() - new Date(startedAt).getTime();
+  if (!Number.isFinite(ms) || ms < 0) return '0:00';
+  const sec = Math.floor(ms / 1000);
+  const m = Math.floor(sec / 60);
+  const s = sec % 60;
+  if (m >= 60) {
+    const h = Math.floor(m / 60);
+    return `${h}:${String(m % 60).padStart(2, '0')}:${String(s).padStart(2, '0')}`;
+  }
+  return `${m}:${String(s).padStart(2, '0')}`;
+}
+
+module.exports = {
+  SINGLE_LINE_PREFIX,
+  CHUNK_PREFIX_REGEX,
+  SINGLE_LINE_MAX_BYTES,
+  encodeMessage,
+  parseMessage,
+  parseChunked,
+  isCompletionSummaryLine,
+  validatePayload,
+  renderMultiWorker
+};
+
+if (require.main === module) {
+  const [,, cmd, ...rest] = process.argv;
+  if (cmd === 'encode') {
+    const payload = JSON.parse(rest.join(' '));
+    console.log(encodeMessage(payload).join('\n'));
+  } else if (cmd === 'parse') {
+    const r = parseMessage(rest.join(' '));
+    console.log(JSON.stringify(r, null, 2));
+  } else {
+    console.log('Usage: flow-workspace-summary <encode <json>|parse <line>>');
+  }
+}

package/scripts/hooks/adapters/base-adapter.js

@@ -38,7 +38,7 @@ class BaseAdapter {
    * @param {Object} coreResult - Result from core module
    * @returns {Object} CLI-specific format
    */
-  transformResult(_event, coreResult) {
+  transformResult(_event, _coreResult) {
     throw new Error('transformResult() must be implemented by subclass');
   }
 
@@ -58,7 +58,7 @@ class BaseAdapter {
    * @param {Object} [transportConfig] - Transport config: { transport, url, headers, allowedEnvVars }
    * @returns {Object} CLI-specific hook configuration
    */
-  generateConfig(_rules, projectRoot, transportConfig) {
+  generateConfig(_rules, _projectRoot, _transportConfig) {
     throw new Error('generateConfig() must be implemented by subclass');
   }
 

package/scripts/hooks/core/feature-dossier-gate.js

@@ -0,0 +1,194 @@
+#!/usr/bin/env node
+
+/**
+ * Wogi Flow - Feature Dossier Gate (Core Module)
+ *
+ * Auto-injects matching feature dossiers + cross-cutting logic rules into
+ * the phase context so Claude doesn't have to fetch them under token pressure.
+ *
+ * Problem this solves (2026-04-24 workspace failure catalog):
+ *   - Claude doesn't proactively fetch context — grabs one thing, ignores rest
+ *   - Feature/workflow knowledge is lost between sessions
+ *   - Owner corrections stop being remembered
+ *   - "I know the rule exists" ≠ "I consulted it before acting"
+ *
+ * Two enforcement surfaces:
+ *   1. buildPhaseInjection() — called by UserPromptSubmit. Returns a
+ *      markdown block with the top matching dossiers' canonical content.
+ *      Injected into the phase prompt alongside the phase-context injection.
+ *
+ *   2. validateSpecContradictions() — called from /wogi-story spec-review.
+ *      Scans a spec file against every matching dossier and returns
+ *      blocking issues (spec mentions rejected alternative, spec reintroduces
+ *      removed element). Returns { blocked: boolean, issues: [...] }.
+ *
+ * Fail-open throughout. Missing dossiers, unreadable files, grep failures —
+ * all fail-open. The gate is an aid, not a hard stopgap; the core invariant
+ * is "don't break existing workflow if dossiers aren't set up yet."
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { PATHS, safeJsonParse, getConfig } = require('../../flow-utils');
+
+function isEnabled() {
+  try {
+    const config = getConfig();
+    return config.featureDossier?.enabled !== false;
+  } catch (_err) {
+    return true;
+  }
+}
+
+function getCurrentTaskInfo() {
+  try {
+    const ready = safeJsonParse(PATHS.ready, null);
+    if (!ready || !Array.isArray(ready.inProgress) || ready.inProgress.length === 0) {
+      return null;
+    }
+    const task = ready.inProgress[0];
+    const files = [];
+    if (task.specPath && fs.existsSync(path.join(PATHS.root, task.specPath))) {
+      files.push(task.specPath);
+    }
+    const changeFiles = listRecentlyChangedFiles();
+    return {
+      id: task.id,
+      title: task.title || '',
+      description: task.notes || task.description || '',
+      criteria: task.criteria || [],
+      files: [...new Set([...files, ...changeFiles])]
+    };
+  } catch (_err) {
+    return null;
+  }
+}
+
+function listRecentlyChangedFiles() {
+  try {
+    const { execSync } = require('node:child_process');
+    const out = execSync('git diff --name-only HEAD 2>/dev/null; git status --porcelain 2>/dev/null | awk \'{print $2}\' ', {
+      cwd: PATHS.root, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe']
+    });
+    return out.split('\n').map(s => s.trim()).filter(Boolean).slice(0, 100);
+  } catch (_err) { return []; }
+}
+
+/**
+ * Build the phase-injection block for the current task.
+ * Returns null if no matches, dossier system is disabled, or on any error.
+ */
+function getDossierInjection() {
+  if (!isEnabled()) return null;
+  let dossier, logicRules;
+  try {
+    dossier = require('../../flow-feature-dossier');
+    logicRules = require('../../flow-logic-rules');
+  } catch (_err) { return null; }
+
+  const taskInfo = getCurrentTaskInfo();
+  if (!taskInfo) return null;
+
+  const criteriaText = (taskInfo.criteria || []).map(c =>
+    typeof c === 'string' ? c : (c && c.text) || ''
+  ).join('\n');
+  const matchInput = {
+    title: taskInfo.title,
+    description: `${taskInfo.description}\n${criteriaText}`,
+    files: taskInfo.files
+  };
+
+  let featureBlock = null, rulesBlock = null;
+  try {
+    const featureMatches = dossier.matchFeatures(matchInput);
+    const config = getConfig();
+    const minScore = config.featureDossier?.autoMatchConfidence ?? 1;
+    featureBlock = dossier.buildPhaseInjection(featureMatches, { minScore, maxDossiers: 3 });
+  } catch (_err) { /* non-blocking */ }
+
+  try {
+    const ruleMatches = logicRules.matchRulesForFiles(
+      taskInfo.files,
+      [taskInfo.title, taskInfo.description].filter(Boolean)
+    );
+    rulesBlock = logicRules.buildRulesInjection(ruleMatches);
+  } catch (_err) { /* non-blocking */ }
+
+  const parts = [featureBlock, rulesBlock].filter(Boolean);
+  if (parts.length === 0) return null;
+  return parts.join('\n\n---\n\n');
+}
+
+/**
+ * Validate a spec file against all matching dossiers.
+ * Returns { blocked, issues } — blocked=true if any blocker-severity issue.
+ *
+ * @param {string} specContent
+ * @param {Object} [taskInfo] — optional pre-computed task info; otherwise detected
+ */
+function validateSpecContradictions(specContent, taskInfo) {
+  if (!isEnabled()) return { blocked: false, issues: [] };
+  let dossier;
+  try { dossier = require('../../flow-feature-dossier'); }
+  catch (_err) { return { blocked: false, issues: [] }; }
+
+  const info = taskInfo || getCurrentTaskInfo();
+  if (!info) return { blocked: false, issues: [] };
+
+  const matches = dossier.matchFeatures({
+    title: info.title,
+    description: info.description,
+    files: info.files
+  });
+
+  const allIssues = [];
+  for (const m of matches) {
+    const d = dossier.loadDossier(m.slug);
+    if (!d) continue;
+    const issues = dossier.validateSpecAgainstDossier(specContent, d);
+    for (const issue of issues) {
+      allIssues.push({ ...issue, dossier: m.slug });
+    }
+  }
+
+  let blockOnContradiction = true;
+  try {
+    const config = getConfig();
+    blockOnContradiction = config.featureDossier?.blockOnContradiction !== false;
+  } catch (_err) { /* default true */ }
+
+  const blockers = allIssues.filter(i => i.severity === 'blocker');
+  return {
+    blocked: blockOnContradiction && blockers.length > 0,
+    issues: allIssues
+  };
+}
+
+/**
+ * Format contradictions as a block message the caller can surface to the user.
+ */
+function formatContradictionMessage(issues) {
+  if (!issues || issues.length === 0) return '';
+  const lines = ['## Feature Dossier Contradiction Gate', ''];
+  lines.push(`${issues.length} contradiction(s) found between the proposed spec and one or more active feature dossiers.`);
+  lines.push('');
+  lines.push('Dossiers capture owner-rejected alternatives and removed elements. A spec that reintroduces any of these would re-introduce a bug the owner already corrected.');
+  lines.push('');
+  for (const issue of issues) {
+    lines.push(`- **[${issue.severity}]** (${issue.dossier} / ${issue.kind}) ${issue.detail}`);
+  }
+  lines.push('');
+  lines.push('**Resolution**:');
+  lines.push('1. Read the referenced dossier section in full.');
+  lines.push('2. If the owner has actually changed their mind, update the dossier (move the item out of Rejected / Removed) before proceeding.');
+  lines.push('3. Otherwise, revise the spec to not reintroduce the rejected/removed item.');
+  return lines.join('\n');
+}
+
+module.exports = {
+  isEnabled,
+  getCurrentTaskInfo,
+  getDossierInjection,
+  validateSpecContradictions,
+  formatContradictionMessage
+};

package/scripts/hooks/core/observation-capture.js

@@ -376,6 +376,27 @@ async function captureObservation(options) {
 // Exports
 // ============================================================
 
+/**
+ * Pick the authoritative tool-execution duration.
+ *
+ * Claude Code 2.1.119+ attaches a numeric `duration_ms` to PostToolUse /
+ * PostToolUseFailure payloads — real tool execution time, excluding
+ * permission prompts and PreToolUse hooks. Older CC versions omit it, so
+ * callers pass a locally-computed fallback (typically near-zero because
+ * the hook only measures the gap between adjacent statements, not the
+ * tool itself). Prefer native when numeric; fall back otherwise.
+ *
+ * @param {object} parsedInput - hook payload
+ * @param {number} fallbackMs - local duration to use when native is absent
+ * @returns {number}
+ */
+function selectDuration(parsedInput, fallbackMs) {
+  if (parsedInput && typeof parsedInput.duration_ms === 'number') {
+    return parsedInput.duration_ms;
+  }
+  return fallbackMs;
+}
+
 module.exports = {
   // Configuration
   isObservationCaptureEnabled,
@@ -387,6 +408,9 @@ module.exports = {
   summarizeInput,
   summarizeOutput,
 
+  // Duration source selection (CC 2.1.119+ native, fallback otherwise)
+  selectDuration,
+
   // Main capture function
   captureObservation
 };

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

@@ -259,10 +259,29 @@ function buildOverdueContext(opts = {}) {
     return lostBlock;
   }
 
-  if ((!Array.isArray(overdue) || overdue.length === 0) && !lostBlock) return null;
+  // Worker completion summaries (Story B / wf-ab59f0e4): surface unseen
+  // summaries from any worker that finished an autonomous epic. Render via
+  // flow-workspace-summary.renderMultiWorker for the multi-worker block.
+  let summariesBlock = null;
+  let seenTaskIds = [];
+  try {
+    const libPath = path.resolve(__dirname, '..', '..', '..', 'lib', 'workspace-dispatch-tracking.js');
+    const { readPendingCompletionSummaries, markCompletionSummariesSeen } = require(libPath);
+    const pending = readPendingCompletionSummaries(workspaceRoot);
+    if (Array.isArray(pending) && pending.length > 0) {
+      const wsSummary = require(path.resolve(__dirname, '..', '..', 'flow-workspace-summary.js'));
+      const payloads = pending.map(p => p.summary);
+      summariesBlock = wsSummary.renderMultiWorker(payloads);
+      seenTaskIds = pending.map(p => p.taskId);
+      markCompletionSummariesSeen(workspaceRoot, seenTaskIds);
+    }
+  } catch (_err) { /* fail-open — surface what we can */ }
+
+  if ((!Array.isArray(overdue) || overdue.length === 0) && !lostBlock && !summariesBlock) return null;
 
   const sections = [];
 
+  if (summariesBlock) sections.push(summariesBlock);
   if (lostBlock) sections.push(lostBlock);
 
   if (Array.isArray(overdue) && overdue.length > 0) {

package/scripts/hooks/core/phase-gate.js

@@ -186,12 +186,26 @@ function transitionPhase(from, to, taskId) {
     }
   }
 
-  return writePhaseState({
+  const wrote = writePhaseState({
     phase: to,
     taskId: taskId || current.taskId,
     updatedAt: new Date().toISOString(),
     previousPhase: from
   });
+
+  // Clear any stale routing-pending flag left over from a prior turn when
+  // crossing a phase boundary. Uses removeRoutingFlag() (not clearRoutingPending)
+  // so the cleared-marker is preserved — we don't want to open a 15s bypass
+  // window just because a phase transitioned. Fail-open if the module is
+  // unavailable (e.g. future CLI adapter without routing-gate wired).
+  if (wrote) {
+    try {
+      const { removeRoutingFlag } = require('./routing-gate');
+      removeRoutingFlag();
+    } catch (_err) { /* fail-open */ }
+  }
+
+  return wrote;
 }
 
 /**

package/scripts/hooks/core/phase-transition-auto-review.js

@@ -0,0 +1,61 @@
+'use strict';
+
+/**
+ * Phase-transition Auto-Review trigger (wf-8d635d0e / E1).
+ *
+ * Called after a successful phase transition. When the transition is
+ * `coding → validating` and `config.autoReview.enabled`, fire a detached
+ * background review worker. Non-blocking by design (AC5) — parent returns
+ * immediately; the worker writes findings asynchronously.
+ *
+ * Failure-mode: any error from the spawn path is swallowed and logged via
+ * DEBUG only. Auto-review is an advisory signal layered on top of the
+ * existing Completion Truth Gate — a crash here must never fail the
+ * primary phase transition.
+ */
+
+const { getConfig } = require('../../flow-utils');
+
+function isAutoReviewEnabled(cfg) {
+  try {
+    const c = cfg || getConfig();
+    return c?.autoReview?.enabled === true;
+  } catch (_err) {
+    return false;
+  }
+}
+
+/**
+ * Trigger a background auto-review when appropriate.
+ *
+ * @param {string} from - prior phase
+ * @param {string} to   - new phase
+ * @param {string} taskId
+ * @param {Object} [opts]
+ * @param {Function} [opts.starter] — injectable startReview (tests)
+ * @returns {{ started:boolean, reason?:string, handle?:Object }}
+ */
+function maybeStartAutoReview(from, to, taskId, opts = {}) {
+  if (from !== 'coding' || to !== 'validating') {
+    return { started: false, reason: 'not-validating-transition' };
+  }
+  if (!taskId) {
+    return { started: false, reason: 'no-task-id' };
+  }
+  if (!isAutoReviewEnabled(opts.config)) {
+    return { started: false, reason: 'disabled' };
+  }
+
+  const starter = opts.starter || require('../../../lib/worktree-review').startReview;
+  try {
+    const handle = starter({ taskId, repoRoot: opts.repoRoot });
+    return { started: true, handle };
+  } catch (err) {
+    if (process.env.DEBUG) {
+      console.error(`[auto-review] startReview failed: ${err.message}`);
+    }
+    return { started: false, reason: 'spawn-error', error: String(err.message || err) };
+  }
+}
+
+module.exports = { maybeStartAutoReview, isAutoReviewEnabled };

package/scripts/hooks/core/post-compact.js

@@ -184,10 +184,13 @@ function handlePostCompact() {
 
   // 3. Re-set routing-pending flag
   // After compaction, the AI has fresh context and may try to act without routing.
-  // Setting routing-pending ensures the next tool use goes through routing checks.
+  // resetRoutingState() first clears any stale cleared-marker from the pre-compact
+  // turn — otherwise setRoutingPending() would short-circuit on the 15s skill-chain
+  // suppression window and leave the flag unset, creating a bypass.
   let routingReArmed = false;
   try {
-    const { setRoutingPending } = require('./routing-gate');
+    const { setRoutingPending, resetRoutingState } = require('./routing-gate');
+    resetRoutingState();
     setRoutingPending();
     routingReArmed = true;
   } catch (err) {

package/scripts/hooks/core/pre-tool-orchestrator.js

@@ -261,6 +261,27 @@ function runPreToolGates(ctx, deps) {
     }
   }
 
+  // Path-discipline gate (Story B / wf-ab59f0e4): runs in BOTH manager and
+  // worker mode (different rules each side). Cross-process state writes are
+  // blocked fail-loud so file corruption is impossible to ignore.
+  if (process.env.WOGI_WORKSPACE_ROOT) {
+    try {
+      if (typeof deps.checkPathDiscipline === 'function') {
+        const pathResult = deps.checkPathDiscipline(toolName, toolInput);
+        if (pathResult.blocked) {
+          return {
+            allowed: false,
+            blocked: true,
+            reason: pathResult.reason,
+            message: pathResult.message,
+          };
+        }
+      }
+    } catch (err) {
+      if (process.env.DEBUG) console.error(`[Hook] Path discipline gate error (fail-open): ${err.message}`);
+    }
+  }
+
   // Commit log gate
   if (toolName === 'Bash' && toolInput.command) {
     try {