@miphamai/cli 0.20.3 → 0.22.0

package/package.json

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

package/src/commands/workflow-view.ts

@@ -0,0 +1,74 @@
+import type { CommandHandler } from '../ui/commands.js'
+import { listRuns, loadJournal } from '../workflow/journal.js'
+
+export const workflowViewCmd: CommandHandler = async (_ctx, args) => {
+  const runId = args[0]
+
+  // /workflow list — show recent runs
+  if (!runId || runId === 'list') {
+    const runs = listRuns()
+    if (runs.length === 0) {
+      return {
+        content:
+          'No workflow runs found.\n\nRuns are saved to ~/.mipham/workflows/ after each Workflow tool invocation.',
+      }
+    }
+
+    const lines: string[] = ['── Recent Workflow Runs ──', '']
+
+    // Show last 10, newest first
+    const recent = runs.sort().reverse().slice(0, 10)
+    for (const id of recent) {
+      const entries = loadJournal(id)
+      const agentCount = entries.filter((e) => e.type === 'agent').length
+      const phaseCount = entries.filter((e) => e.type === 'phase').length
+      const shortId = id.slice(0, 20)
+      lines.push(`  ${shortId}... — ${agentCount} agents, ${phaseCount} phases`)
+    }
+
+    lines.push('', `Total runs: ${runs.length}`)
+    lines.push('', 'Use /workflow view <runId> to see details.')
+    return { content: lines.join('\n') }
+  }
+
+  // /workflow view <runId> — show run details
+  const entries = loadJournal(runId)
+  if (entries.length === 0) {
+    return { content: `Run "${runId}" not found.\n\nUse /workflow list to see available runs.` }
+  }
+
+  const lines: string[] = [`── Workflow: ${runId.slice(0, 30)} ──`, '']
+
+  let currentPhase = ''
+  for (const entry of entries) {
+    if (entry.type === 'phase') {
+      currentPhase = entry.message || ''
+      lines.push(`  ▸ Phase: ${currentPhase}`)
+    } else if (entry.type === 'agent') {
+      const label = entry.opts?.label || entry.prompt?.slice(0, 50) || 'agent'
+      lines.push(`    ● ${label}`)
+    } else if (entry.type === 'log') {
+      lines.push(`    ℹ ${entry.message}`)
+    }
+  }
+
+  lines.push('', `Total entries: ${entries.length}`)
+  return { content: lines.join('\n') }
+}
+
+export const workflowWatchCmd: CommandHandler = async (_ctx, _args) => {
+  // /workflow watch — monitor the currently active workflow
+  // This is a hint: the actual rendering is handled by WorkflowProgress component
+  // which auto-detects active workflows. This command just confirms watch mode.
+  return {
+    content: [
+      '── Workflow Watch Mode ──',
+      '',
+      'Workflow progress is displayed automatically when a workflow is running.',
+      'No active workflow detected.',
+      '',
+      'Use /workflow list to see past runs.',
+      'Use /workflow view <id> to replay a completed run.',
+    ].join('\n'),
+  }
+}

package/src/config/defaults.ts

@@ -17,6 +17,10 @@ export const DEFAULT_CONFIG: MiphamConfig = {
     strictKnownMarketplaces: [],
     blockedMarketplaces: [],
   },
+  features: {
+    mcp: { oauthEnabled: true },
+    context: { useRealTokenizer: true, adaptiveThresholds: true },
+  },
 }
 
 export const DEFAULT_INFERENCE_HOOK_CONFIG: InferenceHookConfig = {

package/src/config/keys-manager.ts

@@ -4,6 +4,7 @@ import { homedir } from 'node:os'
 
 const MIPHAM_DIR = join(homedir(), '.mipham')
 const KEYS_FILE = join(MIPHAM_DIR, 'keys.json')
+const EXPIRY_DAYS = 90
 
 export interface KeyEntry {
   createdAt: string
@@ -62,7 +63,7 @@ export class KeyManager {
       lastRotated: entry.lastRotated,
       rotationCount: entry.rotationCount,
       ageDays: daysSince(entry.lastRotated),
-      expired: daysSince(entry.lastRotated) > 90,
+      expired: daysSince(entry.lastRotated) > EXPIRY_DAYS,
     }))
   }
 
