@colin4k1024/tsp 2.5.1 → 2.5.3

package/scripts/hooks/suggest-compact.js

@@ -16,12 +16,13 @@ const crypto = require('crypto');
 const AUTO_COMPACT_BUFFER_PCT = 16.5;
 const DEFAULT_CONTEXT_LIMIT = 200000;
 const DEFAULT_DEBOUNCE_CALLS = 8;
-const STALE_BRIDGE_SECONDS = 60;
+const STALE_BRIDGE_SECONDS = 120;
 
 const URGENCY = [
   [95, 'critical'],
   [85, 'high'],
   [70, 'medium'],
+  [65, 'advisory'],
   [0, 'low'],
 ];
 
@@ -64,8 +65,11 @@ function sessionKey(data) {
     return raw.replace(/[^a-zA-Z0-9_-]/g, '').slice(-64) || 'default';
   }
 
+  // Use PID + cwd hash to differentiate sessions in the same directory
+  const pidKey = `pid-${process.pid}`;
   const cwd = data.cwd || process.cwd();
-  return crypto.createHash('sha256').update(String(cwd)).digest('hex').slice(0, 16);
+  const cwdHash = crypto.createHash('sha256').update(String(cwd)).digest('hex').slice(0, 16);
+  return `${pidKey}-${cwdHash}`;
 }
 
 function readBridgeMetrics(sessionId) {
@@ -95,7 +99,30 @@ function readBridgeMetrics(sessionId) {
 
 function resolveContextMetrics(data) {
   const contextLimit = toNumber(process.env.CLAUDE_CONTEXT_LIMIT) || DEFAULT_CONTEXT_LIMIT;
-  const cw = data.context_window && typeof data.context_window === 'object' ? data.context_window : {};
+  let cw = {};
+  if (data.context_window && typeof data.context_window === 'object') {
+    cw = data.context_window;
+  } else if (data.context_window != null) {
+    // Malformed: context_window is present but not an object.
+    // Attempt to extract a numeric value (some Claude Code versions
+    // may pass context_size as a bare number).
+    const numericValue = toNumber(data.context_window);
+    if (numericValue != null && numericValue > 0) {
+      const usagePct = clampPct((numericValue / contextLimit) * 100);
+      return {
+        usagePct,
+        remainingPct: null,
+        contextLimit,
+        contextSize: numericValue,
+        source: 'stdin.context_window_raw',
+      };
+    }
+    if (process.env.STRATEGIC_COMPACT_DEBUG === '1') {
+      process.stderr.write(
+        `[strategic-compact] context_window is ${typeof data.context_window}: ${JSON.stringify(data.context_window).slice(0, 100)}\n`
+      );
+    }
+  }
 
   const stdinUsed = toNumber(cw.used_percentage);
   if (stdinUsed != null) {
@@ -133,6 +160,27 @@ function resolveContextMetrics(data) {
     };
   }
 
+  // Transcript JSONL usage parsing (CCometixLine approach)
+  const transcriptPath = data.transcript_path;
+  const modelId = (data.model && data.model.id) || process.env.CLAUDE_MODEL || null;
+  if (transcriptPath && typeof transcriptPath === 'string') {
+    try {
+      const { resolveTranscriptMetrics } = require('../lib/transcript-usage');
+      const transcriptMetrics = resolveTranscriptMetrics(transcriptPath, modelId);
+      if (transcriptMetrics) {
+        return {
+          usagePct: clampPct(transcriptMetrics.usagePct),
+          remainingPct: null,
+          contextLimit: transcriptMetrics.contextLimit,
+          contextSize: transcriptMetrics.contextTokens,
+          source: 'transcript_usage',
+        };
+      }
+    } catch (_) {
+      // transcript parsing failed — fall through
+    }
+  }
+
   const bridge = readBridgeMetrics(sessionKey(data));
   if (bridge) {
     return {
@@ -142,6 +190,26 @@ function resolveContextMetrics(data) {
     };
   }
 
+  // Final fallback: estimate from transcript file size
+  if (transcriptPath && typeof transcriptPath === 'string') {
+    try {
+      const stat = fs.statSync(transcriptPath);
+      const estimatedTokens = Math.round(stat.size * 0.25);
+      if (estimatedTokens > 0) {
+        const usagePct = clampPct((estimatedTokens / contextLimit) * 100);
+        return {
+          usagePct,
+          remainingPct: null,
+          contextLimit,
+          contextSize: estimatedTokens,
+          source: 'transcript_size',
+        };
+      }
+    } catch (_) {
+      // transcript not accessible — fall through
+    }
+  }
+
   return null;
 }
 
@@ -215,12 +283,6 @@ function shouldEmit(sessionId, urgency, usagePct) {
   const debounceCalls =
     toNumber(process.env.STRATEGIC_COMPACT_DEBOUNCE_CALLS) || DEFAULT_DEBOUNCE_CALLS;
   const statePath = path.join(os.tmpdir(), `harness-strategic-compact-${sessionId}.json`);
-  const nextState = {
-    lastUrgency: urgency,
-    lastUsagePct: usagePct,
-    callsSinceEmit: 0,
-    updatedAt: new Date().toISOString(),
-  };
 
   try {
     let previous = null;
@@ -229,22 +291,38 @@ function shouldEmit(sessionId, urgency, usagePct) {
     }
 
     const callsSinceEmit = (previous?.callsSinceEmit || 0) + 1;
-    const severityOrder = { low: 0, medium: 1, high: 2, critical: 3 };
+    const severityOrder = { low: 0, advisory: 1, medium: 2, high: 3, critical: 4 };
     const escalated = severityOrder[urgency] > severityOrder[previous?.lastUrgency || 'low'];
     const usageJumped = usagePct - (previous?.lastUsagePct || 0) >= 8;
     const repeatDue = callsSinceEmit >= debounceCalls;
 
     if (!previous || escalated || usageJumped || repeatDue) {
-      fs.writeFileSync(statePath, JSON.stringify(nextState));
+      fs.writeFileSync(statePath, JSON.stringify({
+        lastUrgency: urgency,
+        lastUsagePct: usagePct,
+        callsSinceEmit: 0,
+        updatedAt: new Date().toISOString(),
+      }));
       return true;
     }
 
-    fs.writeFileSync(statePath, JSON.stringify({
-      ...nextState,
-      callsSinceEmit,
-      lastUrgency: previous.lastUrgency || urgency,
-      lastUsagePct: previous.lastUsagePct || usagePct,
-    }));
+    // Only write if callsSinceEmit actually changed
+    if (callsSinceEmit > 1) {
+      fs.writeFileSync(statePath, JSON.stringify({
+        lastUrgency: previous.lastUrgency || urgency,
+        lastUsagePct: previous.lastUsagePct || usagePct,
+        callsSinceEmit,
+        updatedAt: new Date().toISOString(),
+      }));
+    }
+
+    if (process.env.STRATEGIC_COMPACT_DEBUG === '1') {
+      process.stderr.write(
+        `[strategic-compact] debounce suppressed: callsSinceEmit=${callsSinceEmit}, ` +
+        `urgency=${urgency}, lastUrgency=${previous?.lastUrgency}\n`
+      );
+    }
+
     return false;
   } catch (_) {
     return true;
@@ -254,6 +332,7 @@ function shouldEmit(sessionId, urgency, usagePct) {
 function buildContextMessage({ usagePct, remainingPct, urgency, savings, suggestions, source }) {
   const remainingPart = remainingPct == null ? '' : ` | remaining: ${clampPct(remainingPct)}%`;
   const actionByUrgency = {
+    advisory: 'Context usage is approaching the compaction threshold. Be mindful of context budget; avoid starting large new explorations.',
     medium: 'Finish the current small step, then run `/compact` before more broad reading or implementation.',
     high: 'Stop new exploration, preserve decisions/todos/validation results, and ask the user to run `/compact`.',
     critical: 'Context is nearly exhausted. Do not start new tool chains; ask the user to run `/compact` now.',
@@ -273,14 +352,38 @@ function buildHookOutput(rawInput) {
   try {
     data = JSON.parse(rawInput || '{}');
   } catch (_) {
+    if (process.env.STRATEGIC_COMPACT_DEBUG === '1') {
+      process.stderr.write('[strategic-compact] failed to parse stdin JSON\n');
+    }
     return null;
   }
 
   const metrics = resolveContextMetrics(data);
-  if (!metrics) return null;
+  if (!metrics) {
+    if (process.env.STRATEGIC_COMPACT_DEBUG === '1') {
+      const sessionId = sessionKey(data);
+      const bridgePath = path.join(os.tmpdir(), `harness-ctx-${sessionId}.json`);
+      const bridgeExists = fs.existsSync(bridgePath);
+      process.stderr.write(
+        `[strategic-compact] no metrics available. ` +
+        `context_window=${JSON.stringify(data.context_window || 'missing')}, ` +
+        `session=${sessionId}, bridge_exists=${bridgeExists}, ` +
+        `env_size=${process.env.CLAUDE_CONTEXT_SIZE || 'unset'}, ` +
+        `env_limit=${process.env.CLAUDE_CONTEXT_LIMIT || 'unset'}\n`
+      );
+    }
+    return null;
+  }
 
   const urgency = getUrgency(metrics.usagePct);
-  if (urgency === 'low') return null;
+  if (urgency === 'low') {
+    if (process.env.STRATEGIC_COMPACT_DEBUG === '1') {
+      process.stderr.write(
+        `[strategic-compact] below threshold: ${metrics.usagePct}% (source: ${metrics.source})\n`
+      );
+    }
+    return null;
+  }
 
   const sessionId = sessionKey(data);
   if (!shouldEmit(sessionId, urgency, metrics.usagePct)) return null;

package/scripts/lib/blame-attribution.js

@@ -0,0 +1,210 @@
+'use strict';
+
+/**
+ * blame-attribution.js
+ *
+ * Maps goal iteration failures to specific code changes using git blame/diff.
+ * Produces targeted rework briefs that constrain the next iteration's scope.
+ */
+
+const { execSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+const MAX_REWORK_ATTEMPTS = 3;
+
+function parseFailureLocations(failOutput) {
+  const locations = [];
+  const lines = failOutput.split('\n');
+
+  for (const line of lines) {
+    // Match common test failure patterns:
+    // "FAIL src/auth/refresh.test.ts"
+    // "● Auth > should refresh tokens"
+    // "at Object.<anonymous> (src/auth/refresh.ts:23:5)"
+    // "src/auth/refresh.ts(23,5): error TS2345"
+    const fileLineMatch = line.match(/([a-zA-Z0-9_\-./]+\.[a-z]{1,4})[:(](\d+)/);
+    if (fileLineMatch) {
+      const filePath = fileLineMatch[1];
+      const lineNumber = parseInt(fileLineMatch[2], 10);
+      if (!filePath.includes('node_modules') && !filePath.includes('.git')) {
+        locations.push({ file: filePath, line: lineNumber, context: line.trim() });
+      }
+    }
+
+    // Match "FAIL" prefixed paths
+    const failMatch = line.match(/FAIL\s+(.+\.[a-z]{1,4})/);
+    if (failMatch) {
+      locations.push({ file: failMatch[1].trim(), line: null, context: line.trim() });
+    }
+  }
+
+  // Deduplicate by file
+  const seen = new Set();
+  return locations.filter(loc => {
+    const key = `${loc.file}:${loc.line || 0}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
+function getChangedFiles(cwd) {
+  try {
+    const output = execSync('git diff --name-only HEAD 2>/dev/null || git diff --name-only', {
+      encoding: 'utf-8',
+      cwd,
+      timeout: 10000,
+    }).trim();
+    return output ? output.split('\n').filter(Boolean) : [];
+  } catch {
+    return [];
+  }
+}
+
+function getFileDiff(filePath, cwd) {
+  try {
+    return execSync(`git diff HEAD -- "${filePath}" 2>/dev/null || git diff -- "${filePath}"`, {
+      encoding: 'utf-8',
+      cwd,
+      timeout: 10000,
+    }).trim();
+  } catch {
+    return '';
+  }
+}
+
+function intersectFailuresWithChanges(failureLocations, changedFiles) {
+  return failureLocations.filter(loc => {
+    const normalizedFail = loc.file.replace(/^\.\//, '');
+    return changedFiles.some(changed => {
+      const normalizedChanged = changed.replace(/^\.\//, '');
+      return normalizedFail === normalizedChanged ||
+             normalizedFail.endsWith(normalizedChanged) ||
+             normalizedChanged.endsWith(normalizedFail);
+    });
+  });
+}
+
+function buildReworkBrief(goal, oracleResult, blameResult) {
+  const iteration = goal.currentIteration;
+  const failingFiles = blameResult.blamedLocations.map(l => l.file);
+  const uniqueFiles = [...new Set(failingFiles)];
+
+  const brief = [
+    '## REWORK BRIEF',
+    '',
+    `**Goal:** ${goal.objective}`,
+    `**Iteration:** ${iteration} (rework attempt ${blameResult.attemptCount} for this scope)`,
+    '',
+    '**Failing evidence:**',
+    ...blameResult.blamedLocations.map(l =>
+      `- ${l.file}${l.line ? ':' + l.line : ''} — ${l.context.slice(0, 100)}`
+    ),
+    '',
+    '**Root cause (blame):**',
+    ...blameResult.changedFiles.slice(0, 5).map(f => `- Changed: ${f}`),
+    '',
+    '**Constraint:**',
+    ...uniqueFiles.map(f => `- ONLY modify: ${f}`),
+    '- DO NOT touch test files unless they are the source of the bug',
+    '- DO NOT expand scope beyond the blamed files',
+    '',
+  ];
+
+  if (oracleResult.nextHint) {
+    brief.push('**Oracle hint:**', oracleResult.nextHint, '');
+  }
+
+  return brief.join('\n');
+}
+
+function analyzeBlame(goal, oracleResult, cwd) {
+  const failOutput = (oracleResult.reasons || []).join('\n') +
+    '\n' + (oracleResult.conditionResults || [])
+      .filter(r => !r.passed)
+      .map(r => r.output)
+      .join('\n');
+
+  const failureLocations = parseFailureLocations(failOutput);
+  const changedFiles = getChangedFiles(cwd);
+  const blamedLocations = intersectFailuresWithChanges(failureLocations, changedFiles);
+
+  // Determine if escalation is needed
+  const shouldEscalate = blamedLocations.length === 0 && failureLocations.length > 0;
+
+  return {
+    failureLocations,
+    changedFiles,
+    blamedLocations: blamedLocations.length > 0 ? blamedLocations : failureLocations.slice(0, 5),
+    intersection: blamedLocations.length > 0,
+    shouldEscalate,
+    escalationReason: shouldEscalate ? 'no_blame_intersection' : null,
+    attemptCount: 1, // caller should update from tracking store
+  };
+}
+
+// Rework tracking
+
+function getReworkTrackingPath() {
+  const home = process.env.HOME || process.env.USERPROFILE || '';
+  return path.join(home, '.claude', 'rework-tracking.json');
+}
+
+function loadReworkTracking() {
+  const trackPath = getReworkTrackingPath();
+  if (!fs.existsSync(trackPath)) return {};
+  try {
+    return JSON.parse(fs.readFileSync(trackPath, 'utf-8'));
+  } catch {
+    return {};
+  }
+}
+
+function saveReworkTracking(tracking) {
+  const trackPath = getReworkTrackingPath();
+  const dir = path.dirname(trackPath);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(trackPath, JSON.stringify(tracking, null, 2), 'utf-8');
+}
+
+function recordReworkAttempt(filePath, outcome) {
+  const tracking = loadReworkTracking();
+  if (!tracking[filePath]) {
+    tracking[filePath] = { attempts: 0, outcomes: [], lastAttempt: null, totalCost: 0 };
+  }
+  tracking[filePath].attempts += 1;
+  tracking[filePath].outcomes.push(outcome);
+  tracking[filePath].lastAttempt = new Date().toISOString();
+  saveReworkTracking(tracking);
+  return tracking[filePath];
+}
+
+function shouldEscalateFile(filePath) {
+  const tracking = loadReworkTracking();
+  const record = tracking[filePath];
+  if (!record) return false;
+  return record.attempts >= MAX_REWORK_ATTEMPTS;
+}
+
+function getPersistentTroubleSpots() {
+  const tracking = loadReworkTracking();
+  return Object.entries(tracking)
+    .filter(([, record]) => record.attempts >= MAX_REWORK_ATTEMPTS)
+    .map(([file, record]) => ({ file, ...record }));
+}
+
+module.exports = {
+  MAX_REWORK_ATTEMPTS,
+  parseFailureLocations,
+  getChangedFiles,
+  getFileDiff,
+  intersectFailuresWithChanges,
+  buildReworkBrief,
+  analyzeBlame,
+  loadReworkTracking,
+  saveReworkTracking,
+  recordReworkAttempt,
+  shouldEscalateFile,
+  getPersistentTroubleSpots,
+};