@pellux/goodvibes-tui 0.26.0 → 0.28.0

package/src/runtime/process-lifecycle.ts

@@ -0,0 +1,195 @@
+/**
+ * Process-lifecycle wiring for the TUI shell.
+ *
+ * Extracted from main() to keep the entrypoint under the architecture line-count
+ * gate. `installProcessLifecycle` builds the terminal-restoring crash/termination
+ * handlers and the graceful `exitApp` teardown, then returns them so main() can
+ * register them on the exact same process/stdin/stdout listeners it used before.
+ *
+ * Behavior is identical to the previous inline version: the synchronous terminal
+ * restore runs BEFORE the (possibly slow) async shutdown, the shutdown races a 3s
+ * hard timeout, the recovery file is deleted only when the durable save completed,
+ * signal exit codes are preserved (SIGHUP -> 129, otherwise 143; uncaught -> 1;
+ * exitApp -> 0), and the `exiting`/`terminalRestored` reentrancy guards are kept.
+ *
+ * Some captured values are late-bound or mutable in main(): the InputHandler, the
+ * render closure, and the terminal output guard are constructed AFTER this factory
+ * runs (injected as thunks), while `recoveryInterval` and `stopSpokenOutputForExit`
+ * are assigned later and read at exit time (injected as getters/setter). The
+ * `unsubs` registry is shared by reference and drained on exit.
+ */
+import { logger, summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
+import { formatUserFacingErrorLine } from '../core/format-user-error.ts';
+import { allowTerminalWrite } from './terminal-output-guard.ts';
+import { buildPersistedSessionContext, deleteRecoveryFile } from '@/runtime/index.ts';
+import type { BootstrapContext } from './bootstrap.ts';
+import type { InputHandler } from '../input/handler.ts';
+import type { ConversationMessageSnapshot } from '../core/conversation.ts';
+
+/** ANSI escape sequences used by the synchronous terminal restore. */
+export interface ProcessLifecycleAnsi {
+  readonly CLEAR_SCREEN: string;
+  readonly ALT_SCREEN_EXIT: string;
+  readonly PASTE_DISABLE: string;
+  readonly KEYBOARD_EXT_DISABLE: string;
+  readonly MOUSE_DISABLE: string;
+  readonly CURSOR_SHOW: string;
+}
+
+export interface ProcessLifecycleDeps {
+  readonly stdin: NodeJS.ReadStream;
+  readonly stdout: NodeJS.WriteStream;
+  readonly ctx: BootstrapContext;
+  /** Mirrors cli.flags.noAltScreen: whether the alt screen is exited on restore. */
+  readonly noAltScreen: boolean;
+  readonly ansi: ProcessLifecycleAnsi;
+  /** Late-bound: the InputHandler is constructed after this factory runs. */
+  readonly getInput: () => InputHandler;
+  /** Late-bound: the render closure is defined after this factory runs. */
+  readonly render: () => void;
+  /** Late-bound: the terminal output guard is installed after this factory runs. */
+  readonly getTerminalOutputGuard: () => { readonly dispose: () => void };
+  readonly getPromptContentWidth: () => number;
+  readonly buildSessionContinuityHints: () => Parameters<typeof buildPersistedSessionContext>[2];
+  /** Teardown registry shared with main(); drained on exit. */
+  readonly unsubs: ReadonlyArray<() => void>;
+  readonly getRecoveryInterval: () => ReturnType<typeof setInterval> | null;
+  readonly setRecoveryInterval: (value: ReturnType<typeof setInterval> | null) => void;
+  readonly getStopSpokenOutputForExit: () => (() => void) | null;
+}
+
+export interface ProcessLifecycleHandlers {
+  readonly exitApp: () => Promise<void>;
+  readonly restoreTerminal: () => void;
+  readonly resizeHandler: () => void;
+  readonly sigintHandler: () => void;
+  readonly unhandledRejectionHandler: (reason: unknown) => void;
+  readonly uncaughtExceptionHandler: (err: Error) => void;
+  readonly terminationSignalHandler: (signal: NodeJS.Signals) => void;
+  readonly exitListener: () => void;
+}
+
+export function installProcessLifecycle(deps: ProcessLifecycleDeps): ProcessLifecycleHandlers {
+  const {
+    stdin,
+    stdout,
+    ctx,
+    noAltScreen,
+    ansi,
+    getInput,
+    render,
+    getTerminalOutputGuard,
+    getPromptContentWidth,
+    buildSessionContinuityHints,
+    unsubs,
+    getRecoveryInterval,
+    setRecoveryInterval,
+    getStopSpokenOutputForExit,
+  } = deps;
+
+  const sigintHandler = (): void => getInput().feed('\x03');
+  let _unhandledRejectionCount = 0;
+  let _unhandledRejectionWindowStart = Date.now();
+  const unhandledRejectionHandler = (reason: unknown): void => {
+    const now = Date.now();
+    if (now - _unhandledRejectionWindowStart > 10000) {
+      _unhandledRejectionCount = 0;
+      _unhandledRejectionWindowStart = now;
+    }
+    _unhandledRejectionCount++;
+    const msg = summarizeError(reason);
+    if (_unhandledRejectionCount > 3) {
+      logger.error('CRITICAL: cascading unhandled rejections — consider restarting', {
+        count: _unhandledRejectionCount,
+        windowMs: now - _unhandledRejectionWindowStart,
+        error: String(reason),
+      });
+      ctx.systemMessageRouter.high(
+        `[Critical] Multiple errors detected (${_unhandledRejectionCount} in 10s). If the issue persists, please restart. Latest: ${msg}`
+      );
+    } else {
+      const formatted = formatUserFacingErrorLine(reason);
+      ctx.systemMessageRouter.high(`[Error] ${formatted}`);
+      logger.error('unhandledRejection', { error: String(reason) });
+    }
+    render();
+  };
+  const resizeHandler = (): void => {
+    getInput().setContentWidth(getPromptContentWidth());
+    ctx.compositor.resetDiff();
+    render();
+  };
+
+  let terminalRestored = false;
+  // Idempotent, synchronous-only terminal restore. Safe to call from process.on('exit'),
+  // signal handlers, uncaughtException, and exitApp. Disposes the output guard FIRST so a
+  // crash stack reaches the real stderr instead of being suppressed by the guard.
+  const restoreTerminal = (): void => {
+    if (terminalRestored) return;
+    terminalRestored = true;
+    const exitScreen = noAltScreen ? ansi.CLEAR_SCREEN : ansi.CLEAR_SCREEN + ansi.ALT_SCREEN_EXIT;
+    allowTerminalWrite(() => stdout.write(ansi.PASTE_DISABLE + ansi.KEYBOARD_EXT_DISABLE + ansi.MOUSE_DISABLE + ansi.CURSOR_SHOW + exitScreen));
+    getTerminalOutputGuard().dispose();
+    try { stdin.setRawMode(false); } catch { /* stdin may not be a TTY */ }
+  };
+
+  const uncaughtExceptionHandler = (err: Error): void => {
+    restoreTerminal();
+    logger.error('uncaughtException — terminal restored, exiting', { error: summarizeError(err) });
+    process.exit(1);
+  };
+  const terminationSignalHandler = (signal: NodeJS.Signals): void => {
+    restoreTerminal();
+    logger.error(`Received ${signal} — terminal restored, exiting`, {});
+    process.exit(signal === 'SIGHUP' ? 129 : 143);
+  };
+  const exitListener = (): void => { restoreTerminal(); };
+
+  let exiting = false;
+  const exitApp = async (): Promise<void> => {
+    // Reentrancy guard: a second /exit or keypress during the awaited shutdown below
+    // must not re-run teardown or double-fire ctx.shutdown.
+    if (exiting) return;
+    exiting = true;
+    getStopSpokenOutputForExit()?.();
+    unsubs.forEach(fn => fn());
+    const interval = getRecoveryInterval();
+    if (interval !== null) { clearInterval(interval); setRecoveryInterval(null); }
+    stdin.removeAllListeners('data');
+    stdout.removeListener('resize', resizeHandler);
+    process.removeListener('SIGINT', sigintHandler);
+    process.removeListener('unhandledRejection', unhandledRejectionHandler);
+    // Restore the terminal synchronously BEFORE the (possibly slow) async shutdown so the
+    // user is not left staring at a frozen alt screen while we drain and persist.
+    restoreTerminal();
+    const snapshot = ctx.conversation.toJSON() as { messages: Array<ConversationMessageSnapshot>; timestamp?: number };
+    let shutdownOk = false;
+    try {
+      // Race the graceful shutdown against a hard timeout — externalServices.stop() can hang
+      // and we must still exit; deferredStartup.drain only budgets 100ms internally.
+      await Promise.race([
+        ctx.shutdown({ ...snapshot, ...buildPersistedSessionContext(snapshot.messages, ctx.conversation.getTitleSource(), buildSessionContinuityHints()) }).then(() => { shutdownOk = true; }),
+        new Promise<void>((resolve) => setTimeout(resolve, 3000)),
+      ]);
+    } catch (err) {
+      logger.debug('ctx.shutdown error during exitApp (non-fatal)', { error: summarizeError(err) });
+    }
+    // Only remove the recovery fallback once the durable shutdown save actually completed,
+    // so an interrupted or timed-out shutdown leaves the snapshot for the next launch.
+    if (shutdownOk) {
+      deleteRecoveryFile({ homeDirectory: ctx.services.homeDirectory });
+    }
+    process.exit(0);
+  };
+
+  return {
+    exitApp,
+    restoreTerminal,
+    resizeHandler,
+    sigintHandler,
+    unhandledRejectionHandler,
+    uncaughtExceptionHandler,
+    terminationSignalHandler,
+    exitListener,
+  };
+}

package/src/runtime/services.ts

@@ -63,6 +63,7 @@ import { CacheHitTracker } from '@pellux/goodvibes-sdk/platform/providers';
 import { FavoritesStore } from '@pellux/goodvibes-sdk/platform/providers';
 import { BenchmarkStore } from '@pellux/goodvibes-sdk/platform/providers';
 import { ModelLimitsService } from '@pellux/goodvibes-sdk/platform/providers';
+import { inferFallbackContextWindow } from '@pellux/goodvibes-sdk/platform/providers';
 import { KeybindingsManager } from '../input/keybindings.ts';
 import { SessionMemoryStore } from '@pellux/goodvibes-sdk/platform/core';
 import { SessionLineageTracker } from '@pellux/goodvibes-sdk/platform/core';
@@ -123,7 +124,9 @@ function buildFallbackModelDefinition(provider: string, modelId: string): ModelD
       reasoning: isReasoningProvider,
       multimodal: isReasoningProvider,
     },
