wogiflow 2.8.0 → 2.9.1

package/scripts/flow-gate-latch.js

@@ -0,0 +1,119 @@
+#!/usr/bin/env node
+
+/**
+ * Wogi Flow - Gate Latch
+ *
+ * Records when quality gates have passed for a task.
+ * The TaskCompleted hook checks for this latch before allowing
+ * a task to move to recentlyCompleted.
+ *
+ * Without the latch, agents can call TaskUpdate(status: "completed")
+ * and bypass all quality gates. The latch ensures that the only path
+ * to completion goes through the quality gate pipeline.
+ *
+ * Flow:
+ * 1. flow-done.js runs quality gates → gates pass → writes latch
+ * 2. Agent calls TaskUpdate → TaskCompleted hook fires
+ * 3. Hook checks latch → if present and recent → allows completion
+ * 4. If no latch → blocks completion with actionable error message
+ *
+ * Latch file: .workflow/state/.gates-passed.json
+ * TTL: 30 minutes (stale latches are ignored)
+ */
+
+const path = require('node:path');
+const fs = require('node:fs');
+const { PATHS, safeJsonParse } = require('./flow-utils');
+
+/** Latch time-to-live in milliseconds (30 minutes) */
+const LATCH_TTL_MS = 30 * 60 * 1000;
+
+/** Path to the gate latch file */
+const LATCH_PATH = path.join(PATHS.state, '.gates-passed.json');
+
+/**
+ * Record that quality gates have passed for a task.
+ * Called by flow-done.js after all gates pass.
+ *
+ * @param {string} taskId - The task ID that passed gates
+ * @param {string[]} gatesPassed - Names of gates that passed
+ * @returns {{ written: boolean, path: string }}
+ */
+function setGateLatch(taskId, gatesPassed = []) {
+  try {
+    const latch = {
+      taskId,
+      gatesPassed,
+      passedAt: new Date().toISOString(),
+      pid: process.pid
+    };
+    fs.writeFileSync(LATCH_PATH, JSON.stringify(latch, null, 2));
+    return { written: true, path: LATCH_PATH };
+  } catch (err) {
+    if (process.env.DEBUG) {
+      console.error(`[gate-latch] Failed to write latch: ${err.message}`);
+    }
+    return { written: false, path: LATCH_PATH };
+  }
+}
+
+/**
+ * Check if quality gates have passed for a task.
+ * Returns the latch data if valid, null if no latch or expired.
+ *
+ * @param {string} taskId - The task ID to check
+ * @returns {{ valid: boolean, latch: Object|null, reason: string }}
+ */
+function checkGateLatch(taskId) {
+  const latch = safeJsonParse(LATCH_PATH, null);
+
+  if (!latch) {
+    return {
+      valid: false,
+      latch: null,
+      reason: 'No gate latch found. Quality gates have not been run for this task.'
+    };
+  }
+
+  // Check task ID matches
+  if (latch.taskId !== taskId) {
+    return {
+      valid: false,
+      latch,
+      reason: `Gate latch is for task ${latch.taskId}, not ${taskId}.`
+    };
+  }
+
+  // Check TTL
+  const passedAt = new Date(latch.passedAt).getTime();
+  const age = Date.now() - passedAt;
+  if (age > LATCH_TTL_MS) {
+    return {
+      valid: false,
+      latch,
+      reason: `Gate latch expired (${Math.round(age / 60000)} min old, TTL is ${LATCH_TTL_MS / 60000} min).`
+    };
+  }
+
+  return {
+    valid: true,
+    latch,
+    reason: `Gates passed at ${latch.passedAt} (${latch.gatesPassed.length} gates)`
+  };
+}
+
+/**
+ * Clear the gate latch after task completion.
+ * Prevents stale latches from persisting.
+ */
+function clearGateLatch() {
+  try {
+    if (fs.existsSync(LATCH_PATH)) {
+      fs.unlinkSync(LATCH_PATH);
+    }
+  } catch (_err) {
+    // Non-critical
+  }
+}
+
+module.exports = { setGateLatch, checkGateLatch, clearGateLatch, LATCH_PATH };

