@colin4k1024/tsp 2.5.1 → 2.5.2

package/schemas/goal.schema.json

@@ -0,0 +1,172 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "ECC Goal Definition",
+  "description": "Schema for goal-oriented autonomous loop with external completion oracle",
+  "type": "object",
+  "properties": {
+    "goalId": {
+      "type": "string",
+      "pattern": "^goal-[a-z0-9]{8}$",
+      "description": "Unique goal identifier"
+    },
+    "objective": {
+      "type": "string",
+      "minLength": 5,
+      "description": "Natural language description of the goal"
+    },
+    "stoppingConditions": {
+      "type": "array",
+      "minItems": 1,
+      "items": {
+        "type": "object",
+        "properties": {
+          "type": {
+            "type": "string",
+            "enum": ["test_pass", "lint_clean", "coverage_threshold", "build_pass", "custom_command"],
+            "description": "Type of stopping condition"
+          },
+          "command": {
+            "type": "string",
+            "minLength": 1,
+            "description": "Shell command to evaluate the condition"
+          },
+          "threshold": {
+            "type": "number",
+            "description": "Numeric threshold for the condition (e.g., coverage percentage)"
+          },
+          "description": {
+            "type": "string",
+            "description": "Human-readable description of what this condition checks"
+          }
+        },
+        "required": ["type", "command"],
+        "additionalProperties": false
+      }
+    },
+    "budget": {
+      "type": "object",
+      "properties": {
+        "maxIterations": {
+          "type": "integer",
+          "minimum": 1,
+          "maximum": 100,
+          "default": 15,
+          "description": "Maximum maker iterations before escalation"
+        },
+        "maxDuration": {
+          "type": "string",
+          "pattern": "^[0-9]+(m|h)$",
+          "default": "2h",
+          "description": "Maximum wall-clock time (e.g., '30m', '2h')"
+        },
+        "maxDollars": {
+          "type": "number",
+          "minimum": 0.1,
+          "default": 10,
+          "description": "Maximum cost in USD before pausing"
+        }
+      },
+      "additionalProperties": false
+    },
+    "oracle": {
+      "type": "object",
+      "properties": {
+        "model": {
+          "type": "string",
+          "default": "haiku",
+          "description": "Model to use for completion verification (must differ from maker)"
+        },
+        "allowedTools": {
+          "type": "array",
+          "items": { "type": "string" },
+          "default": ["Read", "Bash"],
+          "description": "Tools the oracle can use (read-only by convention)"
+        },
+        "prompt": {
+          "type": "string",
+          "description": "Custom oracle prompt override (optional)"
+        }
+      },
+      "additionalProperties": false
+    },
+    "state": {
+      "type": "string",
+      "enum": ["active", "paused", "converged", "escalated", "failed"],
+      "default": "active",
+      "description": "Current goal lifecycle state"
+    },
+    "currentIteration": {
+      "type": "integer",
+      "minimum": 0,
+      "default": 0
+    },
+    "createdAt": {
+      "type": "string",
+      "format": "date-time"
+    },
+    "updatedAt": {
+      "type": "string",
+      "format": "date-time"
+    },
+    "history": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "properties": {
+          "iteration": {
+            "type": "integer",
+            "minimum": 0
+          },
+          "makerSummary": {
+            "type": "string",
+            "description": "Brief summary of what the maker did this iteration"
+          },
+          "oracleVerdict": {
+            "type": "string",
+            "enum": ["pass", "fail", "partial"],
+            "description": "Oracle's assessment of stopping conditions"
+          },
+          "failReasons": {
+            "type": "array",
+            "items": { "type": "string" },
+            "description": "Specific reasons for failure"
+          },
+          "nextHint": {
+            "type": "string",
+            "description": "Oracle's guidance for the next iteration"
+          },
+          "timestamp": {
+            "type": "string",
+            "format": "date-time"
+          },
+          "costDollars": {
+            "type": "number",
+            "description": "Cost of this iteration"
+          }
+        },
+        "required": ["iteration", "oracleVerdict", "timestamp"],
+        "additionalProperties": false
+      }
+    },
+    "escalation": {
+      "type": "object",
+      "properties": {
+        "reason": {
+          "type": "string",
+          "enum": ["budget_exhausted", "repeated_failure", "oracle_uncertain", "manual"],
+          "description": "Why the goal was escalated"
+        },
+        "details": {
+          "type": "string"
+        },
+        "escalatedAt": {
+          "type": "string",
+          "format": "date-time"
+        }
+      },
+      "additionalProperties": false
+    }
+  },
+  "required": ["goalId", "objective", "stoppingConditions", "state"],
+  "additionalProperties": false
+}

