@miphamai/cli 0.33.1 → 0.33.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miphamai/cli",
-  "version": "0.33.1",
+  "version": "0.33.2",
   "description": "Mipham Code — Multi-model open-core intelligent coding terminal by MiphamAI",
   "keywords": [
     "ai",

package/src/agent/cross-session/file-inbox.ts

@@ -23,12 +23,23 @@ const INBOX_DIR = join(MIPHAM_HOME, 'inbox')
  * Each message file is named: <ISO-timestamp>-<msg-id>.json
  */
 export class FileInboxTransport implements CrossSessionTransport {
+  private initialized = false
+
   private ensureDir(dir: string): void {
     mkdirSync(dir, { recursive: true })
   }
 
+  /** Ensure the inbox root directory exists (call on first use). */
+  private ensureInboxRoot(): void {
+    if (!this.initialized) {
+      this.ensureDir(INBOX_DIR)
+      this.initialized = true
+    }
+  }
+
   async send(from: SessionInfo, toSessionId: string, msg: AgentMessage): Promise<boolean> {
     try {
+      this.ensureInboxRoot()
       const inboxDir = join(INBOX_DIR, toSessionId)
       this.ensureDir(inboxDir)
 
@@ -36,13 +47,17 @@ export class FileInboxTransport implements CrossSessionTransport {
       const filename = `${timestamp}-${msg.id}.json`
       const filePath = join(inboxDir, filename)
 
+      // Serialize with structured sender fields
+      const envelope = {
+        ...msg,
+        senderName: from.id,
+        senderMachine: from.machine,
+        senderSession: from.id,
+      }
+
       // Atomic write: temp file then rename
       const tmpPath = filePath + '.tmp'
-      writeFileSync(
-        tmpPath,
-        JSON.stringify({ ...msg, _fromSession: from.id, _fromMachine: from.machine }, null, 2),
-        'utf-8',
-      )
+      writeFileSync(tmpPath, JSON.stringify(envelope, null, 2), 'utf-8')
       renameSync(tmpPath, filePath)
 
       return true
@@ -52,6 +67,8 @@ export class FileInboxTransport implements CrossSessionTransport {
   }
 
   async poll(sessionId: string): Promise<AgentMessage[]> {
+    // Fix 6: Ensure inbox root exists before checking subdirectory
+    this.ensureInboxRoot()
     const inboxDir = join(INBOX_DIR, sessionId)
     if (!existsSync(inboxDir)) return []
 
@@ -65,21 +82,22 @@ export class FileInboxTransport implements CrossSessionTransport {
         try {
           const raw = readFileSync(join(inboxDir, file), 'utf-8')
           const parsed = JSON.parse(raw) as AgentMessage & {
-            _fromSession?: string
-            _fromMachine?: string
+            senderName?: string
+            senderMachine?: string
+            senderSession?: string
           }
 
-          // Build the message body with cross-session origin prefix
-          const originPrefix = parsed._fromSession
-            ? `[From: ${parsed._fromSession}@${parsed._fromMachine || 'unknown'}]\n\n`
-            : ''
+          // Fix 5: Structured sender display — separate From: line before body
+          const senderName = parsed.senderName || parsed.from || 'unknown'
+          const senderMachine = parsed.senderMachine || ''
+          const originLine = `[From: ${senderName}${senderMachine ? ` @ ${senderMachine}` : ''}]`
 
           messages.push({
             id: parsed.id,
             from: parsed.from,
             to: parsed.to,
             summary: parsed.summary,
-            message: `${originPrefix}${parsed.message}`,
+            message: `${originLine}\n${parsed.message}`,
             timestamp: new Date(parsed.timestamp),
             read: parsed.read,
             type: parsed.type,

package/src/core/compaction-progress.ts

@@ -0,0 +1,205 @@
+/**
+ * P1.1: Compaction Progress Tracker
+ *
+ * Provides user-visible progress feedback during context compaction:
+ *   - Phase indicator (which compaction layer is active)
+ *   - Message count (how many messages being processed)
+ *   - Retry countdown for API-based summarization
+ *   - Stuck detection hints
+ *
+ * Designed as an event emitter that the UI layer subscribes to.
+ * Falls back to stderr output when no UI subscriber is registered.
+ */
+
+// ── Types ──
+
+export type CompactionPhase =
+  'microcompact' | 'snip' | 'reactive-compact' | 'emergency-drain' | 'complete'
+
+export interface CompactionStatus {
+  phase: CompactionPhase
+  /** Human-readable description of current action */
+  message: string
+  /** 0-100 percentage, or -1 if indeterminate */
+  percent: number
+  /** Total messages before compaction */
+  messagesBefore: number
+  /** Messages remaining after compaction */
+  messagesAfter: number
+  /** Tokens before compaction */
+  tokensBefore: number
+  /** Tokens after compaction */
+  tokensAfter: number
+  /** Elapsed ms since compaction started */
+  elapsedMs: number
+  /** Retry count for summarization API calls */
+  retryCount: number
+  /** Whether a retry is in progress */
+  retrying: boolean
+  /** Whether the compaction appears stuck (no progress for >30s) */
+  stuck: boolean
+}
+
+export type ProgressCallback = (status: CompactionStatus) => void
+
+// ── Constants ──
+
+/** Timeout in ms after which we consider compaction "stuck" */
+const STUCK_TIMEOUT_MS = 30_000
+
+/** Max retries for summarizer API calls */
+const MAX_SUMMARIZER_RETRIES = 3
+
+/** Retry delay in ms between summarizer attempts */
+const RETRY_DELAY_MS = 2_000
+
+// ── Tracker ──
+
+export class CompactionProgressTracker {
+  private callback: ProgressCallback | null = null
+  private status: CompactionStatus
+  private startTime = 0
+  private lastProgressTime = 0
+
+  constructor(messagesBefore: number, tokensBefore: number) {
+    this.status = {
+      phase: 'microcompact',
+      message: 'Starting compaction...',
+      percent: 0,
+      messagesBefore,
+      messagesAfter: messagesBefore,
+      tokensBefore,
+      tokensAfter: tokensBefore,
+      elapsedMs: 0,
+      retryCount: 0,
+      retrying: false,
+      stuck: false,
+    }
+    this.startTime = Date.now()
+    this.lastProgressTime = Date.now()
+  }
+
+  /** Register a UI callback for progress updates. */
+  onProgress(cb: ProgressCallback): void {
+    this.callback = cb
+  }
+
+  /** Update phase with new values. */
+  update(partial: {
+    phase?: CompactionPhase
+    message?: string
+    percent?: number
+    messagesAfter?: number
+    tokensAfter?: number
+    retrying?: boolean
+  }): void {
+    if (partial.phase !== undefined) this.status.phase = partial.phase
+    if (partial.message !== undefined) this.status.message = partial.message
+    if (partial.percent !== undefined) this.status.percent = partial.percent
+    if (partial.messagesAfter !== undefined) this.status.messagesAfter = partial.messagesAfter
+    if (partial.tokensAfter !== undefined) this.status.tokensAfter = partial.tokensAfter
+    if (partial.retrying !== undefined) this.status.retrying = partial.retrying
+
+    this.status.elapsedMs = Date.now() - this.startTime
+
+    // Check for stuck detection
+    if (this.status.phase !== 'complete') {
+      const timeSinceProgress = Date.now() - this.lastProgressTime
+      this.status.stuck = timeSinceProgress > STUCK_TIMEOUT_MS
+    }
+
+    this.emit()
+  }
+
+  /** Mark current retry attempt. */
+  onRetry(attempt: number): void {
+    this.status.retryCount = attempt
+    this.status.retrying = true
+    this.emit()
+  }
+
+  /** Mark retry as complete (success or giving up). */
+  onRetryComplete(): void {
+    this.status.retrying = false
+    this.lastProgressTime = Date.now()
+    this.status.stuck = false
+    this.emit()
+  }
+
+  /** Mark compaction as complete. */
+  complete(messagesAfter: number, tokensAfter: number): void {
+    this.status.phase = 'complete'
+    this.status.percent = 100
+    this.status.messagesAfter = messagesAfter
+    this.status.tokensAfter = tokensAfter
+    this.status.message = `Compaction complete: ${this.status.messagesBefore} → ${messagesAfter} messages`
+    this.status.elapsedMs = Date.now() - this.startTime
+    this.emit()
+  }
+
+  /** Get current status. */
+  getStatus(): CompactionStatus {
+    return { ...this.status }
+  }
+
+  /** Generate a compact summary string for CLI display. */
+  getSummary(): string {
+    const s = this.status
+    const elapsed = (s.elapsedMs / 1000).toFixed(1)
+    const stuckHint = s.stuck ? ' (stalled — press Esc to cancel)' : ''
+    const retryHint = s.retrying ? ` [retry ${s.retryCount}/${MAX_SUMMARIZER_RETRIES}...]` : ''
+    const pct = s.percent >= 0 ? ` ${s.percent}%` : ''
+    return `🔄 [${s.phase}]${pct} ${s.message}${retryHint}${stuckHint} (${elapsed}s)`
+  }
+
+  private emit(): void {
+    if (this.callback) {
+      try {
+        this.callback(this.getStatus())
+      } catch {
+        // UI callback failure shouldn't block compaction
+      }
+    }
+  }
+
+  // ── Static helpers ──
+
+  /** Retry a summarizer call with backoff and progress tracking. */
+  static async retrySummarizer(
+    summarizer: () => Promise<string>,
+    tracker: CompactionProgressTracker,
+    messagesToSummarize: number,
+  ): Promise<string> {
+    let lastError: Error | undefined
+
+    for (let attempt = 1; attempt <= MAX_SUMMARIZER_RETRIES; attempt++) {
+      try {
+        tracker.update({
+          message: `Summarizing ${messagesToSummarize} messages${attempt > 1 ? ` (attempt ${attempt}/${MAX_SUMMARIZER_RETRIES})` : ''}...`,
+          percent: 30 + attempt * 20,
+          retrying: attempt > 1,
+        })
+
+        const result = await summarizer()
+        tracker.onRetryComplete()
+        return result
+      } catch (err) {
+        lastError = err instanceof Error ? err : new Error(String(err))
+
+        if (attempt < MAX_SUMMARIZER_RETRIES) {
+          tracker.onRetry(attempt)
+          // Wait before retry
+          await new Promise((resolve) => setTimeout(resolve, RETRY_DELAY_MS))
+          tracker.onRetryComplete()
+        }
+      }
+    }
+
+    tracker.update({
+      message: `Summarization failed after ${MAX_SUMMARIZER_RETRIES} attempts — falling back to truncation`,
+      percent: 60,
+    })
+
+    throw lastError ?? new Error('Summarization failed')
+  }
+}

package/src/core/context-compact.ts

@@ -1,5 +1,6 @@
 import type { ContextManager, Summarizer } from './context'
 import { snipMessages } from './context-snip'
+import { CompactionProgressTracker } from './compaction-progress'
 
 /**
  * Layer 3: Reactive Compact — API-based summarization.
@@ -20,33 +21,85 @@ function getKeepRecent(contextWindow: number): number {
   return Math.max(20, Math.floor(contextWindow / 12500))
 }
 
+export interface CompactResult {
+  /** Messages before compaction */
+  beforeCount: number
+  /** Messages after compaction */
+  afterCount: number
+  /** Whether compaction was actually performed */
+  compacted: boolean
+  /** Progress summary for display */
+  summary: string
+}
+
 export async function reactiveCompact(
   context: ContextManager,
   summarizer: Summarizer,
   heading: string,
   keepRecent?: number,
-): Promise<void> {
+): Promise<CompactResult> {
   // Use explicit override, or adaptive default based on context window
   const effectiveKeepRecent = keepRecent ?? getKeepRecent(context.getMaxTokens())
   const messages = context.getMessages()
+  const tokensBefore = context.getEstimatedTokens()
 
-  if (messages.length <= effectiveKeepRecent + 4) return
+  if (messages.length <= effectiveKeepRecent + 4) {
+    return {
+      beforeCount: messages.length,
+      afterCount: messages.length,
+      compacted: false,
+      summary: `Context has ${messages.length} messages — no compaction needed (threshold: ${effectiveKeepRecent + 4}).`,
+    }
+  }
+
+  // ── Progress tracker ──
+  const tracker = new CompactionProgressTracker(messages.length, tokensBefore)
+  tracker.update({ phase: 'snip', message: 'Snipping empty pairs...', percent: 5 })
 
   // First, run snip to remove empty pairs
   const { messages: snipped } = snipMessages(messages)
+  tracker.update({
+    phase: 'snip',
+    message: `Snipped ${messages.length - snipped.length} empty pairs`,
+    percent: 15,
+    messagesAfter: snipped.length,
+  })
 
-  if (snipped.length <= effectiveKeepRecent + 4) return
+  if (snipped.length <= effectiveKeepRecent + 4) {
+    const afterCount = snipped.length
+    tracker.complete(afterCount, tokensBefore)
+    return {
+      beforeCount: messages.length,
+      afterCount,
+      compacted: true,
+      summary: `Snip-only: ${messages.length} → ${afterCount} messages (removed ${messages.length - afterCount} empty pairs).`,
+    }
+  }
 
   // Split: old messages to summarize, recent messages to keep
   const toSummarize = snipped.slice(0, -effectiveKeepRecent)
   const toKeep = snipped.slice(-effectiveKeepRecent)
 
-  // Generate summary
+  tracker.update({
+    phase: 'reactive-compact',
+    message: `Summarizing ${toSummarize.length} messages...`,
+    percent: 20,
+  })
+
+  // Generate summary with retry logic
   let summary: string
   try {
-    summary = await summarizer(toSummarize, heading)
+    summary = await CompactionProgressTracker.retrySummarizer(
+      () => summarizer(toSummarize, heading),
+      tracker,
+      toSummarize.length,
+    )
   } catch {
     // On summarizer failure, do a simple truncation
+    tracker.update({
+      message: `Summarizer unavailable — truncating to last ${effectiveKeepRecent} messages.`,
+      percent: 80,
+    })
     summary = `Earlier conversation (${toSummarize.length} messages) omitted due to context limits.`
   }
 
@@ -56,5 +109,16 @@ export async function reactiveCompact(
     content: `[Earlier conversation summary — ${heading}]: ${summary.slice(0, 8000)}`,
   }
 
-  context.replaceMessages([summaryMsg, ...toKeep])
+  const newMessages = [summaryMsg, ...toKeep]
+  context.replaceMessages(newMessages)
+
+  const tokensAfter = context.getEstimatedTokens()
+  tracker.complete(newMessages.length, tokensAfter)
+
+  return {
+    beforeCount: messages.length,
+    afterCount: newMessages.length,
+    compacted: true,
+    summary: tracker.getSummary(),
+  }
 }

package/src/core/context-drain.ts

@@ -1,4 +1,5 @@
 import type { ContextManager } from './context'
+import type { CompactionProgressTracker } from './compaction-progress'
 
 const MINIMAL_KEEP = 5
 let drainLevel = 0
@@ -12,22 +13,62 @@ let drainLevel = 0
  * Level 1: Drop earliest 50% of messages
  * Level 2+: Keep only system prompt + last 5 messages
  *
- * Returns true if recovery was possible, false if context is already minimal.
+ * Returns drain result with progress summary.
  */
-export async function emergencyDrain(context: ContextManager): Promise<boolean> {
+export interface DrainResult {
+  /** Whether recovery was possible */
+  recovered: boolean
+  /** Messages before drain */
+  beforeCount: number
+  /** Messages after drain */
+  afterCount: number
+  /** Current drain level */
+  level: number
+  /** Human-readable summary */
+  summary: string
+}
+
+export async function emergencyDrain(
+  context: ContextManager,
+  progress?: CompactionProgressTracker,
+): Promise<DrainResult> {
   const messages = context.getMessages()
 
   if (messages.length <= MINIMAL_KEEP) {
-    return false // Already minimal, cannot drain further
+    return {
+      recovered: false,
+      beforeCount: messages.length,
+      afterCount: messages.length,
+      level: drainLevel,
+      summary: `Cannot drain further: already at minimal ${messages.length} messages.`,
+    }
   }
 
+  progress?.update({
+    phase: 'emergency-drain',
+    message: `Emergency drain level ${drainLevel + 1}: recovering from 413 error...`,
+    percent: 50,
+  })
+
   if (drainLevel === 0) {
     // First attempt: drop earliest 50%
     const keepCount = Math.max(MINIMAL_KEEP, Math.floor(messages.length / 2))
     const kept = messages.slice(-keepCount)
     context.replaceMessages(kept)
     drainLevel++
-    return true
+    progress?.update({
+      phase: 'emergency-drain',
+      message: `Drain level 1: dropped ${messages.length - keepCount} messages (${messages.length} → ${keepCount})`,
+      percent: 80,
+      messagesAfter: keepCount,
+    })
+    return {
+      recovered: true,
+      beforeCount: messages.length,
+      afterCount: keepCount,
+      level: drainLevel,
+      summary: `Emergency drain level 1: ${messages.length} → ${keepCount} messages (dropped earliest 50%).`,
+    }
   }
 
   // Subsequent attempts: keep only system + last MINIMAL_KEEP messages
@@ -37,7 +78,7 @@ export async function emergencyDrain(context: ContextManager): Promise<boolean>
   if (messages.length > MINIMAL_KEEP * 2) {
     const summaryMsg = {
       role: 'user' as const,
-      content: `[Emergency context drain: ${messages.length - MINIMAL_KEEP} earlier messages discarded due to token limit.]`,
+      content: `[Emergency context drain level ${drainLevel + 1}: ${messages.length - MINIMAL_KEEP} earlier messages discarded due to token limit.]`,
     }
     context.replaceMessages([summaryMsg, ...kept])
   } else {
@@ -45,10 +86,28 @@ export async function emergencyDrain(context: ContextManager): Promise<boolean>
   }
 
   drainLevel++
-  return true
+  progress?.update({
+    phase: 'emergency-drain',
+    message: `Drain level ${drainLevel}: ${messages.length} → ${kept.length} messages`,
+    percent: 90,
+    messagesAfter: kept.length,
+  })
+
+  return {
+    recovered: true,
+    beforeCount: messages.length,
+    afterCount: kept.length,
+    level: drainLevel,
+    summary: `Emergency drain level ${drainLevel}: ${messages.length} → ${kept.length} messages.`,
+  }
 }
 
 /** Reset drain level (call at session start). */
 export function resetDrainLevel(): void {
   drainLevel = 0
 }
+
+/** Get current drain level for display. */
+export function getDrainLevel(): number {
+  return drainLevel
+}

package/src/core/context.ts

@@ -124,8 +124,13 @@ export class ContextManager {
     return this.estimatedTokens > this.config.maxTokens * this.config.compactionThreshold
   }
 
-  async compact(heading: string): Promise<void> {
-    if (this.messages.length <= 30) return
+  async compact(heading: string): Promise<{ before: number; after: number }> {
+    const beforeMsgs = this.messages.length
+    const beforeTokens = this.estimatedTokens
+
+    if (this.messages.length <= 30) {
+      return { before: beforeTokens, after: beforeTokens }
+    }
 
     const keep = 20
     const toDrop = this.messages.slice(0, -keep)
@@ -155,6 +160,8 @@ export class ContextManager {
         typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content),
       )
     }
+
+    return { before: beforeTokens, after: this.estimatedTokens }
   }
 
   getEstimatedTokens(): number {
@@ -266,11 +273,11 @@ export class ContextManager {
    */
   async on413Error(): Promise<boolean> {
     const result = await emergencyDrain(this)
-    if (result) {
+    if (result.recovered) {
       this.compactionStats.drainCount++
       this.compactionStats.lastCompaction = new Date()
     }
-    return result
+    return result.recovered
   }
 
   // ── Forced compaction (e.g. /compact command) ──

package/src/core/engine.ts

@@ -160,6 +160,11 @@ export class QueryEngine {
     this.hookEngine = hooks
   }
 
+  /** Get the registered hook engine (for health inspection). */
+  getHookEngine(): HookEngine | undefined {
+    return this.hookEngine
+  }
+
   /** Register the artifact server for tool context. */
   setArtifactServer(server: ArtifactServer): void {
     this.artifactServer = server

package/src/core/hooks.ts

@@ -6,6 +6,29 @@ import type {
   ToolResult,
 } from '../shared/index.ts'
 
+// ── Hook resilience types ──
+
+interface HookHealth {
+  /** Consecutive failure count */
+  failures: number
+  /** Timestamp of last failure (ms since epoch) */
+  lastFailureTime: number
+  /** Whether the hook is currently disabled due to repeated failures */
+  disabled: boolean
+  /** Timestamp when disabled (ms since epoch) */
+  disabledAt: number
+  /** Total failure count (lifetime) */
+  totalFailures: number
+}
+
+/** Max consecutive failures before auto-disabling a hook */
+const MAX_CONSECUTIVE_FAILURES = 5
+
+/** Cooldown period in ms before a disabled hook is re-tried (5 minutes) */
+const COOLDOWN_MS = 5 * 60 * 1000
+
+// ── Helpers ──
+
 /**
  * Merge two permission decisions, keeping the more restrictive one.
  * Priority: deny > defer > ask > allow
@@ -22,6 +45,8 @@ export function mergePermissionDecision(
 
 export class HookEngine {
   private hooks: HookDefinition[] = []
+  /** Health tracking per hook key (event[:toolName]) */
+  private health = new Map<string, HookHealth>()
 
   register(hook: HookDefinition): void {
     this.hooks.push(hook)
@@ -71,31 +96,26 @@ export class HookEngine {
 
   // ── NEW event executors ──
 
-  /** Stop hook: fires when AI completes a turn. Can block to force continuation. */
   async executeStop(sessionId: string): Promise<HookResult> {
     const ctx: HookContext = { event: 'Stop', sessionId }
     return this.runHooks('Stop', undefined, ctx)
   }
 
-  /** UserPromptSubmit: fires when user submits input. Can block malicious input. */
   async executeUserPromptSubmit(prompt: string, sessionId: string): Promise<HookResult> {
     const ctx: HookContext = { event: 'UserPromptSubmit', sessionId, userPrompt: prompt }
     return this.runHooks('UserPromptSubmit', undefined, ctx)
   }
 
-  /** PreCompact: fires before context compaction. */
   async executePreCompact(sessionId: string): Promise<HookResult> {
     const ctx: HookContext = { event: 'PreCompact', sessionId }
     return this.runHooks('PreCompact', undefined, ctx)
   }
 
-  /** PostCompact: fires after context compaction. Can inject additional context. */
   async executePostCompact(sessionId: string): Promise<HookResult> {
     const ctx: HookContext = { event: 'PostCompact', sessionId }
     return this.runHooks('PostCompact', undefined, ctx)
   }
 
-  /** ConfigChange: fires when configuration changes. */
   async executeConfigChange(key: string, value: unknown, sessionId: string): Promise<HookResult> {
     const ctx: HookContext = {
       event: 'ConfigChange',
@@ -106,7 +126,6 @@ export class HookEngine {
     return this.runHooks('ConfigChange', undefined, ctx)
   }
 
-  /** SubagentStart: fires when a sub-agent begins execution. */
   async executeSubagentStart(
     agentType: string,
     description: string,
@@ -120,7 +139,6 @@ export class HookEngine {
     return this.runHooks('SubagentStart', undefined, ctx)
   }
 
-  /** SubagentStop: fires when a sub-agent completes (success or failure). */
   async executeSubagentStop(
     agentType: string,
     description: string,
@@ -137,7 +155,6 @@ export class HookEngine {
     return this.runHooks('SubagentStop', undefined, ctx)
   }
 
-  /** PostToolUseFailure: fires when a tool call fails. */
   async executePostToolUseFailure(
     toolName: string,
     toolInput: Record<string, unknown>,
@@ -154,7 +171,6 @@ export class HookEngine {
     return this.runHooks('PostToolUseFailure', toolName, ctx)
   }
 
-  /** PreInference: fires before every model API call for DLP inspection. */
   async executePreInference(
     messages: Array<{ role: string; content: string }>,
     toolCalls: Array<{
@@ -177,6 +193,79 @@ export class HookEngine {
     return this.runHooks('PreInference', undefined, ctx)
   }
 
+  // ── Health & Resilience ──
+
+  /** Get a hook health key for tracking. */
+  private healthKey(hook: HookDefinition): string {
+    return hook.toolName ? `${hook.event}:${hook.toolName}` : hook.event
+  }
+
+  /** Check if a hook should be skipped due to repeated failures. */
+  private shouldSkip(key: string): boolean {
+    const h = this.health.get(key)
+    if (!h) return false
+
+    // If disabled, check cooldown
+    if (h.disabled) {
+      const elapsed = Date.now() - h.disabledAt
+      if (elapsed < COOLDOWN_MS) {
+        return true // still in cooldown
+      }
+      // Cooldown expired — re-enable for a trial
+      h.disabled = false
+      h.failures = 0
+      process.stderr.write(`🔄 Hook "${key}" cooldown expired — re-enabled for trial.\n`)
+      return false
+    }
+
+    return false
+  }
+
+  /** Record a hook success — resets failure counter. */
+  private recordSuccess(key: string): void {
+    const h = this.health.get(key)
+    if (h) {
+      h.failures = 0
+      h.disabled = false
+    }
+  }
+
+  /** Record a hook failure — may trigger auto-disable. */
+  private recordFailure(key: string): void {
+    let h = this.health.get(key)
+    if (!h) {
+      h = { failures: 0, lastFailureTime: 0, disabled: false, disabledAt: 0, totalFailures: 0 }
+      this.health.set(key, h)
+    }
+
+    h.failures++
+    h.totalFailures++
+    h.lastFailureTime = Date.now()
+
+    if (h.failures >= MAX_CONSECUTIVE_FAILURES && !h.disabled) {
+      h.disabled = true
+      h.disabledAt = Date.now()
+      process.stderr.write(
+        `⚠️  Hook "${key}" failed ${MAX_CONSECUTIVE_FAILURES} consecutive times — auto-disabled for ${COOLDOWN_MS / 60_000} minutes.\n` +
+          `   Use /hooks enable "${key}" to re-enable manually.\n`,
+      )
+    }
+  }
+
+  /** Get the health status of all hooks. */
+  getHookHealth(): Array<{ key: string; health: HookHealth }> {
+    return Array.from(this.health.entries()).map(([key, health]) => ({ key, health }))
+  }
+
+  /** Manually re-enable a disabled hook. */
+  reEnableHook(key: string): boolean {
+    const h = this.health.get(key)
+    if (!h || !h.disabled) return false
+    h.disabled = false
+    h.failures = 0
+    return true
+  }
+
   // ── Core execution ──
 
   private async runHooks(
@@ -191,9 +280,23 @@ export class HookEngine {
     const result: HookResult = { allowed: true }
 
     for (const hook of matching) {
+      const key = this.healthKey(hook)
+
+      // ── Resilience: skip disabled hooks ──
+      if (this.shouldSkip(key)) {
+        result.additionalContext = result.additionalContext
+          ? result.additionalContext +
+            `\n[Hook "${key}" skipped — temporarily disabled after repeated failures]`
+          : `[Hook "${key}" skipped — temporarily disabled after repeated failures]`
+        continue
+      }
+
       try {
         const hookResult = await hook.handler(ctx)
 
+        // Record success
+        this.recordSuccess(key)
+
         // Block on first deny — stops further hook execution
         if (!hookResult.allowed) {
           return { ...hookResult }
@@ -233,6 +336,8 @@ export class HookEngine {
           result.updatedOutput = hookResult.updatedOutput
         }
       } catch {
+        // Record failure — may trigger auto-disable
+        this.recordFailure(key)
         // Hook failures do not block execution
       }
     }

package/src/ui/app.tsx

@@ -1,6 +1,7 @@
 import React, { useState, useCallback, useEffect, useRef, useMemo } from 'react'
 import { Box, Text, useInput } from 'ink'
 import TextInput from 'ink-text-input'
+import { ErrorBoundary } from './error-boundary'
 import type { QueryEngine } from '../core/engine'
 import type { RemoteEngine } from '../daemon/remote-engine'
 import type { MiphamConfig } from '../shared/index.ts'
@@ -410,7 +411,17 @@ export function App({
               role: msg.role,
               content: typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content),
             }))
-            setMessages((prev) => [...prev, ...restored])
+            if (result.resumeWarning) {
+              // Fix 7: Session isolation — add a visual separator between current session
+              // and restored history to prevent accidental leakage/confusion
+              const separator: ChatMessage = {
+                role: 'assistant' as const,
+                content: '── Restored session history below ──',
+              }
+              setMessages((prev) => [...prev, separator, ...restored])
+            } else {
+              setMessages((prev) => [...prev, ...restored])
+            }
           }
           if (result.copyContent) {
             // Copy to clipboard via pbcopy (macOS) or clip (Windows)
@@ -743,140 +754,142 @@ export function App({
   }
 
   return (
-    <Box flexDirection="column" padding={1} height="100%">
-      {/* Workflow progress — auto-detects active workflows, renders nothing when idle */}
-      <WorkflowProgress />
-
-      {/* Agent View Dashboard — Ctrl+G overlay (replaces chat + input) */}
-      {agentViewOpen && agentViewManager ? (
-        <AgentViewDashboard
-          manager={agentViewManager}
-          onAttach={() => {}}
-          onExit={() => setAgentViewOpen(false)}
-        />
-      ) : (
-        <>
-          {/* Chat panel */}
-          <ChatPanel messages={messages} focusMode={focusMode} />
-
-          {/* Input with separator lines */}
-          {pickerOpen ? (
-            <ModelPicker
-              config={config}
-              currentProvider={providerId}
-              currentModel={modelId}
-              onSelect={(newProvider, newModel) => {
-                engine.switchProvider(newProvider, newModel)
-                setProviderId(newProvider)
-                setModelId(newModel)
-                setPickerOpen(false)
-                setMessages((prev) => [
-                  ...prev,
-                  { role: 'system', content: `✓ Switched to ${newProvider}/${newModel}` },
-                ])
-              }}
-              onNeedsApiKey={(providerId, modelId, providerName) => {
-                setApiKeyPrompt({ providerId, modelId, providerName })
-                setApiKeyInput('')
-                setPickerOpen(false)
-                setMessages((prev) => [
-                  ...prev,
-                  {
-                    role: 'system',
-                    content: t('ui.picker.needs_api_key', { provider: providerName }),
-                  },
-                ])
-              }}
-              onClose={() => setPickerOpen(false)}
-            />
-          ) : (
-            /* Input bar (hidden when picker is open) */
-            <Box flexDirection="column">
-              <Text dimColor>──────────────────────────────</Text>
-              <InputBar
-                onSubmit={handleSubmit}
-                isLoading={isLoading}
-                onTogglePicker={() => setPickerOpen((prev) => !prev)}
-                onToggleFocus={() => setFocusMode((prev) => !prev)}
-                onToggleExpand={() => {
-                  setMessages((prev) => {
-                    const msgs = [...prev]
-                    for (let i = msgs.length - 1; i >= 0; i--) {
-                      if (msgs[i]?.toolMeta) {
-                        const meta = msgs[i]!.toolMeta!
-                        if (meta.collapsed) {
-                          msgs[i] = {
-                            ...msgs[i]!,
-                            content: `🔧 ${meta.name}: ${meta.input}\n📋 Result: ${meta.output || '(pending)'}`,
-                            toolMeta: { ...meta, collapsed: false },
-                          }
-                        } else {
-                          const short =
-                            meta.input.length > 50 ? meta.input.slice(0, 50) + '...' : meta.input
-                          msgs[i] = {
-                            ...msgs[i]!,
-                            content: `⏺ ${meta.name} · ${short} (Ctrl+O to expand)`,
-                            toolMeta: { ...meta, collapsed: true },
+    <ErrorBoundary>
+      <Box flexDirection="column" padding={1} height="100%">
+        {/* Workflow progress — auto-detects active workflows, renders nothing when idle */}
+        <WorkflowProgress />
+
+        {/* Agent View Dashboard — Ctrl+G overlay (replaces chat + input) */}
+        {agentViewOpen && agentViewManager ? (
+          <AgentViewDashboard
+            manager={agentViewManager}
+            onAttach={() => {}}
+            onExit={() => setAgentViewOpen(false)}
+          />
+        ) : (
+          <>
+            {/* Chat panel */}
+            <ChatPanel messages={messages} focusMode={focusMode} />
+
+            {/* Input with separator lines */}
+            {pickerOpen ? (
+              <ModelPicker
+                config={config}
+                currentProvider={providerId}
+                currentModel={modelId}
+                onSelect={(newProvider, newModel) => {
+                  engine.switchProvider(newProvider, newModel)
+                  setProviderId(newProvider)
+                  setModelId(newModel)
+                  setPickerOpen(false)
+                  setMessages((prev) => [
+                    ...prev,
+                    { role: 'system', content: `✓ Switched to ${newProvider}/${newModel}` },
+                  ])
+                }}
+                onNeedsApiKey={(providerId, modelId, providerName) => {
+                  setApiKeyPrompt({ providerId, modelId, providerName })
+                  setApiKeyInput('')
+                  setPickerOpen(false)
+                  setMessages((prev) => [
+                    ...prev,
+                    {
+                      role: 'system',
+                      content: t('ui.picker.needs_api_key', { provider: providerName }),
+                    },
+                  ])
+                }}
+                onClose={() => setPickerOpen(false)}
+              />
+            ) : (
+              /* Input bar (hidden when picker is open) */
+              <Box flexDirection="column">
+                <Text dimColor>──────────────────────────────</Text>
+                <InputBar
+                  onSubmit={handleSubmit}
+                  isLoading={isLoading}
+                  onTogglePicker={() => setPickerOpen((prev) => !prev)}
+                  onToggleFocus={() => setFocusMode((prev) => !prev)}
+                  onToggleExpand={() => {
+                    setMessages((prev) => {
+                      const msgs = [...prev]
+                      for (let i = msgs.length - 1; i >= 0; i--) {
+                        if (msgs[i]?.toolMeta) {
+                          const meta = msgs[i]!.toolMeta!
+                          if (meta.collapsed) {
+                            msgs[i] = {
+                              ...msgs[i]!,
+                              content: `🔧 ${meta.name}: ${meta.input}\n📋 Result: ${meta.output || '(pending)'}`,
+                              toolMeta: { ...meta, collapsed: false },
+                            }
+                          } else {
+                            const short =
+                              meta.input.length > 50 ? meta.input.slice(0, 50) + '...' : meta.input
+                            msgs[i] = {
+                              ...msgs[i]!,
+                              content: `⏺ ${meta.name} · ${short} (Ctrl+O to expand)`,
+                              toolMeta: { ...meta, collapsed: true },
+                            }
                           }
+                          break
                         }
-                        break
                       }
+                      return msgs
+                    })
+                  }}
+                  onCyclePermission={() => {
+                    setPermissionMode((prev) => {
+                      const idx = PERMISSION_MODES.indexOf(prev)
+                      const next = PERMISSION_MODES[(idx + 1) % PERMISSION_MODES.length]!
+                      engine.getPermission().setMode(next)
+                      return next
+                    })
+                  }}
+                  onCancel={() => {
+                    if (abortRef.current) {
+                      abortRef.current.abort()
                     }
-                    return msgs
-                  })
-                }}
-                onCyclePermission={() => {
-                  setPermissionMode((prev) => {
-                    const idx = PERMISSION_MODES.indexOf(prev)
-                    const next = PERMISSION_MODES[(idx + 1) % PERMISSION_MODES.length]!
-                    engine.getPermission().setMode(next)
-                    return next
-                  })
-                }}
-                onCancel={() => {
-                  if (abortRef.current) {
-                    abortRef.current.abort()
-                  }
-                }}
-                onToggleAgentView={() => setAgentViewOpen((prev) => !prev)}
-              />
-              <Text dimColor>──────────────────────────────</Text>
-            </Box>
-          )}
-
-          {/* Agent status footer — shows active tool indicator + inline agent progress + running background agents */}
-          <AgentFooter
-            agents={Object.values(runningAgents)}
-            tick={agentTick}
-            activeTool={activeTool}
-            agentProgress={agentProgress}
-          />
-
-          {/* Status line — Claude Code style */}
-          <Box marginTop={1} flexDirection="column">
-            {goalText && (
-              <Box>
-                <Text color="green">🎯 Goal: {goalText}</Text>
+                  }}
+                  onToggleAgentView={() => setAgentViewOpen((prev) => !prev)}
+                />
+                <Text dimColor>──────────────────────────────</Text>
               </Box>
             )}
-            <Box flexDirection="row">
-              <Text color={PERMISSION_COLORS[permissionMode]}>
-                ⏵⏵ {PERMISSION_LABELS[permissionMode]}
-              </Text>
-              <Text dimColor>
-                {' '}
-                ({t('ui.status.shift_tab_cycle')}: {PERMISSION_LABELS.default} ·{' '}
-                {PERMISSION_LABELS.acceptEdits} · {PERMISSION_LABELS.bypassPermissions} ·{' '}
-                {PERMISSION_LABELS.plan} · {PERMISSION_LABELS.auto} · {PERMISSION_LABELS.dontAsk})
-                {' · '}
-                {t('ui.status.esc_to_interrupt')}
-                {' · '}
-                {t('ui.status.left_for_agents')}
-              </Text>
+
+            {/* Agent status footer — shows active tool indicator + inline agent progress + running background agents */}
+            <AgentFooter
+              agents={Object.values(runningAgents)}
+              tick={agentTick}
+              activeTool={activeTool}
+              agentProgress={agentProgress}
+            />
+
+            {/* Status line — Claude Code style */}
+            <Box marginTop={1} flexDirection="column">
+              {goalText && (
+                <Box>
+                  <Text color="green">🎯 Goal: {goalText}</Text>
+                </Box>
+              )}
+              <Box flexDirection="row">
+                <Text color={PERMISSION_COLORS[permissionMode]}>
+                  ⏵⏵ {PERMISSION_LABELS[permissionMode]}
+                </Text>
+                <Text dimColor>
+                  {' '}
+                  ({t('ui.status.shift_tab_cycle')}: {PERMISSION_LABELS.default} ·{' '}
+                  {PERMISSION_LABELS.acceptEdits} · {PERMISSION_LABELS.bypassPermissions} ·{' '}
+                  {PERMISSION_LABELS.plan} · {PERMISSION_LABELS.auto} · {PERMISSION_LABELS.dontAsk})
+                  {' · '}
+                  {t('ui.status.esc_to_interrupt')}
+                  {' · '}
+                  {t('ui.status.left_for_agents')}
+                </Text>
+              </Box>
             </Box>
-          </Box>
-        </>
-      )}
-    </Box>
+          </>
+        )}
+      </Box>
+    </ErrorBoundary>
   )
 }

package/src/ui/commands.ts

@@ -83,6 +83,8 @@ export interface CommandResult {
   forwardToAI?: string
   /** If set, restored messages to load into the session (used by /resume last). */
   forwardedMessages?: Message[]
+  /** If true, resume into current non-empty session — app should warn before loading */
+  resumeWarning?: boolean
   /** API Key 补录请求：切换前需用户输入 Key */
   needsApiKey?: {
     providerId: string
@@ -269,11 +271,31 @@ const exitCmd: CommandHandler = () => ({ content: '', exit: true })
 const compactCmd: CommandHandler = async (ctx) => {
   const t = resolveT(ctx)
   const context = ctx.engine.getContext()
-  const before = context.getEstimatedTokens()
-  await context.compact('user requested compaction')
-  const after = context.getEstimatedTokens()
+  const msgsBefore = context.getMessageCount()
+  const tokensBefore = context.getEstimatedTokens()
+
+  // Show start progress
+  process.stderr.write(
+    `🔄 Compacting: ${msgsBefore} messages, ${tokensBefore.toLocaleString()} tokens...\n`,
+  )
+
+  const startTime = Date.now()
+  const result = await context.compact('user requested compaction')
+  const elapsed = ((Date.now() - startTime) / 1000).toFixed(1)
+  const msgsAfter = context.getMessageCount()
+  const saved = result.before > 0 ? ((1 - result.after / result.before) * 100).toFixed(0) : '0'
+
   return {
-    content: `${t('commands.compact.confirmed')}\n${t('commands.compact.tokens', { before: before.toLocaleString(), after: after.toLocaleString(), saved: ((1 - after / before) * 100).toFixed(0) })}`,
+    content: [
+      t('commands.compact.confirmed'),
+      `Messages: ${msgsBefore} → ${msgsAfter} | Tokens: ${result.before.toLocaleString()} → ${result.after.toLocaleString()} (${saved}% saved)`,
+      `Duration: ${elapsed}s`,
+      msgsBefore > msgsAfter
+        ? `💡 Tip: Use /compact early to prevent automatic compaction delays.`
+        : '',
+    ]
+      .filter(Boolean)
+      .join('\n'),
   }
 }
 
@@ -2256,6 +2278,46 @@ const hooksCmd: CommandHandler = async (ctx) => {
   }
 }
 
+const hooksHealthCmd: CommandHandler = (ctx) => {
+  const hookEngine = ctx.engine.getHookEngine?.()
+  if (!hookEngine) {
+    return { content: 'Hook engine not available.' }
+  }
+
+  const health = hookEngine.getHookHealth()
+  if (health.length === 0) {
+    return { content: '✅ All hooks are healthy — no failures recorded.' }
+  }
+
+  const lines: string[] = ['## 🪝 Hook Health Status', '']
+  for (const { key, health: h } of health) {
+    const status = h.disabled ? '🔴 DISABLED' : h.failures > 0 ? '🟡 DEGRADED' : '🟢 HEALTHY'
+    lines.push(`### ${status} \`${key}\``)
+    lines.push(`| 连续失败 | ${h.failures} (threshold: 5) |`)
+    lines.push(`| 总失败次数 | ${h.totalFailures} |`)
+    if (h.disabled) {
+      const remaining = Math.max(0, 5 - (Date.now() - h.disabledAt) / 60_000)
+      lines.push(`| 自动恢复 | ${remaining.toFixed(0)} min remaining |`)
+      lines.push('')
+      lines.push(`Use \`/hooks enable "${key}"\` to re-enable manually.`)
+    }
+    lines.push('')
+  }
+  return { content: lines.join('\n') }
+}
+
+const hooksEnableCmd: CommandHandler = (ctx, args) => {
+  const hookEngine = ctx.engine.getHookEngine?.()
+  if (!hookEngine) return { content: 'Hook engine not available.' }
+  const keyArg = args[0]?.trim().replace(/"/g, '')
+  if (!keyArg) {
+    return { content: 'Usage: /hooks enable "<hook-key>"\n\nUse /hooks health to see hook keys.' }
+  }
+  return hookEngine.reEnableHook(keyArg)
+    ? { content: `✅ Hook "${keyArg}" re-enabled.` }
+    : { content: `Hook "${keyArg}" not found or not disabled. Use /hooks health to check status.` }
+}
+
 const batchCmd: CommandHandler = async (ctx) => {
   const t = resolveT(ctx)
   return { content: t('commands.batch.title') }
@@ -2426,6 +2488,7 @@ const resumeLastCmd: CommandHandler = async (ctx) => {
         : t('commands.resume.restored_full_footer', { loaded: String(messages.length) }),
     ].join('\n'),
     forwardedMessages: messages,
+    resumeWarning: true,
   }
 }
 
@@ -3776,6 +3839,8 @@ registry.set('/stats', statsCmd)
 registry.set('/summary', summaryCmd)
 registry.set('/cd', cdCmd)
 registry.set('/hooks', hooksCmd)
+registry.set('/hooks health', hooksHealthCmd)
+registry.set('/hooks enable', hooksEnableCmd)
 registry.set('/batch', batchCmd)
 
 // ═══════════════════════════════════════════════════════════════
@@ -3909,6 +3974,8 @@ const COMMAND_DESCRIPTIONS: Record<string, string> = {
   '/summary': 'Generate session summary',
   '/cd': 'Change session working directory',
   '/hooks': 'Manage lifecycle hook scripts',
+  '/hooks health': 'Check hook health — see failures, disabled hooks, recovery status',
+  '/hooks enable': 'Manually re-enable a hook that was auto-disabled after repeated failures',
   '/batch': 'Apply changes across multiple files',
 }
 

package/src/ui/error-boundary.tsx

@@ -0,0 +1,85 @@
+/**
+ * Fix 8: Error Boundary for UI Rendering Protection
+ *
+ * Catches rendering errors in the React/Ink component tree,
+ * preventing the "layout freeze" bug where the interactive session
+ * stops redrawing while the process stays alive.
+ *
+ * Recovery path: renders a fallback message with a hint that the
+ * user can press Enter to attempt recovery (re-render).
+ */
+
+import React, { Component } from 'react'
+import { Text, Box } from 'ink'
+
+interface Props {
+  children: React.ReactNode
+  /** Called when a render error is caught */
+  onError?: (error: Error, errorInfo: React.ErrorInfo) => void
+}
+
+interface State {
+  hasError: boolean
+  error: Error | null
+  errorCount: number
+}
+
+export class ErrorBoundary extends Component<Props, State> {
+  private resetTimer: ReturnType<typeof setTimeout> | null = null
+
+  constructor(props: Props) {
+    super(props)
+    this.state = { hasError: false, error: null, errorCount: 0 }
+  }
+
+  static getDerivedStateFromError(error: Error): Partial<State> {
+    return { hasError: true, error }
+  }
+
+  override componentDidCatch(error: Error, errorInfo: React.ErrorInfo): void {
+    // Log to stderr for diagnostics
+    process.stderr.write(
+      `\n⚠️  UI Error Boundary caught: ${error.message}\n` +
+        `   Component: ${errorInfo.componentStack?.slice(0, 200) || 'unknown'}\n`,
+    )
+
+    this.props.onError?.(error, errorInfo)
+
+    // Auto-recovery: reset after 5 seconds to attempt re-render
+    this.resetTimer = setTimeout(() => {
+      this.setState((prev) => ({
+        hasError: false,
+        error: null,
+        errorCount: prev.errorCount,
+      }))
+    }, 5_000)
+  }
+
+  override componentWillUnmount(): void {
+    if (this.resetTimer) {
+      clearTimeout(this.resetTimer)
+    }
+  }
+
+  override render(): React.ReactNode {
+    if (this.state.hasError) {
+      return (
+        <Box flexDirection="column" padding={1}>
+          <Text color="red" bold>
+            ⚠️ UI Render Error
+          </Text>
+          <Text dimColor>{this.state.error?.message || 'Unknown rendering error'}</Text>
+          <Text> </Text>
+          <Text dimColor>
+            The terminal interface encountered a rendering issue. Auto-recovery in 5 seconds...
+            Press Enter to attempt immediate recovery.
+          </Text>
+          <Text> </Text>
+          <Text color="yellow">Your session data and conversation history are preserved.</Text>
+        </Box>
+      )
+    }
+
+    return this.props.children
+  }
+}