wogiflow 2.7.1 → 2.9.0

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;
 }
 

package/scripts/hooks/core/task-completed.js

@@ -21,6 +21,7 @@ const fs = require('node:fs');
 const { getConfig, PATHS, safeJsonParse, writeJson, withLock, validateTaskId, archiveCompletedTasksToLog } = require('../../flow-utils');
 const { resetPhase, isPhaseGateEnabled } = require('./phase-gate');
 const { clearOnTaskComplete } = require('../../flow-hook-status');
+const { checkGateLatch, clearGateLatch } = require('../../flow-gate-latch');
 
 /**
  * Check if task completed handling is enabled
@@ -90,6 +91,22 @@ async function handleTaskCompleted(input) {
       }
       result.taskId = completedTask.id;
 
+      // Gate latch check — verify quality gates have passed before allowing completion.
+      // Without this, agents can call TaskUpdate and bypass all quality gates.
+      // The latch is written by flow-done.js after gates pass.
+      const config = getConfig();
+      const requireGateLatch = config.enforcement?.requireGateLatch !== false;
+      if (requireGateLatch) {
+        const latchResult = checkGateLatch(completedTask.id);
+        if (!latchResult.valid) {
+          result.message = `BLOCKED: ${latchResult.reason} ` +
+            'Quality gates must pass before a task can be completed. ' +
+            'Run the full /wogi-start pipeline (Step 4: Quality Gates) or `flow done` first.';
+          result.gateBlocked = true;
+          return;
+        }
+      }
+
       // Move task to recentlyCompleted
       completedTask.status = 'completed';
       completedTask.completedAt = new Date().toISOString();
@@ -158,6 +175,15 @@ async function handleTaskCompleted(input) {
       }
     }
 
+    // Clear gate latch after successful completion
+    if (result.completed) {
+      try {
+        clearGateLatch();
+      } catch (_err) {
+        // Non-critical
+      }
+    }
+
     // Clear progress tracker state on task completion
     if (result.completed) {
       try {

package/scripts/postinstall.js

@@ -928,6 +928,26 @@ function main() {
   // so the correct hooks are already in place when stale ones are removed.
   migrateStaleLocalHooks();
 
+  // Migrate config.json defaults when they change between versions.
+  // Without this, existing users keep stale defaults forever because
+  // deepMerge(defaults, userConfig) lets user values win.
+  // Only upgrades keys that still match the OLD default — user-customized values are preserved.
+  try {
+    const configPath = path.join(WORKFLOW_DIR, 'config.json');
+    if (fs.existsSync(configPath)) {
+      const { migrateConfigFile } = require('./flow-config-migrate');
+      const migrationResult = migrateConfigFile(configPath);
+      if (migrationResult.migrated && !shouldBeSilent()) {
+        process.stderr.write(`\x1b[36mWogiFlow:\x1b[0m Migrated config (v${migrationResult.fromVersion} → v${migrationResult.toVersion}): ${migrationResult.applied.length} change(s).\n`);
+      }
+    }
+  } catch (err) {
+    // Non-fatal — config migration should never fail installation
+    if (process.env.DEBUG) {
+      console.error(`[postinstall] Config migration failed: ${err.message}`);
+    }
+  }
+
   // NOTE: Scripts and .workflow/ managed dirs (bridges, templates, agents, lib) are
   // NO LONGER copied to the project. They live exclusively in the wogiflow package
   // under node_modules/wogiflow/. This keeps user projects clean.