tycono 0.3.13-beta.7 → 0.3.14-beta.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tycono",
-  "version": "0.3.13-beta.7",
+  "version": "0.3.14-beta.0",
   "description": "Build an AI company. Watch them work.",
   "type": "module",
   "bin": {

package/src/api/src/create-app.ts

@@ -17,6 +17,7 @@ import { engineRouter } from './routes/engine.js';
 import { sessionsRouter } from './routes/sessions.js';
 import { setupRouter } from './routes/setup.js';
 import { skillsRouter } from './routes/skills.js';
+import { presetsRouter } from './routes/presets.js';
 
 export function createApp() {
   const app = express();
@@ -53,6 +54,7 @@ export function createApp() {
   app.use('/api/engine', engineRouter);
   app.use('/api/sessions', sessionsRouter);
   app.use('/api/skills', skillsRouter);
+  app.use('/api/presets', presetsRouter);
 
   app.get('/api/health', (_req, res) => {
     res.json({ status: 'ok', companyRoot: COMPANY_ROOT });

package/src/api/src/engine/org-tree.ts

@@ -85,7 +85,7 @@ interface RawRoleYaml {
 
 /* ─── Build ──────────────────────────────────── */
 
-export function buildOrgTree(companyRoot: string): OrgTree {
+export function buildOrgTree(companyRoot: string, presetId?: string): OrgTree {
   const rolesDir = path.join(companyRoot, 'roles');
   const tree: OrgTree = { root: 'ceo', nodes: new Map() };
 
@@ -102,53 +102,68 @@ export function buildOrgTree(companyRoot: string): OrgTree {
     reports: { daily: '', weekly: '' },
   });
 
-  if (!fs.existsSync(rolesDir)) return tree;
-
-  // Read all role.yaml files
-  const entries = fs.readdirSync(rolesDir, { withFileTypes: true });
-  for (const entry of entries) {
-    if (!entry.isDirectory()) continue;
-    const yamlPath = path.join(rolesDir, entry.name, 'role.yaml');
-    if (!fs.existsSync(yamlPath)) continue;
-
-    try {
-      const raw = YAML.parse(fs.readFileSync(yamlPath, 'utf-8')) as RawRoleYaml;
-      const node: OrgNode = {
-        id: raw.id || entry.name,
-        name: raw.name || entry.name,
-        level: (raw.level as OrgNode['level']) || 'member',
-        reportsTo: (raw.reports_to || 'ceo').toLowerCase(),
-        children: [],
-        persona: raw.persona || '',
-        authority: {
-          autonomous: raw.authority?.autonomous ?? [],
-          needsApproval: raw.authority?.needs_approval ?? [],
-        },
-        knowledge: {
-          reads: raw.knowledge?.reads ?? [],
-          writes: raw.knowledge?.writes ?? [],
-        },
-        reports: {
-          daily: raw.reports?.daily ?? '',
-          weekly: raw.reports?.weekly ?? '',
-        },
-        skills: raw.skills,
-        model: raw.model,
-        source: raw.source ? {
-          id: raw.source.id || '',
-          sync: (raw.source.sync as RoleSource['sync']) || 'manual',
-          forked_at: raw.source.forked_at,
-          upstream_version: raw.source.upstream_version,
-        } : undefined,
-        heartbeat: raw.heartbeat ? {
-          enabled: raw.heartbeat.enabled ?? false,
-          intervalSec: raw.heartbeat.intervalSec ?? 120,
-          maxTicks: raw.heartbeat.maxTicks ?? 60,
-        } : undefined,
-      };
-      tree.nodes.set(node.id, node);
-    } catch {
-      // Skip malformed YAML
+  // Collect role directories to scan: base roles/ + preset roles/
+  const roleDirs: string[] = [];
+  if (fs.existsSync(rolesDir)) roleDirs.push(rolesDir);
+
+  // If preset specified, also scan preset's roles directory
+  if (presetId && presetId !== 'default') {
+    const presetRolesDir = path.join(companyRoot, 'company', 'presets', presetId, 'roles');
+    if (fs.existsSync(presetRolesDir)) roleDirs.push(presetRolesDir);
+  }
+
+  // Read all role.yaml files from all role directories
+  for (const dir of roleDirs) {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const yamlPath = path.join(dir, entry.name, 'role.yaml');
+      if (!fs.existsSync(yamlPath)) continue;
+
+      try {
+        const raw = YAML.parse(fs.readFileSync(yamlPath, 'utf-8')) as RawRoleYaml;
+        const nodeId = raw.id || entry.name;
+
+        // Skip if already loaded (base roles take precedence over preset roles)
+        if (tree.nodes.has(nodeId)) continue;
+
+        const node: OrgNode = {
+          id: nodeId,
+          name: raw.name || entry.name,
+          level: (raw.level as OrgNode['level']) || 'member',
+          reportsTo: (raw.reports_to || 'ceo').toLowerCase(),
+          children: [],
+          persona: raw.persona || '',
+          authority: {
+            autonomous: raw.authority?.autonomous ?? [],
+            needsApproval: raw.authority?.needs_approval ?? [],
+          },
+          knowledge: {
+            reads: raw.knowledge?.reads ?? [],
+            writes: raw.knowledge?.writes ?? [],
+          },
+          reports: {
+            daily: raw.reports?.daily ?? '',
+            weekly: raw.reports?.weekly ?? '',
+          },
+          skills: raw.skills,
+          model: raw.model,
+          source: raw.source ? {
+            id: raw.source.id || '',
+            sync: (raw.source.sync as RoleSource['sync']) || 'manual',
+            forked_at: raw.source.forked_at,
+            upstream_version: raw.source.upstream_version,
+          } : undefined,
+          heartbeat: raw.heartbeat ? {
+            enabled: raw.heartbeat.enabled ?? false,
+            intervalSec: raw.heartbeat.intervalSec ?? 120,
+            maxTicks: raw.heartbeat.maxTicks ?? 60,
+          } : undefined,
+        };
+        tree.nodes.set(node.id, node);
+      } catch {
+        // Skip malformed YAML
+      }
     }
   }
 
@@ -231,8 +246,8 @@ export function canConsult(tree: OrgTree, source: string, target: string): boole
 }
 
 /** Refresh tree (re-read all role.yaml files) */
-export function refreshOrgTree(companyRoot: string): OrgTree {
-  return buildOrgTree(companyRoot);
+export function refreshOrgTree(companyRoot: string, presetId?: string): OrgTree {
+  return buildOrgTree(companyRoot, presetId);
 }
 
 /** Get a human-readable org chart string for context injection */

package/src/api/src/routes/execute.ts

@@ -223,6 +223,7 @@ 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;
 
     // Always use supervisor mode — CEO supervises C-Levels who supervise members
     {
@@ -231,6 +232,7 @@ function handleStartJob(body: Record<string, unknown>, res: ServerResponse): voi
         actualDirective,
         targetRoles && targetRoles.length > 0 ? targetRoles : undefined,
         continuous,
+        preset,
       );
 
       if (state.status === 'error') {

package/src/api/src/routes/presets.ts

@@ -0,0 +1,35 @@
+/**
+ * presets.ts — Preset API routes
+ *
+ * GET /api/presets          — list all preset summaries
+ * GET /api/presets/:id      — get full preset detail
+ */
+import { Router } from 'express';
+import { COMPANY_ROOT } from '../services/file-reader.js';
+import { getPresetSummaries, getPresetById } from '../services/preset-loader.js';
+
+export const presetsRouter = Router();
+
+/** GET /api/presets — list preset summaries for TUI */
+presetsRouter.get('/', (_req, res) => {
+  try {
+    const summaries = getPresetSummaries(COMPANY_ROOT);
+    res.json(summaries);
+  } catch (err) {
+    res.status(500).json({ error: 'Failed to load presets' });
+  }
+});
+
+/** GET /api/presets/:id — get full preset detail */
+presetsRouter.get('/:id', (req, res) => {
+  try {
+    const preset = getPresetById(COMPANY_ROOT, req.params.id);
+    if (!preset) {
+      res.status(404).json({ error: `Preset not found: ${req.params.id}` });
+      return;
+    }
+    res.json(preset.definition);
+  } catch (err) {
+    res.status(500).json({ error: 'Failed to load preset' });
+  }
+});

package/src/api/src/services/preset-loader.ts

@@ -0,0 +1,149 @@
+/**
+ * preset-loader.ts — Load presets from company/presets/
+ *
+ * Scans company/presets/ for:
+ *   - _default.yaml (auto-generated from existing roles/)
+ *   - {name}/preset.yaml (installed presets with roles/skills/knowledge)
+ *
+ * Returns PresetSummary[] for TUI display and full LoadedPreset for wave creation.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import YAML from 'yaml';
+import type { PresetDefinition, LoadedPreset, PresetSummary } from '../../../shared/types.js';
+
+const PRESETS_DIR = 'company/presets';
+const DEFAULT_PRESET_FILE = '_default.yaml';
+
+/**
+ * Build a default preset definition from existing roles/ directory.
+ * This is generated on-the-fly — no need to persist _default.yaml.
+ */
+function buildDefaultPreset(companyRoot: string): LoadedPreset {
+  const rolesDir = path.join(companyRoot, 'roles');
+  const roles: string[] = [];
+
+  if (fs.existsSync(rolesDir)) {
+    const entries = fs.readdirSync(rolesDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const yamlPath = path.join(rolesDir, entry.name, 'role.yaml');
+      if (fs.existsSync(yamlPath)) {
+        roles.push(entry.name);
+      }
+    }
+  }
+
+  return {
+    definition: {
+      spec: 'preset/v1',
+      id: 'default',
+      name: 'Default Team',
+      tagline: 'Your current team',
+      version: '1.0.0',
+      roles,
+    },
+    path: null,
+    isDefault: true,
+  };
+}
+
+/**
+ * Load a single preset from a directory containing preset.yaml.
+ */
+function loadPresetFromDir(presetDir: string): LoadedPreset | null {
+  const yamlPath = path.join(presetDir, 'preset.yaml');
+  if (!fs.existsSync(yamlPath)) return null;
+
+  try {
+    const raw = YAML.parse(fs.readFileSync(yamlPath, 'utf-8')) as PresetDefinition;
+    if (!raw.id || !raw.name || !Array.isArray(raw.roles)) return null;
+
+    return {
+      definition: {
+        spec: raw.spec || 'preset/v1',
+        id: raw.id,
+        name: raw.name,
+        tagline: raw.tagline,
+        version: raw.version || '1.0.0',
+        description: raw.description,
+        author: raw.author,
+        category: raw.category,
+        industry: raw.industry,
+        stage: raw.stage,
+        use_case: raw.use_case,
+        roles: raw.roles,
+        knowledge_docs: raw.knowledge_docs,
+        skills_count: raw.skills_count,
+        pricing: raw.pricing,
+        tags: raw.tags,
+        languages: raw.languages,
+        stats: raw.stats,
+        wave_scoped: raw.wave_scoped,
+      },
+      path: presetDir,
+      isDefault: false,
+    };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Load all presets from company/presets/ + auto-generated default.
+ * Returns [default, ...installed] — default is always first.
+ */
+export function loadPresets(companyRoot: string): LoadedPreset[] {
+  const presets: LoadedPreset[] = [];
+
+  // 1. Default preset (always present)
+  const defaultPreset = buildDefaultPreset(companyRoot);
+
+  // Check if _default.yaml exists with overrides
+  const defaultYamlPath = path.join(companyRoot, PRESETS_DIR, DEFAULT_PRESET_FILE);
+  if (fs.existsSync(defaultYamlPath)) {
+    try {
+      const raw = YAML.parse(fs.readFileSync(defaultYamlPath, 'utf-8')) as Partial<PresetDefinition>;
+      if (raw.name) defaultPreset.definition.name = raw.name;
+      if (raw.tagline) defaultPreset.definition.tagline = raw.tagline;
+      if (raw.description) defaultPreset.definition.description = raw.description;
+    } catch { /* ignore malformed _default.yaml */ }
+  }
+
+  presets.push(defaultPreset);
+
+  // 2. Installed presets from company/presets/{name}/preset.yaml
+  const presetsDir = path.join(companyRoot, PRESETS_DIR);
+  if (fs.existsSync(presetsDir)) {
+    const entries = fs.readdirSync(presetsDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const preset = loadPresetFromDir(path.join(presetsDir, entry.name));
+      if (preset) presets.push(preset);
+    }
+  }
+
+  return presets;
+}
+
+/**
+ * Get preset summaries for TUI display.
+ */
+export function getPresetSummaries(companyRoot: string): PresetSummary[] {
+  return loadPresets(companyRoot).map(p => ({
+    id: p.definition.id,
+    name: p.definition.name,
+    description: p.definition.description ?? p.definition.tagline,
+    rolesCount: p.definition.roles.length,
+    roles: p.definition.roles,
+    isDefault: p.isDefault,
+  }));
+}
+
+/**
+ * Find a specific preset by ID.
+ */
+export function getPresetById(companyRoot: string, presetId: string): LoadedPreset | null {
+  const presets = loadPresets(companyRoot);
+  return presets.find(p => p.definition.id === presetId) ?? null;
+}

package/src/api/src/services/scaffold.ts

@@ -319,7 +319,7 @@ export function scaffold(config: ScaffoldConfig): string[] {
     'operations/decisions', 'operations/activity-streams',
     'operations/sessions', 'operations/cost',
     'knowledge', 'methodologies', '.claude/skills',
-    '.claude/skills/_shared', '.tycono',
+    '.claude/skills/_shared', '.tycono', 'company/presets',
   ];
   for (const dir of dirs) {
     fs.mkdirSync(path.join(root, dir), { recursive: true });

package/src/api/src/services/supervisor-heartbeat.ts

@@ -28,6 +28,7 @@ interface SupervisorState {
   directive: string;
   targetRoles?: string[];
   continuous: boolean;
+  preset?: string;
   supervisorSessionId: string | null;
   executionId: string | null;
   status: 'starting' | 'running' | 'restarting' | 'stopped' | 'error';
@@ -66,7 +67,7 @@ class SupervisorHeartbeat {
    * This creates a supervisor session and starts an execution.
    * If the execution dies, it auto-restarts (heartbeat).
    */
-  start(waveId: string, directive: string, targetRoles?: string[], continuous = false): SupervisorState {
+  start(waveId: string, directive: string, targetRoles?: string[], continuous = false, preset?: string): SupervisorState {
     // Check if supervisor already running for this wave
     const existing = this.supervisors.get(waveId);
     if (existing && (existing.status === 'running' || existing.status === 'starting')) {
@@ -79,6 +80,7 @@ class SupervisorHeartbeat {
       directive,
       targetRoles,
       continuous,
+      preset,
       supervisorSessionId: null,
       executionId: null,
       status: 'starting',
@@ -100,7 +102,7 @@ class SupervisorHeartbeat {
     }
 
     // Save wave file immediately so directive persists across restarts
-    this.saveWaveFile(waveId, directive);
+    this.saveWaveFile(waveId, directive, preset);
 
     this.spawnSupervisor(state);
     return state;
@@ -110,20 +112,22 @@ class SupervisorHeartbeat {
    * Save wave file immediately so directive persists across restarts.
    * saveCompletedWave() adds session/role details on completion.
    */
-  private saveWaveFile(waveId: string, directive: string): void {
+  private saveWaveFile(waveId: string, directive: string, preset?: string): void {
     try {
       const wavesDir = path.join(COMPANY_ROOT, 'operations', 'waves');
       if (!fs.existsSync(wavesDir)) fs.mkdirSync(wavesDir, { recursive: true });
       const wavePath = path.join(wavesDir, `${waveId}.json`);
       if (!fs.existsSync(wavePath)) {
-        fs.writeFileSync(wavePath, JSON.stringify({
+        const waveData: Record<string, unknown> = {
           id: waveId,
           waveId,
           directive,
           startedAt: new Date().toISOString(),
           sessionIds: [],
           roles: [],
-        }, null, 2));
+        };
+        if (preset) waveData.preset = preset;
+        fs.writeFileSync(wavePath, JSON.stringify(waveData, null, 2));
         console.log(`[Supervisor] Wave file created: ${wavePath}`);
       }
     } catch (err) {
@@ -510,7 +514,7 @@ Do NOT dispatch anyone. Do NOT create new files. Just answer concisely.`;
   /* ─── Internal: Spawn / Restart ────────────── */
 
   private spawnSupervisor(state: SupervisorState): void {
-    const orgTree = buildOrgTree(COMPANY_ROOT);
+    const orgTree = buildOrgTree(COMPANY_ROOT, state.preset);
     let cLevelRoles = getSubordinates(orgTree, 'ceo');
 
     if (state.targetRoles && state.targetRoles.length > 0) {

package/src/api/src/services/wave-tracker.ts

@@ -304,7 +304,16 @@ export function saveCompletedWave(waveId: string, directive: string): { ok: bool
       }
     }
 
-    const waveJson = {
+    // Preserve preset field from existing wave file
+    let existingPreset: string | undefined;
+    if (existing) {
+      try {
+        const existingData = JSON.parse(fs.readFileSync(existing, 'utf-8'));
+        existingPreset = existingData.preset;
+      } catch { /* ignore */ }
+    }
+
+    const waveJson: Record<string, unknown> = {
       id: baseName,
       directive,
       startedAt: startedAt.toISOString(),
@@ -313,6 +322,7 @@ export function saveCompletedWave(waveId: string, directive: string): { ok: bool
       waveId,
       sessionIds: allSessionIds,
     };
+    if (existingPreset) waveJson.preset = existingPreset;
     fs.writeFileSync(jsonPath, JSON.stringify(waveJson, null, 2), 'utf-8');
 
     const relativePath = `operations/waves/${baseName}.json`;

package/src/shared/types.ts

@@ -144,3 +144,81 @@ export function eventTypeToMessageStatus(eventType: ActivityEventType): MessageS
 
 /** TeamStatus — Role별 현재 상태 + 작업 내용 (context-assembler, runner에서 공유) */
 export type TeamStatus = Record<string, { status: RoleStatus; task?: string }>;
+
+/* ═══════════════════════════════════════════════
+ *  Preset — Wave-scoped team configuration
+ * ═══════════════════════════════════════════════ */
+
+/** preset.yaml 스키마 */
+export interface PresetDefinition {
+  /** Spec version (e.g. "preset/v1") */
+  spec: string;
+  /** Unique identifier (directory name) */
+  id: string;
+  /** Display name */
+  name: string;
+  /** Short tagline */
+  tagline?: string;
+  /** Version string */
+  version: string;
+  /** Full description */
+  description?: string;
+  /** Author info */
+  author?: {
+    id: string;
+    name: string;
+    verified?: boolean;
+  };
+  /** Category / classification */
+  category?: string;
+  industry?: string;
+  stage?: string;
+  use_case?: string[];
+  /** Role IDs included in this preset */
+  roles: string[];
+  /** Counts */
+  knowledge_docs?: number;
+  skills_count?: number;
+  /** Pricing */
+  pricing?: {
+    type: 'one-time' | 'subscription';
+    price: number;
+    wave_scoped_tier?: string;
+  };
+  /** Tags for search */
+  tags?: string[];
+  languages?: string[];
+  /** Stats (marketplace) */
+  stats?: {
+    installs: number;
+    rating: number;
+    reviews: number;
+    waves_used: number;
+  };
+  /** Wave-scoped recommendations */
+  wave_scoped?: {
+    recommended_tasks?: string[];
+    task_keywords?: string[];
+    avg_wave_duration?: string;
+    complexity?: string;
+  };
+}
+
+/** Loaded preset with resolved path info */
+export interface LoadedPreset {
+  definition: PresetDefinition;
+  /** Absolute path to preset directory (or null for _default) */
+  path: string | null;
+  /** Whether this is the _default preset */
+  isDefault: boolean;
+}
+
+/** Preset summary for TUI display */
+export interface PresetSummary {
+  id: string;
+  name: string;
+  description?: string;
+  rolesCount: number;
+  roles: string[];
+  isDefault: boolean;
+}

package/src/tui/api.ts

@@ -136,6 +136,7 @@ export async function fetchExecStatus(): Promise<ExecStatus> {
 export async function dispatchWave(directive?: string, options?: {
   targetRoles?: string[];
   continuous?: boolean;
+  preset?: string;
 }): Promise<WaveResponse> {
   return fetchJson<WaveResponse>('/api/jobs', {
     method: 'POST',
@@ -144,6 +145,7 @@ export async function dispatchWave(directive?: string, options?: {
       directive: directive ?? '',
       targetRoles: options?.targetRoles,
       continuous: options?.continuous ?? false,
+      preset: options?.preset,
     },
   });
 }
@@ -211,6 +213,21 @@ export async function cleanupSessions(): Promise<{ cleaned: number; remaining: n
   return fetchJson<{ cleaned: number; remaining: number }>('/api/active-sessions/cleanup', { method: 'POST' });
 }
 
+/* ─── Presets ─── */
+
+export interface PresetSummary {
+  id: string;
+  name: string;
+  description?: string;
+  rolesCount: number;
+  roles: string[];
+  isDefault: boolean;
+}
+
+export async function fetchPresets(): Promise<PresetSummary[]> {
+  return fetchJson<PresetSummary[]>('/api/presets');
+}
+
 /* ─── Knowledge docs ─── */
 
 export interface KnowledgeDoc {

package/src/tui/app.tsx

@@ -21,7 +21,7 @@ import { useApi } from './hooks/useApi';
 import { useSSE } from './hooks/useSSE';
 import { useCommand, type WaveInfo } from './hooks/useCommand';
 import { dispatchWave } from './api';
-import type { ActiveSessionInfo } from './api';
+import type { ActiveSessionInfo, PresetSummary } from './api';
 import { buildOrgTree, flattenOrgRoleIds } from './store';
 
 type Mode = 'command' | 'panel';
@@ -231,6 +231,10 @@ export const App: React.FC = () => {
   // System messages (command feedback displayed in stream area)
   const [systemMessages, setSystemMessages] = useState<StreamLine[]>([]);
 
+  // Preset selection state (for /new without args)
+  const [pendingPresetSelect, setPendingPresetSelect] = useState<PresetSummary[] | null>(null);
+  const selectedPresetRef = useRef<string | null>(null);
+
   // Terminal full height with resize tracking (minus 1 for wide-char overflow safety)
   const [termHeight, setTermHeight] = useState((process.stdout.rows || 30) - 1);
 
@@ -337,21 +341,24 @@ export const App: React.FC = () => {
     return waves.find(w => w.waveId === focusedWaveId)?.startedAt ?? 0;
   }, [focusedWaveId, waves]);
 
+  // Wave creation callback — shared by useCommand and preset selection flow
+  const onWaveCreated = useCallback((newWaveId: string, directive: string) => {
+    const newWave: WaveInfo = {
+      waveId: newWaveId,
+      directive,
+      startedAt: Date.now(),
+    };
+    setWaves(prev => [...prev, newWave]);
+    setFocusedWaveId(newWaveId);
+    sse.clearEvents();
+    api.refresh();
+  }, [sse, api]);
+
   // Command handler
   const { execute } = useCommand({
     focusedWaveId,
     waves,
-    onWaveCreated: (newWaveId, directive) => {
-      const newWave: WaveInfo = {
-        waveId: newWaveId,
-        directive,
-        startedAt: Date.now(),
-      };
-      setWaves(prev => [...prev, newWave]);
-      setFocusedWaveId(newWaveId);
-      sse.clearEvents();
-      api.refresh();
-    },
+    onWaveCreated,
     onFocusWave: (waveId) => {
       setFocusedWaveId(waveId);
       sse.clearEvents();
@@ -366,6 +373,44 @@ export const App: React.FC = () => {
   const handleCommandSubmit = useCallback(async (input: string) => {
     // User input is already shown by CommandMode (immediate commit to Static)
 
+    // Preset selection mode: user types a number to pick preset
+    if (pendingPresetSelect) {
+      const trimmed = input.trim();
+      const idx = parseInt(trimmed, 10);
+      if (!isNaN(idx) && idx >= 1 && idx <= pendingPresetSelect.length) {
+        const selected = pendingPresetSelect[idx - 1];
+        setPendingPresetSelect(null);
+        addSystemMessage(`Selected: ${selected.name}. Type your directive:`, 'cyan');
+        // Store selected preset for next input
+        selectedPresetRef.current = selected.id;
+        return;
+      }
+      // If user typed text instead of number, treat as directive with selected/default preset
+      const presetId = selectedPresetRef.current || 'default';
+      setPendingPresetSelect(null);
+      selectedPresetRef.current = null;
+      try {
+        const waveResult = await dispatchWave(trimmed || undefined, { preset: presetId });
+        onWaveCreated(waveResult.waveId, trimmed);
+      } catch (err) {
+        addSystemMessage(`Wave failed: ${err instanceof Error ? err.message : 'unknown'}`, 'red');
+      }
+      return;
+    }
+
+    // If a preset was selected previously, this input is the directive
+    if (selectedPresetRef.current) {
+      const presetId = selectedPresetRef.current;
+      selectedPresetRef.current = null;
+      try {
+        const waveResult = await dispatchWave(input.trim() || undefined, { preset: presetId });
+        onWaveCreated(waveResult.waveId, input.trim());
+      } catch (err) {
+        addSystemMessage(`Wave failed: ${err instanceof Error ? err.message : 'unknown'}`, 'red');
+      }
+      return;
+    }
+
     const result = await execute(input);
 
     switch (result.type) {
@@ -513,6 +558,7 @@ export const App: React.FC = () => {
         addSystemMessage('  /sessions            Sessions + ports (kill/cleanup)', 'white');
         addSystemMessage('  /kill <id>           Kill a session', 'white');
         addSystemMessage('  /cleanup             Remove dead sessions', 'white');
+        addSystemMessage('  /preset list         Installed presets', 'white');
         addSystemMessage('  /help                This help', 'white');
         addSystemMessage('  /quit                Exit', 'white');
         addSystemMessage('Keys: [Tab] team panel  [1-9] wave  [Esc] back  [Ctrl+C] quit', 'gray');
@@ -526,6 +572,46 @@ export const App: React.FC = () => {
           addSystemMessage(`Sessions: ${api.sessions.length}  Active: ${activeCount}  Waves: ${waves.length}  Ports: ${api.portSummary.totalPorts}`, 'white');
         }
         break;
+      case 'preset_list': {
+        const presets = result.presets ?? [];
+        if (presets.length === 0) {
+          addSystemMessage('No presets installed.', 'gray');
+        } else {
+          addSystemMessage('Installed presets:', 'cyan');
+          for (const p of presets) {
+            const star = p.isDefault ? ' \u2605' : '';
+            const desc = p.description ? ` \u2014 ${p.description}` : '';
+            addSystemMessage(`  ${p.id} (${p.rolesCount} roles)${desc}${star}`, p.isDefault ? 'green' : 'white');
+          }
+        }
+        break;
+      }
+      case 'preset_select': {
+        const presets = result.presets ?? [];
+        if (presets.length === 0) {
+          addSystemMessage('No presets. Creating wave with default team.', 'gray');
+          try {
+            const waveResult = await dispatchWave();
+            onWaveCreated(waveResult.waveId, '');
+          } catch { /* ignore */ }
+        } else if (presets.length === 1) {
+          // Only default → show prompt to enter directive
+          addSystemMessage('Only default preset available. Type your directive:', 'gray');
+        } else {
+          // Multiple presets → show selection
+          addSystemMessage('Select a team preset for this wave:', 'cyan');
+          for (let i = 0; i < presets.length; i++) {
+            const p = presets[i];
+            const star = p.isDefault ? ' \u2605' : '';
+            const desc = p.description ? ` \u2014 ${p.description}` : '';
+            addSystemMessage(`  ${i + 1}. ${p.name} (${p.rolesCount} roles)${desc}${star}`, p.isDefault ? 'green' : 'white');
+          }
+          addSystemMessage('Type a number to select, then enter your directive.', 'gray');
+          // Store presets for number selection — handled via pendingPresetSelect
+          setPendingPresetSelect(presets);
+        }
+        break;
+      }
       case 'panel':
         break;
       case 'quit':
@@ -535,7 +621,7 @@ export const App: React.FC = () => {
           addSystemMessage(result.message, 'green');
         }
     }
-  }, [execute, addSystemMessage, addSystemLines, focusedWaveId, focusedWaveIndex, derivedWaveStatus, api.sessions.length, activeCount, waves, api.activeSessions, api.portSummary]);
+  }, [execute, addSystemMessage, addSystemLines, focusedWaveId, focusedWaveIndex, derivedWaveStatus, api.sessions.length, activeCount, waves, api.activeSessions, api.portSummary, pendingPresetSelect, onWaveCreated]);
 
   // Global key handler: Tab to toggle mode, Ctrl+C always exits
   useInput((input, key) => {

package/src/tui/components/CommandMode.tsx

@@ -299,6 +299,7 @@ const COMMANDS: Array<{ cmd: string; desc: string }> = [
   { cmd: '/sessions', desc: 'Active sessions' },
   { cmd: '/kill <id>', desc: 'Kill session' },
   { cmd: '/cleanup', desc: 'Remove dead' },
+  { cmd: '/preset list', desc: 'Installed presets' },
   { cmd: '/help', desc: 'Help' },
   { cmd: '/quit', desc: 'Exit' },
 ];

package/src/tui/components/PanelMode.tsx

@@ -139,7 +139,7 @@ function readFilePreview(filePath: string, maxLines: number): string[] {
   }
 }
 
-export const PanelMode: React.FC<PanelModeProps> = ({
+export const PanelMode: React.FC<PanelModeProps> = React.memo(({
   tree, flatRoles, events, selectedRoleIndex, selectedRoleId,
   streamStatus, waveId, activeSessions, allSessions, companyRoot, waves,
   focusedWaveId, onMove, onSelect, onEscape, onFocusWave,
@@ -545,4 +545,4 @@ export const PanelMode: React.FC<PanelModeProps> = ({
       </Box>
     </Box>
   );
-};
+}));

package/src/tui/components/StreamView.tsx

@@ -116,7 +116,7 @@ function renderEvent(event: SSEEvent): { content: string; contentColor: string }
   }
 }
 
-export const StreamView: React.FC<StreamViewProps> = ({
+export const StreamView: React.FC<StreamViewProps> = React.memo(({
   events,
   allRoleIds,
   streamStatus,
@@ -162,10 +162,10 @@ export const StreamView: React.FC<StreamViewProps> = ({
           <Box key={`${event.seq}-${i}`}>
             <Text color="gray" dimColor>{formatTime(event.ts)} </Text>
             <Text color={roleColor} bold>{event.roleId.padEnd(12)}</Text>
-            <Text color={rendered.contentColor} wrap="wrap">{rendered.content}</Text>
+            <Text color={rendered.contentColor} wrap="truncate">{rendered.content}</Text>
           </Box>
         );
       })}
     </Box>
   );
-};
+}));

package/src/tui/hooks/useCommand.ts

@@ -16,7 +16,8 @@
  */
 
 import { useCallback } from 'react';
-import { dispatchWave, sendDirective, stopWave, fetchJson, killSession, cleanupSessions, fetchActiveSessions } from '../api';
+import { dispatchWave, sendDirective, stopWave, fetchJson, killSession, cleanupSessions, fetchActiveSessions, fetchPresets } from '../api';
+import type { PresetSummary } from '../api';
 
 export interface WaveInfo {
   waveId: string;
@@ -25,9 +26,10 @@ export interface WaveInfo {
 }
 
 export interface CommandResult {
-  type: 'success' | 'error' | 'info' | 'wave_started' | 'directive_sent' | 'stopped' | 'quit' | 'help' | 'panel' | 'waves_list' | 'focus_changed' | 'agents' | 'ports' | 'sessions' | 'cleanup' | 'docs' | 'read_file' | 'open_file';
+  type: 'success' | 'error' | 'info' | 'wave_started' | 'directive_sent' | 'stopped' | 'quit' | 'help' | 'panel' | 'waves_list' | 'focus_changed' | 'agents' | 'ports' | 'sessions' | 'cleanup' | 'docs' | 'read_file' | 'open_file' | 'preset_list' | 'preset_select';
   message: string;
   waveId?: string;
+  presets?: PresetSummary[];
 }
 
 async function postAssign(roleId: string, task: string): Promise<{ waveId?: string }> {
@@ -80,6 +82,15 @@ export function useCommand(options: UseCommandOptions) {
 
         case 'new': {
           const directive = args || undefined;
+          if (!directive) {
+            // No args → show preset selection UI
+            try {
+              const presets = await fetchPresets();
+              return { type: 'preset_select', message: '', presets };
+            } catch (err) {
+              return { type: 'error', message: `Failed to load presets: ${err instanceof Error ? err.message : 'unknown'}` };
+            }
+          }
           try {
             const result = await dispatchWave(directive);
             onWaveCreated(result.waveId, directive ?? '');
@@ -168,6 +179,19 @@ export function useCommand(options: UseCommandOptions) {
           }
         }
 
+        case 'preset': {
+          const subCmd = args.split(/\s+/)[0]?.toLowerCase() || 'list';
+          if (subCmd === 'list' || !subCmd) {
+            try {
+              const presets = await fetchPresets();
+              return { type: 'preset_list', message: '', presets };
+            } catch (err) {
+              return { type: 'error', message: `Failed to load presets: ${err instanceof Error ? err.message : 'unknown'}` };
+            }
+          }
+          return { type: 'error', message: `Unknown preset command: ${subCmd}. Try: /preset list` };
+        }
+
         case 'roles':
           onShowPanel();
           return { type: 'panel', message: '' };