@inceptionstack/roundhouse 0.5.26 → 0.5.28

package/CHANGELOG.md

@@ -2,6 +2,25 @@
 
 All notable changes to `@inceptionstack/roundhouse` are documented here.
 
+## [0.5.28] — 2026-05-14
+
+### Fixed
+- **PR #126 actually shipped this time.** v0.5.26's CHANGELOG advertised the emergency-compact-loop fix, but the underlying PR (`fix/compact-loop-thresholds-and-thinking`) was still OPEN — only the version bump and self-update patch went out. Users on v0.5.26/v0.5.27 still hit `Summarization failed: prompt is too long: 212776 tokens > 200000 maximum` on overflowed sessions because `DEFAULT_HARD_TOKENS` was still 200k with no headroom clamp. This release contains the actual code change: `DEFAULT_HARD_TOKENS=150_000`, `DEFAULT_SOFT_TOKENS=130_000`, `COMPACT_HEADROOM_TOKENS=50_000`, plus `thinkingLevel='off'` forced inside `compactWithModel`. (#126)
+
+## [0.5.27] — 2026-05-14
+
+### Fixed
+- **Self-update no longer falsely fails on mise/nvm hosts** — on systems where Node is managed by mise (or nvm), `npm install -g` triggers a post-install reshim hook that exits 127 when its tool isn't on PATH, causing `execSync` to throw even though the package was written to disk correctly. The user-visible bug: "Self-update failed: Command failed: npm install -g …" plus `/status` continuing to show the old version forever (because the gateway never restarted). Fix: when the install command throws, consult `npm list -g <pkg>` and trust the on-disk version. If it matches the target, treat the install as successful. Same logic applied to extension updates. (#128)
+- **Side effect:** `/update` now fires its existing 'restarting…' branch on this case, so `/status` reflects the new version on next boot.
+
+### Changed
+- **DRY in `cli/update.ts`:** extracted `getInstalledVersion()` helper used by both pre-install version check and post-failure verification; introduced `SELF_PACKAGE` constant; fixed stale `commands/update.ts` header comment.
+
+## [0.5.26] — 2026-05-14
+
+### Fixed
+- **Emergency compact loop — output-cap mismatch + summarization input overflow.** Two compounding bugs caused infinite emergency-compact loops on Haiku 4.5 sessions near the context limit. (1) `reserveTokens=150000` + Haiku's 64k output cap produced `maxTokens=120000`, which Bedrock rejected. (2) `hardTokens=200k`/`softTokens=180k` against a 200k window left no headroom for the summarizer prompt itself. Fix: lower thresholds to 150k/130k, add `COMPACT_HEADROOM_TOKENS=50k`, force `thinkingLevel:off` in `compactWithModel`, drop `reserveTokens` to 78k. State is now loaded once and reused; phase timing is hoisted; telemetry is accurate on failure. (#126)
+
 ## [0.5.25] — 2026-05-12
 
 ### Fixed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inceptionstack/roundhouse",
-  "version": "0.5.26",
+  "version": "0.5.28",
   "type": "module",
   "description": "Multi-platform chat gateway that routes messages through a configured AI agent",
   "license": "MIT",

package/src/agents/pi/pi-adapter.ts

@@ -608,7 +608,9 @@ export const createPiAgentAdapter: AgentAdapterFactory = (config) => {
 
         const agentState = (entry.session as any).agent?.state;
         let currentModel: any;
+        let currentThinkingLevel: any;
         let modelSwapped = false;
+        let thinkingSwapped = false;
 
         // Resolve and swap model for compact
         if (!agentState) {
@@ -627,6 +629,19 @@ export const createPiAgentAdapter: AgentAdapterFactory = (config) => {
             modelSwapped = true;
             console.log(`[pi-agent] compact using model (in-memory): ${modelId}`);
           }
+
+          // Force thinking off for compact regardless of agent's default.
+          // Summarization doesn't benefit from reasoning, costs more tokens,
+          // and complicates the maxTokens math (adjustMaxTokensForThinking adds
+          // up to 16k thinking budget). Direct state mutation matches the model
+          // swap above and avoids setThinkingLevel(), which would persist to
+          // settings.json.
+          if (agentState.thinkingLevel && agentState.thinkingLevel !== "off") {
+            currentThinkingLevel = agentState.thinkingLevel;
+            agentState.thinkingLevel = "off";
+            thinkingSwapped = true;
+            console.log(`[pi-agent] compact forcing thinkingLevel=off (was ${currentThinkingLevel})`);
+          }
         }
 
         try {
@@ -640,6 +655,9 @@ export const createPiAgentAdapter: AgentAdapterFactory = (config) => {
           if (modelSwapped) {
             agentState.model = currentModel;
           }
+          if (thinkingSwapped) {
+            agentState.thinkingLevel = currentThinkingLevel;
+          }
         }
       });
     },