package/scripts/hooks/session-start-goal-resume.js

@@ -0,0 +1,95 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * session-start-goal-resume.js
+ *
+ * SessionStart hook that checks for active goals and injects a resume reminder.
+ *
+ * Part of the Loop Engineering upgrade (Phase 1.3: Inter-session state bridge).
+ * When active goals exist from a previous session, this hook adds context to the
+ * session start output so the user knows they can resume with `/goal resume`.
+ *
+ * Behavior:
+ *   1. Scans ~/.claude/goals/ for goal files with state "active" or "paused"
+ *   2. If found, appends a summary to the hook output
+ *   3. Non-blocking: failures are silently ignored
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+function getGoalsDir() {
+  const home = process.env.HOME || process.env.USERPROFILE || '';
+  return path.join(home, '.claude', 'goals');
+}
+
+function scanActiveGoals() {
+  const dir = getGoalsDir();
+  if (!fs.existsSync(dir)) return [];
+
+  try {
+    return fs.readdirSync(dir)
+      .filter(f => f.endsWith('.json'))
+      .map(f => {
+        try {
+          return JSON.parse(fs.readFileSync(path.join(dir, f), 'utf-8'));
+        } catch {
+          return null;
+        }
+      })
+      .filter(g => g && (g.state === 'active' || g.state === 'paused'))
+      .sort((a, b) => new Date(b.updatedAt) - new Date(a.updatedAt));
+  } catch {
+    return [];
+  }
+}
+
+function formatGoalSummary(goal) {
+  const stateIcon = goal.state === 'active' ? '▶' : '⏸';
+  const progress = `${goal.currentIteration}/${goal.budget?.maxIterations || 15}`;
+  const lastHint = goal.history?.length > 0
+    ? goal.history[goal.history.length - 1].nextHint || ''
+    : '';
+  return `  ${stateIcon} [${goal.goalId}] "${goal.objective}" (iter ${progress})${lastHint ? `\n    Last hint: ${lastHint.slice(0, 120)}` : ''}`;
+}
+
+function main() {
+  let raw = '';
+  try {
+    raw = fs.readFileSync(0, 'utf8');
+  } catch {
+    // stdin may not be available
+  }
+
+  const activeGoals = scanActiveGoals();
+
+  if (activeGoals.length === 0) {
+    process.stdout.write(raw);
+    return;
+  }
+
+  // Parse the input event and add goal context
+  let event;
+  try {
+    event = JSON.parse(raw);
+  } catch {
+    process.stdout.write(raw);
+    return;
+  }
+
+  const goalSummary = activeGoals.map(formatGoalSummary).join('\n');
+  const message = `\n[Loop Engineering] ${activeGoals.length} active goal(s) from previous session:\n${goalSummary}\n\nResume with: /goal resume\n`;
+
+  // Inject into session context if possible
+  if (event && typeof event === 'object') {
+    if (!event.additionalContext) {
+      event.additionalContext = '';
+    }
+    event.additionalContext += message;
+  }
+
+  process.stdout.write(JSON.stringify(event));
+}
+
+main();

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) {
@@ -215,12 +242,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 +250,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 +291,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 +311,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,
+};