wogiflow 2.31.0 → 2.31.2

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

@@ -0,0 +1,269 @@
+'use strict';
+
+/**
+ * Wogi Flow — SessionStart Orchestrator (wf-6e31850e A-3)
+ *
+ * Extracted from scripts/hooks/entry/claude-code/session-start.js to bring
+ * that entry file under the 120-LOC budget per
+ * .claude/rules/architecture/hook-three-layer.md.
+ *
+ * Same control flow as before. Entry session-start.js is now a thin
+ * pass-through that imports boot-instrumentation helpers + this orchestrator.
+ */
+
+const { gatherSessionContext } = require('./session-context');
+const { setCliSessionId, clearStaleCurrentTaskAsync, resetSessionTaskCounter } = require('../../flow-session-state');
+const { checkAndResetStalePhase } = require('./phase-gate');
+const { setRoutingPending } = require('./routing-gate');
+const { getConfig } = require('../../flow-utils');
+
+let autoSyncBridge = null;
+function getAutoSyncBridge() {
+  if (!autoSyncBridge) {
+    try {
+      autoSyncBridge = require('../../flow-bridge-state').autoSyncBridge;
+    } catch (_err) {
+      autoSyncBridge = async () => ({ synced: false, reason: 'unavailable' });
+    }
+  }
+  return autoSyncBridge;
+}
+
+async function orchestrateSessionStart({ parsedInput, bootMark, bootTime }) {
+  bootMark('SessionStart hook entered');
+
+  const bridgeSyncPromise = bootTime('bridge auto-sync', async () => {
+    try {
+      const syncFn = getAutoSyncBridge();
+      await syncFn('claude-code', { silent: true });
+    } catch (err) {
+      if (process.env.DEBUG) console.error(`[session-start] Bridge auto-sync failed: ${err.message}`);
+    }
+  });
+  await bridgeSyncPromise;
+  bootMark('after bridge sync');
+
+  // wf-b8839d99: Refresh standing no-defer pin from decisions.md policy.
+  try {
+    const { refreshFromPolicy } = require('./no-defer-policy');
+    const r = refreshFromPolicy();
+    if (r.refreshed && process.env.DEBUG) {
+      console.error(`[session-start] Refreshed no-defer pin from policy: ${r.header}`);
+    }
+  } catch (err) {
+    if (process.env.DEBUG) console.error(`[session-start] no-defer policy refresh failed: ${err.message}`);
+  }
+
+  // CLAUDE.md drift detection
+  let driftDetected = false;
+  let driftMarkerMissing = false;
+  try {
+    const { checkClaudeMdDrift } = require('../../flow-bridge-state');
+    const drift = checkClaudeMdDrift();
+    if (drift.drifted && drift.reason === 'content-changed') {
+      if (process.env.DEBUG) console.error('[session-start] CLAUDE.md drift detected — content changed since last sync');
+      driftDetected = true;
+    } else if (drift.drifted && drift.reason === 'marker-missing') {
+      if (process.env.DEBUG) console.error('[session-start] CLAUDE.md appears manually maintained (no generation marker)');
+      driftDetected = true;
+      driftMarkerMissing = true;
+    }
+  } catch (err) {
+    if (process.env.DEBUG) console.error(`[session-start] Drift detection failed: ${err.message}`);
+  }
+
+  // Version compatibility checks (parallelized)
+  let versionWarning = null;
+  let updateWarning = null;
+  await bootTime('version checks', async () => {
+    try {
+      const { checkClaudeCodeVersionOnce, checkWogiFlowUpdateOnce } = require('../../flow-version-check');
+      const [vw, uw] = await Promise.all([
+        (async () => { try { return await checkClaudeCodeVersionOnce(); } catch (_err) { return null; } })(),
+        (async () => { try { return await checkWogiFlowUpdateOnce(); } catch (_err) { return null; } })()
+      ]);
+      versionWarning = vw;
+      updateWarning = uw;
+    } catch (err) {
+      if (process.env.DEBUG) console.error(`[session-start] Version check failed: ${err.message}`);
+    }
+  });
+  bootMark('after version checks');
+
+  // Batch 1: Independent pre-context operations
+  let scriptWarnings = [];
+  try {
+    const wasReset = checkAndResetStalePhase();
+    if (wasReset && process.env.DEBUG) console.error('[session-start] Reset stale workflow phase to idle');
+  } catch (err) {
+    if (process.env.DEBUG) console.error(`[session-start] Failed to check stale phase: ${err.message}`);
+  }
+  try { resetSessionTaskCounter(); } catch (_err) { /* non-blocking */ }
+  try {
+    const routingResult = setRoutingPending();
+    if (process.env.DEBUG) console.error(`[session-start] Set routing-pending: ${routingResult.reason}`);
+  } catch (err) {
+    if (process.env.DEBUG) console.error(`[session-start] Failed to set routing-pending: ${err.message}`);
+  }
+  try {
+    const { validateScripts } = require('../../flow-script-resolver');
+    scriptWarnings = validateScripts();
+  } catch (err) {
+    if (process.env.DEBUG) console.error(`[session-start] Script validation failed: ${err.message}`);
+  }
+
+  // BUG-005: Create durable-session.json for active tasks on session start.
+  try {
+    const { getReadyData } = require('../../flow-utils');
+    const readyData = getReadyData();
+    if (Array.isArray(readyData.inProgress) && readyData.inProgress.length > 0) {
+      const task = readyData.inProgress[0];
+      const taskId = task && task.id;
+      if (taskId) {
+        const { loadDurableSession, createDurableSession } = require('../../flow-durable-session');
+        const existing = loadDurableSession();
+        if (!existing || existing.taskId !== taskId) {
+          const criteria = task.acceptanceCriteria || task.scenarios || [];
+          const steps = Array.isArray(criteria) ? criteria : [];
+          const sessionSteps = steps.length > 0 ? steps : [task.title || taskId];
+          createDurableSession(taskId, 'task', sessionSteps);
+          if (process.env.DEBUG) console.error(`[session-start] Created durable session for active task ${taskId}`);
+        }
+      }
+    }
+  } catch (err) {
+    if (process.env.DEBUG) console.error(`[session-start] Durable session init failed: ${err.message}`);
+  }
+
+  // Async pre-ops batched with gatherSessionContext
+  const asyncPreOps = [];
+  if (parsedInput.sessionId) {
+    asyncPreOps.push(setCliSessionId(parsedInput.sessionId).catch(err => {
+      if (process.env.DEBUG) console.error(`[session-start] Failed to store session ID: ${err.message}`);
+    }));
+  }
+  asyncPreOps.push(clearStaleCurrentTaskAsync().catch(err => {
+    if (process.env.DEBUG) console.error(`[session-start] Failed to clear stale task: ${err.message}`);
+  }));
+
+  bootMark('before gatherSessionContext + asyncPreOps');
+  const [, coreResult] = await Promise.all([
+    Promise.all(asyncPreOps),
+    bootTime('gatherSessionContext', () => gatherSessionContext({
+      includeSuspended: true,
+      includeDecisions: true,
+      includeActivity: true
+    }))
+  ]);
+  bootMark('after gatherSessionContext + asyncPreOps');
+
+  // Batch 2: Post-context — plugin scan + community pull (parallel, non-blocking)
+  await bootTime('postContextOps (plugin-scan + community-pull)', () => Promise.all([
+    runPluginAutoScan(coreResult),
+    runCommunityPull(coreResult)
+  ]));
+  bootMark('after postContextOps');
+
+  // Inject warnings into context
+  if (scriptWarnings.length > 0 && coreResult?.context) {
+    coreResult.context.scriptWarnings = scriptWarnings.map(w => w.message);
+  }
+  if (versionWarning && coreResult?.context) coreResult.context.versionWarning = versionWarning;
+  if (updateWarning && coreResult?.context) coreResult.context.updateWarning = updateWarning;
+  if (driftDetected && coreResult?.context) {
+    coreResult.context.driftWarning = driftMarkerMissing
+      ? 'CLAUDE.md appears to have been manually edited (generation marker missing). Was this intentional? If yes, WogiFlow will respect your custom CLAUDE.md. If not, run `flow bridge sync` to regenerate from template.'
+      : 'CLAUDE.md content has changed since the last bridge sync. Was this intentional? If yes, WogiFlow will preserve your changes. If not, run `flow bridge sync` to regenerate from template.';
+  }
+
+  // State file drift detection
+  try {
+    const { detectDrift, saveSnapshot, formatDriftReport } = require('../../flow-state-drift-detector');
+    const driftResult = detectDrift();
+    if (driftResult.hasDrift && coreResult?.context) {
+      coreResult.context.stateDriftWarning = formatDriftReport(driftResult);
+    }
+    saveSnapshot();
+  } catch (_err) {
+    if (process.env.DEBUG) console.error(`[session-start] State drift detection failed: ${_err.message}`);
+  }
+
+  // Workspace worker restart-handoff
+  await bootTime('worker session-start handler', async () => {
+    try {
+      const { handleWorkerSessionStart } = require('./session-start-worker');
+      const workerResult = handleWorkerSessionStart();
+      if (workerResult.context && coreResult?.context) {
+        if (workerResult.branch === 'auto-resume') {
+          coreResult.context.workerAutoResume = workerResult.context;
+        } else if (workerResult.branch === 'announce-ready') {
+          coreResult.context.workerReadyAnnounce = workerResult.context;
+        }
+      }
+    } catch (err) {
+      if (process.env.DEBUG) console.error(`[session-start] Worker session-start handler failed: ${err.message}`);
+    }
+  });
+  bootMark('SessionStart hook returning');
+
+  return coreResult;
+}
+
+async function runPluginAutoScan(coreResult) {
+  try {
+    const config = getConfig();
+    if (!config.plugins?.enabled || !config.plugins?.autoScanOnSessionStart) return;
+    const { scanUnregisteredMcpServers, registerPlugin, deactivateStaleMcpPlugins, listPlugins } = require('../../flow-plugin-registry');
+
+    const unregistered = scanUnregisteredMcpServers();
+    for (const server of unregistered) {
+      registerPlugin({
+        name: server.serverName,
+        description: `Auto-discovered MCP server: ${server.serverName}`,
+        source: 'auto-scan',
+        triggers: [`use ${server.serverName}`, `send to ${server.serverName}`, server.serverName],
+        capabilities: [],
+        metadata: { mcpServer: server.serverName }
+      });
+      if (process.env.DEBUG) console.error(`[session-start] Auto-registered plugin: ${server.serverName}`);
+    }
+    const deactivated = deactivateStaleMcpPlugins();
+    if (deactivated.length > 0 && process.env.DEBUG) {
+      console.error(`[session-start] Deactivated ${deactivated.length} stale plugin(s): ${deactivated.join(', ')}`);
+    }
+    if (coreResult?.context) {
+      const activePlugins = listPlugins({ activeOnly: true });
+      if (unregistered.length > 0 || activePlugins.length > 0) {
+        coreResult.context.pluginScan = {
+          newlyRegistered: unregistered.map(s => s.serverName),
+          activePlugins: activePlugins.map(p => ({ name: p.name, capabilities: (p.capabilities || []).length }))
+        };
+      }
+    }
+  } catch (err) {
+    if (process.env.DEBUG) console.error(`[session-start] Plugin auto-scan failed: ${err.message}`);
+  }
+}
+
+async function runCommunityPull(coreResult) {
+  try {
+    const communityConfig = getConfig();
+    if (!communityConfig.community?.enabled) return;
+    const community = require('../../flow-community');
+    community.retryPendingSuggestions(communityConfig).catch(() => {});
+    if (communityConfig.community?.pullOnSessionStart !== false) {
+      const knowledge = await community.pullFromServer(communityConfig);
+      if (knowledge && coreResult?.context) {
+        coreResult.context.communityKnowledge = knowledge;
+        try { community.mergeCommunityKnowledge(knowledge, communityConfig); }
+        catch (err) {
+          if (process.env.DEBUG) console.error(`[session-start] Community merge failed: ${err.message}`);
+        }
+      }
+    }
+  } catch (err) {
+    if (process.env.DEBUG) console.error(`[session-start] Community pull failed: ${err.message}`);
+  }
+}
+
+module.exports = { orchestrateSessionStart };

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

