The agent harness performance optimization system. Skills, instincts, memory, security, and research-first development for Claude Code, Codex, Opencode, Cursor and beyond.
fix(suggest-compact): clean up old counter temp files (#2159)
Gaurav Dubeya08445ad783d
diff --git a/scripts/hooks/suggest-compact.js b/scripts/hooks/suggest-compact.jsindex 0e9d5e66a..0638ae2bd 100644--- a/scripts/hooks/suggest-compact.js+++ b/scripts/hooks/suggest-compact.js@@ -23,6 +23,72 @@ const {output} = require('../lib/utils');+const COUNTER_FILE_PREFIX = 'claude-tool-count-';+const DEFAULT_COMPACT_STATE_TTL_DAYS = 14;++function getCounterRetentionDays() {+ const raw = process.env.COMPACT_STATE_TTL_DAYS;+ if (!raw) return DEFAULT_COMPACT_STATE_TTL_DAYS;+ const parsed = Number.parseInt(raw, 10);+ return Number.isInteger(parsed) && parsed > 0 ? parsed : DEFAULT_COMPACT_STATE_TTL_DAYS;+}++/**+ * Sweep stale counter files from the temp dir.+ *+ * Each session writes `claude-tool-count-<sessionId>` into the OS temp+ * dir; nothing else removes them. Without a sweep these files accumulate+ * one-per-session forever. This helper removes counters whose mtime is+ * older than `retentionDays`, while preserving the active session's+ * counter (which is about to be re-written by the caller).+ *+ * The helper never throws; per the always-exit-0 hook contract any+ * filesystem failure is swallowed and logged to stderr.+ *+ * @param {string} tempDir - The temp directory to sweep.+ * @param {number} retentionDays - Files older than this many days are removed.+ * @param {string} currentCounterFile - Absolute path of the active session's+ * counter file; preserved unconditionally.+ */+function cleanupOldCounters(tempDir, retentionDays, currentCounterFile) {+ let entries;+ try {+ entries = fs.readdirSync(tempDir, { withFileTypes: true });+ } catch (err) {+ log(`[StrategicCompact] Skipping counter sweep; readdir failed: ${err.message}`);+ return;+ }++ const cutoffMs = Date.now() - retentionDays * 24 * 60 * 60 * 1000;+ const currentBasename = path.basename(currentCounterFile);++ for (const entry of entries) {+ if (!entry.isFile()) continue;+ if (!entry.name.startsWith(COUNTER_FILE_PREFIX)) continue;+ if (entry.name === currentBasename) continue;++ const fullPath = path.join(tempDir, entry.name);+ let stats;+ try {+ stats = fs.statSync(fullPath);+ } catch {+ continue;+ }++ // Strict "older than" semantics per the docstring: a file whose mtime+ // sits exactly on the cutoff boundary has age == retentionDays, which+ // is not *older than* retentionDays, so preserve it. Use >= so only+ // strictly older files (mtimeMs < cutoffMs) fall through to deletion.+ if (stats.mtimeMs >= cutoffMs) continue;++ try {+ fs.rmSync(fullPath, { force: true });+ } catch (err) {+ log(`[StrategicCompact] Warning: failed to prune stale counter ${fullPath}: ${err.message}`);+ }+ }+}+async function resolveSessionId() {// Claude Code passes hook input via stdin JSON; session_id is the// canonical field. Fall back to the legacy env var, then 'default'.@@ -43,7 +109,13 @@ async function main() {// legacy env var, or 'default' as fallback.const rawSessionId = await resolveSessionId();const sessionId = rawSessionId.replace(/[^a-zA-Z0-9_-]/g, '') || 'default';- const counterFile = path.join(getTempDir(), `claude-tool-count-${sessionId}`);+ const tempDir = getTempDir();+ const counterFile = path.join(tempDir, `${COUNTER_FILE_PREFIX}${sessionId}`);++ // Sweep stale counter files (concern 1 of #2156). Cheap, swallows errors,+ // skips the active session's file. See cleanupOldCounters for details.+ cleanupOldCounters(tempDir, getCounterRetentionDays(), counterFile);+const rawThreshold = parseInt(process.env.COMPACT_THRESHOLD || '50', 10);const threshold = Number.isFinite(rawThreshold) && rawThreshold > 0 && rawThreshold <= 10000? rawThresholddiff --git a/tests/hooks/suggest-compact.test.js b/tests/hooks/suggest-compact.test.jsindex dc3c5c232..2ad564a4f 100644--- a/tests/hooks/suggest-compact.test.js+++ b/tests/hooks/suggest-compact.test.js@@ -451,6 +451,192 @@ function runTests() {})) passed++;else failed++;+ // ── Counter file cleanup (#2156) ──+ // claude-tool-count-<sessionId> files were never removed. The hook now+ // sweeps stale counters older than COMPACT_STATE_TTL_DAYS (default 14)+ // before opening the active counter. These tests pin the contract.+ console.log('\nCounter file cleanup (#2156):');++ /**+ * Set a file's mtime/atime to N days ago.+ */+ function setMtimeDaysAgo(filePath, daysAgo) {+ const seconds = Math.floor(Date.now() / 1000) - daysAgo * 24 * 60 * 60;+ fs.utimesSync(filePath, seconds, seconds);+ }++ if (test('removes counter files older than retention window', () => {+ const { sessionId, cleanup } = createCounterContext();+ const stale = getCounterFilePath(`stale-${Date.now()}`);+ fs.writeFileSync(stale, '1');+ setMtimeDaysAgo(stale, 30);+ try {+ const result = runCompact({ CLAUDE_SESSION_ID: sessionId });+ assert.strictEqual(result.code, 0, 'Should exit 0');+ assert.ok(!fs.existsSync(stale),+ `Stale counter file should have been swept. Path: ${stale}`);+ } finally {+ try { fs.unlinkSync(stale); } catch (_err) { /* ignore */ }+ cleanup();+ }+ })) passed++;+ else failed++;++ if (test('preserves counter files within retention window', () => {+ const { sessionId, cleanup } = createCounterContext();+ const fresh = getCounterFilePath(`fresh-${Date.now()}`);+ fs.writeFileSync(fresh, '1');+ setMtimeDaysAgo(fresh, 5);+ try {+ runCompact({ CLAUDE_SESSION_ID: sessionId });+ assert.ok(fs.existsSync(fresh),+ `Fresh counter file should be preserved. Path: ${fresh}`);+ } finally {+ try { fs.unlinkSync(fresh); } catch (_err) { /* ignore */ }+ cleanup();+ }+ })) passed++;+ else failed++;++ if (test('preserves the active session\'s counter file even if old', () => {+ const { sessionId, counterFile, cleanup } = createCounterContext();+ cleanup();+ fs.writeFileSync(counterFile, '7');+ setMtimeDaysAgo(counterFile, 30);+ try {+ const result = runCompact({ CLAUDE_SESSION_ID: sessionId });+ assert.strictEqual(result.code, 0, 'Should exit 0');+ // Active counter survives the sweep AND is incremented by the hook (7 -> 8).+ assert.ok(fs.existsSync(counterFile),+ 'Active session counter must survive the sweep');+ const count = parseInt(fs.readFileSync(counterFile, 'utf8').trim(), 10);+ assert.strictEqual(count, 8,+ `Active counter should be incremented by the hook. Got ${count}`);+ } finally {+ cleanup();+ }+ })) passed++;+ else failed++;++ if (test('honours COMPACT_STATE_TTL_DAYS env var', () => {+ const { sessionId, cleanup } = createCounterContext();+ const target = getCounterFilePath(`ttl-${Date.now()}`);+ fs.writeFileSync(target, '1');+ setMtimeDaysAgo(target, 5); // Within default 14d window, but outside TTL=3+ try {+ const result = runCompact({+ CLAUDE_SESSION_ID: sessionId,+ COMPACT_STATE_TTL_DAYS: '3'+ });+ assert.strictEqual(result.code, 0);+ assert.ok(!fs.existsSync(target),+ `TTL=3 should sweep a 5-day-old file. Path: ${target}`);+ } finally {+ try { fs.unlinkSync(target); } catch (_err) { /* ignore */ }+ cleanup();+ }+ })) passed++;+ else failed++;++ if (test('falls back to default for invalid COMPACT_STATE_TTL_DAYS', () => {+ const { sessionId, cleanup } = createCounterContext();+ const target = getCounterFilePath(`fallback-${Date.now()}`);+ fs.writeFileSync(target, '1');+ setMtimeDaysAgo(target, 5); // Within default 14d window, would survive a fallback+ try {+ // Each invalid form: zero, negative, non-numeric — should fall back to 14d default.+ for (const bad of ['0', '-5', 'abc']) {+ // Reset mtime each iteration so the file remains 5 days old.+ setMtimeDaysAgo(target, 5);+ const result = runCompact({+ CLAUDE_SESSION_ID: sessionId,+ COMPACT_STATE_TTL_DAYS: bad+ });+ assert.strictEqual(result.code, 0);+ assert.ok(fs.existsSync(target),+ `Invalid TTL '${bad}' should fall back to default (14d) and preserve a 5-day-old file`);+ }+ } finally {+ try { fs.unlinkSync(target); } catch (_err) { /* ignore */ }+ cleanup();+ }+ })) passed++;+ else failed++;++ if (test('does not touch unrelated temp files', () => {+ const { sessionId, cleanup } = createCounterContext();+ const unrelated = path.join(os.tmpdir(), `unrelated-${Date.now()}.tmp`);+ fs.writeFileSync(unrelated, 'do not touch');+ setMtimeDaysAgo(unrelated, 60);+ try {+ runCompact({ CLAUDE_SESSION_ID: sessionId });+ assert.ok(fs.existsSync(unrelated),+ `Unrelated temp file should not be swept. Path: ${unrelated}`);+ } finally {+ try { fs.unlinkSync(unrelated); } catch (_err) { /* ignore */ }+ cleanup();+ }+ })) passed++;+ else failed++;++ if (test('preserves files whose mtime sits at or after the TTL cutoff', () => {+ // Contract: docstring says files "older than" retentionDays are removed.+ // A file at the exact boundary (age == retentionDays) is NOT older than+ // retentionDays, so it must survive the sweep. Pins the >= comparison+ // in cleanupOldCounters: anything with mtimeMs >= cutoffMs is skipped.+ //+ // We can't pin the boundary by clock — the sweep computes its own+ // Date.now() after this test runs, so `setMtimeDaysAgo(file, 14)` is+ // effectively "14d + handful of ms", placing the file just past the+ // cutoff. To exercise the boundary deterministically, set the file's+ // mtime two seconds *newer* than the projected cutoff: with `>` the+ // file would be deleted (mtimeMs > cutoffMs is false at the cutoff+ // edge); with `>=` it survives.+ const { sessionId, cleanup } = createCounterContext();+ const boundary = getCounterFilePath(`boundary-${Date.now()}`);+ fs.writeFileSync(boundary, '1');+ const retentionDays = 14;+ const boundaryMs = Date.now() - retentionDays * 24 * 60 * 60 * 1000 + 2000;+ const sec = Math.floor(boundaryMs / 1000);+ fs.utimesSync(boundary, sec, sec);+ try {+ const result = runCompact({ CLAUDE_SESSION_ID: sessionId });+ assert.strictEqual(result.code, 0);+ assert.ok(fs.existsSync(boundary),+ `Boundary-aged counter file should be preserved. Path: ${boundary}`);+ } finally {+ try { fs.unlinkSync(boundary); } catch (_err) { /* ignore */ }+ cleanup();+ }+ })) passed++;+ else failed++;++ if (test('exit 0 holds when sweep encounters a populated temp dir', () => {+ // Functional smoke: with a mix of stale, fresh, and unrelated files+ // present, the hook must still exit 0 — the always-exit-0 contract+ // takes precedence over sweep failures.+ const { sessionId, cleanup } = createCounterContext();+ const stale = getCounterFilePath(`mix-stale-${Date.now()}`);+ const fresh = getCounterFilePath(`mix-fresh-${Date.now()}`);+ const unrelated = path.join(os.tmpdir(), `mix-unrelated-${Date.now()}.tmp`);+ fs.writeFileSync(stale, '1');+ fs.writeFileSync(fresh, '1');+ fs.writeFileSync(unrelated, '1');+ setMtimeDaysAgo(stale, 30);+ setMtimeDaysAgo(fresh, 1);+ setMtimeDaysAgo(unrelated, 30);+ try {+ const result = runCompact({ CLAUDE_SESSION_ID: sessionId });+ assert.strictEqual(result.code, 0, 'Hook must exit 0 even with files in temp dir');+ } finally {+ for (const p of [stale, fresh, unrelated]) {+ try { fs.unlinkSync(p); } catch (_err) { /* ignore */ }+ }+ cleanup();+ }+ })) passed++;+ else failed++;+// Summaryconsole.log(`Results: Passed: ${passed}, Failed: ${failed}`);