@pellux/goodvibes-tui 0.21.0 → 0.22.0

package/src/panels/memory-panel.ts

@@ -1,18 +1,26 @@
 /**
- * MemoryPanel — project memory substrate TUI panel.
+ * MemoryPanel — merged project memory substrate panel.
  *
- * Migrated to SearchableListPanel<MemoryRecord> (Wave B1).
+ * TASK-040: Merged from the former separate MemoryPanel + KnowledgePanel.
+ * One panel, two filter modes toggled with Tab:
+ *   - 'all'    : full record list with search (former MemoryPanel behaviour)
+ *   - 'review' : review-queue view with r/s/c/f actions (former KnowledgePanel behaviour)
+ *
+ * Panel id stays 'memory'; the 'knowledge' id is repointed to the graph view.
+ * No capability removed from either previous surface.
  */
 
 import type { Line } from '../types/grid.ts';
 import type { MemoryRegistry } from '@pellux/goodvibes-sdk/platform/state';
-import type { MemoryRecord, MemoryClass } from '@pellux/goodvibes-sdk/platform/state';
-import { SearchableListPanel } from './scrollable-list-panel.ts';
+import type { MemoryClass, MemoryRecord, MemoryReviewState } from '@pellux/goodvibes-sdk/platform/state';
+import { ScrollableListPanel, SearchableListPanel } from './scrollable-list-panel.ts';
+import { type ConfirmState, handleConfirmInput, renderConfirmLines } from './confirm-state.ts';
 import {
   buildBodyText,
   buildGuidanceLine,
   buildKeyValueLine,
   buildPanelLine,
+  buildPanelWorkspace,
   extendPalette,
   DEFAULT_PANEL_PALETTE,
 } from './polish.ts';
@@ -21,6 +29,10 @@ import {
   isPanelSearchCancel,
 } from './search-focus.ts';
 
