@lh8ppl/claude-memory-kit 0.3.4 → 0.3.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lh8ppl/claude-memory-kit",
-  "version": "0.3.4",
+  "version": "0.3.5",
   "description": "cmk — the CLI for claude-memory-kit. Per-project, in-repo memory system for Claude Code.",
   "type": "module",
   "bin": {

package/src/compress-retry.mjs

@@ -37,6 +37,31 @@
 // a time, gated by the cooldown), so there is no herd to avoid — a plain exponential
 // backoff is sufficient and keeps the timing deterministic for tests.
 
+// The timeout for compress callers that have NO outer hook ceiling — the cron /
+// detached-lazy children (daily-distill, weekly-curate, the lazy compressSession).
+// The D-92/F-2 composition rule: a ceiling-free caller must NOT inherit the
+// hook-sized 50s bound (which is sized under the 60s SessionEnd ceiling, §8.5).
+// 120s is chosen against MEASURED `claude --print` latency: it runs ~18-27s when
+// fast but was observed at 78s (Task 163 live, on a 4.7KB input) and 89s (the v0.3.4
+// cut-gate, 10KB) in slow-Haiku windows — environmental, not size-driven (D-174).
+// 120s clears those with headroom; the 50s budget killed them needlessly, leaving
+// `recent.md` stale (D-179). One constant so the family can't drift back to 50s.
+// (auto-extract uses its own 90s under the Stop hook — a separate detached path.)
+export const CEILING_FREE_TIMEOUT_MS = 120_000;
+
+// The backoff BETWEEN retries on the ceiling-free paths. The default baseBackoffMs
+// (600ms) is far too short for the kit's failure mode: `claude --print` slowness is
+// a transient WINDOW (slow for a stretch, then fine — D-174), and the whole point of
+// backoff is to let that window PASS before retrying. A 600ms wait retries while
+// still INSIDE the same slow window, so attempt 2 hits the same slowness and also
+// times out. The field waits SECONDS for exactly this reason (graphiti 5-120s,
+// Letta cap 10s, mempalace 2-8s — all checked across 19 systems; NONE use sub-second
+// backoff, and NONE escalate the timeout itself). 5s is the field's low end — one
+// 5s wait between the 2 ceiling-free attempts gives the slow window room to clear.
+// Safe on every path: the HOOK path is maxAttempts:1 (no retry → backoff never
+// fires); the ceiling-free paths run detached/cron, so a multi-second wait is free.
+export const CEILING_FREE_BACKOFF_MS = 5_000;
+
 /**
  * Classify a compress() rejection as transient (worth a retry) or deterministic
  * (a re-call re-fails identically — don't waste the attempt or the budget).

package/src/compress-session.mjs

@@ -232,6 +232,16 @@ export async function compressSession({
   // caller (runLazyCompress) passes maxAttempts:2 to opt into one retry; the hook
   // keeps its restore-on-failure (D-79) and delegates the retry to that lazy path.
   maxAttempts = 1,
+  // DEFAULT 50s = the SessionEnd-hook budget (sized under the 60s ceiling, §8.5).
+  // The ceiling-free LAZY caller (runLazyCompress, a detached SessionStart child
+  // with NO outer ceiling) passes 120s so a slow-but-not-broken `claude --print`
+  // window doesn't time out needlessly — the D-92/F-2 composition rule: a
+  // ceiling-free caller must not inherit a ceiling-sized timeout.
+  timeoutMs = 50_000,
+  // Backoff between retries (only the lazy maxAttempts:2 path retries). DEFAULT
+  // undefined → compressWithRetry's 600ms; the ceiling-free LAZY caller passes the
+  // 5s ceiling-free backoff so a retry lands AFTER the slow-Haiku window (D-179).
+  baseBackoffMs,
 } = {}) {
   const ts = now ?? nowIso();
   const date = dateFromIso(ts);
@@ -343,9 +353,11 @@ export async function compressSession({
         instructions,
         preserveCitationIds: true,
         maxOutputBytes,
-        timeoutMs: 50_000,
+        timeoutMs,
       },
-      { maxAttempts, onRetry: () => { retries += 1; } },
+      // baseBackoffMs only forwarded when the caller set it (the lazy ceiling-free
+      // path passes the 5s backoff); undefined → compressWithRetry's 600ms default.
+      { maxAttempts, ...(baseBackoffMs != null ? { baseBackoffMs } : {}), onRetry: () => { retries += 1; } },
     );
   } catch (err) {
     // Distinguish HAIKU_TIMEOUT (slow Anthropic) from COMPRESS_FAILED

package/src/daily-distill.mjs

@@ -28,7 +28,7 @@ import { join } from 'node:path';
 import { nowIso } from './audit-log.mjs';
 import { ERROR_CATEGORIES } from './result-shapes.mjs';
 import { HaikuTimeoutError } from './compressor.mjs';
-import { compressWithRetry } from './compress-retry.mjs';
+import { compressWithRetry, CEILING_FREE_TIMEOUT_MS, CEILING_FREE_BACKOFF_MS } from './compress-retry.mjs';
 import {
   DEFAULT_COOLDOWN_MS,
   isCooldownActive,
@@ -209,9 +209,13 @@ export async function dailyDistill({
         instructions,
         preserveCitationIds: true,
         maxOutputBytes,
-        timeoutMs: 50_000,
+        // Ceiling-free (cron / detached lazy child, NO 60s hook ceiling) → the
+        // generous ceiling-free timeout, NOT the hook-sized 50s (D-92/F-2 + D-179).
+        timeoutMs: CEILING_FREE_TIMEOUT_MS,
       },
-      { maxAttempts: 2, onRetry: () => { retries += 1; } },
+      // 5s backoff between the 2 attempts (NOT the 600ms default) so a retry lands
+      // AFTER the transient slow-Haiku window, not inside it (D-179).
+      { maxAttempts: 2, baseBackoffMs: CEILING_FREE_BACKOFF_MS, onRetry: () => { retries += 1; } },
     );
     touchCooldownMarker({ projectRoot, now: ts });
   } catch (err) {

package/src/lazy-compress.mjs

@@ -44,6 +44,7 @@ import {
 import { dailyDistill } from './daily-distill.mjs';
 import { weeklyCurate } from './weekly-curate.mjs';
 import { compressSession } from './compress-session.mjs';
+import { CEILING_FREE_TIMEOUT_MS, CEILING_FREE_BACKOFF_MS } from './compress-retry.mjs';
 import { syncDecisionsJournal } from './decisions-journal.mjs';
 
 const DEFAULT_DAILY_TTL_MS = 24 * 60 * 60 * 1000; // 24 hours
@@ -416,6 +417,11 @@ export async function runLazyCompress({
       // is where the SessionEnd-hook's failed roll (which restored now.md, D-79) gets
       // its real bounded retry.
       maxAttempts: 2,
+      // Ceiling-free (detached child, no 60s ceiling) → the generous timeout + the 5s
+      // backoff so a retry lands AFTER the slow-Haiku window (D-92/F-2 + D-179; matches
+      // daily-distill / weekly-curate). compressSession forwards both to compressWithRetry.
+      timeoutMs: CEILING_FREE_TIMEOUT_MS,
+      baseBackoffMs: CEILING_FREE_BACKOFF_MS,
     });
   } else if (verdict.action === 'stale-weekly') {
     delegatedTo = 'weekly-curate';

package/src/weekly-curate.mjs

@@ -39,7 +39,7 @@ import { canonicalize } from '@lh8ppl/cmk-canonicalize';
 import { nowIso } from './audit-log.mjs';
 import { ERROR_CATEGORIES, errorResult } from './result-shapes.mjs';
 import { HaikuTimeoutError } from './compressor.mjs';
-import { compressWithRetry } from './compress-retry.mjs';
+import { compressWithRetry, CEILING_FREE_TIMEOUT_MS, CEILING_FREE_BACKOFF_MS } from './compress-retry.mjs';
 import {
   DEFAULT_COOLDOWN_MS,
   isCooldownActive,
@@ -344,7 +344,8 @@ export async function weeklyCurate({
       // corpus (heavier than a session summary) and runs as a cron/lazy child
       // with no 60s hook ceiling — give the classifier headroom so a large
       // corpus doesn't time out. (Corpus is byte-capped at PERSONA_CORPUS_BYTES.)
-      timeoutMs: 120_000,
+      // The shared ceiling-free timeout (D-92/F-2; was the original 120s literal).
+      timeoutMs: CEILING_FREE_TIMEOUT_MS,
     });
   }
 
@@ -400,9 +401,11 @@ export async function weeklyCurate({
         instructions,
         preserveCitationIds: true,
         maxOutputBytes: archiveMaxBytes,
-        timeoutMs: 50_000,
+        // Ceiling-free → the generous timeout, NOT the hook-sized 50s (D-92/F-2 + D-179).
+        timeoutMs: CEILING_FREE_TIMEOUT_MS,
       },
-      { maxAttempts: 2, onRetry: () => { retries += 1; } },
+      // 5s backoff so a retry lands after the slow-Haiku window, not inside it (D-179).
+      { maxAttempts: 2, baseBackoffMs: CEILING_FREE_BACKOFF_MS, onRetry: () => { retries += 1; } },
     );
     touchCooldownMarker({ projectRoot, now: ts });
   } catch (err) {