package/src/cli/update.ts

@@ -1,5 +1,5 @@
 /**
- * commands/update.ts — Handle the /update command
+ * cli/update.ts — Handle the /update command
  *
  * Transport-agnostic: receives a ProgressReporter interface,
  * not a Telegram-specific thread object.
@@ -15,6 +15,28 @@ const GLOBAL_PI_EXTENSION_PACKAGES = [
   "@inceptionstack/pi-branch-enforcer",
 ];
 
+const SELF_PACKAGE = "@inceptionstack/roundhouse";
+
+/**
+ * Read globally-installed version of a package from disk.
+ * Returns empty string if the package is not installed or query fails.
+ *
+ * Used both for pre-install version checks and for post-failure verification
+ * (mise/nvm/npm reshim hooks can fail with exit 127 even after `npm install -g`
+ * actually wrote the new version to disk — see PR fix/self-update-verify-on-failure).
+ */
+function getInstalledVersion(pkg: string): string {
+  try {
+    const out = execSync(`npm list -g ${pkg} --json --depth=0 2>/dev/null`, {
+      timeout: 10_000,
+      encoding: "utf8",
+    });
+    return JSON.parse(out)?.dependencies?.[pkg]?.version ?? "";
+  } catch {
+    return "";
+  }
+}
+
 export interface UpdateProgress {
   update(text: string): Promise<void>;
 }
