tycono 0.3.13-beta.6 → 0.3.13

package/bin/cli.js

@@ -10,9 +10,8 @@ if (!process.env.__TYCONO_HEAP_SET && !process.execArgv.some(a => a.includes('ma
   process.env.__TYCONO_HEAP_SET = '1';
   try {
     execFileSync(process.execPath, [
-      '--max-old-space-size=4096',
+      '--max-old-space-size=8192',
       '--expose-gc',
-      '--heapsnapshot-near-heap-limit=1',
       ...process.execArgv,
       fileURLToPath(import.meta.url),
       ...process.argv.slice(2),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tycono",
-  "version": "0.3.13-beta.6",
+  "version": "0.3.13",
   "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/routes/execute.ts

@@ -27,6 +27,9 @@ executionManager.onExecutionCreated((exec) => {
   waveMultiplexer.onExecutionCreated(exec);
 });
 
+// OOM fix: wave recovery runs once, not on every 5s poll
+let waveRecoveryDone = false;
+
 /* ─── Runner — lazy, re-created when engine changes ── */
 
 function getRunner() {
@@ -50,15 +53,15 @@ export function handleExecRequest(req: IncomingMessage, res: ServerResponse): vo
 
   // ── /api/waves/active — restore active waves after refresh ──
   if (method === 'GET' && url === '/api/waves/active') {
-    // Recovery: rebuild wave→session mapping from session-store
-    // Include done sessions (persistent channel model) but limit to CEO sessions
-    const waves = waveMultiplexer.getActiveWaves();
-    if (waves.length === 0) {
+    // Recovery: rebuild wave→session mapping from session-store (ONE TIME ONLY)
+    // Previous bug: recovery ran on EVERY poll (5s) because getActiveWaves()
+    // returns empty for done executions → recovery loop → OOM
+    if (!waveRecoveryDone) {
+      waveRecoveryDone = true;
       const allSessions = listSessions();
       let recovered = 0;
       for (const ses of allSessions) {
         if (!ses.waveId) continue;
-        // Only recover CEO sessions for wave display (team sessions loaded on demand)
         if (ses.roleId !== 'ceo') continue;
         const exec = executionManager.getActiveExecution(ses.id);
         if (exec) {
@@ -67,7 +70,7 @@ export function handleExecRequest(req: IncomingMessage, res: ServerResponse): vo
         }
       }
       if (recovered > 0) {
-        console.log(`[WaveRecovery] Recovered ${recovered} active sessions`);
+        console.log(`[WaveRecovery] Recovered ${recovered} sessions (one-time)`);
       }
     }
     jsonResponse(res, 200, { waves: waveMultiplexer.getActiveWaves() });

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/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/components/PanelMode.tsx

@@ -139,26 +139,11 @@ function readFilePreview(filePath: string, maxLines: number): string[] {
   }
 }
 
-// OOM debug: track render count
-let panelRenderCount = 0;
-
 export const PanelMode: React.FC<PanelModeProps> = ({
   tree, flatRoles, events, selectedRoleIndex, selectedRoleId,
   streamStatus, waveId, activeSessions, allSessions, companyRoot, waves,
   focusedWaveId, onMove, onSelect, onEscape, onFocusWave,
 }) => {
-  panelRenderCount++;
-  if (panelRenderCount % 100 === 0) {
-    const mem = process.memoryUsage();
-    console.error(`[PanelMode] render #${panelRenderCount} heap=${Math.round(mem.heapUsed/1024/1024)}MB events=${events.length}`);
-  }
-  if (panelRenderCount > 1000) {
-    console.error(`[PanelMode] ⛔ RENDER LOOP DETECTED: ${panelRenderCount} renders. Bailing out.`);
-    onEscape(); // Force back to command mode
-    panelRenderCount = 0;
-    return null;
-  }
-
   const [termHeight, setTermHeight] = useState(process.stdout.rows || 30);
   const [rightTab, setRightTab] = useState<RightTab>('stream');
   const [docsFilter, setDocsFilter] = useState<DocsFilter>('all');

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: '' };