package/scripts/flow-health.js

@@ -714,6 +714,186 @@ function main() {
     }
   }
 
+  // Knowledge linting
+  console.log('');
+  printSection('Knowledge linting...');
+
+  // 1. Check section-index freshness
+  if (fileExists(PATHS.sectionIndex)) {
+    try {
+      const indexStat = fs.statSync(PATHS.sectionIndex);
+      const indexAge = Date.now() - indexStat.mtimeMs;
+      const maxAge = 7 * 24 * 60 * 60 * 1000; // 7 days
+      if (indexAge > maxAge) {
+        const days = Math.round(indexAge / (24 * 60 * 60 * 1000));
+        warn(`section-index.json is ${days} days old — may be stale`);
+        console.log(`    ${color('dim', "→ Run 'node scripts/flow-section-index.js --force' to regenerate")}`);
+        warnings++;
+      } else {
+        success(`section-index.json is fresh`);
+      }
+    } catch (_err) {
+      warn(`Could not check section-index.json age`);
+      warnings++;
+    }
+  } else {
+    warn(`section-index.json not found — knowledge navigation unavailable`);
+    console.log(`    ${color('dim', "→ Run 'node scripts/flow-section-index.js --force' to generate")}`);
+    warnings++;
+  }
+
+  // 2. Check feedback-patterns.md for stale/duplicate entries
+  if (fileExists(PATHS.feedbackPatterns)) {
+    try {
+      const fpContent = fs.readFileSync(PATHS.feedbackPatterns, 'utf-8');
+      const fpLines = fpContent.split('\n').filter(l => l.startsWith('|') && !l.includes('---') && !l.includes('Date'));
+      const totalPatterns = fpLines.length;
+      const needsSkill = fpLines.filter(l => l.includes('#needs-skill')).length;
+      const promoted = fpLines.filter(l => l.includes('Fixed') || l.includes('Promoted')).length;
+      const stale = fpLines.filter(l => {
+        const dateMatch = l.match(/\d{4}-\d{2}-\d{2}/);
+        if (!dateMatch) return false;
+        const entryDate = new Date(dateMatch[0]);
+        const age = Date.now() - entryDate.getTime();
+        return age > 90 * 24 * 60 * 60 * 1000; // older than 90 days
+      }).length;
+
+      if (totalPatterns > 0) {
+        success(`feedback-patterns.md: ${totalPatterns} entries`);
+        if (needsSkill > totalPatterns * 0.7) {
+          warn(`${needsSkill}/${totalPatterns} entries are #needs-skill — skill gap detected`);
+          console.log(`    ${color('dim', '→ Consider creating skills for common file patterns')}`);
+          warnings++;
+        }
+        if (stale > 0) {
+          warn(`${stale} entries older than 90 days — consider archiving`);
+          warnings++;
+        }
+        if (promoted > 0) {
+          console.log(`  ${color('dim', 'ℹ')} ${promoted} patterns promoted/fixed`);
+        }
+      }
+    } catch (_err) {
+      warn(`Could not parse feedback-patterns.md`);
+      warnings++;
+    }
+  }
+
+  // 3. Check decisions.md references are still valid
+  if (fileExists(PATHS.decisions)) {
+    try {
+      const decContent = fs.readFileSync(PATHS.decisions, 'utf-8');
+      const fileRefs = decContent.match(/`[^`]*\.(js|ts|md|json)`/g) || [];
+      let orphanedRefs = 0;
+      const checkedRefs = new Set();
+
+      for (const ref of fileRefs) {
+        const filePath = ref.replace(/`/g, '');
+        if (checkedRefs.has(filePath)) continue;
+        checkedRefs.add(filePath);
+
+        // Resolve relative to project root, trying common prefixes
+        const candidates = [
+          path.join(PROJECT_ROOT, filePath),
+          path.join(PROJECT_ROOT, '.workflow', filePath),
+          path.join(PROJECT_ROOT, '.claude', filePath),
+        ];
+
+        const exists = candidates.some(c => fileExists(c));
+        if (!exists && !filePath.includes('*') && !filePath.includes('{')) {
+          orphanedRefs++;
+        }
+      }
+
+      if (orphanedRefs > 0) {
+        warn(`decisions.md has ${orphanedRefs} reference(s) to files that may no longer exist`);
+        warnings++;
+      } else if (fileRefs.length > 0) {
+        success(`decisions.md file references verified (${checkedRefs.size} checked)`);
+      }
+    } catch (_err) {
+      warn(`Could not lint decisions.md references`);
+      warnings++;
+    }
+  }
+
+  // 4. Check skill feedback loop — verify skills with learnings get loaded
+  try {
+    const skillsDir = path.join(PROJECT_ROOT, '.claude', 'skills');
+    if (dirExists(skillsDir)) {
+      const skillDirs = fs.readdirSync(skillsDir, { withFileTypes: true })
+        .filter(d => d.isDirectory() && d.name !== '_template' && d.name !== 'README.md');
+
+      let skillsWithLearnings = 0;
+      for (const dir of skillDirs) {
+        const learningsPath = path.join(skillsDir, dir.name, 'knowledge', 'learnings.md');
+        if (fileExists(learningsPath)) {
+          try {
+            const content = fs.readFileSync(learningsPath, 'utf-8').trim();
+            if (content.length > 50) { // Non-empty learnings
+              skillsWithLearnings++;
+            }
+          } catch (_err) {}
+        }
+      }
+
+      const config = getConfig();
+      const loadLearnings = config.skills?.loadLearnings !== false;
+
+      if (skillsWithLearnings > 0 && !loadLearnings) {
+        warn(`${skillsWithLearnings} skill(s) have learnings but skills.loadLearnings is disabled`);
+        console.log(`    ${color('dim', '→ Set skills.loadLearnings: true in config.json to use accumulated learnings')}`);
+        warnings++;
+      } else if (skillsWithLearnings > 0) {
+        success(`${skillsWithLearnings} skill(s) with learnings — feedback loop active`);
+      } else if (skillDirs.length > 0) {
+        console.log(`  ${color('dim', 'ℹ')} ${skillDirs.length} skill(s) installed — no learnings yet`);
+      }
+    }
+  } catch (_err) {
+    // Skills directory check is non-critical
+  }
+
+  // 5. Check registry maps for orphaned file references
+  try {
+    const { getActiveRegistries, STATE_DIR: stateDir } = require('./flow-utils');
+    const registries = getActiveRegistries();
+    let totalOrphans = 0;
+    let totalChecked = 0;
+
+    for (const reg of registries) {
+      const mapPath = path.join(stateDir, reg.mapFile);
+      if (!fileExists(mapPath)) continue;
+
+      try {
+        const mapContent = fs.readFileSync(mapPath, 'utf-8');
+        // Extract file paths from markdown table rows (typically in a "File" or "Path" column)
+        const pathRefs = mapContent.match(/(?:src|lib|scripts|components|pages|app)\/[\w/.-]+\.\w+/g) || [];
+        const unique = [...new Set(pathRefs)];
+
+        for (const ref of unique) {
+          totalChecked++;
+          const fullPath = path.join(PROJECT_ROOT, ref);
+          if (!fileExists(fullPath)) {
+            totalOrphans++;
+          }
+        }
+      } catch (_err) {
+        // Skip unreadable maps
+      }
+    }
+
+    if (totalOrphans > 0) {
+      warn(`Registry maps have ${totalOrphans} orphaned file reference(s) (${totalChecked} checked)`);
+      console.log(`    ${color('dim', "→ Run 'flow registry-manager scan' to update maps")}`);
+      warnings++;
+    } else if (totalChecked > 0) {
+      success(`Registry map file references verified (${totalChecked} checked)`);
+    }
+  } catch (_err) {
+    // Registry system unavailable — skip silently
+  }
+
   // Check agents
   console.log('');
   printSection('Checking agents...');