@@ -28,14 +50,11 @@ export interface UpdateResult {
 
 export async function updateExtensions(progress: UpdateProgress): Promise<void> {
   for (const extensionPackage of GLOBAL_PI_EXTENSION_PACKAGES) {
+    let latestExtVersion = "";
     try {
       // Check if already at latest
-      const installed = execSync(`npm list -g ${extensionPackage} --json 2>/dev/null`, {
-        timeout: 10_000,
-        encoding: "utf8",
-      });
-      const installedVersion = JSON.parse(installed)?.dependencies?.[extensionPackage]?.version ?? "";
-      const latestExtVersion = execSync(`npm view ${extensionPackage} version 2>/dev/null`, {
+      const installedVersion = getInstalledVersion(extensionPackage);
+      latestExtVersion = execSync(`npm view ${extensionPackage} version 2>/dev/null`, {
         timeout: 10_000,
         encoding: "utf8",
       }).trim();
@@ -57,6 +76,14 @@ export async function updateExtensions(progress: UpdateProgress): Promise<void>
       await progress.update(`✅ ${extensionPackage} updated`);
     } catch (e) {
       const msg = e instanceof Error ? e.message : String(e);
+      // Verify-after-fail: post-install reshim hooks (mise/nvm) can exit non-zero
+      // even when the package landed on disk correctly.
+      const onDisk = getInstalledVersion(extensionPackage);
+      if (onDisk && (!latestExtVersion || onDisk === latestExtVersion)) {
+        console.warn(`[roundhouse] ${extensionPackage} install reported failure but v${onDisk} is on disk — treating as success:`, msg);
+        await progress.update(`✅ ${extensionPackage} updated to v${onDisk} (post-install hook warned, ignored)`);
+        continue;
+      }
       console.warn(`[roundhouse] failed to update extension ${extensionPackage}:`, msg);
       await progress.update(`⚠️ Failed to update ${extensionPackage}: ${msg.slice(0, 150)}`);
     }
@@ -71,13 +98,20 @@ export async function updateSelf(
   await progress.update(`📦 Updating v${currentVersion} → v${latestVersion}...`);
 
   try {
-    execSync("npm install -g @inceptionstack/roundhouse@latest 2>&1", {
+    execSync(`npm install -g ${SELF_PACKAGE}@latest 2>&1`, {
       timeout: 120_000,
       encoding: "utf8",
     });
     return undefined;
   } catch (e) {
     const msg = e instanceof Error ? e.message : String(e);
+    // Verify-after-fail: mise/nvm post-install reshim can exit 127 even when
+    // npm wrote the new version to disk. Trust the on-disk state over the exit code.
+    const onDisk = getInstalledVersion(SELF_PACKAGE);
+    if (onDisk === latestVersion) {
+      console.warn(`[roundhouse] self-update install reported failure but v${onDisk} is on disk — treating as success:`, msg);
+      return undefined;
+    }
     console.warn("[roundhouse] self-update failed:", msg);
     return `Self-update failed: ${msg}`;
   }
@@ -106,7 +140,7 @@ export async function performUpdate(progress: UpdateProgress): Promise<UpdateRes
 
   let latestVersion: string;
   try {
-    latestVersion = execSync("npm view @inceptionstack/roundhouse version 2>/dev/null", {
+    latestVersion = execSync(`npm view ${SELF_PACKAGE} version 2>/dev/null`, {
       timeout: 30_000,
       encoding: "utf8",
     }).trim();

package/src/memory/lifecycle.ts

@@ -20,6 +20,36 @@ import { appendFile, mkdir } from "node:fs/promises";
 import { join } from "node:path";
 import { homedir } from "node:os";
 
+// ── Telemetry helper ─────────────────────────────────
+
+interface CompactLogEntry {
+  threadId: string;
+  level: string;
+  effectiveLevel: string;
+  flushSkipped: boolean;
+  tokensBefore: number | null;
+  tokensAfter: number | null;
+  flushMs: number;
+  compactMs: number;
+  totalMs: number;
+  model: string;
+  status: "ok" | "failed";
+  error: string | null;
+}
+
+/**
+ * Append a compact telemetry entry. Fire-and-forget.
+ * Schema is uniform across success/failure (status discriminator) so
+ * downstream parsers don't have to handle missing fields.
+ */
+function appendCompactLog(entry: CompactLogEntry): void {
+  const logDir = join(homedir(), ".roundhouse", "logs");
+  const line = JSON.stringify({ ts: new Date().toISOString(), ...entry }) + "\n";
+  mkdir(logDir, { recursive: true })
+    .then(() => appendFile(join(logDir, "compact-timing.jsonl"), line))
+    .catch((err) => console.warn(`[memory] timing log write failed:`, (err as Error).message));
+}
+
 // ── Memory mode detection ────────────────────────────
 
 /**
@@ -246,11 +276,16 @@ export async function flushMemoryThenCompact(
   // "manual" level, attempting the flush in that condition will hit the same
   // 200k rejection. Deferring flush to a later (successful) turn is the safe
   // recovery path.
-  const stuckInEmergency = (await loadThreadMemoryState(threadId)).pendingCompact === "emergency";
+  const stateBeforeCompact = await loadThreadMemoryState(threadId);
+  const stuckInEmergency = stateBeforeCompact.pendingCompact === "emergency";
   const skipFlush = effectiveLevel === "emergency" || stuckInEmergency;
 
+  // Hoisted so the catch block can report accurate flush vs compact timing
+  // (a failure during compact() would otherwise conflate the two phases).
+  let flushMs = 0;
+  let compactMs = 0;
+
   try {
-    let flushMs = 0;
     if (!skipFlush) {
       // Step 1: flush
       const flushText = buildFlushPrompt(mode === "unknown" ? "full" : mode, effectiveLevel);
@@ -276,16 +311,18 @@ export async function flushMemoryThenCompact(
     const result = usedCompactModel
       ? await agent.compactWithModel!(threadId, flushModel!)
       : await agent.compact!(threadId);
-    const compactMs = Date.now() - t1;
+    compactMs = Date.now() - t1;
     if (!result) return null;
 
-    // Step 3: mark force re-inject (Full mode only)
+    // Step 3: mark force re-inject (Full mode only). Reuse the state we
+    // already loaded above; the compact step doesn't mutate memory-state
+    // (it mutates the pi session, a separate file), so the in-memory copy
+    // is still authoritative for our fields.
     if (mode !== "complement") {
-      const state = await loadThreadMemoryState(threadId);
-      state.forceInjectReason = "after-compact";
-      state.lastCompactAt = new Date().toISOString();
-      state.pendingCompact = undefined;
-      await saveThreadMemoryState(threadId, state);
+      stateBeforeCompact.forceInjectReason = "after-compact";
+      stateBeforeCompact.lastCompactAt = new Date().toISOString();
+      stateBeforeCompact.pendingCompact = undefined;
+      await saveThreadMemoryState(threadId, stateBeforeCompact);
     }
 
     const totalMs = Date.now() - t0;
@@ -302,30 +339,44 @@ export async function flushMemoryThenCompact(
     const timing = { flushMs, compactMs, totalMs, model: usedCompactModel ? flushModel! : "default" };
     console.log(`[memory] flush+compact done for ${threadId}: ${result.tokensBefore} → ${result.tokensAfter ?? "?"} tokens | flush=${flushMs}ms compact=${compactMs}ms total=${totalMs}ms model=${timing.model}`);
 
-    // Persist timing log for debugging (async, fire-and-forget)
-    const logDir = join(homedir(), ".roundhouse", "logs");
-    mkdir(logDir, { recursive: true })
-      .then(() => {
-        const entry = JSON.stringify({
-          ts: new Date().toISOString(),
-          threadId,
-          level,
-          tokensBefore: result.tokensBefore,
-          tokensAfter: result.tokensAfter,
-          ...timing,
-        });
-        return appendFile(join(logDir, "compact-timing.jsonl"), entry + "\n");
-      })
-      .catch((err) => console.warn(`[memory] timing log write failed:`, (err as Error).message));
+    // Persist timing log for debugging (async, fire-and-forget).
+    // Schema is intentionally uniform across success and failure entries
+    // (status discriminator + same field set) so jsonl parsers don't have
+    // to special-case missing fields.
+    appendCompactLog({
+      threadId,
+      level,
+      effectiveLevel,
+      flushSkipped: skipFlush,
+      tokensBefore: result.tokensBefore,
+      tokensAfter: result.tokensAfter ?? null,
+      ...timing,
+      status: "ok",
+      error: null,
+    });
 
     return { ...result, timing };
   } catch (err) {
-    console.error(`[memory] flush+compact failed for ${threadId}:`, (err as Error).message);
-    // Mark pending so we retry on next turn
+    const errMsg = (err as Error).message;
+    console.error(`[memory] flush+compact failed for ${threadId}:`, errMsg);
+    appendCompactLog({
+      threadId,
+      level,
+      effectiveLevel,
+      flushSkipped: skipFlush,
+      tokensBefore: null,
+      tokensAfter: null,
+      flushMs,    // accurate: 0 if skipped or failed before flush completed
+      compactMs,  // accurate: 0 if failed before/during compact
+      totalMs: Date.now() - t0,
+      model: flushModel ?? "default",
+      status: "failed",
+      error: errMsg.slice(0, 500),
+    });
+    // Mark pending so we retry on next turn. Reuse the state we already loaded.
     try {
-      const state = await loadThreadMemoryState(threadId);
-      state.pendingCompact = effectiveLevel;
-      await saveThreadMemoryState(threadId, state);
+      stateBeforeCompact.pendingCompact = effectiveLevel;
+      await saveThreadMemoryState(threadId, stateBeforeCompact);
     } catch {}
     return null;
   }

package/src/memory/policy.ts

@@ -10,12 +10,26 @@ import { formatDate } from "./files";
 // ── Defaults ─────────────────────────────────────────
 
 const DEFAULT_SOFT_PERCENT = 0.45;
-const DEFAULT_SOFT_TOKENS = 180_000;
+const DEFAULT_SOFT_TOKENS = 130_000;
 const DEFAULT_HARD_PERCENT = 0.50;
-const DEFAULT_HARD_TOKENS = 200_000;
+const DEFAULT_HARD_TOKENS = 150_000;
 const DEFAULT_EMERGENCY_THRESHOLD = 32_768;
 const DEFAULT_COOLDOWN_MS = 10 * 60_000; // 10 minutes
 
+// Headroom reserved for the summarization payload itself when compact runs.
+// The summarizer prompt serializes ALL discarded history (everything older
+// than ~20k of recent tokens) plus scaffolding plus previous summary, then
+// asks the model to summarize. If the prompt itself overflows the model
+// context, compact() throws. 50k is the empirical headroom that fits a
+// typical summarization prompt on Claude family.
+const COMPACT_HEADROOM_TOKENS = 50_000;
+
+// Why 130k/150k as the default absolute thresholds against a 200k window:
+// see COMPACT_HEADROOM_TOKENS above and
+// ~/.roundhouse/workspace/compaction-loop-diagnosis.md (Bug B).
+// For smaller-window models, classifyContextPressure() clamps the absolute
+// thresholds to `window - HEADROOM` so they never exceed the window.
+
 // ── Injection policy ─────────────────────────────────
 
 export interface InjectionDecision {
@@ -87,14 +101,21 @@ export function classifyContextPressure(
 
   const pctDecimal = percent != null ? percent / 100 : tokens / window;
 
+  // Clamp absolute thresholds so they never exceed `window - HEADROOM`.
+  // Defends against future smaller-window models where the configured
+  // 150k/130k absolute thresholds would otherwise sit above the window.
+  // The percent thresholds already scale with window naturally.
+  const headroom = COMPACT_HEADROOM_TOKENS;
+  const ceiling = Math.max(0, window - headroom);
+
   // Hard threshold
   const hardPct = config?.hardPercent ?? DEFAULT_HARD_PERCENT;
-  const hardTok = config?.hardTokens ?? DEFAULT_HARD_TOKENS;
+  const hardTok = Math.min(config?.hardTokens ?? DEFAULT_HARD_TOKENS, ceiling);
   if (pctDecimal >= hardPct || tokens >= hardTok) return "hard";
 
-  // Soft threshold
+  // Soft threshold (clamped one step below hard so soft fires first).
   const softPct = config?.softPercent ?? DEFAULT_SOFT_PERCENT;
-  const softTok = config?.softTokens ?? DEFAULT_SOFT_TOKENS;
+  const softTok = Math.min(config?.softTokens ?? DEFAULT_SOFT_TOKENS, Math.max(0, hardTok - 1));
   if (pctDecimal >= softPct || tokens >= softTok) return "soft";
 
   return "none";