@@ -0,0 +1,126 @@
+'use strict';
+
+/**
+ * Wogi Flow — Stop-Hook Orchestrator (wf-6e31850e A-3)
+ *
+ * Extracted from scripts/hooks/entry/claude-code/stop.js to bring that entry
+ * file under the 120-LOC budget per .claude/rules/architecture/hook-three-layer.md.
+ *
+ * Same control flow as before; just moved here. Entry stop.js is now a thin
+ * pass-through that imports and delegates.
+ *
+ * Returns the Stop-hook result `{ __raw?, continue?, stopReason?, ... }`.
+ */
+
+const { isRoutingPending, incrementStopAttempts } = require('./routing-gate');
+const { checkLoopExit } = require('./loop-check');
+
+async function orchestrateStop({ parsedInput }) {
+  const activeGates = {};
+  try {
+    const { isLongInputPending } = require('./long-input-enforcement');
+    activeGates['long-input-pending'] = isLongInputPending();
+  } catch (_err) { /* fail-open */ }
+
+  let recoveryGraceActive = false;
+  try {
+    const fs = require('node:fs');
+    const path = require('node:path');
+    const { PATHS } = require('../../flow-utils');
+    const gracePath = path.join(PATHS.state, 'routing-recovery-grace.json');
+    if (fs.existsSync(gracePath)) {
+      const raw = fs.readFileSync(gracePath, 'utf-8');
+      const data = JSON.parse(raw);
+      if (data?.expiresAt && Date.parse(data.expiresAt) > Date.now()) {
+        recoveryGraceActive = true;
+      } else {
+        try { fs.unlinkSync(gracePath); } catch (_err) { /* fine */ }
+      }
+    }
+  } catch (_err) { /* fail-open */ }
+
+  let orchestratorTopGate = null;
+  try {
+    const { pickStopHookGate } = require('./gate-orchestrator');
+    // wf-740f47e4 (NULL-CHECK): guard against malformed return shape.
+    const result = pickStopHookGate({
+      'long-input-pending': activeGates['long-input-pending'] === true
+    });
+    orchestratorTopGate = (result && typeof result === 'object' && typeof result.topGateId === 'string')
+      ? result.topGateId
+      : null;
+  } catch (_err) { /* fail-open */ }
+  const longInputActive = orchestratorTopGate === 'long-input-pending';
+
+  try {
+    if (isRoutingPending() && !longInputActive && !recoveryGraceActive) {
+      const { cleared, attempts } = incrementStopAttempts(10);
+      if (cleared) {
+        if (process.env.DEBUG) {
+          console.error(`[Stop] Max routing enforcement attempts reached (${attempts}), surfacing to user`);
+        }
+        return {
+          __raw: true,
+          continue: false,
+          stopReason: `ROUTING VIOLATION (unrecoverable): max ${attempts} attempts exceeded. The AI failed to call Skill(skill="wogi-start") after ${attempts} stop attempts. Manual review required — this may indicate a stuck routing flag or a session that bypassed /wogi-start through context compaction. To unstick: invoke /wogi-start manually, or check .workflow/state/routing-pending.json.`
+        };
+      } else {
+        return {
+          __raw: true,
+          continue: true,
+          stopReason: [
+            `ROUTING VIOLATION (attempt ${attempts}/10): You MUST call Skill(skill="wogi-start") before responding.`,
+            '',
+            'Call Skill(skill="wogi-start", args="<user\'s message>") NOW. No text. No explanation. Just the Skill tool call.'
+          ].join('\n')
+        };
+      }
+    }
+  } catch (err) {
+    if (process.env.DEBUG) {
+      console.error(`[Stop] Routing check error (fail-closed, forcing continue): ${err.message}`);
+    }
+    return {
+      __raw: true,
+      continue: true,
+      stopReason: 'Routing enforcement check encountered an error. Please invoke /wogi-start with your request.'
+    };
+  }
+
+  const workspaceNotify = require('./workspace-stop-notify');
+  await workspaceNotify.notifyWorkerStopped();
+
+  const restartCoordinator = require('./task-boundary-restart-coordinator');
+  const restartResult = await restartCoordinator.handleTaskBoundaryRestart({ parsedInput });
+  if (restartResult?.shouldReturn) return restartResult.result;
+
+  // Research-Required Stop-Hook Gate
+  try {
+    if (longInputActive) {
+      // skip — defer to long-input remediation
+    } else {
+      const { checkResearchRequiredGate } = require('./research-required-gate');
+      const { getConfig } = require('../../flow-utils');
+      const config = getConfig();
+      const result = checkResearchRequiredGate({
+        transcriptPath: parsedInput?.transcriptPath,
+        config
+      });
+      if (result.blocked) {
+        if (result.hardStop) return { __raw: true, continue: false, stopReason: result.message };
+        return { __raw: true, continue: true, stopReason: result.message };
+      }
+    }
+  } catch (err) {
+    if (process.env.DEBUG) console.error(`[Stop] Research-required gate error (fail-open): ${err.message}`);
+  }
+
+  // Workspace + worker gates
+  const workspaceGates = require('./workspace-stop-gates');
+  const wsResult = await workspaceGates.checkWorkspaceStopGates({ parsedInput });
+  if (wsResult?.shouldReturn) return wsResult.result;
+
+  return await checkLoopExit();
+}
+
+module.exports = { orchestrateStop };

