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

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

@@ -0,0 +1,310 @@
+/**
+ * preset-loader.ts — Load presets from multiple sources (2-Layer Knowledge)
+ *
+ * Scan order (first match wins per preset ID):
+ *   1. knowledge/presets/{name}/preset.yaml    (legacy/local presets)
+ *   2. .tycono/agencies/{name}/preset.yaml     (local agency install)
+ *   3. ~/.tycono/agencies/{name}/preset.yaml   (global agency install)
+ *   4. Bundled presets (shipped with tycono-server)
+ *
+ * Returns PresetSummary[] for TUI display and full LoadedPreset for wave creation.
+ */
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { execSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import YAML from 'yaml';
+import type { PresetDefinition, LoadedPreset, PresetSummary } from '../../../shared/types.js';
+
+const PRESETS_DIR = 'knowledge/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, 'knowledge', '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 knowledge/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 knowledge/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);
+    }
+  }
+
+  // 3. Installed agencies from .tycono/agencies/ (2-Layer Knowledge)
+  //    Local project agencies take priority, then global (~/.tycono/agencies/)
+  const agencyDirs = [
+    path.join(companyRoot, '.tycono', 'agencies'),
+    path.join(os.homedir(), '.tycono', 'agencies'),
+  ];
+  const loadedIds = new Set(presets.map(p => p.definition.id));
+  for (const agenciesDir of agencyDirs) {
+    if (!fs.existsSync(agenciesDir)) continue;
+    const entries = fs.readdirSync(agenciesDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      if (loadedIds.has(entry.name)) continue; // earlier sources take priority
+      const preset = loadPresetFromDir(path.join(agenciesDir, entry.name));
+      if (preset) {
+        presets.push(preset);
+        loadedIds.add(preset.definition.id);
+      }
+    }
+  }
+
+  // 4. Bundled presets (shipped with tycono-server, fallback if not in user's project)
+  const __dirname_esm = path.dirname(fileURLToPath(import.meta.url));
+  const bundledPresetsDir = path.resolve(__dirname_esm, '../../../../presets');
+  if (fs.existsSync(bundledPresetsDir)) {
+    const entries = fs.readdirSync(bundledPresetsDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      if (loadedIds.has(entry.name)) continue; // user's preset takes priority
+      const preset = loadPresetFromDir(path.join(bundledPresetsDir, 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.
+ * Falls back to remote download from tycono.ai if not found locally.
+ */
+export function getPresetById(companyRoot: string, presetId: string): LoadedPreset | null {
+  const presets = loadPresets(companyRoot);
+  const local = presets.find(p => p.definition.id === presetId);
+  if (local) return local;
+
+  // Try downloading from tycono.ai preset registry
+  const downloaded = downloadPreset(companyRoot, presetId);
+  return downloaded;
+}
+
+/**
+ * Download a preset from the remote registry (tycono.ai).
+ * Saves to knowledge/presets/{id}/ for future use.
+ */
+function downloadPreset(companyRoot: string, presetId: string): LoadedPreset | null {
+  const REGISTRY_URL = process.env.TYCONO_PRESET_REGISTRY || 'https://tycono.ai/api/presets';
+
+  try {
+    // Synchronous HTTP request (preset download is a blocking init step)
+    const response = execSync(
+      `curl -s --max-time 10 "${REGISTRY_URL}/${presetId}/download"`,
+      { encoding: 'utf-8' },
+    );
+
+    const data = JSON.parse(response);
+    if (!data.preset || !data.files) return null;
+
+    // Save to local presets directory
+    const targetDir = path.join(companyRoot, PRESETS_DIR, presetId);
+    fs.mkdirSync(targetDir, { recursive: true });
+
+    // Write preset.yaml
+    fs.writeFileSync(
+      path.join(targetDir, 'preset.yaml'),
+      YAML.stringify(data.preset),
+    );
+
+    // Write knowledge files
+    if (data.files && typeof data.files === 'object') {
+      for (const [filePath, content] of Object.entries(data.files)) {
+        const fullPath = path.join(targetDir, filePath);
+        fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+        fs.writeFileSync(fullPath, content as string);
+      }
+    }
+
+    console.log(`[Preset] Downloaded "${presetId}" from ${REGISTRY_URL}`);
+    return loadPresetFromDir(targetDir);
+  } catch (err) {
+    console.warn(`[Preset] Failed to download "${presetId}": ${(err as Error).message}`);
+    return null;
+  }
+}
+
+/**
+ * Auto-select the best preset based on directive text.
+ *
+ * Matches directive words against each preset's:
+ *   - wave_scoped.task_keywords (highest weight: 3)
+ *   - tags (weight: 2)
+ *   - use_case (weight: 2)
+ *   - category + industry (weight: 1)
+ *
+ * Returns preset ID with highest score, or undefined if no meaningful match.
+ * Minimum score threshold: 2 (at least one strong keyword match).
+ */
+export function autoSelectPreset(companyRoot: string, directive: string): string | undefined {
+  const presets = loadPresets(companyRoot).filter(p => !p.isDefault);
+  if (presets.length === 0) return undefined;
+
+  const words = directive.toLowerCase().split(/[\s,.:;!?'"()\-]+/).filter(w => w.length > 2);
+  if (words.length === 0) return undefined;
+
+  let bestId: string | undefined;
+  let bestScore = 0;
+
+  for (const preset of presets) {
+    const def = preset.definition;
+    let score = 0;
+
+    // task_keywords: strongest signal — exact match (weight 5), partial (weight 2)
+    const taskKeywords = def.wave_scoped?.task_keywords ?? [];
+    for (const kw of taskKeywords) {
+      const kwLower = kw.toLowerCase();
+      if (words.includes(kwLower)) {
+        score += 5; // exact word match
+      } else if (words.some(w => (w.length > 3 && kwLower.includes(w)) || (kwLower.length > 3 && w.includes(kwLower)))) {
+        score += 2; // partial match (only for longer words)
+      }
+    }
+
+    // tags: exact match (weight 3), partial (weight 1)
+    const tags = def.tags ?? [];
+    for (const tag of tags) {
+      const tagLower = tag.toLowerCase();
+      if (words.includes(tagLower)) {
+        score += 3;
+      } else if (words.some(w => w.length > 3 && (w.includes(tagLower) || tagLower.includes(w)))) {
+        score += 1;
+      }
+    }
+
+    // use_case: word match (weight 2)
+    const useCases = def.use_case ?? [];
+    for (const uc of useCases) {
+      const ucWords = uc.toLowerCase().split(/[\s\-_]+/).filter(u => u.length > 2);
+      for (const ucw of ucWords) {
+        if (words.includes(ucw)) score += 2;
+      }
+    }
+
+    // category + industry: exact match only (weight 1)
+    if (def.category && words.includes(def.category.toLowerCase())) score += 1;
+    if (def.industry && words.includes(def.industry.toLowerCase())) score += 1;
+
+    if (score > bestScore) {
+      bestScore = score;
+      bestId = def.id;
+    }
+  }
+
+  // Minimum threshold: need at least one exact keyword match (score 3+)
+  // Score 2 = only partial matches, too weak for confident auto-selection
+  return bestScore >= 3 ? bestId : undefined;
+}

package/{src → packages/server/src}/api/src/services/supervisor-heartbeat.ts

@@ -35,7 +35,7 @@ interface SupervisorState {
   preset?: string;
   supervisorSessionId: string | null;
   executionId: string | null;
-  status: 'starting' | 'running' | 'restarting' | 'stopped' | 'error';
+  status: 'starting' | 'running' | 'restarting' | 'stopped' | 'error' | 'awaiting_approval';
   crashCount: number;
   maxCrashRetries: number;
   restartTimer: ReturnType<typeof setTimeout> | null;
@@ -231,8 +231,11 @@ class SupervisorHeartbeat {
     // Record user message in wave conversation history
     appendWaveMessage(waveId, { role: 'user', content: text });
 
-    // If supervisor is stopped (agent finished or idle wave), wake it up
-    if (state.status === 'stopped') {
+    // If supervisor is stopped or awaiting approval, wake it up
+    if (state.status === 'stopped' || state.status === 'awaiting_approval') {
+      if (state.status === 'awaiting_approval') {
+        console.log(`[Supervisor] Directive received while awaiting approval for wave ${waveId}. Restarting supervisor.`);
+      }
       // Update the wave's directive if it was empty (idle wave first message)
       if (!state.directive) {
         state.directive = text;
@@ -633,6 +636,36 @@ ${cLevelList}
 5. **Done condition**: ALL subordinates must be done before you report done
 6. **Crash resilience**: If you restart, digest catches you up
 
+## ⛔ Amend-First Rule (COST CRITICAL — G-10)
+**When a C-Level needs follow-up work on the SAME topic, ALWAYS amend instead of re-dispatch.**
+
+Re-dispatch creates a new session that reloads ALL context from scratch (~3M tokens = ~$45).
+Amend sends instructions to the existing session — near-zero additional cost.
+
+| Situation | Action | Why |
+|-----------|--------|-----|
+| Critic CHALLENGE on Scout's work | **amend** Scout | Scout already has the code loaded |
+| Validator FAIL on Scout's output | **amend** Scout | Scout knows what it changed |
+| Need different work from same role | **dispatch** new | Genuinely new scope |
+| Role crashed or timed out | **dispatch** new | Session is dead |
+
+**Decision rule**: If the follow-up references files/code the role already touched → **amend**.
+Only dispatch a NEW session when the task is genuinely unrelated to previous work.
+
+**Wrong** (costs $45 per re-dispatch):
+\`\`\`
+dispatch scout "fix token mapping"     → ses-001 (3M tokens)
+# Critic challenges...
+dispatch scout "fix token mapping again" → ses-002 (3M tokens, WASTED)
+\`\`\`
+
+**Correct** (costs ~$0.01):
+\`\`\`
+dispatch scout "fix token mapping"     → ses-001 (3M tokens)
+# Critic challenges...
+amend ses-001 "Critic found issue: [challenge]. Fix the token mapping."
+\`\`\`
+
 ## Supervisor Guidelines
 - G-01: After amending a C-Level, verify on next tick that they reflected it. If not, escalate to CEO directive priority.
 - G-02: If a C-Level crashes 3+ times consecutively, stop dispatching them and report to CEO.
@@ -652,6 +685,13 @@ When C-Level A completes while C-Level B is still active:
 3. amend B: "C-Level A completed. Here are their deliverables relevant to your work: [summary]. Review and incorporate."
 4. On next tick, verify B acknowledged and reflected A's input
 
+## Critic CHALLENGE Relay (MANDATORY)
+⛔ When Critic issues a CHALLENGE, you MUST relay it verbatim to the target role.
+1. Detect CHALLENGE in Critic's output (keywords: CHALLENGE, BLOCK, SNOWBALL, "진짜 원인")
+2. amend target role: "Critic CHALLENGE: [exact challenge content]. Address this specifically."
+3. On next tick, verify the target's response addresses the specific challenge
+4. If not addressed: re-amend: "Critic challenged [X]. Your response did not address it. Respond to the specific challenge."
+
 When C-Level A produces intermediate results that B needs:
 1. amend B with the relevant intermediate output
 2. You don't need to wait for A to finish — relay as results become available
@@ -774,6 +814,12 @@ ${state.continuous ? `## Continuous Improvement Mode (ON)
       } else if (event.type === 'msg:error') {
         exec.stream.unsubscribe(subscriber);
         this.onSupervisorCrash(state, String(event.data.message ?? 'unknown error'));
+      } else if (event.type === 'approval:needed') {
+        // BUG-APPROVAL-DIRECTIVE-LOSS: CEO outputs [APPROVAL_NEEDED] then exits.
+        // Don't complete the wave — transition to awaiting_approval so directive can restart supervisor.
+        console.log(`[Supervisor] CEO awaiting approval for wave ${state.waveId}. Wave stays alive for directive.`);
+        state.status = 'awaiting_approval';
+        // Don't unsubscribe — CEO process will emit msg:done next, which we need to catch
       } else if (event.type === 'msg:awaiting_input') {
         // BUG-016: turn:limit causes awaiting_input — treat as done-guard
         // If all children are done → complete wave. Otherwise restart supervisor.
@@ -787,23 +833,57 @@ ${state.continuous ? `## Continuous Improvement Mode (ON)
   }
 
   private onSupervisorDone(state: SupervisorState): void {
-    // Check if there are still running C-Level sessions for this wave
+    // BUG-APPROVAL-DIRECTIVE-LOSS: If CEO exited after [APPROVAL_NEEDED],
+    // don't complete the wave. Wait for user directive to restart supervisor.
+    if (state.status === 'awaiting_approval') {
+      console.log(`[Supervisor] CEO done with approval pending for wave ${state.waveId}. Wave stays alive for directive.`);
+      return;
+    }
+
+    // Check if there are still running or paused C-Level sessions for this wave
     const waveSessions = listSessions().filter(s => s.waveId === state.waveId && s.id !== state.supervisorSessionId);
     const runningChildren = waveSessions.filter(s => {
       const exec = executionManager.getActiveExecution(s.id);
       return exec && exec.status === 'running';
     });
+    const awaitingChildren = waveSessions.filter(s => {
+      const exec = executionManager.getActiveExecution(s.id);
+      return exec && exec.status === 'awaiting_input';
+    });
 
-    if (runningChildren.length > 0) {
+    if (awaitingChildren.length > 0) {
+      // Auto-continue children that hit turn limit (using --resume for context continuity)
+      console.log(`[Supervisor] ${awaitingChildren.length} children awaiting_input (turn limit). Auto-continuing.`);
+      for (const session of awaitingChildren) {
+        executionManager.continueSession(session.id, '턴 한도에 도달했습니다. 이전 작업을 이어서 계속 진행하세요.');
+      }
+      // Restart supervisor to watch the resumed children
+      state.crashCount = 0;
+      this.scheduleRestart(state, 5_000);
+    } else if (runningChildren.length > 0) {
       // Principle 5: can't be done with running children → restart supervisor
       console.log(`[Supervisor] Done but ${runningChildren.length} children still running. Restarting.`);
       state.crashCount = 0; // Not a crash, intentional restart
       this.scheduleRestart(state, 5_000); // 5s delay
     } else if (state.continuous) {
-      // Continuous Improvement Mode: don't stop — restart supervisor to ask C-Levels for improvements
-      console.log(`[Supervisor] Wave ${state.waveId} iteration complete. Continuous mode ON — restarting for next improvement cycle.`);
-      state.crashCount = 0;
-      this.scheduleRestart(state, 5_000);
+      // BUG-CONTINUOUS-TURN1-STORM: Check if CEO actually did meaningful work.
+      // If turn 1 + 0 dispatches → "nothing to do" → stop loop instead of infinite restart.
+      const exec = state.executionId ? executionManager.getExecution(state.executionId) : undefined;
+      const turns = exec?.result?.turns ?? 0;
+      const dispatches = exec?.result?.dispatches?.length ?? 0;
+
+      if (turns <= 1 && dispatches === 0) {
+        console.log(`[Supervisor] Continuous mode: CEO finished in turn ${turns} with 0 dispatches. Stopping loop (nothing to do).`);
+        state.status = 'stopped';
+        // Don't restart — treat as normal wave completion (same as non-continuous done)
+        return;
+      } else {
+        // Continuous Improvement Mode: restart for next iteration
+        console.log(`[Supervisor] Wave ${state.waveId} iteration complete (${turns} turns, ${dispatches} dispatches). Continuous mode ON — restarting.`);
+        state.crashCount = 0;
+        this.scheduleRestart(state, 5_000);
+        return; // Don't fall through to completion
+      }
     } else {
       console.log(`[Supervisor] Wave ${state.waveId} complete. All subordinates done.`);
       state.status = 'stopped';

package/{src → packages/server/src}/api/src/services/wave-multiplexer.ts

@@ -300,14 +300,14 @@ class WaveMultiplexer {
   getActiveWaves(): Array<{
     id: string;
     directive: string;
-    dispatches: Array<{ sessionId: string; roleId: string; roleName: string }>;
+    dispatches: Array<{ sessionId: string; roleId: string; roleName: string; status: string; approvalNeeded?: boolean; approvalQuestion?: string }>;
     startedAt: number;
     sessionIds: string[];
   }> {
     const result: Array<{
       id: string;
       directive: string;
-      dispatches: Array<{ sessionId: string; roleId: string; roleName: string }>;
+      dispatches: Array<{ sessionId: string; roleId: string; roleName: string; status: string; approvalNeeded?: boolean; approvalQuestion?: string }>;
       startedAt: number;
       sessionIds: string[];
     }> = [];
@@ -316,13 +316,23 @@ class WaveMultiplexer {
       const hasActive = Array.from(sessions.values()).some(e => e.status === 'running' || e.status === 'awaiting_input');
       if (!hasActive) continue;
 
+      // Include ALL sessions (not just root) so plugin can show full team status
+      const APPROVAL_RE = /\[APPROVAL_NEEDED\]|\[CEO_DECISION\]|\[DECISION_REQUIRED\]/;
       const rootSessions = Array.from(sessions.values())
-        .filter(e => !e.parentSessionId || !sessions.has(e.parentSessionId))
-        .map(e => ({
-          sessionId: e.sessionId,
-          roleId: e.roleId,
-          roleName: e.roleId.toUpperCase(),
-        }));
+        .map(e => {
+          const output = e.result?.output ?? '';
+          const hasApproval = APPROVAL_RE.test(output);
+          return {
+            sessionId: e.sessionId,
+            roleId: e.roleId,
+            roleName: e.roleId.toUpperCase(),
+            status: e.status,
+            ...(hasApproval && {
+              approvalNeeded: true,
+              approvalQuestion: output.slice(output.search(APPROVAL_RE)).split('\n').slice(0, 5).join(' ').slice(0, 200),
+            }),
+          };
+        });
 
       const firstExec = rootSessions.length > 0
         ? Array.from(sessions.values()).find(e => e.sessionId === rootSessions[0].sessionId)

package/{src → packages/server/src}/api/src/services/wave-tracker.ts

@@ -313,6 +313,30 @@ export function saveCompletedWave(waveId: string, directive: string): { ok: bool
       } catch { /* ignore */ }
     }
 
+    // Collect dispatch statistics across all sessions
+    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,
@@ -323,6 +347,7 @@ export function saveCompletedWave(waveId: string, directive: string): { ok: bool
       sessionIds: allSessionIds,
     };
     if (existingPreset) waveJson.preset = existingPreset;
+    if (dispatchStats.attempted > 0) waveJson.dispatch = dispatchStats;
     fs.writeFileSync(jsonPath, JSON.stringify(waveJson, null, 2), 'utf-8');
 
     const relativePath = `.tycono/waves/${baseName}.json`;