tycono 0.3.45-beta.2 → 0.3.45-beta.3

package/{src → packages/server/src}/api/src/routes/execute.ts

@@ -2,6 +2,8 @@ import type { IncomingMessage, ServerResponse } from 'node:http';
 import fs from 'node:fs';
 import path from 'node:path';
 import { COMPANY_ROOT } from '../services/file-reader.js';
+import { autoSelectPreset } from '../services/preset-loader.js';
+import { readConfig } from '../services/company-config.js';
 // activity-tracker removed — executionManager is Single Source of Truth
 import { buildOrgTree, canDispatchTo, getSubordinates } from '../engine/org-tree.js';
 import { createRunner, type RunnerResult } from '../engine/runners/index.js';
@@ -21,6 +23,7 @@ import { earnCoinsInternal } from './coins.js';
 import { appendFollowUpToWave } from '../services/wave-tracker.js';
 import { waveMultiplexer } from '../services/wave-multiplexer.js';
 import { supervisorHeartbeat } from '../services/supervisor-heartbeat.js';
+import { decideDispatchOrAmend } from '../services/dispatch-classifier.js';
 
 /* ─── Auto-attach child executions to wave multiplexer ── */
 executionManager.onExecutionCreated((exec) => {
@@ -126,6 +129,32 @@ export function handleExecRequest(req: IncomingMessage, res: ServerResponse): vo
     return;
   }
 
+  // ── GET /api/waves/:waveId — Single wave status ──
+  const waveDetailMatch = url.match(/^\/api\/waves\/([^/]+)$/);
+  if (method === 'GET' && waveDetailMatch) {
+    const waveId = waveDetailMatch[1];
+    // Try active waves first
+    const activeWaves = waveMultiplexer.getActiveWaves();
+    const active = activeWaves.find((w: { waveId: string }) => w.waveId === waveId);
+    if (active) {
+      jsonResponse(res, 200, active);
+      return;
+    }
+    // Fallback: read wave file from disk
+    const wavePath = path.join(COMPANY_ROOT, '.tycono', 'waves', `${waveId}.json`);
+    if (fs.existsSync(wavePath)) {
+      try {
+        const waveData = JSON.parse(fs.readFileSync(wavePath, 'utf-8'));
+        jsonResponse(res, 200, waveData);
+      } catch {
+        jsonResponse(res, 500, { error: 'Failed to read wave file' });
+      }
+      return;
+    }
+    jsonResponse(res, 404, { error: 'Wave not found' });
+    return;
+  }
+
   // ── Legacy /api/exec/* routes ──
   const sessionMatch = url.match(/\/api\/exec\/session\/([^/]+)\/message$/);
 
@@ -156,31 +185,47 @@ function handleJobsRequest(url: string, method: string, req: IncomingMessage, re
     return;
   }
 
-  // GET /api/jobs/:id — internal only
+  // GET /api/jobs/:id — internal only (dispatch bridge --check)
   const jobMatch = reqPath.match(/^\/api\/jobs\/([^/]+)$/);
   if (method === 'GET' && jobMatch) {
     const id = jobMatch[1];
     const exec = executionManager.getExecution(id) ?? executionManager.getActiveExecution(id);
     if (!exec) {
-      // Try reading from stream file directly
+      // Fallback: read from activity-stream file on disk
       if (ActivityStream.exists(id)) {
         const events = ActivityStream.readAll(id);
-        res.writeHead(200, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ id, events }));
+        const doneEvent = [...events].reverse().find(e => e.type === 'msg:done' || e.type === 'msg:error');
+        const output = doneEvent?.data?.output as string ?? '';
+        const status = doneEvent?.type === 'msg:done' ? 'done' : doneEvent?.type === 'msg:error' ? 'error' : 'unknown';
+        jsonResponse(res, 200, { id, status, output, fromStream: true });
       } else {
-        res.writeHead(404);
-        res.end(JSON.stringify({ error: 'Not found' }));
+        jsonResponse(res, 404, { error: 'Not found' });
       }
     } else {
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({
+      // Include output from result if available
+      const output = exec.result?.output?.slice(-2000) ?? '';
+      jsonResponse(res, 200, {
         id: exec.id,
         roleId: exec.roleId,
         task: exec.task,
         status: exec.status,
         sessionId: exec.sessionId,
         createdAt: exec.createdAt,
-      }));
+        output,
+      });
+    }
+    return;
+  }
+
+  // GET /api/jobs/:id/history — activity-stream events (dispatch bridge get_result)
+  const historyMatch = reqPath.match(/^\/api\/jobs\/([^/]+)\/history$/);
+  if (method === 'GET' && historyMatch) {
+    const id = historyMatch[1];
+    if (ActivityStream.exists(id)) {
+      const events = ActivityStream.readAll(id);
+      jsonResponse(res, 200, { id, events });
+    } else {
+      jsonResponse(res, 404, { error: 'Stream not found' });
     }
     return;
   }
