tycono 0.3.14-beta.1 → 0.3.14-beta.10

package/package.json

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

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

@@ -33,6 +33,7 @@ import { questsRouter } from './routes/quests.js';
 import { coinsRouter } from './routes/coins.js';
 import { activeSessionsRouter } from './routes/active-sessions.js';
 import { supervisionRouter } from './routes/supervision.js';
+import { presetsRouter } from './routes/presets.js';
 import { importKnowledge } from './services/knowledge-importer.js';
 import { AnthropicProvider, type LLMProvider } from './engine/llm-adapter.js';
 import { readConfig } from './services/company-config.js';
@@ -212,6 +213,7 @@ export function createExpressApp(): express.Application {
   app.use('/api/coins', coinsRouter);
   app.use('/api/active-sessions', activeSessionsRouter);
   app.use('/api/supervision', supervisionRouter);
+  app.use('/api/presets', presetsRouter);
 
   app.get('/api/health', (_req, res) => {
     res.json({ status: 'ok', companyRoot: COMPANY_ROOT });

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

@@ -1,16 +1,21 @@
 /**
  * presets.ts — Preset API routes
  *
- * GET /api/presets          — list all preset summaries
- * GET /api/presets/:id      — get full preset detail
+ * GET  /api/presets          — list all preset summaries
+ * GET  /api/presets/:id      — get full preset detail
+ * POST /api/presets/install  — install preset from data
+ * DELETE /api/presets/:id    — remove installed preset
  */
 import { Router } from 'express';
+import fs from 'node:fs';
+import path from 'node:path';
+import YAML from 'yaml';
 import { COMPANY_ROOT } from '../services/file-reader.js';
-import { getPresetSummaries, getPresetById } from '../services/preset-loader.js';
+import { getPresetSummaries, getPresetById, loadPresets } from '../services/preset-loader.js';
 
 export const presetsRouter = Router();
 
-/** GET /api/presets — list preset summaries for TUI */
+/** GET /api/presets — list preset summaries */
 presetsRouter.get('/', (_req, res) => {
   try {
     const summaries = getPresetSummaries(COMPANY_ROOT);
@@ -33,3 +38,86 @@ presetsRouter.get('/:id', (req, res) => {
     res.status(500).json({ error: 'Failed to load preset' });
   }
 });
+
+/** POST /api/presets/install — install a preset from provided data */
+presetsRouter.post('/install', (req, res) => {
+  try {
+    const { id, preset } = req.body as { id: string; preset: Record<string, unknown> };
+    if (!id || !preset) {
+      res.status(400).json({ error: 'id and preset are required' });
+      return;
+    }
+
+    // Validate preset has required fields
+    if (!preset.name || !preset.roles || !Array.isArray(preset.roles)) {
+      res.status(400).json({ error: 'preset must have name and roles array' });
+      return;
+    }
+
+    // Check for conflict with existing preset
+    const existing = getPresetById(COMPANY_ROOT, id);
+    if (existing && !existing.isDefault) {
+      res.status(409).json({ error: `Preset already installed: ${id}` });
+      return;
+    }
+
+    // Create preset directory and write preset.yaml
+    const presetDir = path.join(COMPANY_ROOT, 'company', 'presets', id);
+    fs.mkdirSync(presetDir, { recursive: true });
+
+    // Write preset.yaml
+    const yamlContent = YAML.stringify(preset);
+    fs.writeFileSync(path.join(presetDir, 'preset.yaml'), yamlContent);
+
+    // Create subdirectories for roles/knowledge/skills
+    fs.mkdirSync(path.join(presetDir, 'roles'), { recursive: true });
+    fs.mkdirSync(path.join(presetDir, 'knowledge'), { recursive: true });
+    fs.mkdirSync(path.join(presetDir, 'skills'), { recursive: true });
+
+    // Write knowledge docs if provided
+    const knowledge = req.body.knowledge as Array<{ filename: string; content: string }> | undefined;
+    if (knowledge) {
+      for (const doc of knowledge) {
+        fs.writeFileSync(path.join(presetDir, 'knowledge', doc.filename), doc.content);
+      }
+    }
+
+    // Write role yamls if provided
+    const roleDefinitions = req.body.roleDefinitions as Array<{ id: string; yaml: string }> | undefined;
+    if (roleDefinitions) {
+      for (const role of roleDefinitions) {
+        const roleDir = path.join(presetDir, 'roles', role.id);
+        fs.mkdirSync(roleDir, { recursive: true });
+        fs.writeFileSync(path.join(roleDir, 'role.yaml'), role.yaml);
+      }
+    }
+
+    res.json({ ok: true, id, path: `company/presets/${id}` });
+  } catch (err) {
+    res.status(500).json({ error: `Install failed: ${err instanceof Error ? err.message : 'unknown'}` });
+  }
+});
+
+/** DELETE /api/presets/:id — remove installed preset */
+presetsRouter.delete('/:id', (req, res) => {
+  try {
+    const { id } = req.params;
+    if (id === 'default' || id === '_default') {
+      res.status(400).json({ error: 'Cannot remove default preset' });
+      return;
+    }
+
+    const presetDir = path.join(COMPANY_ROOT, 'company', 'presets', id);
+    if (!fs.existsSync(presetDir)) {
+      res.status(404).json({ error: `Preset not found: ${id}` });
+      return;
+    }
+
+    // Remove preset directory recursively
+    fs.rmSync(presetDir, { recursive: true, force: true });
+
+    res.json({ ok: true, id });
+  } catch (err) {
+    res.status(500).json({ error: `Remove failed: ${err instanceof Error ? err.message : 'unknown'}` });
+  }
+});

package/src/api/src/services/execution-manager.ts

@@ -180,7 +180,7 @@ class ExecutionManager {
 
     this.executions.set(execId, execution);
 
-    this.initializeAndRunExecution(execution, params, orgTree);
+    this.initializeAndRunExecution(execution, params, orgTree, presetId);
 
     return execution;
   }
@@ -189,6 +189,7 @@ class ExecutionManager {
     execution: Execution,
     params: StartExecutionParams,
     orgTree: ReturnType<typeof buildOrgTree>,
+    presetId?: string,
   ): Promise<void> {
     try {
       const ports = await portRegistry.allocate(execution.sessionId || execution.id, params.roleId, params.task);
@@ -724,8 +725,8 @@ Your job: monitor progress, course-correct if needed, wait for completion, then
     console.log(`[ExecMgr] Supervision recovery: ${deadExecution.roleId} died with ${runningChildren.length} running children. Restarting.`);
 
     // Propagate waveId from the dead session
-    const deadSession = getSession(deadExecution.sessionId);
-    const waveId = deadSession?.waveId;
+    const deadSes = getSession(deadExecution.sessionId);
+    const waveId = deadSes?.waveId;
 
     // Create new session for recovery
     const newSession = createSession(deadExecution.roleId, {

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

@@ -172,13 +172,15 @@ class SupervisorHeartbeat {
       const waveSessions = listSessions().filter(s => s.waveId === waveId);
       const ceoSession = waveSessions.find(s => s.roleId === 'ceo') ?? null;
 
-      // Read original directive from wave artifact file
+      // Read original directive + preset from wave artifact file
       let originalDirective = '';
+      let originalPreset: string | undefined;
       try {
         const waveFile = path.join(COMPANY_ROOT, 'operations', 'waves', `${waveId}.json`);
         if (fs.existsSync(waveFile)) {
           const waveData = JSON.parse(fs.readFileSync(waveFile, 'utf-8'));
           originalDirective = waveData.directive ?? '';
+          originalPreset = waveData.preset;
         }
       } catch { /* ignore */ }
 
@@ -188,6 +190,7 @@ class SupervisorHeartbeat {
           waveId,
           directive: originalDirective || text,
           continuous: false,
+          preset: originalPreset,
           supervisorSessionId: ceoSession?.id ?? null,
           executionId: null,
           status: 'stopped',

package/src/tui/app.tsx

@@ -14,6 +14,8 @@
 import React, { useState, useCallback, useMemo, useEffect, useRef } from 'react';
 import { Box, Text, useApp, useInput } from 'ink';
 import { StatusBar } from './components/StatusBar';
+import { OrgTree } from './components/OrgTree';
+import { StreamView } from './components/StreamView';
 import { CommandMode, type StreamLine } from './components/CommandMode';
 import { PanelMode } from './components/PanelMode';
 import { SetupWizard } from './components/SetupWizard';
@@ -668,8 +670,51 @@ export const App: React.FC = () => {
   // Command Mode: scrollable terminal (no fullscreen)
   // Panel Mode: fullscreen (intentional — like vim for inspection)
   if (mode === 'panel') {
+    // OOM debug levels: 0=full, 1=minimal, 2=orgTree only, 3=stream only
+    const debugLevel = parseInt(process.env.PANEL_MINIMAL || '0', 10);
+    if (debugLevel === 1) {
+      return (
+        <Box flexDirection="column">
+          <Text color="cyan">Panel Mode (minimal)</Text>
+          <Text color="gray">Events: {sse.events.length} | Press Esc</Text>
+        </Box>
+      );
+    }
+    if (debugLevel === 2) {
+      return (
+        <Box flexDirection="column">
+          <OrgTree tree={orgTree} focused={true} selectedIndex={0} flatRoles={flatRoleIds} ceoStatus="idle" />
+          <Text color="gray">OrgTree only | Press Esc</Text>
+        </Box>
+      );
+    }
+    if (debugLevel === 3) {
+      return (
+        <Box flexDirection="column">
+          <StreamView events={sse.events} allRoleIds={flatRoleIds} streamStatus={sse.streamStatus} waveId={focusedWaveId} roleLabel="All" />
+          <Text color="gray">StreamView only | Press Esc</Text>
+        </Box>
+      );
+    }
+    if (debugLevel === 4) {
+      // Full layout structure but empty content
+      return (
+        <Box flexDirection="column" height={termHeight}>
+          <Box flexGrow={1}>
+            <Box flexDirection="column" width={28}>
+              <Text color="green">Left Panel</Text>
+            </Box>
+            <Text color="gray">{'\u2502'}</Text>
+            <Box flexGrow={1} flexDirection="column" overflow="hidden">
+              <Text color="cyan">Right Panel</Text>
+            </Box>
+          </Box>
+          <StatusBar companyName="test" waveIndex={1} waveCount={1} waveStatus="idle" activeCount={0} portCount={0} totalCost={0} />
+        </Box>
+      );
+    }
     return (
-      <Box flexDirection="column" height={termHeight}>
+      <Box flexDirection="column">
         <Box flexGrow={1} flexDirection="column">
           <PanelMode
             tree={orgTree}

package/src/tui/components/OrgTree.tsx

@@ -1,6 +1,6 @@
 /**
- * OrgTree — left panel showing organization hierarchy with real-time status
- * CEO is now selectable (index 0 in flatRoles)
+ * OrgTree — left panel showing organization hierarchy
+ * Simplified to single Text render to prevent yoga OOM on wide terminals
  */
 
 import React from 'react';
@@ -16,103 +16,36 @@ interface OrgTreeProps {
   ceoStatus?: string;
 }
 
-function statusColor(status: string): string {
-  switch (status) {
-    case 'working':
-    case 'streaming':
-      return 'green';
-    case 'done':
-      return 'gray';
-    case 'error':
-      return 'red';
-    case 'awaiting_input':
-      return 'yellow';
-    default:
-      return 'gray';
-  }
-}
-
-interface FlatEntry {
-  roleId: string;
-  level: string;
-  status: string;
-  prefix: string;
-}
-
-function flattenTree(nodes: OrgNode[], prefix: string = '', isLast: boolean[] = []): FlatEntry[] {
-  const result: FlatEntry[] = [];
-
+function flattenTree(nodes: OrgNode[], isLast: boolean[] = []): Array<{ roleId: string; status: string; line: string }> {
+  const result: Array<{ roleId: string; status: string; line: string }> = [];
   for (let i = 0; i < nodes.length; i++) {
     const node = nodes[i];
     const last = i === nodes.length - 1;
-
-    let linePrefix = '';
+    let prefix = '';
     for (let j = 0; j < isLast.length; j++) {
-      linePrefix += isLast[j] ? '   ' : '\u2502  ';
+      prefix += isLast[j] ? '   ' : '\u2502  ';
     }
-    linePrefix += isLast.length > 0 || i > 0 || nodes.length > 1
-      ? (last ? '\u2514\u2500 ' : '\u251C\u2500 ')
-      : '';
-
-    result.push({
-      roleId: node.role.id,
-      level: node.role.level,
-      status: node.status,
-      prefix: linePrefix,
-    });
-
+    prefix += last ? '\u2514\u2500 ' : '\u251C\u2500 ';
+    const icon = statusIcon(node.status);
+    result.push({ roleId: node.role.id, status: node.status, line: `${prefix}${icon} ${node.role.id}` });
     if (node.children.length > 0) {
-      result.push(...flattenTree(node.children, '', [...isLast, last]));
+      result.push(...flattenTree(node.children, [...isLast, last]));
     }
   }
-
   return result;
 }
 
 export const OrgTree: React.FC<OrgTreeProps> = React.memo(({ tree, focused, selectedIndex, flatRoles, ceoStatus }) => {
-  const entries = flattenTree(tree);
-  const isCeoSelected = focused && flatRoles[selectedIndex] === 'ceo';
   const ceoIcon = statusIcon(ceoStatus ?? 'idle');
-  const ceoColor = statusColor(ceoStatus ?? 'idle');
+  const entries = flattenTree(tree);
+
+  // Render entire tree as single Text block (1 yoga node instead of 50+)
+  const lines = [`${ceoIcon} CEO`, ...entries.map(e => e.line)];
 
   return (
     <Box flexDirection="column" paddingX={1}>
       <Text bold color={focused ? 'cyan' : 'gray'}>{'\u2500\u2500 Org Tree \u2500\u2500'}</Text>
-      <Box marginTop={1}>
-        <Text color={ceoColor} bold={ceoStatus === 'working'}>{ceoIcon} </Text>
-        <Text
-          color={isCeoSelected ? 'cyan' : 'yellow'}
-          bold={isCeoSelected}
-          inverse={isCeoSelected}
-        >
-          CEO
-        </Text>
-      </Box>
-      {entries.map((entry, i) => {
-        const isSelected = focused && flatRoles[selectedIndex] === entry.roleId;
-        const icon = statusIcon(entry.status);
-        const color = statusColor(entry.status);
-
-        return (
-          <Box key={entry.roleId + '-' + i}>
-            <Text color="gray">{entry.prefix}</Text>
-            <Text
-              color={color}
-              bold={entry.status === 'working'}
-            >
-              {icon}
-            </Text>
-            <Text> </Text>
-            <Text
-              color={isSelected ? 'cyan' : 'white'}
-              bold={isSelected}
-              inverse={isSelected}
-            >
-              {entry.roleId}
-            </Text>
-          </Box>
-        );
-      })}
+      <Text color="white">{'\n' + lines.join('\n')}</Text>
     </Box>
   );
 });

package/src/tui/components/PanelMode.tsx

@@ -401,7 +401,7 @@ const PanelModeInner: React.FC<PanelModeProps> = ({
         <Text color="gray">{separatorStr}</Text>
 
         {/* Right: Tabbed panel */}
-        <Box flexGrow={1} flexDirection="column" overflow="hidden">
+        <Box flexGrow={1} flexDirection="column">
           {/* Tab bar */}
           <Box paddingX={1} marginBottom={0}>
             {(['stream', 'docs', 'info'] as RightTab[]).map(tab => (

package/src/tui/components/StreamView.tsx

@@ -1,13 +1,13 @@
 /**
- * StreamView — detailed stream panel for Panel Mode (right side)
- * Shows full event details with timestamps for a selected role.
- * No aggressive truncation — shows tools, thinking, dispatch like Claude Code.
+ * StreamView — stream panel for Panel Mode
+ * Simplified to single Text render to prevent yoga OOM on wide terminals.
+ * Previous: 30 events × 3 React elements = 90 yoga nodes → OOM on 245+ columns
+ * Now: 1 Text element with pre-formatted string
  */
 
 import React from 'react';
 import { Box, Text } from 'ink';
 import type { SSEEvent } from '../api';
-import { getRoleColor } from '../theme';
 
 interface StreamViewProps {
   events: SSEEvent[];
@@ -21,111 +21,58 @@ function formatTime(ts: string): string {
   try {
     const d = new Date(ts);
     return d.toLocaleTimeString('en-US', { hour12: false, hour: '2-digit', minute: '2-digit', second: '2-digit' });
-  } catch {
-    return '--:--:--';
-  }
+  } catch { return '--:--:--'; }
 }
 
-function renderEvent(event: SSEEvent): { content: string; contentColor: string } | null {
-  switch (event.type) {
-    case 'msg:start':
-      return {
-        content: `\u25B6 Started: ${(event.data.task as string)?.replace(/\u26D4[^\u26D4]*\u26D4[^"]*/g, '').trim().slice(0, 80) ?? ''}`,
-        contentColor: 'green',
-      };
+function eventToLine(event: SSEEvent): string | null {
+  const time = formatTime(event.ts);
+  const role = event.roleId.padEnd(12);
 
+  switch (event.type) {
+    case 'msg:start': {
+      const task = ((event.data.task as string) ?? '').replace(/\u26D4[^\u26D4]*\u26D4[^"]*/g, '').trim().slice(0, 80);
+      return `${time} ${role} \u25B6 Started: ${task}`;
+    }
     case 'msg:done': {
       const turns = event.data.turns as number | undefined;
-      return {
-        content: `\u2713 Done${turns ? ` (${turns} turns)` : ''}`,
-        contentColor: 'green',
-      };
+      return `${time} ${role} \u2713 Done${turns ? ` (${turns} turns)` : ''}`;
     }
-
     case 'msg:error':
-      return {
-        content: `\u2717 Error: ${(event.data.error as string ?? event.data.message as string ?? '').slice(0, 120)}`,
-        contentColor: 'red',
-      };
-
+      return `${time} ${role} \u2717 ${((event.data.error ?? event.data.message) as string ?? '').slice(0, 80)}`;
     case 'text': {
-      const text = ((event.data.text as string) ?? '');
-      if (!text.trim()) return null;
-      // Don't truncate — let terminal wrap
-      return { content: text, contentColor: 'white' };
+      const text = ((event.data.text as string) ?? '').trim();
+      if (!text) return null;
+      return `${time} ${role} ${text.slice(0, 120)}`;
     }
-
     case 'thinking': {
-      const text = ((event.data.text as string) ?? '').slice(0, 150);
-      if (!text.trim()) return null;
-      return { content: `\uD83D\uDCAD ${text}`, contentColor: 'gray' };
+      const text = ((event.data.text as string) ?? '').trim().slice(0, 100);
+      if (!text) return null;
+      return `${time} ${role} \uD83D\uDCAD ${text}`;
     }
-
     case 'tool:start': {
       const name = (event.data.name as string) ?? 'tool';
-      const input = event.data.input;
+      const input = event.data.input as Record<string, unknown> | undefined;
       let detail = '';
-      if (input && typeof input === 'object') {
-        const inp = input as Record<string, unknown>;
-        if (inp.file_path) detail = ` ${String(inp.file_path)}`;
-        else if (inp.command) detail = ` ${String(inp.command).slice(0, 80)}`;
-        else if (inp.pattern) detail = ` ${String(inp.pattern)}`;
-        else detail = ` ${JSON.stringify(input).slice(0, 80)}`;
+      if (input) {
+        if (input.file_path) detail = ` ${String(input.file_path).slice(0, 60)}`;
+        else if (input.command) detail = ` ${String(input.command).slice(0, 60)}`;
+        else if (input.pattern) detail = ` ${String(input.pattern)}`;
       }
-      return {
-        content: `\u2192 ${name}${detail}`,
-        contentColor: 'gray',
-      };
+      return `${time} ${role} \u2192 ${name}${detail}`;
     }
-
-    case 'tool:result':
-      return {
-        content: `\u2190 ${(event.data.name as string) ?? 'tool'} done`,
-        contentColor: 'gray',
-      };
-
     case 'dispatch:start':
-      return {
-        content: `\u21D2 dispatch ${event.data.targetRole as string ?? ''}: ${(event.data.task as string)?.replace(/\u26D4[^\u26D4]*\u26D4[^"]*/g, '').trim().slice(0, 80) ?? ''}`,
-        contentColor: 'yellow',
-      };
-
-    case 'dispatch:done':
-      return {
-        content: `\u21D0 ${event.data.targetRole as string ?? ''} completed`,
-        contentColor: 'yellow',
-      };
-
-    case 'msg:awaiting_input': {
-      const question = (event.data.question as string) ?? '';
-      return {
-        content: question ? `? ${question.slice(0, 120)}` : '? Awaiting input...',
-        contentColor: 'yellow',
-      };
-    }
-
-    // Hidden (truly internal only)
-    case 'heartbeat:tick':
-    case 'heartbeat:skip':
-    case 'prompt:assembled':
-    case 'trace:response':
-      return null;
-
+      return `${time} ${role} \u21D2 dispatch ${event.data.targetRole as string ?? ''}`;
     default:
       return null;
   }
 }
 
 const StreamViewInner: React.FC<StreamViewProps> = ({
-  events,
-  allRoleIds,
-  streamStatus,
-  waveId,
-  roleLabel,
+  events, allRoleIds, streamStatus, waveId, roleLabel,
 }) => {
-  const maxVisible = 30;
+  const termRows = process.stdout.rows || 40;
+  const maxVisible = Math.min(Math.max(5, termRows - 15), 20);
   const visibleEvents = events.slice(-maxVisible);
-
   const turnCount = events.filter(e => e.type === 'text' || e.type === 'tool:start').length;
 
   const statusLabel = streamStatus === 'streaming' ? '\u25CF streaming'
@@ -133,39 +80,24 @@ const StreamViewInner: React.FC<StreamViewProps> = ({
     : streamStatus === 'error' ? '\u2717 error'
     : 'idle';
 
+  // Build single text block (1 yoga node instead of 90+)
+  const lines = visibleEvents
+    .map(e => eventToLine(e))
+    .filter(Boolean) as string[];
+
+  const content = lines.length > 0
+    ? lines.join('\n')
+    : (waveId ? `Streaming... waiting for ${roleLabel !== 'All' ? roleLabel + ' ' : ''}events` : 'No active stream. Dispatch a wave to start.');
+
   return (
-    <Box flexDirection="column" paddingX={1} flexGrow={1}>
-      <Box justifyContent="space-between">
-        <Text bold color="cyan">
-          Stream ({roleLabel})
-        </Text>
+    <Box flexDirection="column" paddingX={1}>
+      <Text bold color="cyan">
+        Stream ({roleLabel}){'  '}
         <Text color={streamStatus === 'streaming' ? 'green' : 'gray'}>
           {statusLabel} {turnCount > 0 ? `turn ${turnCount}` : ''}
         </Text>
-      </Box>
-
-      {visibleEvents.length === 0 && (
-        <Box marginTop={1}>
-          <Text color="gray" dimColor>
-            {waveId
-              ? `Streaming... waiting for ${roleLabel !== 'All' ? roleLabel + ' ' : ''}events`
-              : 'No active stream. Dispatch a wave to start.'}
-          </Text>
-        </Box>
-      )}
-
-      {visibleEvents.map((event, i) => {
-        const rendered = renderEvent(event);
-        if (!rendered) return null;
-        const roleColor = getRoleColor(event.roleId, allRoleIds);
-        return (
-          <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="truncate">{rendered.content}</Text>
-          </Box>
-        );
-      })}
+      </Text>
+      <Text color="white" wrap="truncate">{content}</Text>
     </Box>
   );
 };