@inceptionstack/roundhouse 0.5.25 → 0.5.27

package/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 All notable changes to `@inceptionstack/roundhouse` are documented here.
 
+## [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.25",
+  "version": "0.5.27",
   "type": "module",
   "description": "Multi-platform chat gateway that routes messages through a configured AI agent",
   "license": "MIT",

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/gateway/gateway.ts

@@ -439,6 +439,26 @@ export class Gateway {
 
       stopTyping = startTypingLoop(thread);
 
+      // Pre-turn recovery: if a prior turn failed to compact (state has
+      // pendingCompact === "emergency"), the live session is almost certainly
+      // still over the model's context limit, so calling agent.prompt() now
+      // will throw with "prompt is too long" before our post-turn pressure
+      // handler ever runs — perpetuating the loop. Run the pressure handler
+      // BEFORE the agent call to recover. Best-effort: if it fails, fall
+      // through to the normal turn (which will then post the error and let
+      // the user see something is wrong).
+      if (memoryPrepared?.pendingCompact === "emergency") {
+        console.log(`[roundhouse] pre-turn recovery: pendingCompact=emergency, compacting before agent.prompt for thread=${agentThreadId}`);
+        try {
+          await this.handleContextPressure(thread, agentThreadId, agent, memoryRoot, "emergency");
+          // Clear the pending flag in our prepared snapshot so the post-turn
+          // pressure logic doesn't double-up on a redundant emergency pass.
+          memoryPrepared.pendingCompact = undefined;
+        } catch (err) {
+          console.error(`[roundhouse] pre-turn emergency compact failed:`, (err as Error).message);
+        }
+      }
+
       let deferredSoftFlush: { thread: any; agentThreadId: string; agent: AgentAdapter; memoryRoot: string } | undefined;
       try {
         let turnUsedTools = false;

package/src/memory/lifecycle.ts

@@ -239,7 +239,15 @@ export async function flushMemoryThenCompact(
   // NOT require the live session to fit under the limit — so skipping flush
   // lets us recover. Facts-to-MEMORY.md (the whole point of flush) is a
   // best-effort nicety that the next soft/hard flush can catch up on.
-  const skipFlush = effectiveLevel === "emergency";
+  //
+  // We also skip flush when state already has pendingCompact === "emergency":
+  // a prior turn detected emergency pressure and could not complete (e.g. the
+  // current call was triggered by /compact while stuck). Even at "hard" or
+  // "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 skipFlush = effectiveLevel === "emergency" || stuckInEmergency;
 
   try {
     let flushMs = 0;
@@ -255,10 +263,12 @@ export async function flushMemoryThenCompact(
     }
 
     // Step 2: compact (use flush model if compactWithModel is available)
-    const flushNote = skipFlush ? "flush skipped (emergency)" : `flush took ${flushMs}ms`;
+    const flushNote = skipFlush
+      ? (effectiveLevel === "emergency" ? "flush skipped (emergency)" : "flush skipped (recovery from prior emergency)")
+      : `flush took ${flushMs}ms`;
     console.log(`[memory] compacting ${threadId} (${flushNote})`);
     const progressNote = skipFlush
-      ? "✂️ Compacting context... (emergency — skipping flush)"
+      ? `✂️ Compacting context... (${effectiveLevel === "emergency" ? "emergency — " : "recovery — "}skipping flush)`
       : `✂️ Compacting context... (flush took ${(flushMs / 1000).toFixed(1)}s)`;
     await onProgress?.(progressNote);
     const t1 = Date.now();