@@ -206,7 +251,7 @@ function handleJobsRequest(url: string, method: string, req: IncomingMessage, re
 
 /* ─── POST /api/jobs ─────────────────────── */
 
-function handleStartJob(body: Record<string, unknown>, res: ServerResponse): void {
+async function handleStartJob(body: Record<string, unknown>, res: ServerResponse): Promise<void> {
   const type = (body.type as string) ?? 'assign';
   const roleId = body.roleId as string;
   const task = body.task as string;
@@ -224,6 +269,12 @@ function handleStartJob(body: Record<string, unknown>, res: ServerResponse): voi
     const targetRoles = body.targetRoles as string[] | undefined;
     const continuous = body.continuous === true;
     const preset = body.preset as string | undefined;
+    const permissionMode = body.permissionMode as string | undefined;
+
+    // Set permission mode for agent runners (auto = model-based safety, bypassPermissions = full access)
+    if (permissionMode) {
+      process.env.TYCONO_PERMISSION_MODE = permissionMode;
+    }
 
     // Always use supervisor mode — CEO supervises C-Levels who supervise members
     {
@@ -256,12 +307,76 @@ function handleStartJob(body: Record<string, unknown>, res: ServerResponse): voi
     return;
   }
 
-  const orgTree = buildOrgTree(COMPANY_ROOT);
+  // Resolve preset from wave for correct org tree (includes agency roles)
+  let presetId: string | undefined;
+  if (waveId) {
+    try {
+      const wavePath = path.join(COMPANY_ROOT, '.tycono', 'waves', `${waveId}.json`);
+      if (fs.existsSync(wavePath)) {
+        presetId = JSON.parse(fs.readFileSync(wavePath, 'utf-8')).preset;
+      }
+    } catch { /* ignore */ }
+  }
+  const orgTree = buildOrgTree(COMPANY_ROOT, presetId);
   if (!canDispatchTo(orgTree, sourceRole, roleId)) {
-    jsonResponse(res, 403, { error: `${sourceRole} cannot dispatch to ${roleId}.` });
+    const errorMsg = `${sourceRole} cannot dispatch to ${roleId}`;
+    // Emit dispatch:error on parent's activity stream so it surfaces in SSE
+    if (parentSessionId) {
+      const parentStream = ActivityStream.getOrCreate(parentSessionId, sourceRole);
+      parentStream.emit('dispatch:error', sourceRole, {
+        sourceRole,
+        targetRole: roleId,
+        error: errorMsg,
+        timestamp: Date.now(),
+      });
+    }
+    console.warn(`[Dispatch:Error] ${errorMsg} (parent=${parentSessionId ?? 'none'}, wave=${waveId ?? 'none'})`);
+    jsonResponse(res, 403, { error: `${errorMsg}.` });
     return;
   }
 
+  // Auto-amend: check if we should amend an existing session instead of creating a new one
+  if (!readOnly && waveId) {
+    try {
+      const decision = await decideDispatchOrAmend(waveId, roleId, sourceRole, task);
+      if (decision.action === 'amend' && decision.prevSessionId) {
+        console.log(`[AutoAmend] Converting dispatch to amend: ${roleId} → ${decision.prevSessionId} (${decision.reason})`);
+        const amendedExec = executionManager.continueSession(
+          decision.prevSessionId,
+          `[FOLLOW-UP from ${sourceRole}] ${task}`,
+          sourceRole,
+        );
+        if (amendedExec) {
+          jsonResponse(res, 200, {
+            sessionId: decision.prevSessionId,
+            executionId: amendedExec.id,
+            status: 'running',
+            autoAmend: true,
+            reason: decision.reason,
+          });
+          return;
+        }
+        // continueSession failed — if role is active, do NOT create new session (1-session invariant)
+        if (decision.reason === 'role-already-active') {
+          console.warn(`[Dispatch] ${roleId}: active session ${decision.prevSessionId} cannot be amended yet (running). Queued.`);
+          // Store as pending amendment on the session — will be processed when execution completes
+          executionManager.queueAmendment(decision.prevSessionId!, `[FOLLOW-UP from ${sourceRole}] ${task}`);
+          jsonResponse(res, 200, {
+            sessionId: decision.prevSessionId,
+            status: 'queued',
+            autoAmend: true,
+            reason: 'amendment-queued',
+          });
+          return;
+        }
+        // done session amend failed — fall through to new dispatch as last resort
+        console.warn(`[AutoAmend] continueSession failed for ${decision.prevSessionId}, falling back to new dispatch`);
+      }
+    } catch (err) {
+      console.warn('[AutoAmend] Decision failed, proceeding with new dispatch:', err);
+    }
+  }
+
   const sessionSource: 'wave' | 'dispatch' = waveId ? 'wave' : 'dispatch';
   const session = createSession(roleId, {
     mode: readOnly ? 'talk' : 'do',
@@ -459,7 +574,31 @@ function handleSaveWave(body: Record<string, unknown>, res: ServerResponse): voi
     }
   }
 
-  const waveJson = {
+  // Collect dispatch statistics
+  const dispatchStats = {
+    attempted: 0,
+    succeeded: 0,
+    failed: 0,
+    errors: [] as Array<{ sourceRole: string; targetRole: string; error: string }>,
+  };
+  for (const role of rolesData) {
+    for (const e of role.events) {
+      if (e.type === 'dispatch:start') {
+        dispatchStats.attempted++;
+        dispatchStats.succeeded++;
+      } else if (e.type === 'dispatch:error') {
+        dispatchStats.attempted++;
+        dispatchStats.failed++;
+        dispatchStats.errors.push({
+          sourceRole: (e.data.sourceRole as string) ?? 'unknown',
+          targetRole: (e.data.targetRole as string) ?? 'unknown',
+          error: (e.data.error as string) ?? 'unknown',
+        });
+      }
+    }
+  }
+
+  const waveJson: Record<string, unknown> = {
     id: baseName,
     directive,
     startedAt: startedAt.toISOString(),
@@ -468,6 +607,7 @@ function handleSaveWave(body: Record<string, unknown>, res: ServerResponse): voi
     ...(waveId && { waveId }),
     sessionIds: allSessionIds,
   };
+  if (dispatchStats.attempted > 0) waveJson.dispatch = dispatchStats;
   fs.writeFileSync(jsonPath, JSON.stringify(waveJson, null, 2), 'utf-8');
 
   const roleCount = rolesData.length;
@@ -636,6 +776,9 @@ function handleAssign(body: Record<string, unknown>, req: IncomingMessage, res:
       case 'dispatch:start':
         sendSSE(res, 'dispatch', { roleId: event.data.targetRoleId, task: event.data.task, childSessionId: event.data.childSessionId });
         break;
+      case 'dispatch:error':
+        sendSSE(res, 'dispatch:error', { sourceRole: event.data.sourceRole, targetRole: event.data.targetRole, error: event.data.error, timestamp: event.data.timestamp });
+        break;
       case 'msg:turn-complete':
         sendSSE(res, 'turn', { turn: event.data.turn });
         break;
@@ -680,21 +823,79 @@ function handleWave(body: Record<string, unknown>, req: IncomingMessage, res: Se
 
   const targetRoles = body.targetRoles as string[] | undefined;
   const continuous = body.continuous === true;
+  let preset = body.preset as string | undefined;
+
+  // Agency resolution priority: --agency flag > config.defaultAgency > auto-select
+  if (!preset) {
+    const config = readConfig(COMPANY_ROOT);
+    if (config.defaultAgency) {
+      preset = config.defaultAgency;
+      console.log(`[Wave] Using default agency: ${preset} (from .tycono/config.json)`);
+    } else {
+      preset = autoSelectPreset(COMPANY_ROOT, directive);
+      if (preset) {
+        console.log(`[Wave] Auto-selected agency: ${preset} (from directive keywords)`);
+      }
+    }
+  }
+
+  // BUG-FORKBOMB: Check for active waves — amend existing CEO instead of creating new wave
+  const activeWaves = waveMultiplexer.getActiveWaves();
+  if (activeWaves.length > 0) {
+    const existingWave = activeWaves[0];
+    console.log(`[Wave] Active wave detected: ${existingWave.id}. Amending CEO instead of new wave.`);
+
+    // Find CEO session for existing wave
+    const ceoSession = listSessions().find(
+      s => s.waveId === existingWave.id && s.roleId === 'ceo' && s.status === 'active',
+    );
+
+    if (ceoSession) {
+      const amendedExec = executionManager.continueSession(
+        ceoSession.id,
+        `[ADDITIONAL DIRECTIVE] ${directive}`,
+        'user',
+      );
+      if (amendedExec) {
+        jsonResponse(res, 200, {
+          waveId: existingWave.id,
+          sessionId: ceoSession.id,
+          executionId: amendedExec.id,
+          amended: true,
+          message: `Amended existing wave ${existingWave.id}`,
+        });
+        return;
+      }
+      // CEO is running — queue the amendment
+      executionManager.queueAmendment(ceoSession.id, `[ADDITIONAL DIRECTIVE] ${directive}`);
+      jsonResponse(res, 200, {
+        waveId: existingWave.id,
+        sessionId: ceoSession.id,
+        amended: true,
+        queued: true,
+        message: `Amendment queued for active wave ${existingWave.id}`,
+      });
+      return;
+    }
+    // No CEO session found — unusual, proceed with new wave
+    console.warn(`[Wave] Active wave ${existingWave.id} has no CEO session. Creating new wave.`);
+  }
 
   // Always supervisor mode — CEO supervises C-Levels
-  handleWaveSupervisor(directive, targetRoles, continuous, req, res);
+  handleWaveSupervisor(directive, targetRoles, continuous, req, res, preset);
 }
 
 /**
  * Supervisor mode: Start a single CEO Supervisor session that dispatches C-Levels.
  * The supervisor uses dispatch/watch/amend tools — same pattern as any supervisor node.
  */
-function handleWaveSupervisor(directive: string, targetRoles: string[] | undefined, continuous: boolean, req: IncomingMessage, res: ServerResponse): void {
+function handleWaveSupervisor(directive: string, targetRoles: string[] | undefined, continuous: boolean, req: IncomingMessage, res: ServerResponse, preset?: string): void {
   const state = supervisorHeartbeat.start(
     `wave-${Date.now()}`,
     directive,
     targetRoles && targetRoles.length > 0 ? targetRoles : undefined,
     continuous,
+    preset,
   );
 
   if (state.status === 'error') {
@@ -733,11 +934,14 @@ function handleWaveDirective(waveId: string, body: Record<string, unknown>, res:
   }
 
   if (!directive) {
-    jsonResponse(res, 404, { error: `No active supervisor for wave ${waveId}` });
+    jsonResponse(res, 404, { error: `No active supervisor for wave ${waveId}. The wave may have been cleaned up.` });
     return;
   }
 
-  jsonResponse(res, 200, { directive });
+  // Provide status context so caller knows what's happening
+  const state = supervisorHeartbeat.getState(waveId);
+  const status = state?.status ?? 'unknown';
+  jsonResponse(res, 200, { directive, supervisorStatus: status });
 }
 
 /* ─── POST /api/waves/:waveId/question ──────── */

package/packages/server/src/api/src/services/claude-md-manager.ts

@@ -0,0 +1,190 @@
+/**
+ * claude-md-manager.ts — CLAUDE.md lifecycle management
+ *
+ * Three modes:
+ * 1. No CLAUDE.md → create from AKB template
+ * 2. User-owned CLAUDE.md (no tycono:managed marker) → append AKB section
+ * 3. Tycono-managed CLAUDE.md → full replace on version change
+ *
+ * Also installs methodology/agentic-knowledge-base.md if missing.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const TEMPLATES_DIR = path.resolve(__dirname, '../../../../templates');
+
+const AKB_SECTION_MARKER = '<!-- tycono:akb-guide -->';
+
+function getPackageVersion(): string {
+  const pkgPath = path.resolve(__dirname, '../../../../package.json');
+  try {
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+    return pkg.version || '0.0.0';
+  } catch {
+    return '0.0.0';
+  }
+}
+
+function generateClaudeMd(version: string): string {
+  const tmplPath = path.join(TEMPLATES_DIR, 'CLAUDE.md.tmpl');
+  const template = fs.readFileSync(tmplPath, 'utf-8');
+  return template.replaceAll('{{VERSION}}', version);
+}
+
+/**
+ * Generate the AKB appendix section for user-owned CLAUDE.md files.
+ * This is a condensed version of the key AKB principles.
+ */
+function generateAkbAppendix(version: string): string {
+  return `
+${AKB_SECTION_MARKER}
+
+---
+
+## AKB Knowledge Navigation (Tycono)
+
+> Auto-appended by Tycono v${version}. Your content above is untouched.
+> Full reference: \`methodology/agentic-knowledge-base.md\`
+
+### Structure: Root → Hub → Node
+
+| Layer | Role | AI Usage |
+|-------|------|----------|
+| **Root** (CLAUDE.md) | Minimal routing | Auto-injected as system prompt |
+| **Hub** ({folder}.md) | Human TOC + guides | **Check before starting work** |
+| **Node** (*.md) | Actual information | Direct search via Grep/Glob |
+
+### Hub-First Principle
+
+> ⛔ **Read Hub document BEFORE implementing/testing**
+
+| Situation | Read First | What to Find |
+|-----------|------------|--------------|
+| Debugging/Testing | Hub → guides/ | Existing debug tools |
+| API Calls | Hub → related Node | Documented methods |
+| New Feature | Hub | Similar existing features |
+| Strategy/Design | Hub + detail docs | Design philosophy, past decisions |
+
+### Anti-Patterns
+
+\`\`\`
+❌ Skip Hub → code directly
+❌ Skip Hub → Write from scratch
+❌ Read only Hubs → "sufficient" judgment → superficial answers
+\`\`\`
+
+### Exploration Depth
+
+| Question Type | Minimum | Additional |
+|---------------|---------|------------|
+| Implementation | Hub | Related Nodes |
+| **Strategy/Ideas** | Hub | **Design philosophy, core problems, phase docs** |
+| **Connecting A and B** | **Both Hubs** | **Both core docs** |
+
+### Knowledge Gate
+
+> Before creating a new document, search existing docs first (grep 3+ keywords).
+
+<!-- tycono:akb-guide-end -->
+`;
+}
+
+/**
+ * Install methodology/agentic-knowledge-base.md if not present.
+ */
+function ensureAkbMethodology(companyRoot: string): void {
+  const targetDir = path.join(companyRoot, 'knowledge', 'methodology');
+  const targetPath = path.join(targetDir, 'agentic-knowledge-base.md');
+
+  if (fs.existsSync(targetPath)) return;
+
+  // Also check methodologies/ (plural)
+  const altDir = path.join(companyRoot, 'knowledge', 'methodologies');
+  const altPath = path.join(altDir, 'agentic-knowledge-base.md');
+  if (fs.existsSync(altPath)) return;
+
+  // Try to copy from templates
+  const srcPath = path.join(TEMPLATES_DIR, 'agentic-knowledge-base.md');
+  if (!fs.existsSync(srcPath)) return;
+
+  // Use whichever directory exists, or create methodology/
+  const dir = fs.existsSync(altDir) ? altDir : fs.existsSync(targetDir) ? targetDir : targetDir;
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+
+  fs.copyFileSync(srcPath, path.join(dir, 'agentic-knowledge-base.md'));
+  console.log(`[AKB] Installed methodology/agentic-knowledge-base.md`);
+}
+
+/**
+ * Ensure CLAUDE.md has AKB navigation guide.
+ *
+ * Two modes:
+ * 1. No CLAUDE.md → create from full AKB template
+ * 2. CLAUDE.md exists (any) → append/update AKB section only, never touch user content
+ *
+ * No full replacement ever. User content is always preserved.
+ */
+export function ensureClaudeMd(companyRoot: string): void {
+  const tyconoDir = path.join(companyRoot, '.tycono');
+  const rulesVersionPath = path.join(tyconoDir, 'rules-version');
+  const claudeMdPath = path.join(companyRoot, 'knowledge', 'CLAUDE.md');
+  const knowledgeDir = path.join(companyRoot, 'knowledge');
+  const customRulesPath = path.join(knowledgeDir, 'custom-rules.md');
+
+  // Skip if not initialized (no .tycono/ directory)
+  if (!fs.existsSync(tyconoDir)) return;
+
+  const currentVersion = getPackageVersion();
+
+  // Read stored version
+  let storedVersion = '0.0.0';
+  if (fs.existsSync(rulesVersionPath)) {
+    storedVersion = fs.readFileSync(rulesVersionPath, 'utf-8').trim();
+  }
+
+  // Skip if already up-to-date
+  if (storedVersion === currentVersion) return;
+
+  // No knowledge/ directory → don't create anything (plugin mode: zero footprint)
+  if (!fs.existsSync(knowledgeDir)) {
+    console.log(`[CLAUDE.md] Skipping — no knowledge/ directory (plugin mode)`);
+    fs.writeFileSync(rulesVersionPath, currentVersion);
+    return;
+  }
+
+  // No CLAUDE.md → don't create (user hasn't set up AKB)
+  if (!fs.existsSync(claudeMdPath)) {
+    console.log(`[CLAUDE.md] Skipping — no CLAUDE.md found`);
+    fs.writeFileSync(rulesVersionPath, currentVersion);
+    return;
+  }
+
+  // CLAUDE.md exists → append/update AKB section only, never create files
+  ensureAkbMethodology(companyRoot);
+
+  const existing = fs.readFileSync(claudeMdPath, 'utf-8');
+
+  if (existing.includes(AKB_SECTION_MARKER)) {
+    // Already has AKB section → replace just that section
+    const before = existing.split(AKB_SECTION_MARKER)[0].trimEnd();
+    const afterMarker = existing.indexOf('<!-- tycono:akb-guide-end -->');
+    const after = afterMarker >= 0
+      ? existing.substring(afterMarker + '<!-- tycono:akb-guide-end -->'.length).trimStart()
+      : '';
+    const updated = before + generateAkbAppendix(currentVersion) + (after ? '\n' + after : '');
+    fs.writeFileSync(claudeMdPath, updated);
+    console.log(`[CLAUDE.md] Updated AKB section (v${currentVersion})`);
+  } else {
+    // No AKB section yet → append
+    const updated = existing.trimEnd() + '\n' + generateAkbAppendix(currentVersion);
+    fs.writeFileSync(claudeMdPath, updated);
+    console.log(`[CLAUDE.md] Appended AKB guide (v${currentVersion})`);
+  }
+
+  fs.writeFileSync(rulesVersionPath, currentVersion);
+}

package/{src → packages/server/src}/api/src/services/company-config.ts

@@ -20,6 +20,7 @@ export interface CompanyConfig {
   model?: string;
   apiKey?: string;
   codeRoot?: string;  // 코드 프로젝트 경로 (AKB와 분리된 코드 repo)
+  defaultAgency?: string;  // 기본 agency — /tycono에서 --agency 없을 때 사용
   conversationLimits?: Partial<ConversationLimits>;
   supervision?: {
     mode: 'supervisor' | 'direct';

package/{src → packages/server/src}/api/src/services/digest-engine.ts

@@ -12,7 +12,7 @@ import type { ActivityEvent, ActivityEventType } from '../../../shared/types.js'
 /* ─── Types ──────────────────────────────────── */
 
 export interface Anomaly {
-  type: 'error' | 'stall' | 'scope_creep' | 'awaiting_input' | 'budget_warning' | 'ceo_directive';
+  type: 'error' | 'stall' | 'scope_creep' | 'awaiting_input' | 'budget_warning' | 'ceo_directive' | 'dispatch_error';
   sessionId: string;
   message: string;
   severity: number; // 0-10
@@ -37,6 +37,7 @@ const EVENT_TIER_MAP: Partial<Record<ActivityEventType, EventTier>> = {
   'msg:awaiting_input': 'critical',
   'dispatch:start': 'high',
   'dispatch:done': 'high',
+  'dispatch:error': 'critical',
   'msg:done': 'high',
   'msg:start': 'high',
   'thinking': 'medium',
@@ -197,6 +198,8 @@ function summarizeEvent(event: ActivityEvent): string | null {
       return `Dispatched → ${event.data?.targetRoleId}: ${(event.data?.task as string ?? '').slice(0, 60)}`;
     case 'dispatch:done':
       return `Dispatch completed: ${event.data?.targetRoleId}`;
+    case 'dispatch:error':
+      return `❌ Dispatch FAILED: ${event.data?.sourceRole} → ${event.data?.targetRole}: ${(event.data?.error as string ?? 'unknown').slice(0, 80)}`;
     case 'tool:start': {
       const toolName = event.data?.name as string ?? 'unknown';
       const input = event.data?.input as Record<string, unknown> | undefined;