wogiflow 2.26.2 → 2.29.0

package/scripts/hooks/core/worker-tool-first-gate.js

@@ -0,0 +1,275 @@
+'use strict';
+
+/**
+ * Worker Tool-First Turn Gate — G1 + G4 + G6 (epic wf-34290000, Workstream G)
+ *
+ * In workspace worker mode, every turn that follows a UserPromptSubmit
+ * (channel dispatch from the manager) MUST contain at least one tool call,
+ * and — in strict mode — the first assistant content block MUST be a tool
+ * call, not text.
+ *
+ * Why this exists
+ * ----------------
+ * Workers communicate with the manager via tool calls (channel dispatches,
+ * file edits, test runs) and structured `## Results` payloads. A pure-text
+ * response from a worker is invisible to the user (who only sees the manager
+ * terminal) and disqualifies the worker from the three-state end-of-turn
+ * contract (ACTION | ESCALATION | IDLE — see CLAUDE.md rule "Workspace
+ * Autonomous-Mode Action-After-Completion Contract").
+ *
+ * Three violations this gate detects
+ * ----------------------------------
+ *   G1 — silent halt:            zero tool_use blocks in the turn
+ *   G4 — text-before-tool-call:  first content block is text, not tool_use
+ *                                (strict mode only)
+ *   G6 — documented contract:    the named "worker-tool-first-turn" rule
+ *                                referenced in block messages, so the worker
+ *                                sees one coherent contract, not three gates.
+ *
+ * Fail-open throughout: missing transcript, parse errors, config errors all
+ * return `{ blocked: false }`. Silent-halt false-negatives are recoverable;
+ * blocking legitimate stops on a gate bug is not.
+ *
+ * Scope: worker mode only. Main-mode (non-workspace) turns are unaffected —
+ * the caller must gate on `isWorkerMode()` before invoking this check.
+ */
+
+const fs = require('node:fs');
+
+const MAX_TRANSCRIPT_BYTES = 4 * 1024 * 1024;  // 4MB cap — large transcripts read last-N lines only
+
+/**
+ * Inspect the current turn in a worker transcript and determine whether it
+ * violates the tool-first contract.
+ *
+ * @param {Object} opts
+ * @param {string} opts.transcriptPath - absolute path to Claude Code JSONL transcript
+ * @param {boolean} [opts.strict=true]  - when true, also flag text-before-tool-call
+ * @returns {{ blocked: boolean, reason?: string, violation?: 'silent-halt'|'text-before-tool-call', ruleId?: string }}
+ */
+function checkWorkerToolFirstTurn(opts) {
+  const { transcriptPath, strict = true } = opts || {};
+  if (!transcriptPath || typeof transcriptPath !== 'string') {
+    return { blocked: false, reason: 'no-transcript-path' };
+  }
+
+  const events = readTranscript(transcriptPath);
+  if (!events) {
+    return { blocked: false, reason: 'transcript-unreadable' };
+  }
+
+  const turn = extractCurrentTurn(events);
+  if (!turn) {
+    return { blocked: false, reason: 'no-current-turn' };
+  }
+
+  // G1 — zero tool_use blocks across the entire turn.
+  if (turn.toolUseCount === 0) {
+    return {
+      blocked: true,
+      violation: 'silent-halt',
+      ruleId: 'worker-tool-first-turn',
+      reason: 'worker turn after UserPromptSubmit had zero tool calls (silent-halt / text-only response)'
+    };
+  }
+
+  // G4 — first content block is text, not tool_use (strict mode only).
+  if (strict && turn.firstBlockType === 'text') {
+    return {
+      blocked: true,
+      violation: 'text-before-tool-call',
+      ruleId: 'worker-tool-first-turn',
+      reason: 'worker turn began with a text block before any tool call (text-before-tool-call)'
+    };
+  }
+
+  return { blocked: false };
+}
+
+/**
+ * Read a JSONL transcript and return parsed event objects. Large transcripts
+ * are truncated to the last MAX_TRANSCRIPT_BYTES by reading the file size
+ * and, if oversized, reading only the tail. This bounds per-Stop overhead.
+ *
+ * Returns null on any IO failure (fail-open signal to the caller).
+ */
+function readTranscript(p) {
+  let raw;
+  try {
+    const stat = fs.statSync(p);
+    if (stat.size > MAX_TRANSCRIPT_BYTES) {
+      // Read the last MAX_TRANSCRIPT_BYTES — the first partial line will be
+      // dropped by JSON.parse failure (we skip unparseable lines).
+      const fd = fs.openSync(p, 'r');
+      try {
+        const buf = Buffer.alloc(MAX_TRANSCRIPT_BYTES);
+        fs.readSync(fd, buf, 0, MAX_TRANSCRIPT_BYTES, stat.size - MAX_TRANSCRIPT_BYTES);
+        raw = buf.toString('utf-8');
+      } finally {
+        fs.closeSync(fd);
+      }
+    } else {
+      raw = fs.readFileSync(p, 'utf-8');
+    }
+  } catch (_err) {
+    return null;
+  }
+  if (!raw) return [];
+
+  const events = [];
+  const lines = raw.split('\n');
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      events.push(JSON.parse(trimmed));
+    } catch (_err) {
+      // Unparseable line (likely the truncated first line when we tailed the
+      // file, or a mid-write line) — skip.
+    }
+  }
+  return events;
+}
+
+/**
+ * From a list of transcript events, isolate the current turn: everything
+ * AFTER the most recent user message. Returns turn-level summary:
+ *
+ *   {
+ *     toolUseCount: number,      // total tool_use blocks in the turn
+ *     firstBlockType: 'text'|'tool_use'|null,  // first assistant block type
+ *     assistantEventCount: number
+ *   }
+ *
+ * Returns null if no user message is found (pre-dispatch — not a worker turn
+ * we should gate).
+ */
+function extractCurrentTurn(events) {
+  if (!Array.isArray(events) || events.length === 0) return null;
+
+  // Find the last user message index. Scan from end.
+  let lastUserIdx = -1;
+  for (let i = events.length - 1; i >= 0; i--) {
+    if (isUserEvent(events[i])) {
+      lastUserIdx = i;
+      break;
+    }
+  }
+  if (lastUserIdx === -1) return null;
+
+  // Collect assistant blocks after the last user message, in order.
+  let toolUseCount = 0;
+  let firstBlockType = null;
+  let assistantEventCount = 0;
+
+  for (let i = lastUserIdx + 1; i < events.length; i++) {
+    const entry = events[i];
+    if (!isAssistantEvent(entry)) continue;
+    assistantEventCount++;
+    const blocks = extractContentBlocks(entry);
+    for (const block of blocks) {
+      if (!block || typeof block !== 'object') continue;
+      const t = block.type;
+      if (!firstBlockType && (t === 'text' || t === 'tool_use')) {
+        firstBlockType = t;
+      }
+      if (t === 'tool_use') {
+        toolUseCount++;
+      }
+    }
+  }
+
+  return { toolUseCount, firstBlockType, assistantEventCount };
+}
+
+function isUserEvent(entry) {
+  if (!entry || typeof entry !== 'object') return false;
+  return (
+    entry.role === 'user' ||
+    entry.type === 'user' ||
+    (entry.message && entry.message.role === 'user')
+  );
+}
+
+function isAssistantEvent(entry) {
+  if (!entry || typeof entry !== 'object') return false;
+  return (
+    entry.role === 'assistant' ||
+    entry.type === 'assistant' ||
+    (entry.message && entry.message.role === 'assistant')
+  );
+}
+
+/**
+ * Extract the content-blocks array from a transcript event. Claude Code's
+ * transcript format has evolved, so accept any of:
+ *   { content: [ {...} ] }
+ *   { message: { content: [ {...} ] } }
+ *   { content: 'string' }       → [{ type: 'text', text: 'string' }]
+ *   { message: { content: '...' } } same
+ */
+function extractContentBlocks(entry) {
+  const content = entry.content ?? entry.message?.content;
+  if (typeof content === 'string') {
+    return [{ type: 'text', text: content }];
+  }
+  if (Array.isArray(content)) {
+    return content;
+  }
+  return [];
+}
+
+/**
+ * Render the standard block message the Stop hook returns when a violation
+ * is detected. Centralised so G6 (contract name) stays consistent across
+ * violations.
+ */
+function renderBlockMessage({ violation, reason }) {
+  const port = process.env.WOGI_MANAGER_PORT || '8800';
+  const repo = process.env.WOGI_REPO_NAME || '<worker>';
+  const head = violation === 'text-before-tool-call'
+    ? 'WORKER CONTRACT VIOLATION: text-before-tool-call'
+    : 'WORKER CONTRACT VIOLATION: silent-halt (zero tool calls)';
+  return [
+    head,
+    '',
+    `Rule: worker-tool-first-turn`,
+    `Why: ${reason}`,
+    '',
+    'The worker start-of-turn contract requires every turn after a UserPromptSubmit to',
+    'have at least one tool call, with the first content block being a tool call in',
+    'strict mode. Pure-text responses are invisible to the user and disqualify the',
+    'three-state end-of-turn contract (ACTION | ESCALATION | IDLE).',
+    '',
+    'Do ONE of these NOW:',
+    '  (a) ACTION — invoke the tool you intended to use',
+    '  (b) ESCALATE — channel-dispatch a "## QUESTION:" to the manager:',
+    `      curl -s -X POST http://127.0.0.1:${port} \\`,
+    `        -H "X-Wogi-From: ${repo}" \\`,
+    `        --data-binary "## QUESTION: <your question>"`,
+    '  (c) REPLY with ## Results — channel-dispatch the structured task reply to manager',
+    '',
+    'Then end the turn.'
+  ].join('\n');
+}
+
+/**
+ * Convenience: determine worker mode from env. Exported so callers don\'t
+ * have to duplicate the env-check pattern.
+ */
+function isWorkerMode() {
+  return Boolean(
+    process.env.WOGI_WORKSPACE_ROOT &&
+    process.env.WOGI_REPO_NAME &&
+    process.env.WOGI_REPO_NAME !== 'manager'
+  );
+}
+
+module.exports = {
+  checkWorkerToolFirstTurn,
+  renderBlockMessage,
+  isWorkerMode,
+  // Exported for tests
+  extractCurrentTurn,
+  readTranscript
+};