@@ -114,8 +115,23 @@ export class KeyManager {
     if (expired.length === 0) return null
 
     const lines = expired.map(
-      (k) => `  - ${k.provider}: last rotated ${k.ageDays} days ago (90-day threshold exceeded)`,
+      (k) =>
+        `  - ${k.provider}: last rotated ${k.ageDays} days ago (${EXPIRY_DAYS}-day threshold exceeded)`,
     )
     return `⚠️  API key rotation overdue:\n${lines.join('\n')}\n\nRun /keys rotate <provider> to rotate.`
   }
+
+  ensureEntry(provider: string): void {
+    const data = loadKeys()
+    if (!data[provider]) {
+      const now = new Date().toISOString()
+      data[provider] = {
+        provider,
+        createdAt: now,
+        lastRotated: now,
+        rotationCount: 0,
+      }
+      saveKeys(data)
+    }
+  }
 }

package/src/core/context-compact.ts

@@ -12,24 +12,34 @@ import { snipMessages } from './context-snip'
  * 2. The most recent N messages (kept intact)
  * 3. The system prompt (unchanged)
  */
+/**
+ * Adaptive keep-recent count: scales with context window size.
+ * 128K → 20, 200K → 20, 500K → 40, 1M → 80
+ */
+function getKeepRecent(contextWindow: number): number {
+  return Math.max(20, Math.floor(contextWindow / 12500))
+}
+
 export async function reactiveCompact(
   context: ContextManager,
   summarizer: Summarizer,
   heading: string,
-  keepRecent: number = 20,
+  keepRecent?: number,
 ): Promise<void> {
+  // Use explicit override, or adaptive default based on context window
+  const effectiveKeepRecent = keepRecent ?? getKeepRecent(context.getMaxTokens())
   const messages = context.getMessages()
 
-  if (messages.length <= keepRecent + 4) return
+  if (messages.length <= effectiveKeepRecent + 4) return
 
   // First, run snip to remove empty pairs
   const { messages: snipped } = snipMessages(messages)
 
-  if (snipped.length <= keepRecent + 4) return
+  if (snipped.length <= effectiveKeepRecent + 4) return
 
   // Split: old messages to summarize, recent messages to keep
-  const toSummarize = snipped.slice(0, -keepRecent)
-  const toKeep = snipped.slice(-keepRecent)
+  const toSummarize = snipped.slice(0, -effectiveKeepRecent)
+  const toKeep = snipped.slice(-effectiveKeepRecent)
 
   // Generate summary
   let summary: string

package/src/core/context.ts

@@ -55,11 +55,24 @@ export class ContextManager {
   private compressionPending = false
 
   constructor(private config: ContextConfig) {
-    // Adaptive thresholds: larger context → later compaction
-    // 200K → 0.90, 500K → 0.93, 1M → 0.95
-    if (config.contextWindow && config.contextWindow > 200_000) {
-      config.compactionThreshold = Math.max(0.9, 1 - 50000 / config.contextWindow)
-    }
+    this.calculateThresholds()
+  }
+
+  /**
+   * Calculate adaptive compaction thresholds based on the model's context window.
+   *
+   * compaction:  200K→0.75(→clamped 0.90), 500K→0.90, 1M→0.95
+   * microcompact: 200K→0.70(→clamped 0.70), 500K→0.80, 1M→0.85
+   */
+  calculateThresholds(): void {
+    const w = this.config.contextWindow
+    if (!w) return
+
+    // compaction: window越大越晚compact，floor at 0.90
+    this.config.compactionThreshold = Math.max(0.9, 1 - 50000 / w)
+
+    // microcompact threshold is computed inline in checkCompression()
+    // using this.config.contextWindow directly
   }
 
   getCompactionThreshold(): number {
@@ -71,8 +84,8 @@ export class ContextManager {
     this.config.maxTokens = maxTokens
     if (contextWindow) {
       this.config.contextWindow = contextWindow
-      this.config.compactionThreshold = Math.max(0.9, 1 - 50000 / contextWindow)
     }
+    this.calculateThresholds()
   }
 
   getMaxTokens(): number {

package/src/core/memory/memory-manager.ts

@@ -26,15 +26,22 @@ export interface MemoryEntry {
 }
 
 const INDEX_FILE = 'MEMORY.md'
+const LINKS_FILE = 'links.json'
 
 export class MemoryManager {
   private memories = new Map<string, MemoryEntry>()
   private linkGraph: Map<string, Set<string>> = new Map()
+  private contextMaxTokens = 200_000
 
   constructor(private memoryDir: string) {
     mkdirSync(memoryDir, { recursive: true })
   }
 
+  /** Set the model's context window size for adaptive memory budget. */
+  setContextWindow(tokens: number): void {
+    this.contextMaxTokens = tokens
+  }
+
   loadAll(): void {
     this.memories.clear()
     this.linkGraph.clear()
@@ -48,7 +55,7 @@ export class MemoryManager {
     }
 
     for (const entry of entries) {
-      if (entry === INDEX_FILE || extname(entry) !== '.md') continue
+      if (entry === INDEX_FILE || entry === LINKS_FILE || extname(entry) !== '.md') continue
       const filePath = join(this.memoryDir, entry)
       try {
         const raw = readFileSync(filePath, 'utf-8')
@@ -60,7 +67,11 @@ export class MemoryManager {
         // skip unparseable
       }
     }
-    this.rebuildLinkGraph()
+
+    // Try cached link graph first, fall back to rebuild
+    if (!this.loadLinkGraph()) {
+      this.rebuildLinkGraph()
+    }
   }
 
   write(name: string, content: string, metadata: MemoryMetadata): void {
@@ -172,10 +183,15 @@ export class MemoryManager {
       // file may already be gone
     }
     this.memories.delete(name)
+    this.linkGraph.delete(name)
+    this.saveLinkGraph()
     this.updateIndex()
   }
 
-  buildSystemReminder(context: string, maxTokens: number = 15000): string {
+  buildSystemReminder(context: string, maxTokens?: number): string {
+    // Adaptive budget: 5% of context window, min 5000, max 75000
+    const effectiveMaxTokens =
+      maxTokens ?? Math.max(5000, Math.min(75000, Math.floor(this.contextMaxTokens * 0.05)))
     const relevant = this.recall(context, 10)
     if (relevant.length === 0) return ''
 
@@ -185,7 +201,7 @@ export class MemoryManager {
     for (const entry of relevant) {
       const line = `- ${entry.name}: ${entry.content.slice(0, 200)}`
       const lineTokens = Math.ceil(line.length / 4)
-      if (tokenBudget + lineTokens > maxTokens) break
+      if (tokenBudget + lineTokens > effectiveMaxTokens) break
       lines.push(line)
       tokenBudget += lineTokens
     }
@@ -318,6 +334,8 @@ export class MemoryManager {
         this.linkGraph.set(otherName, otherSet)
       }
     }
+
+    this.saveLinkGraph()
   }
 
   private rebuildLinkGraph(): void {
@@ -343,6 +361,33 @@ export class MemoryManager {
     }
   }
 
+  private saveLinkGraph(): void {
+    const obj: Record<string, string[]> = {}
+    for (const [k, v] of this.linkGraph) {
+      obj[k] = Array.from(v)
+    }
+    try {
+      writeFileSync(join(this.memoryDir, LINKS_FILE), JSON.stringify(obj, null, 2), 'utf-8')
+    } catch {
+      // best-effort — never block on cache write
+    }
+  }
+
+  private loadLinkGraph(): boolean {
+    const path = join(this.memoryDir, LINKS_FILE)
+    if (!existsSync(path)) return false
+    try {
+      const raw = JSON.parse(readFileSync(path, 'utf-8'))
+      for (const [k, v] of Object.entries(raw)) {
+        this.linkGraph.set(k, new Set(v as string[]))
+      }
+      return this.linkGraph.size > 0
+    } catch {
+      // corrupt file — rebuild from source
+      return false
+    }
+  }
+
   private parseMemoryFile(raw: string, filePath: string): MemoryEntry | null {
     const match = raw.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/)
     if (!match) return null

package/src/index.tsx

@@ -135,12 +135,21 @@ export async function runApp(options: RunOptions): Promise<void> {
     )
   }
 
+  // Phase 9 feature flags (all default true — opt-out via config)
+  const features = config.features || {}
+  const adaptiveThresholds = features.context?.adaptiveThresholds !== false
+  // gated via TokenCounter — set to false to fall back to chars/4 heuristic
+  const _useRealTokenizer = features.context?.useRealTokenizer !== false
+
   const context = new ContextManager({
     maxTokens: contextMaxTokens,
     compactionThreshold: 0.9,
-    contextWindow: modelContextWindow,
+    contextWindow: adaptiveThresholds ? modelContextWindow : undefined,
   })
 
+  // Adaptive memory budget: scale with model's context window
+  getMemoryManager().setContextWindow(modelContextWindow)
+
   if (options.resume) {
     const saved = SessionStore.load(options.resume)
     if (saved) {

package/src/shared/sanitize.ts

@@ -3,7 +3,7 @@
  * Strips invisible/control characters that could hide command content
  * from visual inspection or enable homoglyph attacks.
  *
- * Claude Code v2.1.223 parity: hidden command text via tabs/invisible Unicode.
+ * Protects against hidden command text via tabs/invisible Unicode characters.
  */
 
 const DANGEROUS_UNICODE = /[​‌‍‎‏‪‫‬‭‮⁠⁦⁧⁨⁩]/g

package/src/shared/types.ts

@@ -160,6 +160,13 @@ export interface MiphamConfig {
     /** Block installs from matching repos (e.g. ["malicious-org/*"]) */
     blockedMarketplaces?: string[]
   }
+  /** Phase 9 feature flags. All default to true. */
+  features?: Partial<FeatureFlags>
+}
+
+export interface FeatureFlags {
+  mcp: { oauthEnabled: boolean }
+  context: { useRealTokenizer: boolean; adaptiveThresholds: boolean }
 }
 
 export interface McpServerConfig {

package/src/ui/app.tsx

@@ -12,6 +12,7 @@ import { ChatPanel } from './chat'
 import { InputBar } from './input'
 import { ModelPicker } from './picker'
 import { AgentFooter, type AgentEntry } from './agent-footer'
+import { WorkflowProgress } from './workflow-progress.js'
 import {
   getCommand,
   looksLikeSlashCommand,
@@ -576,6 +577,9 @@ export function App({
         <Text dimColor>{modelId}</Text>
       </Box>
 
+      {/* Workflow progress — auto-detects active workflows, renders nothing when idle */}
+      <WorkflowProgress />
+
       {/* Chat panel */}
       <ChatPanel messages={messages} focusMode={focusMode} />
 

package/src/ui/commands.ts

@@ -39,6 +39,7 @@ import {
 import { themeCmd, releaseNotesCmd, ideCmd, terminalSetupCmd } from '../commands/environment.js'
 import { commitCmd, pushCmd, prCmd, issueCmd } from '../commands/git.js'
 import { keysCmd } from '../commands/keys'
+import { workflowViewCmd, workflowWatchCmd } from '../commands/workflow-view.js'
 
 export interface CommandContext {
   engine: QueryEngine
@@ -3080,6 +3081,8 @@ const commandsListCmd: CommandHandler = () => {
     '/pr-comments': 'Workflow',
     '/diff': 'Workflow',
     '/workflows': 'Workflow',
+    '/workflow view': 'Workflow',
+    '/workflow watch': 'Workflow',
     '/deep-research': 'Workflow',
     '/loop': 'Workflow',
     '/init': 'Project',
@@ -3217,6 +3220,8 @@ registry.set('/loop', loopCmd)
 registry.set('/no-plan', noPlanCmd)
 registry.set('/workflow', workflowAutoCmd)
 registry.set('/workflows', workflowsCmd)
+registry.set('/workflow view', workflowViewCmd)
+registry.set('/workflow watch', workflowWatchCmd)
 registry.set('/deep-research', deepResearchCmd)
 registry.set('/review', reviewCmd)
 registry.set('/pr-comments', prCommentsCmd)
@@ -3363,6 +3368,8 @@ const COMMAND_DESCRIPTIONS: Record<string, string> = {
   '/pr-comments': 'PR review summary',
   '/diff': 'Show git diff',
   '/workflows': 'List workflow scripts',
+  '/workflow view': 'View workflow run details or list runs',
+  '/workflow watch': 'Monitor active workflow execution',
   '/deep-research':
     'Deep research with multi-agent parallel search, verification, and cited synthesis',
   '/loop': 'Run prompt on interval',

package/src/ui/workflow-progress.tsx

@@ -0,0 +1,176 @@
+import React, { useState, useEffect, useMemo } from 'react'
+import { Box, Text } from 'ink'
+import { getEventBus } from '../workflow/event-bus.js'
+import type { WorkflowEvent } from '../workflow/event-bus.js'
+
+interface AgentState {
+  label: string
+  phase: string
+  status: 'running' | 'done' | 'failed'
+  durationMs: number
+}
+
+interface WorkflowProgressProps {
+  /** If provided, only show progress for this runId. Otherwise auto-detect. */
+  runId?: string
+}
+
+export function WorkflowProgress({ runId }: WorkflowProgressProps) {
+  const [activeRunId, setActiveRunId] = useState<string | null>(null)
+  const [phases, setPhases] = useState<Array<{ name: string; done: boolean }>>([])
+  const [agents, setAgents] = useState<Map<string, AgentState>>(new Map())
+  const [elapsed, setElapsed] = useState(0)
+  const [done, setDone] = useState(false)
+  const [_totalAgents, setTotalAgents] = useState(0)
+  const [cacheHits, setCacheHits] = useState(0)
+
+  useEffect(() => {
+    const bus = getEventBus()
+
+    const handleEvent = (event: WorkflowEvent) => {
+      switch (event.type) {
+        case 'phase:start':
+          setPhases((prev) => [...prev, { name: event.phase, done: false }])
+          setActiveRunId(bus.getActiveRunId())
+          break
+
+        case 'agent:start':
+          setAgents((prev) => {
+            const next = new Map(prev)
+            next.set(event.agentId, {
+              label: event.label,
+              phase: event.phase,
+              status: 'running',
+              durationMs: 0,
+            })
+            return next
+          })
+          break
+
+        case 'agent:end':
+          setAgents((prev) => {
+            const next = new Map(prev)
+            const existing = next.get(event.agentId)
+            if (existing) {
+              next.set(event.agentId, {
+                ...existing,
+                status: event.success ? 'done' : 'failed',
+                durationMs: event.durationMs,
+              })
+              // Mark phase as done if all agents in it are done
+              const phaseName = existing.phase
+              const allInPhase = Array.from(next.values()).filter((a) => a.phase === phaseName)
+              const allDone = allInPhase.every((a) => a.status !== 'running')
+              if (allDone) {
+                setPhases((prev) =>
+                  prev.map((p) => (p.name === phaseName ? { ...p, done: true } : p)),
+                )
+              }
+            }
+            return next
+          })
+          break
+
+        case 'done':
+          setDone(true)
+          setTotalAgents(event.totalAgents)
+          setCacheHits(event.cacheHits)
+          break
+
+        case 'error':
+          break
+      }
+    }
+
+    // Subscribe to all event types
+    const types = [
+      'phase:start',
+      'agent:start',
+      'agent:end',
+      'agent:result',
+      'log',
+      'error',
+      'done',
+    ]
+    for (const type of types) {
+      bus.on(type, handleEvent)
+    }
+
+    // Elapsed timer (ticks every 100ms)
+    const timer = setInterval(() => {
+      setElapsed((prev) => prev + 100)
+    }, 100)
+
+    return () => {
+      for (const type of types) {
+        bus.off(type, handleEvent)
+      }
+      clearInterval(timer)
+    }
+  }, [])
+
+  const agentList = useMemo(() => Array.from(agents.values()), [agents])
+
+  if (!activeRunId && !runId) return null
+  if (done && agentList.length === 0) return null
+
+  const runningCount = agentList.filter((a) => a.status === 'running').length
+  const doneCount = agentList.filter((a) => a.status === 'done').length
+  const failedCount = agentList.filter((a) => a.status === 'failed').length
+
+  const formatDuration = (ms: number) => {
+    if (ms < 1000) return `${ms}ms`
+    return `${(ms / 1000).toFixed(1)}s`
+  }
+
+  const elapsedStr = formatDuration(elapsed)
+
+  return (
+    <Box flexDirection="column" borderStyle="round" borderColor="cyan" paddingX={1}>
+      <Box>
+        <Text bold color="cyan">
+          ═══ Workflow: {activeRunId || runId} ═══
+        </Text>
+      </Box>
+
+      {/* Phases */}
+      {phases.map((phase, i) => {
+        const phaseAgents = agentList.filter((a) => a.phase === phase.name)
+        return (
+          <Box key={i} flexDirection="column" marginTop={1}>
+            <Text>
+              {phase.done ? '●' : '◌'} Phase: {phase.name}
+              {phaseAgents.length > 0 &&
+                ` [${phaseAgents.filter((a) => a.status === 'done').length}/${phaseAgents.length} done]`}
+            </Text>
+            {phaseAgents.map((agent, j) => (
+              <Box key={j} marginLeft={2}>
+                <Text
+                  color={
+                    agent.status === 'done' ? 'green' : agent.status === 'failed' ? 'red' : 'yellow'
+                  }
+                >
+                  {agent.status === 'done' ? '✓' : agent.status === 'failed' ? '✗' : '⏳'}{' '}
+                  {agent.label}
+                  {agent.status !== 'running' && ` ${formatDuration(agent.durationMs)}`}
+                </Text>
+              </Box>
+            ))}
+          </Box>
+        )
+      })}
+
+      {/* Summary footer */}
+      <Box marginTop={1}>
+        <Text dimColor>
+          ═══ Elapsed: {elapsedStr} | Agents: {doneCount}/{agentList.length}
+          {runningCount > 0 && ` (${runningCount} running)`}
+          {failedCount > 0 && ` (${failedCount} failed)`}
+          {done && ` | Cache hits: ${cacheHits}`}
+          {done && ' | DONE ═══'}
+          {!done && ' | Status: running ═══'}
+        </Text>
+      </Box>
+    </Box>
+  )
+}

package/src/workflow/event-bus.ts

@@ -0,0 +1,36 @@
+import { EventEmitter } from 'node:events'
+
+export type WorkflowEvent =
+  | { type: 'phase:start'; phase: string; timestamp: number }
+  | { type: 'phase:end'; phase: string; timestamp: number }
+  | { type: 'agent:start'; agentId: string; label: string; phase: string }
+  | { type: 'agent:end'; agentId: string; label: string; success: boolean; durationMs: number }
+  | { type: 'agent:result'; agentId: string; summary: string }
+  | { type: 'log'; message: string }
+  | { type: 'error'; agentId?: string; message: string }
+  | { type: 'done'; runId: string; totalAgents: number; cacheHits: number }
+
+export class WorkflowEventBus extends EventEmitter {
+  private activeRunId: string | null = null
+
+  startRun(runId: string): void {
+    this.activeRunId = runId
+  }
+
+  emitEvent(event: WorkflowEvent): void {
+    this.emit(event.type, event)
+  }
+
+  getActiveRunId(): string | null {
+    return this.activeRunId
+  }
+}
+
+let instance: WorkflowEventBus | null = null
+
+export function getEventBus(): WorkflowEventBus {
+  if (!instance) {
+    instance = new WorkflowEventBus()
+  }
+  return instance
+}

package/src/workflow/runtime.ts

@@ -6,6 +6,7 @@ import { workflowAgent } from './primitives/agent'
 import { parallel } from './primitives/parallel'
 import { pipeline } from './primitives/pipeline'
 import { phase as phasePrimitive } from './primitives/phase'
+import { getEventBus } from './event-bus'
 import { verify, judge } from './primitives/verify'
 import { loopUntilConvergence } from './primitives/loop'
 import type { ProviderRegistry } from '../providers/registry'
@@ -96,6 +97,9 @@ export async function runWorkflow(
     createJournal(runId, script)
   }
 
+  const bus = getEventBus()
+  bus.startRun(runId)
+
   const registry: ProviderRegistry = engine.getRegistry()
   const toolRegistry = engine.getTools()
   const permission = engine.getPermission()
@@ -114,10 +118,20 @@ export async function runWorkflow(
     }
     cacheMisses++
 
+    const agentId = (opts?.label as string) || `agent-${cacheMisses}`
+    const phase = (opts?.phase as string) || 'default'
+    const startTime = Date.now()
+
+    bus.emitEvent({ type: 'agent:start', agentId, label: agentId, phase })
+
     const result = await workflowAgent(prompt, registry, toolRegistry, {
       ...(opts || {}),
       permissionSystem: permission,
     } as Record<string, unknown>)
+
+    const durationMs = Date.now() - startTime
+    bus.emitEvent({ type: 'agent:end', agentId, label: agentId, success: true, durationMs })
+
     appendJournal(runId, {
       type: 'agent',
       prompt,
@@ -129,10 +143,12 @@ export async function runWorkflow(
 
   const wrappedPhase = (title: string) => {
     phasePrimitive(title)
+    bus.emitEvent({ type: 'phase:start', phase: title, timestamp: Date.now() })
     appendJournal(runId, { type: 'phase', message: title })
   }
 
   const log = (message: string) => {
+    bus.emitEvent({ type: 'log', message })
     appendJournal(runId, { type: 'log', message })
   }
 
@@ -160,8 +176,16 @@ export async function runWorkflow(
   let result: unknown
   try {
     result = await vmScript.runInContext(sandboxCtx, { timeout: 120_000 })
+
+    bus.emitEvent({
+      type: 'done',
+      runId,
+      totalAgents: cacheMisses,
+      cacheHits,
+    })
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err)
+    bus.emitEvent({ type: 'error', message })
     throw new Error(
       `Workflow script execution failed: ${message}\n\n` +
         `This is likely a bug in the workflow script, not in Mipham Code itself. ` +