package/scripts/flow-log-manager.js

@@ -658,12 +658,14 @@ Commands:
   archive             Force archive old entries
   search <query>      Search entries (current + archives)
   list-archives       List archive files
+  rebuild-fts         Rebuild FTS5 full-text search index from current log
   --help              Show this help
 
 Examples:
   node scripts/flow-log-manager.js status
   node scripts/flow-log-manager.js search "#component:Button"
   node scripts/flow-log-manager.js archive
+  node scripts/flow-log-manager.js rebuild-fts
 `);
 }
 
@@ -757,6 +759,42 @@ if (require.main === module) {
       break;
     }
 
+    case 'rebuild-fts': {
+      if (!memoryDb) {
+        error('Memory DB not available — FTS rebuild requires flow-memory-db');
+        process.exit(1);
+      }
+
+      printHeader('Rebuilding FTS Index');
+      const rebuildContent = fileExists(LOG_PATH) ? readFile(LOG_PATH, '') : '';
+      const allEntries = parseEntries(rebuildContent);
+      let indexed = 0;
+
+      (async () => {
+        for (const entry of allEntries) {
+          try {
+            await memoryDb.addRequestLogEntry({
+              id: entry.id,
+              type: entry.type || 'other',
+              tags: entry.tags ? entry.tags.split(/\s+/) : [],
+              request: entry.request || '',
+              result: entry.result || '',
+              files: entry.files ? entry.files.split(/,\s*/) : [],
+              taskId: null
+            });
+            indexed++;
+          } catch (_err) {
+            // Skip duplicates
+          }
+        }
+        success(`Indexed ${indexed}/${allEntries.length} entries into FTS`);
+      })().catch(err => {
+        error(`FTS rebuild failed: ${err.message}`);
+        process.exit(1);
+      });
+      break;
+    }
+
     case '--help':
     case '-h':
       printUsage();

package/scripts/flow-memory-db.js

@@ -137,6 +137,7 @@ function safeParseArray(json) {
 
 let SQL = null;
 let db = null;
+let ftsAvailable = false;
 let embedder = null;
 let initPromise = null;
 
@@ -294,6 +295,24 @@ async function initDatabase() {
       )
     `);
 
