wogiflow 2.26.2 → 2.29.1

package/scripts/hooks/entry/claude-code/session-start.js

@@ -14,6 +14,39 @@ const { setRoutingPending } = require('../../core/routing-gate');
 const { getConfig } = require('../../../flow-utils');
 const { runHook } = require('../shared/hook-runner');
 
+// wf-8294d960: env-guarded boot-latency instrumentation. No effect unless WOGI_DEBUG_BOOT=1.
+// Claude Code suppresses hook process stderr — we write to an append-only log file instead.
+const BOOT_DEBUG = process.env.WOGI_DEBUG_BOOT === '1';
+const _bootT0 = BOOT_DEBUG ? Date.now() : 0;
+const _bootLogFile = BOOT_DEBUG
+  ? require('path').join(require('os').tmpdir(), 'wogi-boot-latency.log')
+  : null;
+let _bootSep = false;
+function _bootWrite(line) {
+  if (!BOOT_DEBUG) return;
+  try {
+    if (!_bootSep) {
+      require('fs').appendFileSync(_bootLogFile, `\n=== SessionStart pid=${process.pid} @ ${new Date().toISOString()} ===\n`);
+      _bootSep = true;
+    }
+    require('fs').appendFileSync(_bootLogFile, line + '\n');
+  } catch (_err) { /* non-blocking */ }
+}
+function _bootMark(label) {
+  if (!BOOT_DEBUG) return;
+  const ms = Date.now() - _bootT0;
+  _bootWrite(`[boot-latency] +${String(ms).padStart(6)}ms ${label}`);
+}
+async function _bootTime(label, fn) {
+  if (!BOOT_DEBUG) return fn();
+  const t = Date.now();
+  try {
+    return await fn();
+  } finally {
+    _bootWrite(`[boot-latency]   (${String(Date.now() - t).padStart(6)}ms) ${label}`);
+  }
+}
+
 // Lazy-load bridge state to avoid circular dependencies
 let autoSyncBridge = null;
 function getAutoSyncBridge() {
@@ -28,8 +61,9 @@ function getAutoSyncBridge() {
 }
 
 runHook('SessionStart', async ({ parsedInput }) => {
+  _bootMark('SessionStart hook entered');
   // Start bridge auto-sync in parallel with other init work
-  const bridgeSyncPromise = (async () => {
+  const bridgeSyncPromise = _bootTime('bridge auto-sync', async () => {
     try {
       const syncFn = getAutoSyncBridge();
       await syncFn('claude-code', { silent: true });
@@ -38,10 +72,11 @@ runHook('SessionStart', async ({ parsedInput }) => {
         console.error(`[session-start] Bridge auto-sync failed: ${err.message}`);
       }
     }
-  })();
+  });
 
   // Wait for bridge sync to complete
   await bridgeSyncPromise;
+  _bootMark('after bridge sync');
 
   // CLAUDE.md drift detection — check if manually edited since last sync
   let driftDetected = false;
@@ -70,19 +105,22 @@ runHook('SessionStart', async ({ parsedInput }) => {
   // --- Version compatibility checks (parallelized) ---
   let versionWarning = null;
   let updateWarning = null;
-  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}`);
+  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 (async + sync) ---
   let scriptWarnings = [];
@@ -173,14 +211,16 @@ runHook('SessionStart', async ({ parsedInput }) => {
   );
 
   // Gather session context concurrently with the async pre-ops
+  _bootMark('before gatherSessionContext + asyncPreOps');
   const [, coreResult] = await Promise.all([
     Promise.all(asyncPreOps),
-    gatherSessionContext({
+    _bootTime('gatherSessionContext', () => gatherSessionContext({
       includeSuspended: true,
       includeDecisions: true,
       includeActivity: true
-    })
+    }))
   ]);
+  _bootMark('after gatherSessionContext + asyncPreOps');
 
   // --- Batch 2: Post-context operations (plugin scan + community pull) ---
   const postContextOps = [];
@@ -260,7 +300,8 @@ runHook('SessionStart', async ({ parsedInput }) => {
     }
   })());
 
-  await Promise.all(postContextOps);
+  await _bootTime('postContextOps (plugin-scan + community-pull)', () => Promise.all(postContextOps));
+  _bootMark('after postContextOps');
 
   // Inject script warnings into context (if any)
   if (scriptWarnings.length > 0 && coreResult && coreResult.context) {
@@ -309,21 +350,24 @@ runHook('SessionStart', async ({ parsedInput }) => {
   // if the queue is truly empty, announce worker-ready so the manager can
   // reconcile against its dispatch log and re-dispatch anything lost during
   // the restart window. See scripts/hooks/core/session-start-worker.js.
-  try {
-    const { handleWorkerSessionStart } = require('../../core/session-start-worker');
-    const workerResult = handleWorkerSessionStart();
-    if (workerResult.context && coreResult && coreResult.context) {
-      if (workerResult.branch === 'auto-resume') {
-        coreResult.context.workerAutoResume = workerResult.context;
-      } else if (workerResult.branch === 'announce-ready') {
-        coreResult.context.workerReadyAnnounce = workerResult.context;
+  await _bootTime('worker session-start handler', async () => {
+    try {
+      const { handleWorkerSessionStart } = require('../../core/session-start-worker');
+      const workerResult = handleWorkerSessionStart();
+      if (workerResult.context && coreResult && 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}`);
       }
     }
-  } catch (err) {
-    if (process.env.DEBUG) {
-      console.error(`[session-start] Worker session-start handler failed: ${err.message}`);
-    }
-  }
+  });
+  _bootMark('SessionStart hook returning');
 
   return coreResult;
 }, { failMode: 'warn' });

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

