@sienklogic/plan-build-run 2.1.0 → 2.1.1

package/plugins/pbr/scripts/session-cleanup.js

@@ -4,7 +4,6 @@
  * SessionEnd cleanup hook.
  *
  * Removes stale planning artifacts that shouldn't persist across sessions:
- *   - .planning/.auto-next (prevents confusion on next session start)
  *   - .planning/.active-operation (stale operation lock)
  *   - .planning/.active-skill (stale skill tracking)
  *
@@ -21,7 +20,9 @@
 const fs = require('fs');
 const path = require('path');
 const { logHook } = require('./hook-logger');
-const { tailLines } = require('./pbr-tools');
+const { tailLines, configLoad } = require('./pbr-tools');
+const { removeSessionDir, releaseSessionClaims } = require('./lib/core');
+const { readSessionMetrics, summarizeMetrics, formatSessionSummary } = require('./local-llm/metrics');
 
 function readStdin() {
   try {
@@ -211,11 +212,35 @@ function main() {
     process.exit(0);
   }
 
+  const sessionId = data.session_id || null;
   const cleaned = [];
 
-  if (tryRemove(path.join(planningDir, '.auto-next'))) {
-    cleaned.push('.auto-next');
+  // NOTE: .auto-next is intentionally NOT cleaned here — it is a one-shot
+  // signal consumed by auto-continue.js (Stop hook). SessionEnd cleanup
+  // races with the Stop hook and would delete the signal before it is read.
+
+  // Session-scoped cleanup: remove the entire session directory if session_id is available
+  if (sessionId) {
+    try {
+      removeSessionDir(planningDir, sessionId);
+      cleaned.push(`.sessions/${sessionId}`);
+    } catch (_e) { /* best-effort */ }
+
+    // Release any phase claims held by this session
+    try {
+      const releasedClaims = releaseSessionClaims(planningDir, sessionId);
+      if (releasedClaims.released.length > 0) {
+        logHook('session-cleanup', `Released ${releasedClaims.released.length} phase claim(s): ${releasedClaims.released.join(', ')}`);
+        cleaned.push(...releasedClaims.released.map(p => `phases/${p}/.claim`));
+      }
+    } catch (_e) { /* best-effort */ }
+  }
+
+  // Primary: remove .session.json (consolidated session state)
+  if (tryRemove(path.join(planningDir, '.session.json'))) {
+    cleaned.push('.session.json');
   }
+  // Legacy fallback: also clean individual signal files during transition period
   if (tryRemove(path.join(planningDir, '.active-operation'))) {
     cleaned.push('.active-operation');
   }
@@ -239,6 +264,36 @@ function main() {
   // Write session history log
   writeSessionHistory(planningDir, data);
 
+  // Local LLM metrics summary (SessionEnd — sync reads only, never throws)
+  let llmAdditionalContext = null;
+  try {
+    const sessionStartFile = path.join(planningDir, '.session-start');
+    if (fs.existsSync(sessionStartFile)) {
+      const sessionStartTime = fs.readFileSync(sessionStartFile, 'utf8').trim();
+      const entries = readSessionMetrics(planningDir, sessionStartTime);
+      if (entries.length > 0) {
+        const summary = summarizeMetrics(entries);
+        logHook('session-cleanup', 'SessionEnd', 'llm-metrics', {
+          total_calls: summary.total_calls,
+          fallback_count: summary.fallback_count,
+          avg_latency_ms: summary.avg_latency_ms,
+          tokens_saved: summary.tokens_saved,
+          cost_saved_usd: summary.cost_saved_usd
+        });
+        if (summary.total_calls > 0) {
+          let modelName = null;
+          try {
+            const rawConfig = configLoad(planningDir) || {};
+            modelName = (rawConfig.local_llm && rawConfig.local_llm.model) || null;
+          } catch (_e) { /* config read failure is non-fatal */ }
+          llmAdditionalContext = formatSessionSummary(summary, modelName);
+        }
+      }
+      // Clean up session-start file
+      try { fs.unlinkSync(sessionStartFile); } catch (_e) { /* non-fatal */ }
+    }
+  } catch (_e) { /* metrics never crash the hook */ }
+
   const decision = cleaned.length > 0 ? 'cleaned' : 'nothing';
   logHook('session-cleanup', 'SessionEnd', decision, {
     reason: data.reason || null,
@@ -247,8 +302,47 @@ function main() {
     orphaned_progress_files: orphans.length > 0 ? orphans : undefined
   });
 
+  if (llmAdditionalContext) {
+    process.stdout.write(JSON.stringify({ additionalContext: llmAdditionalContext }) + '\n');
+  }
+
   process.exit(0);
 }
 
-module.exports = { writeSessionHistory, tryRemove, cleanStaleCheckpoints, rotateHooksLog, findOrphanedProgressFiles };
+/**
+ * handleHttp — hook-server.js interface.
+ * reqBody = { event, tool, data, planningDir, cache }
+ * Returns null. Never calls process.exit().
+ */
+function handleHttp(reqBody) {
+  const data = (reqBody && reqBody.data) || {};
+  const planningDir = reqBody && reqBody.planningDir;
+  if (!planningDir || !fs.existsSync(planningDir)) return null;
+
+  const cleaned = [];
+  if (tryRemove(path.join(planningDir, '.session.json'))) cleaned.push('.session.json');
+  if (tryRemove(path.join(planningDir, '.active-operation'))) cleaned.push('.active-operation');
+  if (tryRemove(path.join(planningDir, '.active-skill'))) cleaned.push('.active-skill');
+  if (tryRemove(path.join(planningDir, '.active-plan'))) cleaned.push('.active-plan');
+
+  const staleCheckpoints = cleanStaleCheckpoints(planningDir);
+  cleaned.push(...staleCheckpoints);
+
+  const rotated = rotateHooksLog(planningDir);
+  const orphans = findOrphanedProgressFiles(planningDir);
+
+  writeSessionHistory(planningDir, data);
+
+  const decision = cleaned.length > 0 ? 'cleaned' : 'nothing';
+  logHook('session-cleanup', 'SessionEnd', decision, {
+    reason: data.reason || null,
+    removed: cleaned,
+    log_rotated: rotated,
+    orphaned_progress_files: orphans.length > 0 ? orphans : undefined
+  });
+
+  return null;
+}
+
+module.exports = { writeSessionHistory, tryRemove, cleanStaleCheckpoints, rotateHooksLog, findOrphanedProgressFiles, handleHttp };
 if (require.main === module || process.argv[1] === __filename) { main(); }

package/plugins/pbr/scripts/session-tracker.js

@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { resolveSessionPath } = require('./lib/core');
+
+const TRACKER_FILE = '.session-tracker';
+
+/**
+ * Resolve the tracker file path, using session-scoped path when sessionId is provided.
+ * @param {string} planningDir - Path to the .planning directory
+ * @param {string} [sessionId] - Session identifier for session-scoped path
+ * @returns {string} Resolved tracker file path
+ */
+function getTrackerPath(planningDir, sessionId) {
+  return sessionId
+    ? resolveSessionPath(planningDir, TRACKER_FILE, sessionId)
+    : path.join(planningDir, TRACKER_FILE);
+}
+
+/**
+ * Reset the session tracker to zero phases completed.
+ * Creates or overwrites the tracker file.
+ * @param {string} planningDir - Path to the .planning directory
+ * @param {string} [sessionId] - Session identifier for session-scoped path
+ */
+function resetTracker(planningDir, sessionId) {
+  const trackerPath = getTrackerPath(planningDir, sessionId);
+  const data = {
+    phases_completed: 0,
+    session_start: new Date().toISOString(),
+    last_phase_completed: null
+  };
+  fs.writeFileSync(trackerPath, JSON.stringify(data, null, 2), 'utf8');
+}
+
+/**
+ * Increment the session phase counter by 1.
+ * Auto-creates the tracker if missing.
+ * @param {string} planningDir - Path to the .planning directory
+ * @param {string} [sessionId] - Session identifier for session-scoped path
+ * @returns {number} The new phases_completed count
+ */
+function incrementTracker(planningDir, sessionId) {
+  const trackerPath = getTrackerPath(planningDir, sessionId);
+  let raw;
+  try {
+    raw = fs.readFileSync(trackerPath, 'utf8');
+  } catch (_e) {
+    // File missing — create it first
+    resetTracker(planningDir, sessionId);
+    raw = fs.readFileSync(trackerPath, 'utf8');
+  }
+  const data = JSON.parse(raw);
+  data.phases_completed += 1;
+  data.last_phase_completed = new Date().toISOString();
+  fs.writeFileSync(trackerPath, JSON.stringify(data, null, 2), 'utf8');
+  return data.phases_completed;
+}
+
+/**
+ * Load the current session tracker data.
+ * @param {string} planningDir - Path to the .planning directory
+ * @param {string} [sessionId] - Session identifier for session-scoped path
+ * @returns {object|null} Parsed tracker data, or null if missing/corrupted
+ */
+function loadTracker(planningDir, sessionId) {
+  const trackerPath = getTrackerPath(planningDir, sessionId);
+  try {
+    const raw = fs.readFileSync(trackerPath, 'utf8');
+    return JSON.parse(raw);
+  } catch (_e) {
+    return null;
+  }
+}
+
+module.exports = { resetTracker, incrementTracker, loadTracker, TRACKER_FILE };

package/plugins/pbr/scripts/status-line.js

@@ -15,6 +15,7 @@ const path = require('path');
 const cp = require('child_process');
 const { logHook } = require('./hook-logger');
 const { configLoad } = require('./pbr-tools');
+const llmMetricsModule = require('./local-llm/metrics');
 
 // ANSI color codes
 const c = {
@@ -36,8 +37,8 @@ const c = {
 
 // Default status_line config — works out of the box with zero config
 const DEFAULTS = {
-  sections: ['phase', 'plan', 'status', 'git', 'context'],
-  brand_text: '\u25C6 Plan-Build-Run',
+  sections: ['phase', 'plan', 'status', 'git', 'context', 'llm'],
+  brand_text: '\u25C6 PBR',
   max_status_length: 50,
   context_bar: {
     width: 10,
@@ -170,6 +171,61 @@ function formatDuration(ms) {
   return `${minutes}m`;
 }
 
+/**
+ * Format a token count with K/M suffixes for compact display.
+ * @param {number} tokens
+ * @returns {string}
+ */
+function formatTokens(tokens) {
+  if (tokens >= 1_000_000) return (tokens / 1_000_000).toFixed(1) + 'M';
+  if (tokens >= 1_000) return (tokens / 1_000).toFixed(1) + 'K';
+  return String(tokens);
+}
+
+/**
+ * Read the current milestone name from ROADMAP.md.
+ * Looks for `## Milestone: {name}` headers, returns the first non-completed one.
+ * Returns null if no ROADMAP.md or no milestone header found.
+ */
+function getMilestone(planningDir) {
+  try {
+    const roadmapPath = path.join(planningDir, 'ROADMAP.md');
+    if (!fs.existsSync(roadmapPath)) return null;
+    const content = fs.readFileSync(roadmapPath, 'utf8');
+    // Match "## Milestone: Name (version)" or "## Milestone: Name"
+    // Skip completed milestones (ending with "-- COMPLETED")
+    const matches = content.matchAll(/^##\s*Milestone:\s*(.+?)(?:\s*--\s*COMPLETED)?$/gm);
+    let lastActive = null;
+    for (const m of matches) {
+      const line = m[0];
+      if (!line.includes('COMPLETED')) {
+        lastActive = m[1].trim();
+        break;
+      }
+    }
+    return lastActive;
+  } catch (_e) {
+    return null;
+  }
+}
+
+/**
+ * Synchronous TCP probe — checks if hook server port is open.
+ * Uses cp.execSync with a tiny node script to avoid async in status line.
+ * Returns true if port is accepting connections, false otherwise.
+ */
+function isHookServerRunning(port) {
+  try {
+    const result = cp.execSync(
+      `node -e "var s=require('net').createConnection(${port || 19836},'127.0.0.1');s.setTimeout(100);s.on('connect',()=>{process.stdout.write('1');s.destroy()});s.on('error',()=>process.stdout.write('0'));s.on('timeout',()=>{process.stdout.write('0');s.destroy()})"`,
+      { timeout: 300, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }
+    ).trim();
+    return result === '1';
+  } catch (_e) {
+    return false;
+  }
+}
+
 function main() {
   const stdinData = readStdin();
   const cwd = process.cwd();
@@ -184,7 +240,7 @@ function main() {
     const slConfig = loadStatusLineConfig(planningDir);
     const content = fs.readFileSync(stateFile, 'utf8');
     const ctxPercent = getContextPercent(stdinData);
-    const status = buildStatusLine(content, ctxPercent, slConfig, stdinData);
+    const status = buildStatusLine(content, ctxPercent, slConfig, stdinData, planningDir);
 
     if (status) {
       process.stdout.write(status);
@@ -197,7 +253,24 @@ function main() {
   process.exit(0);
 }
 
-function buildStatusLine(content, ctxPercent, cfg, stdinData) {
+/**
+ * Parse YAML frontmatter from STATE.md content.
+ * Returns an object with frontmatter fields, or null if no frontmatter.
+ */
+function parseFrontmatter(content) {
+  if (!content.startsWith('---')) return null;
+  const endIdx = content.indexOf('---', 3);
+  if (endIdx === -1) return null;
+  const fm = content.substring(3, endIdx);
+  const result = {};
+  for (const line of fm.split(/\r?\n/)) {
+    const m = line.match(/^(\w[\w_]*):\s*"?([^"]*)"?\s*$/);
+    if (m) result[m[1]] = m[2];
+  }
+  return result;
+}
+
+function buildStatusLine(content, ctxPercent, cfg, stdinData, planningDir) {
   const config = cfg || DEFAULTS;
   const sections = config.sections || DEFAULTS.sections;
   const brandText = config.brand_text || DEFAULTS.brand_text;
@@ -205,39 +278,71 @@ function buildStatusLine(content, ctxPercent, cfg, stdinData) {
   const barCfg = config.context_bar || DEFAULTS.context_bar;
   const sd = stdinData || {};
 
-  const parts = [];
+  // Prefer frontmatter (always up-to-date) over body text (may be stale)
+  const fm = parseFrontmatter(content);
+
+  // Line 1: project state (milestone, phase, plan, status)
+  // Line 2: environment info (git, hooks, model, cost, duration, context)
+  const line1 = [];
+  const line2 = [];
+
+  // Milestone section — show active milestone from ROADMAP.md
+  if (sections.includes('milestone') && planningDir) {
+    const milestone = getMilestone(planningDir);
+    if (milestone) {
+      line1.push(`${c.boldCyan}${brandText}${c.reset} ${c.magenta}${milestone}${c.reset}`);
+    } else {
+      line1.push(`${c.boldCyan}${brandText}${c.reset}`);
+    }
+  }
 
   // Phase section (always includes brand text)
   if (sections.includes('phase')) {
+    const fmPhase = fm && fm.current_phase;
+    // phase_slug is the canonical field; phase_name is a legacy alias
+    const fmSlug = fm && fm.phase_slug;
+    const fmName = fm && fm.phase_name;
     const phaseMatch = content.match(/Phase:\s*(\d+)\s*of\s*(\d+)\s*(?:\(([^)]+)\))?/);
-    if (phaseMatch) {
-      parts.push(`${c.boldCyan}${brandText}${c.reset} ${c.bold}Phase ${phaseMatch[1]}/${phaseMatch[2]}${c.reset}`);
-      if (phaseMatch[3]) {
-        parts.push(`${c.magenta}${phaseMatch[3]}${c.reset}`);
+
+    const phaseNum = fmPhase || (phaseMatch && phaseMatch[1]);
+    const phaseTotal = phaseMatch && phaseMatch[2];
+    // Format phase_slug from "foo-bar" to "Foo Bar" for display
+    const formattedSlug = fmSlug ? String(fmSlug).replace(/-/g, ' ').replace(/\b\w/g, ch => ch.toUpperCase()) : null;
+    const phaseName = fmName || formattedSlug || (phaseMatch && phaseMatch[3]);
+
+    if (phaseNum && phaseTotal) {
+      line1.push(`${c.boldCyan}${brandText}${c.reset} ${c.bold}Phase ${phaseNum}/${phaseTotal}${c.reset}`);
+      if (phaseName) {
+        line1.push(`${c.magenta}${phaseName}${c.reset}`);
       }
     } else {
-      parts.push(`${c.boldCyan}${brandText}${c.reset}`);
+      line1.push(`${c.boldCyan}${brandText}${c.reset}`);
     }
   }
 
-  // Plan section
+  // Plan section — shows current plan progress within the phase
   if (sections.includes('plan')) {
+    const fmComplete = fm && fm.plans_complete;
+    const fmPlansTotal = fm && fm.plans_total;
     const planMatch = content.match(/Plan:\s*(\d+)\s*of\s*(\d+)/);
-    if (planMatch) {
-      const done = parseInt(planMatch[1], 10);
-      const total = parseInt(planMatch[2], 10);
+
+    const done = fmComplete != null ? parseInt(fmComplete, 10) : (planMatch ? parseInt(planMatch[1], 10) : null);
+    const total = fmPlansTotal != null ? parseInt(fmPlansTotal, 10) : (planMatch ? parseInt(planMatch[2], 10) : null);
+
+    if (done != null && total != null && total > 0) {
       const planColor = done === total ? c.green : c.white;
-      parts.push(`${planColor}Plan ${done}/${total}${c.reset}`);
+      line1.push(`${planColor}Plan ${done}/${total}${c.reset}`);
     }
   }
 
   // Status section
   if (sections.includes('status')) {
-    const statusMatch = content.match(/Status:\s*(.+)/);
-    if (statusMatch) {
-      const text = statusMatch[1].trim();
+    const fmStatus = fm && fm.status;
+    const statusMatch = content.match(/^Status:\s*(.+)/m);
+    const text = fmStatus || (statusMatch && statusMatch[1].trim());
+    if (text) {
       const short = text.length > maxLen ? text.slice(0, maxLen - 3) + '...' : text;
-      parts.push(`${statusColor(text)}${short}${c.reset}`);
+      line1.push(`${statusColor(text)}${short}${c.reset}`);
     }
   }
 
@@ -246,13 +351,23 @@ function buildStatusLine(content, ctxPercent, cfg, stdinData) {
     const gitInfo = getGitInfo();
     if (gitInfo) {
       const dirtyMark = gitInfo.dirty ? `${c.yellow}*${c.reset}` : '';
-      parts.push(`${c.cyan}${gitInfo.branch}${c.reset}${dirtyMark}`);
+      line2.push(`${c.cyan}${gitInfo.branch}${c.reset}${dirtyMark}`);
+    }
+  }
+
+  // Hooks section — hook server status indicator
+  if (sections.includes('hooks')) {
+    const running = isHookServerRunning(19836);
+    if (running) {
+      line2.push(`${c.green}\u25CF${c.reset}`);
+    } else {
+      line2.push(`${c.red}\u25CB${c.reset}`);
     }
   }
 
   // Model section — current model display name from stdin
   if (sections.includes('model') && sd.model && sd.model.display_name) {
-    parts.push(`${c.dim}${sd.model.display_name}${c.reset}`);
+    line2.push(`${c.dim}${sd.model.display_name}${c.reset}`);
   }
 
   // Cost section — session cost from stdin
@@ -262,12 +377,12 @@ function buildStatusLine(content, ctxPercent, cfg, stdinData) {
     let costColor = c.dim;
     if (cost > 5) costColor = c.red;
     else if (cost > 1) costColor = c.yellow;
-    parts.push(`${costColor}${costStr}${c.reset}`);
+    line2.push(`${costColor}${costStr}${c.reset}`);
   }
 
   // Duration section — session wall-clock time from stdin
   if (sections.includes('duration') && sd.cost && sd.cost.total_duration_ms != null) {
-    parts.push(`${c.dim}${formatDuration(sd.cost.total_duration_ms)}${c.reset}`);
+    line2.push(`${c.dim}${formatDuration(sd.cost.total_duration_ms)}${c.reset}`);
   }
 
   // Context bar section
@@ -276,13 +391,50 @@ function buildStatusLine(content, ctxPercent, cfg, stdinData) {
       thresholds: barCfg.thresholds || DEFAULTS.context_bar.thresholds,
       chars: barCfg.chars || DEFAULTS.context_bar.chars
     });
-    parts.push(`${bar} ${c.dim}${ctxPercent}%${c.reset}`);
+    line2.push(`${bar} ${c.dim}${ctxPercent}%${c.reset}`);
   }
 
-  if (parts.length === 0) return null;
+  if (line1.length === 0 && line2.length === 0) return null;
+
+  const sep = ` ${c.dim}\u2502${c.reset} `;
+  let output = line1.join(sep);
+  if (line2.length > 0) {
+    output += '\n' + line2.join(sep);
+  }
+
+  // LLM offload section — renders on a second line below the main status
+  // Shows session stats + lifetime total when both are available
+  if (sections.includes('llm') && planningDir) {
+    try {
+      const lifetime = llmMetricsModule.computeLifetimeMetrics(planningDir);
+      if (lifetime && lifetime.total_calls > 0) {
+        // Try to get session-scoped metrics using duration from stdin
+        let sessionPart = '';
+        const durationMs = sd.cost && sd.cost.total_duration_ms;
+        if (durationMs != null && durationMs > 0) {
+          const sessionStart = new Date(Date.now() - durationMs);
+          const sessionEntries = llmMetricsModule.readSessionMetrics(planningDir, sessionStart);
+          const session = llmMetricsModule.summarizeMetrics(sessionEntries);
+          if (session.total_calls > 0) {
+            sessionPart = `${c.dim}${session.total_calls} calls${c.reset} ${c.dim}\u00B7${c.reset} ${c.green}${formatTokens(session.tokens_saved)} saved${c.reset}`;
+          }
+        }
+
+        const lifetimePart = `${c.dim}${formatTokens(lifetime.tokens_saved)} lifetime${c.reset}`;
+
+        if (sessionPart) {
+          output += `\n${c.green}Local LLM${c.reset} ${sessionPart} ${c.dim}\u2502${c.reset} ${lifetimePart}`;
+        } else {
+          output += `\n${c.green}Local LLM${c.reset} ${c.dim}${lifetime.total_calls} calls${c.reset} ${c.dim}\u00B7${c.reset} ${c.green}${formatTokens(lifetime.tokens_saved)} saved${c.reset}`;
+        }
+      }
+    } catch (_e) {
+      // No metrics available — skip silently
+    }
+  }
 
-  return parts.join(` ${c.dim}\u2502${c.reset} `);
+  return output;
 }
 
 if (require.main === module || process.argv[1] === __filename) { main(); }
-module.exports = { buildStatusLine, buildContextBar, getContextPercent, getGitInfo, formatDuration, loadStatusLineConfig, DEFAULTS };
+module.exports = { buildStatusLine, buildContextBar, getContextPercent, getGitInfo, getMilestone, isHookServerRunning, formatDuration, formatTokens, loadStatusLineConfig, parseFrontmatter, DEFAULTS };

package/plugins/pbr/scripts/suggest-compact.js

@@ -4,9 +4,13 @@
  * PostToolUse hook on Write|Edit: Tracks tool call count per session
  * and suggests /compact when approaching context limits.
  *
+ * Primary path: reads .planning/.context-budget.json (written by context-bridge.js)
+ * and emits tier-labeled warnings (DEGRADING/POOR/CRITICAL) when bridge data is
+ * fresh (<60s old). CRITICAL tier always emits; others use REMINDER_INTERVAL debounce.
+ *
+ * Fallback: when bridge is absent or stale, uses call-count threshold.
  * Counter stored in .planning/.compact-counter (JSON).
  * Threshold configurable via config.json hooks.compactThreshold (default: 50).
- * After first suggestion, re-suggests every 25 calls.
  * Counter resets on SessionStart (via progress-tracker.js).
  *
  * Exit codes:
@@ -16,17 +20,40 @@
 const fs = require('fs');
 const path = require('path');
 const { logHook } = require('./hook-logger');
-const { configLoad } = require('./pbr-tools');
+const { loadBridge, TIER_MESSAGES } = require('./context-bridge');
+
 
 const DEFAULT_THRESHOLD = 50;
 const REMINDER_INTERVAL = 25;
 
+const BASE_THRESHOLD = DEFAULT_THRESHOLD; // 50 at 200k tokens
+const BASE_TOKENS = 200000;
+
+/**
+ * Get the compact threshold scaled to context_window_tokens from config.
+ * Base threshold at 200k tokens: 50. At 1M tokens: 250.
+ *
+ * @param {string} planningDir - Path to .planning/
+ * @returns {number} Scaled threshold
+ */
+function getScaledThreshold(planningDir) {
+  try {
+    const { configLoad } = require('./pbr-tools');
+    const config = configLoad(planningDir);
+    const tokens = (config && config.context_window_tokens) || BASE_TOKENS;
+    const scale = tokens / BASE_TOKENS;
+    return Math.round(BASE_THRESHOLD * scale);
+  } catch (_e) {
+    return BASE_THRESHOLD;
+  }
+}
+
 function main() {
   process.stdin.setEncoding('utf8');
   process.stdin.resume();
   process.stdin.on('end', () => {
     try {
-      const cwd = process.cwd();
+      const cwd = process.env.PBR_PROJECT_ROOT || process.cwd();
       const planningDir = path.join(cwd, '.planning');
       if (!fs.existsSync(planningDir)) {
         process.exit(0);
@@ -43,8 +70,41 @@ function main() {
   });
 }
 
+/**
+ * Check the context bridge for the current tier.
+ * Returns { tier, message } for actionable tiers (DEGRADING/POOR/CRITICAL),
+ * or null if bridge is absent, stale (>60s), or tier is PEAK/GOOD (<50%).
+ * @param {string} planningDir - Path to .planning/ directory
+ * @returns {{ tier: string, message: string }|null}
+ */
+function checkBridgeTier(planningDir) {
+  const bridgePath = path.join(planningDir, '.context-budget.json');
+  const bridge = loadBridge(bridgePath);
+  if (!bridge) return null;
+
+  // Check staleness: if timestamp is older than 60 seconds, treat as stale
+  if (bridge.timestamp) {
+    const ageMs = Date.now() - new Date(bridge.timestamp).getTime();
+    if (ageMs > 60000) return null;
+  }
+
+  const percent = bridge.estimated_percent || 0;
+
+  if (percent >= 85) {
+    return { tier: 'CRITICAL', message: TIER_MESSAGES.CRITICAL };
+  } else if (percent >= 70) {
+    return { tier: 'POOR', message: TIER_MESSAGES.POOR };
+  } else if (percent >= 50) {
+    return { tier: 'DEGRADING', message: TIER_MESSAGES.DEGRADING };
+  }
+
+  // PEAK tier (<50%) — no tier message needed
+  return null;
+}
+
 /**
  * Increment tool call counter and return a suggestion if threshold is reached.
+ * Checks bridge tier first; falls back to call-count when bridge is absent or stale.
  * @param {string} planningDir - Path to .planning/ directory
  * @param {string} cwd - Current working directory (for config loading)
  * @returns {Object|null} Hook output with additionalContext, or null
@@ -57,6 +117,28 @@ function checkCompaction(planningDir, cwd) {
   counter.count += 1;
   saveCounter(counterPath, counter);
 
+  // Check bridge tier first
+  const bridgeTier = checkBridgeTier(planningDir);
+  if (bridgeTier !== null) {
+    const { tier, message } = bridgeTier;
+    const isFirstSuggestion = !counter.lastSuggested;
+    const callsSinceSuggestion = counter.count - (counter.lastSuggested || 0);
+    const shouldEmit = tier === 'CRITICAL' || isFirstSuggestion || callsSinceSuggestion >= REMINDER_INTERVAL;
+
+    if (shouldEmit) {
+      counter.lastSuggested = counter.count;
+      saveCounter(counterPath, counter);
+
+      logHook('suggest-compact', 'PostToolUse', 'tier-suggest', { tier, count: counter.count });
+
+      return {
+        additionalContext: `[Context Budget - ${tier}] ${message}`
+      };
+    }
+    return null;
+  }
+
+  // Fall back to counter-based suggestion when bridge is absent or stale
   if (counter.count < threshold) return null;
 
   const isFirstSuggestion = !counter.lastSuggested;
@@ -95,16 +177,35 @@ function saveCounter(counterPath, counter) {
   } catch (_e) {
     // Best-effort
   }
+  // Mirror to .session.json for consolidated session state tracking
+  // Derive planningDir from counterPath (counterPath is planningDir/.compact-counter)
+  try {
+    const planningDir = path.dirname(counterPath);
+    const { sessionSave } = require('./pbr-tools');
+    // Note: saveCounter doesn't have sessionId context — mirror to legacy path
+    sessionSave(planningDir, { compactCounter: counter });
+  } catch (_e) { /* non-fatal mirror */ }
 }
 
 function getThreshold(cwd) {
   const planningDir = path.join(cwd, '.planning');
+  const { configLoad } = require('./pbr-tools');
   const config = configLoad(planningDir);
-  if (!config) return DEFAULT_THRESHOLD;
-  return config.hooks?.compactThreshold || DEFAULT_THRESHOLD;
+  // Honor explicit hooks.compactThreshold override first
+  if (config && config.hooks && config.hooks.compactThreshold != null) {
+    return config.hooks.compactThreshold;
+  }
+  return getScaledThreshold(planningDir);
 }
 
-function resetCounter(planningDir) {
+function resetCounter(planningDir, sessionId) {
+  // Primary: reset compactCounter in .session.json to 0
+  try {
+    const { sessionSave } = require('./pbr-tools');
+    sessionSave(planningDir, { compactCounter: { count: 0, lastSuggested: 0 } }, sessionId);
+  } catch (_e) { /* best-effort */ }
+
+  // Legacy: also delete .compact-counter file if present
   const counterPath = path.join(planningDir, '.compact-counter');
   try {
     if (fs.existsSync(counterPath)) {
@@ -115,5 +216,5 @@ function resetCounter(planningDir) {
   }
 }
 
-module.exports = { checkCompaction, loadCounter, saveCounter, getThreshold, resetCounter, DEFAULT_THRESHOLD, REMINDER_INTERVAL };
+module.exports = { checkCompaction, checkBridgeTier, loadCounter, saveCounter, getThreshold, getScaledThreshold, resetCounter, DEFAULT_THRESHOLD, REMINDER_INTERVAL };
 if (require.main === module || process.argv[1] === __filename) { main(); }