+    // FTS5 virtual table for full-text search over request log
+    // sql.js may not include FTS5 — silently skip if unavailable
+    try {
+      db.run(`
+        CREATE VIRTUAL TABLE IF NOT EXISTS request_log_fts USING fts5(
+          request, result, tags, files,
+          content='request_log',
+          content_rowid='rowid'
+        )
+      `);
+      ftsAvailable = true;
+    } catch (_err) {
+      // FTS5 not available in this sql.js build — fall back to LIKE queries
+      if (process.env.DEBUG) {
+        console.error('[memory-db] FTS5 not available — using LIKE fallback for search');
+      }
+    }
+
     // v10.0: Observations table for automatic tool use capture
     db.run(`
       CREATE TABLE IF NOT EXISTS observations (
@@ -1307,6 +1326,18 @@ async function addRequestLogEntry(entry) {
     entry.taskId || null
   ]);
 
+  // Populate FTS index (skip if FTS5 not available to avoid exception overhead)
+  if (ftsAvailable) {
+    try {
+      db.run(`
+        INSERT INTO request_log_fts (rowid, request, result, tags, files)
+        SELECT rowid, request, result, tags, files FROM request_log WHERE id = ?
+      `, [id]);
+    } catch (_err) {
+      // FTS insert failure is non-critical
+    }
+  }
+
   saveDatabase();
   return { id, stored: true };
 }
@@ -1345,8 +1376,28 @@ async function searchRequestLog(options = {}) {
   }
 
   if (query) {
-    sql += ' AND (request LIKE ? OR result LIKE ?)';
-    params.push(`%${query}%`, `%${query}%`);
+    // Try FTS5 first for better ranking, fall back to LIKE
+    try {
+      const ftsCheck = db.exec("SELECT name FROM sqlite_master WHERE type='table' AND name='request_log_fts'");
+      if (ftsCheck.length > 0 && ftsCheck[0].values.length > 0) {
+        // Escape FTS special characters for safety
+        const ftsQuery = query.replace(/['"]/g, '').replace(/[^\w\s#:-]/g, '').trim();
+        if (ftsQuery) {
+          sql += ' AND rowid IN (SELECT rowid FROM request_log_fts WHERE request_log_fts MATCH ?)';
+          params.push(ftsQuery);
+        } else {
+          // Sanitized query is empty — fall back to LIKE
+          sql += ' AND (request LIKE ? OR result LIKE ?)';
+          params.push(`%${query}%`, `%${query}%`);
+        }
+      } else {
+        sql += ' AND (request LIKE ? OR result LIKE ?)';
+        params.push(`%${query}%`, `%${query}%`);
+      }
+    } catch (_err) {
+      sql += ' AND (request LIKE ? OR result LIKE ?)';
+      params.push(`%${query}%`, `%${query}%`);
+    }
   }
 
   sql += ' ORDER BY timestamp DESC LIMIT ?';

package/scripts/flow-section-resolver.js

@@ -428,6 +428,51 @@ async function main() {
       console.log(JSON.stringify(stats, null, 2));
       break;
 
+    case 'browse': {
+      // Human-readable knowledge index — outputs a browsable catalog of all indexed sections
+      await ensureIndex();
+
+      const indexData = readIndex();
+      if (!indexData) {
+        console.log('No section index found. Run: node scripts/flow-section-index.js --force');
+        break;
+      }
+
+      // Index stores sections per source: { sources: { "file.md": { sections: [...] } } }
+      const bySource = {};
+      let totalSections = 0;
+      const sources = indexData.sources || {};
+      for (const [sourceName, sourceData] of Object.entries(sources)) {
+        const sects = sourceData.sections || [];
+        if (sects.length > 0) {
+          bySource[sourceName] = sects;
+          totalSections += sects.length;
+        }
+      }
+
+      console.log('╔══════════════════════════════════════════════════╗');
+      console.log('║         KNOWLEDGE INDEX (browsable)             ║');
+      console.log('╚══════════════════════════════════════════════════╝');
+      console.log(`  ${totalSections} sections indexed from ${Object.keys(bySource).length} sources\n`);
+
+      for (const [source, sects] of Object.entries(bySource)) {
+        const shortSource = source.replace(/.*\/state\//, '').replace(/.*\/specs\//, 'specs/');
+        console.log(`  ── ${shortSource} (${sects.length} sections) ──`);
+        for (const s of sects.slice(0, 20)) {
+          const pins = (s.pins || []).slice(0, 3).join(', ');
+          const title = s.title || s.id || '(untitled)';
+          console.log(`    • ${title}${pins ? ` [${pins}]` : ''}`);
+        }
+        if (sects.length > 20) {
+          console.log(`    ... and ${sects.length - 20} more`);
+        }
+        console.log('');
+      }
+
+      console.log(`Use 'find <pin>' to drill into a specific topic.`);
+      break;
+    }
+
     default:
       console.log(`
 Usage: node scripts/flow-section-resolver.js <command> [args]
@@ -437,12 +482,14 @@ Commands:
   get <section-id>     Get a section by ID
   find <pins...>       Find sections matching pins
   task "<description>" Find sections relevant to a task
+  browse               Human-readable knowledge index catalog
   stats                Show section statistics
 
 Examples:
   node scripts/flow-section-resolver.js get coding-standards:security-patterns-2026-01-11
   node scripts/flow-section-resolver.js find security error-handling
   node scripts/flow-section-resolver.js task "Add user authentication"
+  node scripts/flow-section-resolver.js browse
 `);
   }
 }

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

@@ -198,7 +198,17 @@ function handlePostCompact() {
     fs.writeFileSync(compactStatePath, JSON.stringify(tracker, null, 2));
 
     if (tracker.count >= 3) {
-      contextParts.push('**WARNING**: Multiple compactions detected in quick succession. Claude Code 2.1.76+ stops auto-compaction after 3 consecutive failures. If context keeps growing, consider starting a new session.');
+      contextParts.push('**WARNING**: Multiple compactions detected in quick succession. Claude Code 2.1.89+ stops auto-compaction after 3 consecutive thrash cycles. If context keeps growing, consider starting a new session.');
+    }
+
+    // CC 2.1.89 context-budget awareness: when 2+ compactions happened in quick succession,
+    // instruct Claude to load context incrementally to avoid the thrash loop.
+    if (tracker.count >= 2) {
+      contextParts.push('**Context budget: LOW** — 2+ compactions in quick succession. To avoid a thrash loop:\n' +
+        '- Load context ON DEMAND only (Read specific files when needed, not bulk)\n' +
+        '- Use the manifest in SessionStart context to know what exists\n' +
+        '- Prefer targeted `Read` of specific sections over loading entire registry files\n' +
+        '- Skip non-essential context (community knowledge, memory recall)');
     }
   } catch (err) {
     if (process.env.DEBUG) {

package/scripts/hooks/core/session-context.js

@@ -18,6 +18,7 @@ const setupCheck = require('./setup-check');
 const { findParallelizable, getParallelConfig } = require('../../flow-parallel');
 const { getBypassTracking } = require('../../flow-session-state');
 const { loadCheckpoint, clearCheckpoint } = require('../../flow-task-checkpoint');
+const { generateManifest, formatManifestForInjection, hasContent } = require('../../flow-context-manifest');
 
 // ============================================================
 // State Folder Hygiene — Whitelist + Age-Based Cleanup
@@ -119,6 +120,9 @@ const KNOWN_STATE_FILES = new Set([
   'pending-skill.json',
   'pending-setup.json',
 
+  // Context manifest (tiered context T2)
+  'session-manifest.md',
+
   // Archive
   'completed-archive.json',
 
@@ -132,6 +136,7 @@ const KNOWN_STATE_FILES = new Set([
   '.claude-md-regen-version',
   '.routing-pending',
   '.routing-cleared',
+  '.gates-passed.json',
 ]);
 
 /** Known directory names within state/ (not files) */
@@ -668,6 +673,7 @@ async function gatherSessionContext(options = {}) {
   }
 
   // Memory pipeline recall (surface relevant memories for current task)
+  // Capped at 2KB to prevent unbounded growth (CC 2.1.89 saves >50K hook output to disk)
   try {
     const currentTask = context.currentTask;
     if (currentTask) {
@@ -677,7 +683,10 @@ async function gatherSessionContext(options = {}) {
         currentTask.type || ''
       );
       if (memories) {
-        context.relevantMemories = memories;
+        const MAX_MEMORY_CHARS = 2048;
+        context.relevantMemories = typeof memories === 'string' && memories.length > MAX_MEMORY_CHARS
+          ? memories.substring(0, MAX_MEMORY_CHARS) + '\n... (truncated — load full via memory DB)'
+          : memories;
       }
     }
   } catch (err) {
@@ -732,11 +741,12 @@ async function gatherSessionContext(options = {}) {
   // v7.0: Real-time correction surfacing
   // When 2+ corrections of the same type are detected in the same session,
   // surface a hint telling Claude to consider recording the pattern.
+  // Capped at 5 types to prevent unbounded growth (CC 2.1.89 >50K disk save)
   try {
     const { getRepeatedCorrectionTypes } = require('../../flow-correction-detector');
     const repeatedTypes = getRepeatedCorrectionTypes();
     if (repeatedTypes.length > 0) {
-      context.correctionSurfacing = repeatedTypes;
+      context.correctionSurfacing = repeatedTypes.slice(0, 5);
     }
   } catch (_err) {
     // Non-critical
@@ -768,6 +778,20 @@ async function gatherSessionContext(options = {}) {
     // Non-critical — community sync module may not be available
   }
 
+  // T2: Context manifest — compact inventory of all registries
+  // Lets Claude know what coding rules, components, utilities, and APIs exist
+  // without injecting full content (loaded on-demand via Read)
+  try {
+    const manifest = generateManifest();
+    if (hasContent(manifest)) {
+      context.contextManifest = manifest;
+    }
+  } catch (err) {
+    if (process.env.DEBUG) {
+      console.error(`[session-context] Manifest generation failed: ${err.message}`);
+    }
+  }
+
   return {
     enabled: true,
     context
@@ -897,8 +921,16 @@ function formatContextForInjection(context) {
     output += `\nConsider running these tasks in parallel for faster completion.\n\n`;
   }
 
-  // Key decisions
-  if (ctx.keyDecisions && ctx.keyDecisions.length > 0) {
+  // T2: Context manifest — replaces key decisions with full registry inventory
+  // Provides one-line summaries so Claude knows WHAT EXISTS without full injection
+  if (ctx.contextManifest) {
+    const manifestText = formatManifestForInjection(ctx.contextManifest);
+    if (manifestText) {
+      output += `### Available Context (load on demand)\n`;
+      output += manifestText + '\n\n';
+    }
+  } else if (ctx.keyDecisions && ctx.keyDecisions.length > 0) {
+    // Fallback: legacy key decisions format (manifest generation failed or unavailable)
     output += `### Key Decisions\n`;
     for (const decision of ctx.keyDecisions) {
       output += `- **${decision.title}**: ${decision.summary}\n`;
@@ -984,13 +1016,14 @@ function formatContextForInjection(context) {
   }
 
   // Community knowledge (pulled from server)
+  // Capped: 3 model intelligence + 2 error strategies + 2 patterns (CC 2.1.89 >50K disk save)
   if (ctx.communityKnowledge && typeof ctx.communityKnowledge === 'object') {
     const ck = ctx.communityKnowledge;
     const items = [];
 
     // Model intelligence
     if (Array.isArray(ck.modelIntelligence)) {
-      for (const item of ck.modelIntelligence.slice(0, 5)) {
+      for (const item of ck.modelIntelligence.slice(0, 3)) {
         if (item.model && (item.strengths || item.adjustments)) {
           const detail = item.adjustments || item.strengths;
           items.push(`Community: ${item.model} — ${detail}`);
@@ -1000,7 +1033,7 @@ function formatContextForInjection(context) {
 
     // Error strategies
     if (Array.isArray(ck.errorStrategies)) {
-      for (const item of ck.errorStrategies.slice(0, 3)) {
+      for (const item of ck.errorStrategies.slice(0, 2)) {
         if (item.category && item.strategy) {
           items.push(`Community: ${item.category} — ${item.strategy}`);
         }
@@ -1009,7 +1042,7 @@ function formatContextForInjection(context) {
 
     // Patterns
     if (Array.isArray(ck.patterns)) {
-      for (const item of ck.patterns.slice(0, 3)) {
+      for (const item of ck.patterns.slice(0, 2)) {
         if (item.description) {
           items.push(`Community: ${item.description}`);
         }
@@ -1025,6 +1058,17 @@ function formatContextForInjection(context) {
     }
   }
 
+  // CC 2.1.89: Hook output >50K chars gets saved to disk with file path + preview.
+  // Cap total output to stay under threshold and keep full context in-session.
+  // If we exceed this, the most important context (T1: task state, routing) is at
+  // the top and will appear in the preview. T2 (manifest) and lower-priority sections
+  // are trimmed first.
+  const MAX_OUTPUT_CHARS = 45000; // Stay safely under 50K
+  if (output.length > MAX_OUTPUT_CHARS) {
+    output = output.substring(0, MAX_OUTPUT_CHARS) +
+      '\n\n*[Context truncated to stay within injection limit. Load full context via `/wogi-context` or Read registry files directly.]*\n';
+  }
+
   return output;
 }