+// ---------------------------------------------------------------------------
+// Colour palette
+// ---------------------------------------------------------------------------
+
 const C = extendPalette(DEFAULT_PANEL_PALETTE, {
   header: '#94a3b8',
   headerBg: '#1e293b',
@@ -38,6 +50,21 @@ const C = extendPalette(DEFAULT_PANEL_PALETTE, {
   searchFg: '#e2e8f0',
 });
 
+// ---------------------------------------------------------------------------
+// Filter modes
+// ---------------------------------------------------------------------------
+
+type FilterMode = 'all' | 'review';
+
+const FILTER_LABELS: Record<FilterMode, string> = {
+  all:    'All Records',
+  review: 'Review Queue',
+};
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
 function fmtTime(ts: number): string {
   const d = new Date(ts);
   return d.toISOString().slice(0, 16).replace('T', ' ');
@@ -45,50 +72,82 @@ function fmtTime(ts: number): string {
 
 function classColor(cls: MemoryClass): string {
   switch (cls) {
-    case 'decision': return C.decision;
-    case 'constraint': return C.constraint;
-    case 'incident': return C.incident;
-    case 'pattern': return C.pattern;
-    case 'fact': return C.fact;
-    case 'risk': return C.risk;
-    case 'runbook': return C.runbook;
+    case 'decision':     return C.decision;
+    case 'constraint':   return C.constraint;
+    case 'incident':     return C.incident;
+    case 'pattern':      return C.pattern;
+    case 'fact':         return C.fact;
+    case 'risk':         return C.risk;
+    case 'runbook':      return C.runbook;
     case 'architecture': return C.architecture;
-    case 'ownership': return C.ownership;
+    case 'ownership':    return C.ownership;
   }
 }
 
+function reviewStateColor(state: MemoryReviewState): string {
+  switch (state) {
+    case 'reviewed':     return C.good;
+    case 'stale':        return C.warn;
+    case 'contradicted': return C.bad;
+    case 'fresh':
+    default:             return C.info;
+  }
+}
+
+function formatConfidence(confidence: number): string {
+  return `${confidence.toString().padStart(3, ' ')}%`;
+}
+
+// ---------------------------------------------------------------------------
+// MemoryPanel
+// ---------------------------------------------------------------------------
+
 export class MemoryPanel extends SearchableListPanel<MemoryRecord> {
-  private registry: MemoryRegistry;
+  private readonly registry: MemoryRegistry;
+  private filterMode: FilterMode = 'all';
   private filterFocused = false;
   private unsubscribe?: () => void;
 
+  // Review-mode confirm state (for destructive stale/contradict actions)
+  private confirm: ConfirmState<{ id: string; action: 'stale' | 'contradicted' }> | null = null;
+
+  // Cached records for review-mode (reviewQueue-first, same as former KnowledgePanel)
+  private reviewRecords: MemoryRecord[] = [];
+
   constructor(registry: MemoryRegistry) {
     super('memory', 'Memory', 'M', 'agent');
     this.registry = registry;
   }
 
-  onActivate(): void {
+  // ---------------------------------------------------------------------------
+  // Lifecycle
+  // ---------------------------------------------------------------------------
+
+  override onActivate(): void {
     super.onActivate();
     this.searchQuery = '';
     this.invalidateFilter();
     this.filterFocused = false;
+    this.confirm = null;
+    this.refreshReviewRecords();
     this.unsubscribe = this.registry.subscribe(() => {
       this.invalidateFilter();
+      this.refreshReviewRecords();
       this.markDirty();
     });
   }
 
-  onDeactivate(): void {
+  override onDeactivate(): void {
     super.onDeactivate();
   }
 
-  onDestroy(): void {
+  override onDestroy(): void {
     this.unsubscribe?.();
     this.unsubscribe = undefined;
   }
 
   // ---------------------------------------------------------------------------
-  // SearchableListPanel implementation
+  // SearchableListPanel implementation (used in 'all' filter mode)
   // ---------------------------------------------------------------------------
 
   protected getAllItems(): readonly MemoryRecord[] {
@@ -109,6 +168,17 @@ export class MemoryPanel extends SearchableListPanel<MemoryRecord> {
   }
 
   protected renderItem(record: MemoryRecord, index: number, selected: boolean, width: number): Line {
+    if (this.filterMode === 'review') {
+      // Review-mode row: reviewState + confidence (matches former KnowledgePanel row)
+      const bg = selected ? C.selectBg : undefined;
+      return buildPanelLine(width, [
+        ['  ', C.label, bg],
+        [record.reviewState.padEnd(13), reviewStateColor(record.reviewState), bg],
+        [` ${formatConfidence(record.confidence)} `, C.value, bg],
+        [record.summary.slice(0, Math.max(0, width - 26)), C.value, bg],
+      ]);
+    }
+    // All-mode row: scope/class + id + time + summary (matches former MemoryPanel row)
     const bg = selected ? C.selected : undefined;
     return buildPanelLine(width, [
       ['  ', C.label, bg],
@@ -122,63 +192,222 @@ export class MemoryPanel extends SearchableListPanel<MemoryRecord> {
   }
 
   protected override getPalette() { return C; }
+
   protected override getEmptyStateMessage() {
+    if (this.filterMode === 'review') return 'No records in the review queue.';
     return this.searchQuery
       ? ` No records matching "${this.searchQuery}"`
       : ' No memory records. Use /recall add <class> <summary> to create one.';
   }
+
   protected override getEmptyStateActions() {
     return [
       { command: '/recall add fact <summary>', summary: 'capture a durable fact directly' },
       { command: '/recall capture incident latest', summary: 'promote the latest incident into memory' },
+      { command: '/recall capture policy', summary: 'store the current policy posture as durable evidence' },
     ];
   }
 
+  // ---------------------------------------------------------------------------
+  // Internal helpers
+  // ---------------------------------------------------------------------------
+
+  /**
+   * Override getItems() so that ScrollableListPanel infrastructure (renderList,
+   * clampSelection, navigation bounds) all operate on reviewRecords in review
+   * mode — preventing the render/action index desync where rendered list index N
+   * did not correspond to reviewRecords[N] when the two lists differ.
+   */
+  protected override getItems(): readonly MemoryRecord[] {
+    if (this.filterMode === 'review') return this.reviewRecords;
+    return super.getItems();
+  }
+
+  private refreshReviewRecords(): void {
+    this.reviewRecords = this.registry.reviewQueue(24);
+    this.clampSelection();
+  }
+
+  private cycleFilter(): void {
+    const modes: FilterMode[] = ['all', 'review'];
+    const next = modes[(modes.indexOf(this.filterMode) + 1) % modes.length];
+    this.filterMode = next;
+    this.invalidateFilter();
+    this.refreshReviewRecords();
+    this.markDirty();
+  }
+
+  // ---------------------------------------------------------------------------
+  // Input
+  // ---------------------------------------------------------------------------
+
   handleInput(key: string): boolean {
-    // Filter-focus mode: typing goes into the search query
-    if (this.filterFocused) {
-      const items = this.getItems();
-      const transition = getPanelSearchFocusTransition(key, { selectedIndex: this.selectedIndex, itemCount: items.length });
-      if (transition === 'focus-list') {
-        this.filterFocused = false;
+    // Review confirm dialog intercepts all input
+    if (this.confirm) {
+      const result = handleConfirmInput(this.confirm, key);
+      if (result === 'confirmed') {
+        const { id, action } = this.confirm.subject;
+        this.confirm = null;
+        const record = this.reviewRecords.find((r) => r.id === id);
+        if (record) {
+          try {
+            if (action === 'stale') {
+              this.registry.review(id, {
+                state: 'stale',
+                confidence: Math.min(record.confidence, 40),
+                reviewedBy: 'operator',
+                staleReason: 'marked stale from the memory panel',
+              });
+            } else {
+              this.registry.review(id, {
+                state: 'contradicted',
+                confidence: 0,
+                reviewedBy: 'operator',
+                staleReason: 'marked contradicted from the memory panel',
+              });
+            }
+          } catch (e) {
+            this.setError(`Review update failed: ${e instanceof Error ? e.message : String(e)}`);
+          }
+        }
+        this.refreshReviewRecords();
         this.markDirty();
         return true;
       }
-      if (isPanelSearchCancel(key)) {
-        this.filterFocused = false;
-        return super.handleInput(key);
+      if (result === 'cancelled') {
+        this.confirm = null;
+        this.markDirty();
+        return true;
       }
-      return super.handleInput(key);
+      if (result === 'absorbed') return true;
     }
 
-    const items = this.getItems();
-    const transition = getPanelSearchFocusTransition(key, { selectedIndex: this.selectedIndex, itemCount: items.length });
-    if (transition === 'focus-search') {
-      this.filterFocused = true;
-      this.markDirty();
+    // Tab cycles filter modes
+    if (key === 'tab') {
+      this.cycleFilter();
       return true;
     }
 
-    if (key === 'r') {
-      this.invalidateFilter();
-      this.markDirty();
-      return true;
+    // Review-mode specific actions (r/s/c/f)
+    if (this.filterMode === 'review') {
+      const selected = this.reviewRecords[this.selectedIndex];
+
+      if (key === 'enter' || key === 'return' || key === 'r') {
+        if (!selected) return false;
+        this.registry.review(selected.id, {
+          state: 'reviewed',
+          confidence: Math.max(selected.confidence, 85),
+          reviewedBy: 'operator',
+        });
+        this.refreshReviewRecords();
+        this.markDirty();
+        return true;
+      }
+      if (key === 's') {
+        if (!selected) return false;
+        this.confirm = { subject: { id: selected.id, action: 'stale' }, label: selected.summary.slice(0, 40) };
+        this.markDirty();
+        return true;
+      }
+      if (key === 'c') {
+        if (!selected) return false;
+        this.confirm = { subject: { id: selected.id, action: 'contradicted' }, label: selected.summary.slice(0, 40) };
+        this.markDirty();
+        return true;
+      }
+      if (key === 'f') {
+        if (!selected) return false;
+        this.registry.review(selected.id, {
+          state: 'fresh',
+          confidence: Math.max(selected.confidence, 60),
+          reviewedBy: 'operator',
+        });
+        this.refreshReviewRecords();
+        this.markDirty();
+        return true;
+      }
+    }
+
+    // All-mode: search filter focus
+    if (this.filterMode === 'all') {
+      if (this.filterFocused) {
+        const items = this.getItems();
+        const transition = getPanelSearchFocusTransition(key, { selectedIndex: this.selectedIndex, itemCount: items.length });
+        if (transition === 'focus-list') {
+          this.filterFocused = false;
+          this.markDirty();
+          return true;
+        }
+        if (isPanelSearchCancel(key)) {
+          this.filterFocused = false;
+          return super.handleInput(key);
+        }
+        return super.handleInput(key);
+      }
+
+      const items = this.getItems();
+      const transition = getPanelSearchFocusTransition(key, { selectedIndex: this.selectedIndex, itemCount: items.length });
+      if (transition === 'focus-search') {
+        this.filterFocused = true;
+        this.markDirty();
+        return true;
+      }
+
+      if (key === 'r') {
+        this.invalidateFilter();
+        this.markDirty();
+        return true;
+      }
     }
 
+    // In review mode, navigation keys (j/k/up/down/etc.) must bypass
+    // SearchableListPanel's printable-character interception, which would
+    // otherwise swallow single-char keys like 'j' and 'k' as search input.
+    if (this.filterMode === 'review') {
+      return ScrollableListPanel.prototype.handleInput.call(this, key);
+    }
     return super.handleInput(key);
   }
 
+  // ---------------------------------------------------------------------------
+  // Render
+  // ---------------------------------------------------------------------------
+
   render(width: number, height: number): Line[] {
     this.clampSelection();
-    const intro = 'Durable project memory across decisions, constraints, incidents, patterns, risks, runbooks, and related provenance.';
 
+    // Review confirm dialog takes over the full panel
+    if (this.confirm) {
+      return buildPanelWorkspace(width, height, {
+        title: 'Memory',
+        intro: '',
+        sections: [{ title: 'Confirmation', lines: renderConfirmLines(width, this.confirm) }],
+        footerLines: [buildPanelLine(width, [['  y confirm  n / Esc cancel', C.dim]])],
+        palette: C,
+      });
+    }
+
+    const filterLabel = FILTER_LABELS[this.filterMode];
+    const filterToggleLine = buildPanelLine(width, [
+      ['  Filter: ', C.label],
+      [filterLabel, C.info],
+      ['  (Tab to toggle)', C.dim],
+    ]);
+
+    if (this.filterMode === 'review') {
+      return this.renderReviewMode(width, height, filterToggleLine);
+    }
+    return this.renderAllMode(width, height, filterToggleLine);
+  }
+
+  private renderAllMode(width: number, height: number, filterToggleLine: Line): Line[] {
     const records = this.getItems();
     const byClass = new Map<MemoryClass, number>();
     for (const record of records) {
       byClass.set(record.cls, (byClass.get(record.cls) ?? 0) + 1);
     }
 
-    const filterLine = this.buildFilterInputLine(width, 'Filter', this.filterFocused);
+    const filterInputLine = this.buildFilterInputLine(width, 'Search', this.filterFocused);
 
     const summaryLines: Line[] = [
       buildKeyValueLine(width, [
@@ -188,7 +417,8 @@ export class MemoryPanel extends SearchableListPanel<MemoryRecord> {
         { label: 'incidents', value: String(byClass.get('incident') ?? 0), valueColor: C.incident },
         { label: 'runbooks', value: String(byClass.get('runbook') ?? 0), valueColor: C.runbook },
       ], C),
-      filterLine,
+      filterToggleLine,
+      filterInputLine,
       buildGuidanceLine(width, '/recall review', 'review durable knowledge and queue posture from the command surface', C),
     ];
 
@@ -218,7 +448,107 @@ export class MemoryPanel extends SearchableListPanel<MemoryRecord> {
       header: summaryLines,
       footer: [
         ...selectedLines,
-        buildPanelLine(width, [['  / search  j/k or Up/Down move  r reload  Esc clear search', C.dim]]),
+        buildPanelLine(width, [['  / search  j/k or Up/Down move  r reload  Tab: Review Queue  Esc clear search', C.dim]]),
+      ],
+    });
+  }
+
+  private renderReviewMode(width: number, height: number, filterToggleLine: Line): Line[] {
+    if (this.reviewRecords.length === 0) this.refreshReviewRecords();
+
+    const allRecords = this.registry.search({ limit: 200 });
+    const queue = this.registry.reviewQueue(24);
+    const byClass = new Map<MemoryClass, number>();
+    const byReview = new Map<MemoryReviewState, number>();
+    const byScope = new Map<string, number>();
+    for (const record of allRecords) {
+      byClass.set(record.cls, (byClass.get(record.cls) ?? 0) + 1);
+      byReview.set(record.reviewState, (byReview.get(record.reviewState) ?? 0) + 1);
+      byScope.set(record.scope, (byScope.get(record.scope) ?? 0) + 1);
+    }
+
+    const classLines: Line[] = [
+      buildPanelLine(width, [
+        [' facts ', C.label], [String(byClass.get('fact') ?? 0), C.good],
+        ['  risks ', C.label], [String(byClass.get('risk') ?? 0), (byClass.get('risk') ?? 0) > 0 ? C.warn : C.good],
+        ['  runbooks ', C.label], [String(byClass.get('runbook') ?? 0), C.info],
+        ['  architecture ', C.label], [String(byClass.get('architecture') ?? 0), C.info],
+        ['  incidents ', C.label], [String(byClass.get('incident') ?? 0), (byClass.get('incident') ?? 0) > 0 ? C.bad : C.good],
+      ]),
+      buildPanelLine(width, [
+        [' decisions ', C.label], [String(byClass.get('decision') ?? 0), C.value],
+        ['  constraints ', C.label], [String(byClass.get('constraint') ?? 0), C.value],
+        ['  ownership ', C.label], [String(byClass.get('ownership') ?? 0), C.value],
+        ['  patterns ', C.label], [String(byClass.get('pattern') ?? 0), C.value],
+        ['  total ', C.label], [String(allRecords.length), C.value],
+      ]),
+    ];
+
+    const reviewLines: Line[] = [
+      buildPanelLine(width, [
+        [' reviewed ', C.label], [String(byReview.get('reviewed') ?? 0), C.good],
+        ['  fresh ', C.label], [String(byReview.get('fresh') ?? 0), C.info],
+        ['  stale ', C.label], [String(byReview.get('stale') ?? 0), C.warn],
+        ['  contradicted ', C.label], [String(byReview.get('contradicted') ?? 0), C.bad],
+        ['  Queue ', C.label], [String(queue.length), queue.length > 0 ? C.warn : C.good],
+      ]),
+      buildPanelLine(width, [
+        [' session ', C.label], [String(byScope.get('session') ?? 0), C.info],
+        ['  project ', C.label], [String(byScope.get('project') ?? 0), C.value],
+        ['  team ', C.label], [String(byScope.get('team') ?? 0), C.good],
+      ]),
+      filterToggleLine,
+      buildGuidanceLine(width, '/recall review', 'work the stale and contradicted queue from the command surface', C),
+    ];
+
+    const selectedRecord = this.reviewRecords[this.selectedIndex];
+    const selectedLines: Line[] = [];
+    if (selectedRecord) {
+      selectedLines.push(buildPanelLine(width, [['  Selected', C.label]]));
+      selectedLines.push(buildKeyValueLine(width, [
+        { label: 'Class', value: selectedRecord.cls, valueColor: C.value },
+        { label: 'Scope', value: selectedRecord.scope, valueColor: C.info },
+        { label: 'Review', value: selectedRecord.reviewState, valueColor: reviewStateColor(selectedRecord.reviewState) },
+        { label: 'Confidence', value: formatConfidence(selectedRecord.confidence), valueColor: C.value },
+      ], C));
+      selectedLines.push(...buildBodyText(width, `Summary: ${selectedRecord.summary}`, C, C.value));
+      if (selectedRecord.detail) selectedLines.push(...buildBodyText(width, `Detail: ${selectedRecord.detail}`, C, C.dim));
+      if (selectedRecord.provenance.length) {
+        selectedLines.push(...buildBodyText(
+          width,
+          `Provenance: ${selectedRecord.provenance.map((p) => `${p.kind}:${p.ref}`).join(', ')}`,
+          C,
+          C.dim,
+        ));
+      }
+      if (selectedRecord.staleReason) {
+        selectedLines.push(...buildBodyText(
+          width,
+          `Stale reason: ${selectedRecord.staleReason}`,
+          C,
+          selectedRecord.reviewState === 'contradicted' ? C.bad : C.warn,
+        ));
+      }
+      if (selectedRecord.reviewedAt) {
+        selectedLines.push(buildPanelLine(width, [
+          ['  Reviewed: ', C.label],
+          [new Date(selectedRecord.reviewedAt).toLocaleString(), C.dim],
+        ]));
+        if (selectedRecord.reviewedBy) {
+          selectedLines.push(buildPanelLine(width, [
+            ['  Reviewer: ', C.label],
+            [selectedRecord.reviewedBy, C.dim],
+          ]));
+        }
+      }
+    }
+
+    return this.renderList(width, height, {
+      title: 'Memory',
+      header: [...classLines, ...reviewLines],
+      footer: [
+        ...(selectedLines.length > 0 ? selectedLines : []),
+        buildPanelLine(width, [['  Tab: All Records  Up/Down move  r/Enter reviewed  s stale  c contradicted  f fresh', C.dim]]),
       ],
     });
   }

package/src/panels/session-maintenance.ts

@@ -1,3 +1,16 @@
+/**
+ * Session maintenance types and local evaluator.
+ *
+ * The canonical evaluator is the SDK version exported from @/runtime/index.ts
+ * (via operations.evaluateSessionMaintenance), which reads from configManager.
+ *
+ * This module provides:
+ *  - The shared type surface used across TUI panels.
+ *  - A thin local evaluator kept in sync with the SDK signature so panel code
+ *    that passes configManager has a coherent call site.
+ */
+import type { ConfigManager } from '@pellux/goodvibes-sdk/platform/config';
+
 export type PanelGuidanceMode = 'off' | 'minimal' | 'guided';
 export type PanelSessionMaintenanceLevel = 'stable' | 'watch' | 'suggest-compact' | 'compacting' | 'needs-repair' | 'unknown';
 
@@ -9,9 +22,12 @@ export interface PanelSessionMaintenanceSession {
   readonly lineage?: readonly PanelSessionMaintenanceLineageEntry[];
   readonly lastCompactedAt?: number;
   readonly compactionMessageCount?: number;
+  readonly compactionState?: string;
 }
 
 export interface PanelSessionMaintenanceInput {
+  /** ConfigManager used to read behavior.autoCompactThreshold and related keys. */
+  readonly configManager: Pick<ConfigManager, 'get'>;
   readonly currentTokens: number;
   readonly contextWindow: number;
   readonly messageCount?: number;
@@ -27,7 +43,15 @@ export interface PanelSessionMaintenanceStatus {
   readonly guidanceMode: PanelGuidanceMode;
   readonly usagePct: number;
   readonly remainingTokens: number;
+  /**
+   * Compact threshold as a percent integer.
+   * SDK schema range is [10, 100]; default is 80.
+   */
   readonly thresholdPct: number;
+  /**
+   * True when autoCompactThreshold is in its valid range (>0).
+   * With SDK default (80), auto-compact is active unless explicitly lowered below 10.
+   */
   readonly autoCompactEnabled: boolean;
   readonly sessionMemoryCount: number;
   readonly compactionCount: number;
@@ -35,19 +59,33 @@ export interface PanelSessionMaintenanceStatus {
   readonly compactRecommended: boolean;
 }
 
+/**
+ * Evaluate session maintenance from config-driven thresholds.
+ *
+ * behavior.autoCompactThreshold (percent integer, SDK schema range [10, 100], default 80):
+ *  - [10, 100] → threshold at that percent; autoCompactEnabled = true.
+ *  - 0 (defensive fallback for null/missing config only; not a valid schema value).
+ *
+ * NOTE: The SDK's evaluateSessionMaintenance (from @/runtime/index.ts) is the
+ * canonical implementation used in production.  This local version exists so
+ * panel tests can import types without crossing the SDK boundary.
+ */
 export function evaluateSessionMaintenance(input: PanelSessionMaintenanceInput): PanelSessionMaintenanceStatus {
-  const guidanceMode: PanelGuidanceMode = 'minimal';
-  const thresholdPct = 80;
-  const autoCompactEnabled = false;
+  const guidanceMode: PanelGuidanceMode = (input.configManager.get('behavior.guidanceMode') as PanelGuidanceMode | undefined) ?? 'minimal';
+  const rawThreshold = Number(input.configManager.get('behavior.autoCompactThreshold') ?? 0);
+  const thresholdPct = Math.max(0, Number.isFinite(rawThreshold) ? rawThreshold : 0);
+  const autoCompactEnabled = thresholdPct > 0;
+
   const usagePct = input.contextWindow > 0 ? Math.min(100, Math.round((Math.max(0, input.currentTokens) / input.contextWindow) * 100)) : 0;
   const remainingTokens = Math.max(0, input.contextWindow - input.currentTokens);
   const sessionMemoryCount = Math.max(0, input.sessionMemoryCount ?? 0);
   const compactionCount = Math.max(0, input.session?.lineage?.filter((entry) => entry.branchReason === 'compaction').length ?? 0);
   const lastCompactedAt = input.session?.lastCompactedAt;
   const messageCount = Math.max(0, input.messageCount ?? 0);
-  const staleByMessageGrowth = compactionCount > 0
+  const staleByMessageGrowth = (input.session?.compactionMessageCount ?? 0) > 0
     ? messageCount - (input.session?.compactionMessageCount ?? 0) >= 12
     : messageCount >= 24;
+
   if (input.contextWindow <= 0) {
     return {
       level: 'unknown',
@@ -66,32 +104,45 @@ export function evaluateSessionMaintenance(input: PanelSessionMaintenanceInput):
     };
   }
 
+  if (input.session?.compactionState === 'failed') {
+    return {
+      level: 'needs-repair',
+      summary: 'Compaction needs operator repair.',
+      reasons: ['Compaction failed and the session may need manual recovery.'],
+      nextSteps: ['/compact', '/health review'],
+      guidanceMode,
+      usagePct,
+      remainingTokens,
+      thresholdPct,
+      autoCompactEnabled,
+      sessionMemoryCount,
+      compactionCount,
+      lastCompactedAt,
+      compactRecommended: true,
+    };
+  }
+
   const reasons: string[] = [];
   const nextSteps: string[] = [];
   let summary = 'Session maintenance is stable.';
   let compactRecommended = false;
   let level: PanelSessionMaintenanceLevel = 'stable';
 
-  if (usagePct >= 90) {
-    level = 'needs-repair';
+  const atThreshold = autoCompactEnabled ? usagePct >= thresholdPct : usagePct >= 80;
+  if (atThreshold || remainingTokens <= 15_000) {
+    level = 'suggest-compact';
     summary = `Compact now to recover context headroom (${usagePct}% used).`;
     reasons.push(`Context pressure is high at ${usagePct}% usage.`);
     nextSteps.push('/compact', '/panel tokens');
     compactRecommended = true;
-  } else if (usagePct >= thresholdPct || remainingTokens <= 15_000) {
-    level = 'suggest-compact';
-    summary = `Watch context growth (${usagePct}% used).`;
-    reasons.push(`Context pressure is climbing at ${usagePct}% usage.`);
-    nextSteps.push('/panel tokens');
-    compactRecommended = true;
-  } else if (usagePct >= 70 || staleByMessageGrowth) {
+  } else if (usagePct >= Math.max(70, autoCompactEnabled ? thresholdPct - 10 : 70) || staleByMessageGrowth) {
     level = 'watch';
     summary = staleByMessageGrowth
       ? `Conversation has grown ${messageCount.toLocaleString()} messages since the last maintenance checkpoint.`
       : `Watch context growth (${usagePct}% used, threshold ${thresholdPct}%).`;
     reasons.push(staleByMessageGrowth
       ? `Conversation has grown ${messageCount.toLocaleString()} messages since the last maintenance checkpoint.`
-      : `Context usage is climbing toward the ${thresholdPct}% maintenance threshold.`);
+      : `Context usage is climbing toward the ${thresholdPct > 0 ? `${thresholdPct}% auto-compact threshold` : 'maintenance band'}.`);
     nextSteps.push('/panel tokens');
   } else {
     reasons.push('Context pressure is currently within the stable operating band.');
@@ -104,7 +155,7 @@ export function evaluateSessionMaintenance(input: PanelSessionMaintenanceInput):
     reasons.push(`Last compaction ran ${lastCompactedAt ? new Date(lastCompactedAt).toISOString() : 'recently'}.`);
   }
   if (!autoCompactEnabled) {
-    reasons.push('Auto-compact is currently disabled; use /compact when you need to recover headroom.');
+    reasons.push('Auto-compaction is disabled; maintenance stays fully manual.');
   }
 
   return {