-    contextWindow: isReasoningProvider ? 128_000 : 32_000,
+    // Pre-catalog fallback uses the SDK's family-aware inference (SDK 0.35.0+),
+    // matching the post-catalog window so the meter/compaction denominator agrees.
+    contextWindow: inferFallbackContextWindow(provider, modelId),
     contextWindowProvenance: 'fallback',
     selectable: true,
     tier: 'standard',

package/src/runtime/ui/model-picker/health-enrichment.ts

@@ -154,6 +154,9 @@ export function enrichModelEntries(
     // Determine source: custom/local providers carry provenance on ModelDefinition;
     // for catalog models, if getContextWindowForModel returned more than the
     // static contextWindow it came from OpenRouter, else it's the registry value.
+    // NOTE: This is a best-effort heuristic. When the OpenRouter live value equals
+    // the static registry value the badge shows 'registry' even though OpenRouter
+    // was consulted. The contextWindow value itself is always accurate.
     let contextWindowSource: ModelPickerEntry['contextWindowSource'];
     if (model.contextWindowProvenance) {
       contextWindowSource = model.contextWindowProvenance;

package/src/runtime/ui/model-picker/types.ts

@@ -97,6 +97,10 @@ export interface ModelPickerEntry {
    * - `fallback`       — default constant (no config or API source)
    * - `openrouter`     — sourced from OpenRouter model data (built-in catalog models)
    * - `registry`       — static value in the built-in model registry
+   *
+   * For built-in catalog models this badge is best-effort: when the OpenRouter
+   * resolved value equals the static registry value the source shows 'registry'
+   * even if OpenRouter was consulted at runtime.
    */
   readonly contextWindowSource:
     | 'provider_api'

package/src/runtime/wrfc-persistence.ts

@@ -10,10 +10,11 @@
  *
  * 2. `WrfcPersistence.rehydrate(router)` is called once on boot (after the
  *    SystemMessageRouter is available). It reads the snapshot, identifies
- *    chains that were in a non-terminal state at last write, and emits a
- *    high-priority 'wrfc' system message per interrupted chain. The
- *    `interruptedChains` accessor makes the data available for panel reads
- *    without coupling this module to wrfc-panel.ts.
+ *    chains that were in a non-terminal state at last write, emits a
+ *    high-priority 'wrfc' system message per interrupted chain, and re-imports
+ *    each interrupted chain into the WrfcController so it reappears as a panel
+ *    row and can be resumed by the operator. The `interruptedChains` accessor
+ *    additionally exposes the recovered set for inspection.
  *
  * 3. Snapshot lifecycle:
  *    - Terminal chains ('passed' | 'failed') are pruned from the snapshot
@@ -57,6 +58,14 @@ interface WrfcSnapshot {
 /** Subset of WrfcController needed by this module. */
 export interface WrfcControllerReader {
   listChains(): WrfcChain[];
+  /**
+   * Re-import a chain recovered from a previous process so it reappears in the
+   * controller's in-memory map and becomes selectable/resumable from the panel.
+   * Optional so read-only test doubles can omit it; the real WrfcController
+   * provides it. `force` is left at its default — on a fresh start the map is
+   * empty so importing never clobbers a live chain.
+   */
+  importChain?(chain: WrfcChain, force?: boolean): boolean;
 }
 
 export interface WrfcPersistenceOptions {
@@ -64,7 +73,7 @@ export interface WrfcPersistenceOptions {
   readonly snapshotPath: string;
   /** Factory for the current SystemMessageRouter — may return null before it is wired. */
   readonly getSystemMessageRouter: () => SystemMessageRouter | null;
-  /** WrfcController reader — only listChains() is needed. */
+  /** WrfcController access — listChains() (read) plus optional importChain() (re-import on rehydrate). */
   readonly controller: WrfcControllerReader;
 }
 
@@ -140,6 +149,12 @@ class WrfcPersistenceImpl implements WrfcPersistence {
 
     const router = this.getSystemMessageRouter();
     for (const chain of interrupted) {
+      // Re-import so the chain reappears in the controller's in-memory map and
+      // becomes selectable/resumable from the panel. On a fresh process start
+      // the map is empty, so importChain (force=false) never clobbers a live
+      // chain. The accessor is optional for read-only test doubles.
+      this.controller.importChain?.(chain);
+
       const msg =
         `[WRFC] Chain ${chain.id.slice(0, 12)} (${chain.task.slice(0, 60).trim()}) ` +
         `was interrupted by a restart — state was '${chain.state}' ` +

package/src/shell/ui-openers.ts

@@ -13,6 +13,7 @@ import type { SecretsManager } from '@pellux/goodvibes-sdk/platform/config';
 import type { ServiceInspectionQuery } from '../runtime/ui-service-queries.ts';
 import type { ModelPickerTargetInfo } from '../input/model-picker.ts';
 import { syncServiceSettingToPlatform } from './service-settings-sync.ts';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
 
 type WireShellUiOpenersOptions = {
   commandContext: CommandContext;
@@ -203,7 +204,7 @@ export function wireShellUiOpeners(options: WireShellUiOpenersOptions): void {
       input.modelPicker.openAllModels(models, getCurrentModelForPickerTarget());
       render();
     })().catch((error: unknown) => {
-      commandContext.print?.(`Model picker failed to open: ${error instanceof Error ? error.message : String(error)}`);
+      commandContext.print?.(`Model picker failed to open: ${summarizeError(error)}`);
       render();
     });
   };
@@ -223,7 +224,7 @@ export function wireShellUiOpeners(options: WireShellUiOpenersOptions): void {
       input.modelPicker.openProviders(providers, getCurrentProviderForPickerTarget());
       render();
     })().catch((error: unknown) => {
-      commandContext.print?.(`Provider picker failed to open: ${error instanceof Error ? error.message : String(error)}`);
+      commandContext.print?.(`Provider picker failed to open: ${summarizeError(error)}`);
       render();
     });
   };

package/src/utils/format-duration.ts

@@ -0,0 +1,55 @@
+/**
+ * Shared ms-duration formatters for the panel layer.
+ *
+ * Three families are exported, each matching a distinct behavior cluster.
+ * DO NOT replace these with formatElapsed from utils/format-elapsed.ts —
+ * formatElapsed floors to integer seconds and lacks the null/'?ms' guards
+ * that the latency panels require.
+ */
+
+/**
+ * Format a latency value in milliseconds with sub-second precision.
+ *
+ * Used by: debug-panel, provider-health-panel, provider-stats-panel
+ *
+ *   ms <= 0     → 'n/a'
+ *   ms >= 10000 → '12.3s'    (one decimal)
+ *   ms >= 1000  → '1.23s'   (two decimals)
+ *   else        → '500ms'   (integer ms)
+ */
+export function formatLatencyMs(ms: number): string {
+  if (ms <= 0)      return 'n/a';
+  if (ms >= 10_000) return `${(ms / 1000).toFixed(1)}s`;
+  if (ms >= 1_000)  return `${(ms / 1000).toFixed(2)}s`;
+  return `${Math.round(ms)}ms`;
+}
+
+/**
+ * Format a task/agent duration with minute-rolling notation.
+ *
+ * Used by: tool-inspector-panel, agent-inspector-shared
+ *
+ *   ms < 1000   → '500ms'
+ *   ms < 60000  → '3.5s'
+ *   else        → '1m30s'
+ */
+export function formatDuration(ms: number): string {
+  if (ms < 1000)  return `${ms}ms`;
+  if (ms < 60000) return `${(ms / 1000).toFixed(1)}s`;
+  return `${Math.floor(ms / 60000)}m${Math.floor((ms % 60000) / 1000)}s`;
+}
+
+/**
+ * Format a short eval/forensics duration; treats undefined as '?ms'.
+ *
+ * Used by: forensics-panel, eval-panel
+ *
+ *   undefined → '?ms'
+ *   ms < 1000 → '500ms'
+ *   else      → '1.5s'
+ */
+export function formatShortDuration(ms: number | undefined): string {
+  if (ms === undefined) return '?ms';
+  if (ms < 1000)        return `${ms}ms`;
+  return `${(ms / 1000).toFixed(1)}s`;
+}

package/src/utils/format-number.ts

@@ -0,0 +1,71 @@
+/**
+ * Parametrised number abbreviation helper.
+ *
+ * Each call site can reproduce its exact current output by passing the
+ * appropriate options rather than a single "agreed" format being imposed.
+ *
+ * Ranges (default opts: guard=1_000, decimals=1, rounding='fixed'):
+ *   n <  guard          → String(n)            e.g. 999  → '999'
+ *   n <  1_000_000      → X.Xk                 e.g. 1500 → '1.5k'
+ *   n <  1_000_000_000  → X.XM                 e.g. 1.5M → '1.5M'
+ *   (with bSuffix)      → X.XB / X.XT
+ *   (with noM)          → always k, never M
+ */
+
+export interface AbbreviateCountOpts {
+  /**
+   * Values strictly below this are returned as-is via String(n).
+   * Default: 1_000
+   */
+  guard?: number;
+  /**
+   * Decimal places used for the k suffix (and for M when mDecimals is not set).
+   * Default: 1
+   */
+  decimals?: number;
+  /**
+   * Override decimal places for the M suffix only.
+   * Default: same as decimals.
+   */
+  mDecimals?: number;
+  /**
+   * 'fixed'  → value.toFixed(decimals)  (default)
+   * 'round'  → String(Math.round(value)) — always integer, decimals ignored
+   */
+  rounding?: 'fixed' | 'round';
+  /**
+   * When true, extend formatting to B (billions) and T (trillions).
+   * Default: false
+   */
+  bSuffix?: boolean;
+  /**
+   * When true, never produce M/B/T — format as k even for millions.
+   * Default: false
+   */
+  noM?: boolean;
+}
+
+/**
+ * Format a non-negative integer with k/M/B/T magnitude suffix.
+ *
+ * Preserves each call site's exact current format by accepting
+ * per-site option overrides (guard, decimals, rounding, etc.).
+ */
+export function abbreviateCount(n: number, opts?: AbbreviateCountOpts): string {
+  const guard     = opts?.guard     ?? 1_000;
+  const decimals  = opts?.decimals  ?? 1;
+  const mDecimals = opts?.mDecimals ?? decimals;
+  const rounding  = opts?.rounding  ?? 'fixed';
+  const noM       = opts?.noM       ?? false;
+  const bSuffix   = opts?.bSuffix   ?? false;
+
+  /** Render a scaled value according to the configured rounding mode. */
+  const fmt = (val: number, d: number): string =>
+    rounding === 'round' ? String(Math.round(val)) : val.toFixed(d);
+
+  if (n < guard)                      return String(n);
+  if (noM || n < 1_000_000)           return fmt(n / 1_000, decimals)          + 'k';
+  if (!bSuffix || n < 1_000_000_000)  return fmt(n / 1_000_000, mDecimals)     + 'M';
+  if (n < 1_000_000_000_000)          return fmt(n / 1_000_000_000, decimals)  + 'B';
+  return                                     fmt(n / 1_000_000_000_000, decimals) + 'T';
+}

package/src/verification/live-verifier.ts

@@ -3,6 +3,7 @@ import { join, resolve } from 'node:path';
 import { spawn } from 'node:child_process';
 import { auditGoodVibesHome } from '../config/goodvibes-home-audit.ts';
 import { buildVerificationLedger } from './verification-ledger.ts';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
 
 export type LiveVerificationStatus = 'pass' | 'warn' | 'fail' | 'skip';
 
@@ -111,7 +112,7 @@ function runCommand(command: string, args: string[], cwd: string, timeoutMs = 15
       resolveCommand({
         exitCode: -1,
         stdout: '',
-        stderr: error instanceof Error ? error.message : String(error),
+        stderr: summarizeError(error),
         timedOut,
       });
     });
@@ -161,7 +162,7 @@ function commandCheck(
         title,
         status: 'fail',
         summary: 'Command succeeded but did not return valid JSON.',
-        detail: error instanceof Error ? error.message : String(error),
+        detail: summarizeError(error),
       };
     }
   }
@@ -208,7 +209,7 @@ async function fetchCheck(
       title,
       status: 'fail',
       summary: 'Request failed.',
-      detail: error instanceof Error ? error.message : String(error),
+      detail: summarizeError(error),
     };
   }
 }