@@ -220,7 +220,9 @@ runHook('Stop', async ({ parsedInput }) => {
       }
     }
 
-    const restartResult = consumeAndTriggerRestart();
+    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`);
@@ -313,6 +315,50 @@ runHook('Stop', async ({ parsedInput }) => {
     }
   }
 
+  // Worker Tool-First Turn Gate (G1 + G4 + G6 — epic wf-34290000, Workstream G).
+  //
+  // In worker mode, every turn after a UserPromptSubmit (channel dispatch)
+  // MUST have at least one tool call. Strict mode also requires the first
+  // assistant content block to be a tool call, not text. Pure-text worker
+  // responses are invisible to the user and violate the three-state
+  // end-of-turn contract.
+  //
+  // Gates in order: G1 (zero tool_use = silent-halt) → G4 (text-first block =
+  // text-before-tool-call). Both share the rule name "worker-tool-first-turn"
+  // (G6). Fail-open — missing transcript / parse errors / config errors
+  // return no-block.
+  try {
+    const { isWorkerMode, checkWorkerToolFirstTurn, renderBlockMessage } =
+      require('../../core/worker-tool-first-gate');
+    if (isWorkerMode() && parsedInput?.transcriptPath) {
+      const { getConfig } = require('../../../flow-utils');
+      const config = getConfig();
+      const gateCfg = config.workspace?.toolFirstTurnGate;
+      const enabled = gateCfg?.enabled !== false;  // default true
+      if (enabled) {
+        const strict = gateCfg?.strict !== false;  // default true
+        const result = checkWorkerToolFirstTurn({
+          transcriptPath: parsedInput.transcriptPath,
+          strict
+        });
+        if (result.blocked) {
+          return {
+            __raw: true,
+            continue: true,
+            stopReason: renderBlockMessage(result)
+          };
+        }
+      }
+    }
+  } catch (err) {
+    // Fail-OPEN — any error in the tool-first gate must not block legitimate
+    // stops. Silent-halt / text-first false-negatives are recoverable; a
+    // false-positive block on every turn is not.
+    if (process.env.DEBUG) {
+      console.error(`[Stop] Worker tool-first gate error (fail-open): ${err.message}`);
+    }
+  }
+
   // G3 (v2.21.0) — AI-based worker-question classifier.
   //
   // If the worker ends a turn with a question to the user in free text (no tool

package/scripts/hooks/entry/claude-code/user-prompt-submit.js

@@ -13,6 +13,7 @@ const { checkResearchRequirement } = require('../../core/research-gate');
 const { setRoutingPending, clearRoutingPending, ROUTING_CLEARED_PATH } = require('../../core/routing-gate');
 const { getPhaseContextPrompt } = require('../../core/phase-gate');
 const { buildOverdueContext } = require('../../core/overdue-dispatches');
+const { getDossierInjection } = require('../../core/feature-dossier-gate');
 const { markSkillPending, loadDurableSession } = require('../../../flow-durable-session');
 const { captureCurrentPrompt } = require('../../../flow-prompt-capture');
 const { spawnBackgroundDetection } = require('../../../flow-correction-detector');
@@ -135,6 +136,22 @@ runHook('UserPromptSubmit', async ({ input, parsedInput }) => {
     }
   }
 
+  // wf-557cf08a — Feature dossier + logic rules auto-injection.
+  // Surfaces canonical per-feature knowledge and cross-cutting logic rules
+  // into the phase prompt so Claude doesn't have to fetch them under token
+  // pressure. Fail-open: returns null on any error.
+  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;
+  }
+
   // Check research gate first (before implementation gate)
   const researchResult = checkResearchRequirement({
     prompt,

package/.workflow/templates/partials/user-commands.hbs

@@ -1,20 +0,0 @@
-## User Commands
-
-| To Do This | Say This |
-|------------|----------|
-| Start a task | "start task wf-XXX" or describe what you want |
-| Code review | "code review" or "review what we did" |
-| Morning briefing | "morning briefing" or "what should I work on" |
-| End session | "wrap up" or "end session" |
-| Peer review | "peer review" |
-| Enable hybrid | "enable hybrid mode" |
-| Show tasks | "show tasks" or "what's ready" |
-| Project status | "project status" or "where are we" |
-| Create a rule | "from now on always..." or "let's make it a rule" |
-| Learn from patterns | "let's learn from this" or "promote pattern" |
-| Session retro | "retro" or "what went well" |
-| Rescan project | "rescan project" or "things changed" or "out of sync" |
-| Project audit | "audit project" or "full analysis" |
-| Register plugin | "register plugin" or "/wogi-register <name>" |
-
-`/wogi-start` is the universal fallback router — it classifies any request and routes to the right action. Detailed per-command docs live in each skill's `.md` file under `.claude/commands/`.