package/scripts/hooks/core/task-boundary-restart-coordinator.js

@@ -0,0 +1,84 @@
+'use strict';
+
+/**
+ * Task-boundary restart coordinator (wf-6e31850e A-3 / extracted from stop.js).
+ *
+ * Coordinates session restart at task boundary. Calls into
+ * task-boundary-reset for the actual SIGTERM, but handles the surrounding
+ * concerns: Phase 1 fallback marking, session-history recording.
+ *
+ * Returns `{ shouldReturn: true, result: {...} }` when the entry should
+ * short-circuit; otherwise `null` to continue.
+ */
+
+async function handleTaskBoundaryRestart({ parsedInput }) {
+  try {
+    const {
+      consumeAndTriggerRestart,
+      hasPendingMarker,
+      ensurePhase1MarkedIfRecentlyCompleted
+    } = require('./task-boundary-reset');
+
+    // Phase 1 fallback
+    try {
+      const fallback = ensurePhase1MarkedIfRecentlyCompleted();
+      if (fallback.marked && process.env.DEBUG) {
+        console.error(`[Stop] Phase 1 fallback marked ${fallback.taskId}`);
+      } else if (!fallback.marked && fallback.reason !== 'marker-already-present' &&
+                 fallback.reason !== 'no-fresh-completion' &&
+                 fallback.reason !== 'stale-completion' &&
+                 fallback.reason !== 'already-triggered-for-this-task' &&
+                 process.env.DEBUG) {
+        console.error(`[Stop] Phase 1 fallback skipped: ${fallback.reason}`);
+      }
+    } catch (err) {
+      if (process.env.DEBUG) console.error(`[Stop] Phase 1 fallback error (fail-open): ${err.message}`);
+    }
+
+    if (hasPendingMarker()) {
+      try {
+        const { recordSessionEnd } = require('./session-history');
+        let cliSessionId = parsedInput?.sessionId || null;
+        if (!cliSessionId) {
+          const { PATHS, safeJsonParse } = require('../../flow-utils');
+          const path = require('node:path');
+          const ss = safeJsonParse(path.join(PATHS.state, 'session-state.json'), {});
+          cliSessionId = ss.cliSessionId || null;
+        }
+        if (cliSessionId) {
+          const { PATHS, safeJsonParse } = require('../../flow-utils');
+          const path = require('node:path');
+          const ready = safeJsonParse(path.join(PATHS.state, 'ready.json'), {});
+          const recent = ready.recentlyCompleted || [];
+          const lastCompleted = recent[0] || null;
+          recordSessionEnd({
+            cliSessionId,
+            endReason: 'task-boundary-restart',
+            tasksCompletedInSession: recent.slice(0, 5).map(t => t.id).filter(Boolean),
+            lastActiveTaskTitle: lastCompleted?.title || null
+          });
+        }
+      } catch (err) {
+        if (process.env.DEBUG) console.error(`[Stop] Session history record failed (non-fatal): ${err.message}`);
+      }
+    }
+
+    const restartResult = await consumeAndTriggerRestart({
+      transcriptPath: parsedInput?.transcriptPath
+    });
+    if (restartResult.triggered) {
+      if (process.env.DEBUG) {
+        console.error(`[Stop] Task-boundary restart triggered — claude will exit, wrapper will relaunch`);
+      }
+      return { shouldReturn: true, result: { __raw: true, continue: false } };
+    }
+    if (restartResult.reason !== 'no-pending-marker' && process.env.DEBUG) {
+      console.error(`[Stop] Task-boundary restart check: ${restartResult.reason}`);
+    }
+  } catch (err) {
+    if (process.env.DEBUG) console.error(`[Stop] Task-boundary restart module error (fail-open): ${err.message}`);
+  }
+  return null;
+}
+
+module.exports = { handleTaskBoundaryRestart };