package/scripts/hooks/entry/claude-code/post-tool-use.js

@@ -11,7 +11,7 @@
  */
 
 const { runValidation } = require('../../core/validation');
-const { captureObservation } = require('../../core/observation-capture');
+const { captureObservation, selectDuration } = require('../../core/observation-capture');
 const { runHook } = require('../shared/hook-runner');
 
 function extractErrorMessage(toolResponse) {
@@ -47,7 +47,7 @@ runHook('PostToolUse', async ({ parsedInput }) => {
       toolName,
       toolInput,
       toolResponse,
-      duration: Date.now() - startTime,
+      duration: selectDuration(parsedInput, Date.now() - startTime),
       explorationStatus: toolFailed ? 'rejected' : undefined,
       rejectionReason: toolFailed ? extractErrorMessage(toolResponse) : undefined
     });

package/scripts/hooks/entry/claude-code/pre-tool-use.js

@@ -63,7 +63,12 @@ try { checkGitSafety = require('../../core/git-safety-gate').checkGitSafety; } c
 let checkManagerBoundary = _noop;
 try { checkManagerBoundary = require('../../core/manager-boundary-gate').checkManagerBoundary; } catch (_err) { if (process.env.DEBUG) console.error(`[Hook] Manager boundary gate not loaded: ${_err.message}`); }
 let checkWorkerBoundary = _noop;
-try { checkWorkerBoundary = require('../../core/worker-boundary-gate').checkWorkerBoundary; } catch (_err) { if (process.env.DEBUG) console.error(`[Hook] Worker boundary gate not loaded: ${_err.message}`); }
+let checkPathDiscipline = _noop;
+try {
+  const wbg = require('../../core/worker-boundary-gate');
+  checkWorkerBoundary = wbg.checkWorkerBoundary;
+  checkPathDiscipline = wbg.checkPathDiscipline;
+} catch (_err) { if (process.env.DEBUG) console.error(`[Hook] Worker boundary gate not loaded: ${_err.message}`); }
 
 const { claudeCodeAdapter } = require('../../adapters/claude-code');
 const { markSkillPending } = require('../../../flow-durable-session');
@@ -101,7 +106,7 @@ runHook('PreToolUse', async ({ input, parsedInput }) => {
     recordEvidenceRead, checkSpecWriteGate, clearResearchEvidence,
     checkDeployGate, checkWriteBlock,
     checkStrikeGate, checkBugfixScope, checkScopeMutation,
-    checkGitSafety, checkManagerBoundary, checkWorkerBoundary,
+    checkGitSafety, checkManagerBoundary, checkWorkerBoundary, checkPathDiscipline,
     // Side-effect helpers
     markSkillPending,
     // Config + runtime

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/`.