package/src/version.ts

@@ -6,7 +6,7 @@ import { join } from 'node:path';
 // The prebuild script updates the fallback value before compilation.
 // Uses import.meta.dir (Bun) to locate package.json relative to this file,
 // which is correct regardless of the process working directory.
-let _version = '0.26.0';
+let _version = '0.28.0';
 try {
   const pkg = JSON.parse(readFileSync(join(import.meta.dir, '..', 'package.json'), 'utf-8'));
   _version = pkg.version ?? _version;

package/src/core/context-auto-compact.ts

@@ -1,110 +0,0 @@
-/**
- * Auto-compaction helper — TASK-058.
- *
- * Evaluates whether auto-compact should run after a turn completes and, if so,
- * triggers compaction and posts an honest transcript notice.
- *
- * behavior.autoCompactThreshold: SDK schema range [10, 100], default 80.
- * Auto-compact is active whenever the threshold is in its valid range (>0).
- * The display/suggestion path (hint + meter) is always active regardless.
- */
-
-import type { ConfigManager } from '@pellux/goodvibes-sdk/platform/config';
-import type { ConversationManager } from './conversation';
-import type { ProviderRegistry } from '@pellux/goodvibes-sdk/platform/providers';
-import type { SystemMessageRouter } from './system-message-router';
-import { logger } from '@pellux/goodvibes-sdk/platform/utils';
-import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
-import { getLastCompactionEvent } from '@pellux/goodvibes-sdk/platform/core';
-import type { CompactionContext } from '@pellux/goodvibes-sdk/platform/core';
-import { buildCompactionPreview, buildCompactionAfterNotice } from '../renderer/compaction-preview.ts';
-
-export interface AutoCompactDeps {
-  readonly configManager: Pick<ConfigManager, 'get'>;
-  readonly conversation: ConversationManager;
-  readonly providerRegistry: ProviderRegistry;
-  readonly systemMessageRouter: SystemMessageRouter;
-  readonly model: string;
-  readonly provider: string;
-  readonly lastInputTokens: number;
-  readonly contextWindow: number;
-}
-
-/**
- * Run after each TURN_COMPLETED event.
- *
- * Reads behavior.autoCompactThreshold from config (SDK default: 80, range [10, 100]).
- * When usage is at or above the threshold, compacts the conversation and posts
- * an honest transcript notice so the user understands any summary discontinuity.
- *
- * This function is intentionally non-throwing; failures are logged and
- * surfaced via the system message router.
- */
-export async function maybeAutoCompact(deps: AutoCompactDeps): Promise<void> {
-  // SDK schema default is 80; valid range is [10, 100]. The ?? 0 fallback is a
-  // defensive guard for missing/null values only — not a normal operating state.
-  const rawThreshold = Number(deps.configManager.get('behavior.autoCompactThreshold') ?? 0);
-  const thresholdPct = Number.isFinite(rawThreshold) ? rawThreshold : 0;
-
-  // Defensive guard: skip only when threshold is missing/non-positive (real config defaults to 80).
-  if (thresholdPct <= 0 || deps.contextWindow <= 0) return;
-
-  const usagePct = Math.min(100, Math.round((Math.max(0, deps.lastInputTokens) / deps.contextWindow) * 100));
-  if (usagePct < thresholdPct) return;
-
-  try {
-    logger.debug('auto-compact triggered', { usagePct, thresholdPct });
-    // Pre-compact preview — uses buildCompactionPreview for an honest estimate.
-    const messages = deps.conversation.getMessagesForLLM();
-    const sessionMemoryStore = deps.conversation.getSessionMemoryStore();
-    const sessionMemories = sessionMemoryStore?.list() ?? [];
-    const pinnedMemoryCount = sessionMemories.length;
-    const preview = buildCompactionPreview({
-      messages,
-      contextWindow: deps.contextWindow,
-      pinnedMemoryCount,
-      trigger: 'auto',
-    });
-    deps.systemMessageRouter.routeSystemMessage(preview, 'high');
-    const eventBefore = getLastCompactionEvent();
-    const compactionCtx: CompactionContext = {
-      messages,
-      sessionMemories,
-      agents: [],
-      wrfcChains: [],
-      activePlan: null,
-      lineageEntries: [],
-      compactionCount: 0,
-      contextWindow: deps.contextWindow,
-      trigger: 'auto',
-      extractionModelId: deps.model,
-      extractionProvider: deps.provider,
-    };
-    await deps.conversation.compact(
-      deps.providerRegistry,
-      deps.model,
-      'auto',
-      deps.provider,
-      compactionCtx,
-    );
-    // Post-compact notice using real CompactionEvent figures.
-    const eventAfter = getLastCompactionEvent();
-    if (eventAfter !== null && eventAfter !== eventBefore) {
-      deps.systemMessageRouter.routeSystemMessage(
-        buildCompactionAfterNotice({ event: eventAfter, pinnedMemoryCount }),
-        'low',
-      );
-    } else {
-      deps.systemMessageRouter.routeSystemMessage(
-        '[Context] Auto-compact complete — older turns summarised. Use /compact to compact again manually.',
-        'low',
-      );
-    }
-  } catch (err) {
-    logger.error('auto-compact failed', { error: summarizeError(err) });
-    deps.systemMessageRouter.routeSystemMessage(
-      `[Context] Auto-compact failed: ${summarizeError(err)}. Use /compact to try manually.`,
-      'high',
-    );
-  }
-}