package/scripts/hooks/core/user-prompt-orchestrator.js

@@ -0,0 +1,201 @@
+'use strict';
+
+/**
+ * Wogi Flow — UserPromptSubmit Orchestrator (wf-6e31850e A-3)
+ *
+ * Extracted from scripts/hooks/entry/claude-code/user-prompt-submit.js to
+ * bring that entry file under the 120-LOC budget per
+ * .claude/rules/architecture/hook-three-layer.md.
+ *
+ * Same control flow as before. Entry user-prompt-submit.js is now a thin
+ * pass-through. Returns the coreResult that the entry forwards to the
+ * adapter.
+ */
+
+const fs = require('node:fs');
+const { checkImplementationGate } = require('./implementation-gate');
+const { checkResearchRequirement } = require('./research-gate');
+const { setRoutingPending, clearRoutingPending, ROUTING_CLEARED_PATH } = require('./routing-gate');
+const { getPhaseContextPrompt } = require('./phase-gate');
+const { buildOverdueContext } = require('./overdue-dispatches');
+const { getDossierInjection } = require('./feature-dossier-gate');
+const {
+  shouldForceExtractReview,
+  buildEnforcementMessage,
+  markLongInputPending
+} = require('./long-input-enforcement');
+const { markSkillPending, loadDurableSession } = require('../../flow-durable-session');
+const { captureCurrentPrompt } = require('../../flow-prompt-capture');
+const { spawnBackgroundDetection } = require('../../flow-correction-detector');
+const { getConfig } = require('../../flow-utils');
+
+async function orchestrateUserPromptSubmit({ input, parsedInput }) {
+  if (!input || Object.keys(input).length === 0) {
+    return { __raw: true, continue: true, hookSpecificOutput: { hookEventName: 'UserPromptSubmit' } };
+  }
+
+  const prompt = parsedInput.prompt;
+  const source = parsedInput.source;
+
+  // wf-729ab5c0 follow-up — clear pending-question marker on user response.
+  try {
+    const { clearPendingQuestion } = require('../../flow-ask');
+    const r = clearPendingQuestion();
+    if (r.wasPresent && process.env.DEBUG) {
+      console.error(`[UserPromptSubmit] Cleared pending-question marker — restart deferral released`);
+    }
+  } catch (_err) { /* non-fatal */ }
+
+  // v4.1: Detect skill commands that need execution tracking
+  if (typeof prompt === 'string') {
+    const skillMatch = prompt.match(/^\/(wogi-bulk|wogi-start)\b/i);
+    if (skillMatch) {
+      const skillName = skillMatch[1].toLowerCase();
+      markSkillPending(skillName, { prompt });
+      if (process.env.DEBUG) console.error(`[Hook] Marked /${skillName} as pending execution`);
+    }
+  }
+
+  let hookConfig;
+  try { hookConfig = getConfig(); } catch (_err) { hookConfig = {}; }
+
+  // v5.0: Capture prompt for learning system (non-blocking)
+  if (hookConfig.hooks?.rules?.intelligence?.promptCapture?.enabled !== false) {
+    if (typeof prompt === 'string' && prompt.trim().length > 0) {
+      setImmediate(() => {
+        try { captureCurrentPrompt(prompt); } catch (err) {
+          if (process.env.DEBUG) console.error(`[Hook] Prompt capture failed: ${err.message}`);
+        }
+      });
+    }
+  }
+
+  // wf-5cd71b1f: Research-required classifier
+  if (typeof prompt === 'string' && prompt.trim().length > 0) {
+    try {
+      const { applyClassification: applyResearchClassification } = require('./research-required-classifier');
+      const r = applyResearchClassification(prompt, hookConfig);
+      if (r.applied && process.env.DEBUG) {
+        console.error(`[Hook] Research-required classifier: category=${r.category}, match="${r.match}"`);
+      }
+    } catch (err) {
+      if (process.env.DEBUG) console.error(`[Hook] Research-required classifier failed: ${err.message}`);
+    }
+  }
+
+  // wf-b8839d99: AI-based deferral classifier
+  if (typeof prompt === 'string' && prompt.trim().length > 0) {
+    try {
+      const { applyClassification } = require('./deferral-classifier');
+      const r = await applyClassification(prompt, hookConfig);
+      if (r.applied && process.env.DEBUG) {
+        console.error(`[Hook] Deferral classifier (AI): intent=${r.intent}, confidence=${r.confidence}, standing=${r.standing}, scope=${JSON.stringify(r.scope)}`);
+      } else if (process.env.DEBUG && r.reason) {
+        console.error(`[Hook] Deferral classifier (AI): no-op — ${r.reason}`);
+      }
+    } catch (err) {
+      if (process.env.DEBUG) console.error(`[Hook] Deferral classifier failed: ${err.message}`);
+    }
+  }
+
+  // Correction detection (background)
+  if (hookConfig.hooks?.rules?.intelligence?.correctionDetection?.enabled !== false) {
+    if (typeof prompt === 'string' && prompt.trim().length > 0) {
+      try {
+        const session = loadDurableSession();
+        spawnBackgroundDetection(prompt, session?.taskId || '');
+      } catch (err) {
+        if (process.env.DEBUG) console.error(`[Hook] Correction detection spawn failed: ${err.message}`);
+      }
+    }
+  }
+
+  // v6.0: Routing-pending flag set/clear
+  const isWogiCommand = typeof prompt === 'string' && /^\/wogi-[a-z0-9-]+\b/i.test(prompt.trim());
+  if (!isWogiCommand) {
+    try { fs.unlinkSync(ROUTING_CLEARED_PATH); }
+    catch (err) {
+      if (err.code !== 'ENOENT' && process.env.DEBUG) console.error(`[Hook] Failed to delete cleared marker: ${err.message}`);
+    }
+    try { setRoutingPending(); }
+    catch (err) {
+      if (process.env.DEBUG) console.error(`[Hook] Routing gate set failed: ${err.message}`);
+    }
+  } else {
+    try {
+      clearRoutingPending();
+      if (process.env.DEBUG) console.error(`[Hook] Cleared routing flag — prompt is a /wogi-* command`);
+    } catch (err) {
+      if (process.env.DEBUG) console.error(`[Hook] Routing gate clear failed: ${err.message}`);
+    }
+  }
+
+  // Phase context + dossier injection
+  let phasePrompt = null;
+  try {
+    const phaseContext = getPhaseContextPrompt();
+    if (phaseContext.inject && phaseContext.prompt) phasePrompt = phaseContext.prompt;
+  } catch (err) {
+    if (process.env.DEBUG) console.error(`[Hook] Phase context injection failed: ${err.message}`);
+  }
+  let dossierPrompt = null;
+  try { dossierPrompt = getDossierInjection(); } catch (err) {
+    if (process.env.DEBUG) console.error(`[Hook] Dossier injection failed: ${err.message}`);
+  }
+  if (dossierPrompt) {
+    phasePrompt = phasePrompt ? `${phasePrompt}\n\n${dossierPrompt}` : dossierPrompt;
+  }
+
+  // Research + implementation gates
+  const researchResult = checkResearchRequirement({ prompt, source });
+  let coreResult = checkImplementationGate({ prompt, source });
+
+  if (researchResult.injectProtocol && researchResult.protocolSteps) {
+    coreResult = {
+      ...coreResult,
+      systemReminder: researchResult.protocolSteps,
+      researchTriggered: true,
+      questionType: researchResult.questionType,
+      suggestedDepth: researchResult.suggestedDepth
+    };
+  } else if (researchResult.warning && coreResult.allowed) {
+    coreResult = {
+      ...coreResult,
+      warning: true,
+      researchWarning: researchResult.message,
+      suggestedCommand: researchResult.suggestedCommand
+    };
+  }
+
+  if (phasePrompt) coreResult = { ...coreResult, phasePrompt };
+
+  // wf-d3e67abe — overdue workspace dispatches
+  try {
+    const overduePrompt = buildOverdueContext();
+    if (overduePrompt) coreResult = { ...coreResult, overduePrompt };
+  } catch (err) {
+    if (process.env.DEBUG) console.error(`[Hook] Overdue dispatches check failed: ${err.message}`);
+  }
+
+  // P11.5 mechanical enforcement — long-form prompts without source-link
+  try {
+    const enforce = shouldForceExtractReview({ text: prompt, source });
+    if (enforce.forced) {
+      const msg = buildEnforcementMessage(enforce.reason, enforce.level);
+      coreResult = { ...coreResult, longInputEnforcement: msg };
+      markLongInputPending({
+        level: enforce.level,
+        reason: enforce.reason,
+        promptPreview: typeof prompt === 'string' ? prompt.slice(0, 200) : '(non-string)',
+        source: source || null,
+        repoName: process.env.WOGI_REPO_NAME || null
+      });
+    }
+  } catch (err) {
+    if (process.env.DEBUG) console.error(`[Hook] Long-input enforcement check failed: ${err.message}`);
+  }
+
+  return coreResult;
+}
+
+module.exports = { orchestrateUserPromptSubmit };