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

package/packages/server/src/api/src/services/dispatch-classifier.ts

@@ -0,0 +1,179 @@
+/**
+ * dispatch-classifier.ts — Role당 1세션 Invariant
+ *
+ * Dispatch 시 같은 wave 내 같은 role의 기존 세션을 찾아:
+ * - active → amend (기존 세션에 추가 지시)
+ * - done → amend (이어서 작업)
+ * - error N회 → new (fresh start)
+ * - 없음 → new (첫 생성)
+ *
+ * Haiku classifier 제거 — deterministic 판단.
+ * BUG-FORKBOMB: CEO 무한 dispatch 루프 구조적 차단.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { COMPANY_ROOT } from './file-reader.js';
+import { listSessions } from './session-store.js';
+import { executionManager } from './execution-manager.js';
+
+/* ─── Types ──────────────────────────── */
+
+export interface DispatchDecision {
+  ts: string;
+  waveId: string;
+  roleId: string;
+  sourceRole: string;
+  newTask: string;
+  prevSessionId: string;
+  decision: 'amend' | 'new';
+  reason: string;
+}
+
+/* ─── Constants ──────────────────────── */
+
+const ERROR_THRESHOLD = 3; // error 3회 초과 시 fresh session 허용
+
+/* ─── Session Finder ─────────────────── */
+
+export interface PrevSessionInfo {
+  sessionId: string;
+  task: string;
+  status: string;
+  cliSessionId?: string;
+}
+
+/**
+ * 같은 wave 내에서 같은 role의 active 세션을 찾는다.
+ */
+export function findActiveSession(waveId: string, roleId: string): PrevSessionInfo | null {
+  const session = listSessions().find(
+    s => s.waveId === waveId && s.roleId === roleId && (s.status === 'active' || s.status === 'awaiting_input'),
+  );
+  if (!session) return null;
+
+  const exec = executionManager.getActiveExecution(session.id);
+  return {
+    sessionId: session.id,
+    task: exec?.task ?? '',
+    status: session.status,
+    cliSessionId: exec?.cliSessionId,
+  };
+}
+
+/**
+ * 같은 wave 내에서 같은 role의 가장 최근 done 세션을 찾는다.
+ */
+export function findPrevDoneSession(waveId: string, roleId: string): PrevSessionInfo | null {
+  const sessions = listSessions().filter(
+    s => s.waveId === waveId && s.roleId === roleId && (s.status === 'done' || s.status === 'closed'),
+  );
+
+  if (sessions.length === 0) return null;
+
+  const latest = sessions[sessions.length - 1];
+  const exec = executionManager.getCompletedExecution(latest.id);
+
+  return {
+    sessionId: latest.id,
+    task: exec?.task ?? '',
+    status: latest.status,
+    cliSessionId: exec?.cliSessionId,
+  };
+}
+
+/**
+ * 같은 wave 내에서 같은 role의 error 세션 수를 센다.
+ */
+function countErrorSessions(waveId: string, roleId: string): number {
+  return listSessions().filter(
+    s => s.waveId === waveId && s.roleId === roleId && s.status === 'error',
+  ).length;
+}
+
+/* ─── Decision Logger ─────────────────── */
+
+function logDecision(decision: DispatchDecision): void {
+  const logDir = path.join(COMPANY_ROOT, '.tycono');
+  const logPath = path.join(logDir, 'dispatch-decisions.jsonl');
+  try {
+    fs.mkdirSync(logDir, { recursive: true });
+    fs.appendFileSync(logPath, JSON.stringify(decision) + '\n');
+  } catch {
+    // Non-critical — don't crash on log failure
+  }
+}
+
+/* ─── Main Decision Function ──────────── */
+
+export interface AutoAmendResult {
+  action: 'amend' | 'new';
+  prevSessionId?: string;
+  reason: string;
+}
+
+/**
+ * dispatch 요청 시 기존 세션 reuse 여부를 deterministic하게 판단.
+ *
+ * Role당 1세션 Invariant:
+ * 1. active 세션 있음 → amend (대기 후 추가 지시)
+ * 2. done 세션 있음 → amend (이어서)
+ * 3. error N회 초과 → new (fresh start)
+ * 4. 세션 없음 → new (첫 생성)
+ */
+export async function decideDispatchOrAmend(
+  waveId: string | undefined,
+  roleId: string,
+  sourceRole: string,
+  newTask: string,
+): Promise<AutoAmendResult> {
+  // No wave context → always new dispatch
+  if (!waveId) {
+    return { action: 'new', reason: 'no-wave-context' };
+  }
+
+  // 1. Active session → amend (BUG-FORKBOMB fix: 기존에는 'new' 반환하여 fork bomb 유발)
+  const active = findActiveSession(waveId, roleId);
+  if (active) {
+    const decision: DispatchDecision = {
+      ts: new Date().toISOString(),
+      waveId, roleId, sourceRole, newTask: newTask.slice(0, 200),
+      prevSessionId: active.sessionId,
+      decision: 'amend', reason: 'role-already-active',
+    };
+    logDecision(decision);
+    console.log(`[Dispatch] ${roleId}: AMEND (active session ${active.sessionId})`);
+    return { action: 'amend', prevSessionId: active.sessionId, reason: 'role-already-active' };
+  }
+
+  // 2. Done session → amend (이어서 작업)
+  const prev = findPrevDoneSession(waveId, roleId);
+  if (prev) {
+    // 2a. Error threshold 체크: error가 많으면 fresh start
+    const errorCount = countErrorSessions(waveId, roleId);
+    if (errorCount >= ERROR_THRESHOLD) {
+      const decision: DispatchDecision = {
+        ts: new Date().toISOString(),
+        waveId, roleId, sourceRole, newTask: newTask.slice(0, 200),
+        prevSessionId: prev.sessionId,
+        decision: 'new', reason: `error-threshold-${errorCount}`,
+      };
+      logDecision(decision);
+      console.log(`[Dispatch] ${roleId}: NEW (${errorCount} errors >= ${ERROR_THRESHOLD} threshold)`);
+      return { action: 'new', reason: `error-threshold-${errorCount}` };
+    }
+
+    const decision: DispatchDecision = {
+      ts: new Date().toISOString(),
+      waveId, roleId, sourceRole, newTask: newTask.slice(0, 200),
+      prevSessionId: prev.sessionId,
+      decision: 'amend', reason: 'prev-session-done',
+    };
+    logDecision(decision);
+    console.log(`[Dispatch] ${roleId}: AMEND (done session ${prev.sessionId})`);
+    return { action: 'amend', prevSessionId: prev.sessionId, reason: 'prev-session-done' };
+  }
+
+  // 3. No session → new dispatch
+  console.log(`[Dispatch] ${roleId}: NEW (first dispatch in wave)`);
+  return { action: 'new', reason: 'no-prev-session' };
+}

package/{src → packages/server/src}/api/src/services/execution-manager.ts

@@ -1,5 +1,6 @@
 import fs from 'node:fs';
 import path from 'node:path';
+import { execSync } from 'node:child_process';
 import { COMPANY_ROOT } from './file-reader.js';
 import { ActivityStream, type ActivityEvent } from './activity-stream.js';
 import { buildOrgTree } from '../engine/org-tree.js';
@@ -42,6 +43,8 @@ export interface Execution {
   knowledgeDebt?: KnowledgeDebtItem[];
   ports?: PortAllocation;
   traceId?: string;
+  /** CLI session ID for --resume (captured from Claude CLI result event) */
+  cliSessionId?: string;
 }
 
 export interface StartExecutionParams {
@@ -56,6 +59,8 @@ export interface StartExecutionParams {
   targetRoles?: string[];
   sessionId: string;
   attachments?: ImageAttachment[];
+  /** CLI session ID for --resume (context continuity across turn limits) */
+  cliSessionId?: string;
 }
 
 /* ─── Helpers ────────────────────────────── */
@@ -77,6 +82,29 @@ function hasQuestion(output: string): boolean {
   return /\?\s*$/.test(lastBlock) || /할까요|해볼까요|어떨까요|확인.*필요/.test(lastBlock);
 }
 
+/* ─── [APPROVAL_NEEDED] Detection ─── */
+
+const APPROVAL_TAGS = /\[APPROVAL_NEEDED\]|\[CEO_DECISION\]|\[DECISION_REQUIRED\]/;
+
+function extractApprovalQuestion(output: string): string | null {
+  const idx = output.search(APPROVAL_TAGS);
+  if (idx === -1) return null;
+  // Extract text after the tag until end or next section marker
+  const afterTag = output.slice(idx);
+  const lines = afterTag.split('\n');
+  // Take up to 10 lines after the tag line for context
+  const relevant = lines.slice(0, 10).join('\n').trim();
+  return relevant || null;
+}
+
+function sendApprovalNotification(roleId: string, question: string): void {
+  try {
+    const title = `Tycono: ${roleId} needs approval`;
+    const msg = question.replace(/["\\\n]/g, ' ').slice(0, 200);
+    execSync(`osascript -e 'display notification "${msg}" with title "${title}" sound name "Ping"'`);
+  } catch { /* ignore on non-macOS */ }
+}
+
 function isExecActive(status: ExecStatus): boolean {
   return status === 'running' || status === 'awaiting_input';
 }
@@ -102,6 +130,7 @@ class ExecutionManager {
   private runner = createRunner();
   private nextId = 1;
   private executionCreatedListeners = new Set<(exec: Execution) => void>();
+  private pendingAmendments = new Map<string, string[]>(); // sessionId → queued tasks
 
   setRunner(newRunner: ExecutionRunner): void {
     this.runner = newRunner;
@@ -246,6 +275,24 @@ class ExecutionManager {
       ...(execution.ports.hmr && { VITE_HMR_PORT: String(execution.ports.hmr) }),
     } : {};
 
+    // Handoff summary: collect prior dispatch results for this wave
+    const priorDispatches: Array<{ roleId: string; task: string; result: string }> = [];
+    const execSession = getSession(params.sessionId);
+    if (execSession?.waveId) {
+      for (const [, exec] of this.executions) {
+        if (exec.status === 'done' && exec.result && exec.sessionId !== params.sessionId) {
+          const s = getSession(exec.sessionId);
+          if (s?.waveId === execSession.waveId) {
+            priorDispatches.push({
+              roleId: exec.roleId,
+              task: exec.task,
+              result: exec.result.output?.slice(0, 500) ?? '',
+            });
+          }
+        }
+      }
+    }
+
     const handle = this.runner.execute(
       {
         companyRoot: COMPANY_ROOT,
@@ -262,6 +309,8 @@ class ExecutionManager {
         presetId,
         codeRoot: resolveCodeRoot(COMPANY_ROOT),
         attachments: params.attachments,
+        cliSessionId: params.cliSessionId,
+        priorDispatches,
         env: {
           ...process.env,
           ...portEnv,
@@ -299,12 +348,16 @@ class ExecutionManager {
             });
           }
         },
-        onDispatch: (subRoleId, subTask) => {
+        onDispatch: async (subRoleId, subTask) => {
           if (params.targetRoles && params.targetRoles.length > 0) {
             if (!params.targetRoles.includes(subRoleId)) {
+              const errorMsg = `Dispatch to ${subRoleId} blocked — not in active target scope for this wave.`;
               console.warn(`[ExecMgr] Dispatch blocked: ${params.roleId} → ${subRoleId} (not in targetRoles)`);
-              execution.stream.emit('stderr', params.roleId, {
-                message: `Dispatch to ${subRoleId} blocked — not in active target scope for this wave.`,
+              execution.stream.emit('dispatch:error', params.roleId, {
+                sourceRole: params.roleId,
+                targetRole: subRoleId,
+                error: errorMsg,
+                timestamp: Date.now(),
               });
               return;
             }
@@ -314,6 +367,32 @@ class ExecutionManager {
           const parentSession = getSession(execution.sessionId);
           const parentWaveId = parentSession?.waveId;
 
+          // BUG-FORKBOMB: Role당 1세션 invariant — active/done 세션 있으면 amend
+          if (parentWaveId) {
+            const { decideDispatchOrAmend } = await import('./dispatch-classifier.js');
+            const decision = await decideDispatchOrAmend(parentWaveId, subRoleId, params.roleId, subTask);
+
+            if (decision.action === 'amend' && decision.prevSessionId) {
+              console.log(`[ExecMgr] AMEND instead of dispatch: ${subRoleId} → ${decision.prevSessionId} (${decision.reason})`);
+
+              if (decision.reason === 'role-already-active') {
+                // Active session — queue amendment
+                this.queueAmendment(decision.prevSessionId, `[FOLLOW-UP from ${params.roleId}] ${subTask}`);
+                return;
+              }
+
+              // Done session — continue
+              const amended = this.continueSession(
+                decision.prevSessionId,
+                `[FOLLOW-UP from ${params.roleId}] ${subTask}`,
+                params.roleId,
+              );
+              if (amended) return;
+              // continueSession failed — fall through to new dispatch
+              console.warn(`[ExecMgr] continueSession failed for ${decision.prevSessionId}, creating new session`);
+            }
+          }
+
           const childSession = createSession(subRoleId, {
             mode: 'do',
             source: 'dispatch',
@@ -424,6 +503,7 @@ class ExecutionManager {
     handle.promise
       .then((result: RunnerResult) => {
         execution.result = result;
+        if (result.cliSessionId) execution.cliSessionId = result.cliSessionId;
 
         const costUsd = estimateCost(
           result.totalTokens.input,
@@ -449,6 +529,34 @@ class ExecutionManager {
 
         const targetRole = resolveTargetRole(params.sourceRole, params.parentSessionId, this.executions);
 
+        // ── [APPROVAL_NEEDED] detection — notify user when agent is blocked ──
+        const approvalQuestion = extractApprovalQuestion(result.output);
+        if (approvalQuestion) {
+          console.log(`[Approval] ${params.roleId} (${execution.sessionId}) output contains approval tag`);
+          execution.stream.emit('approval:needed', params.roleId, {
+            roleId: params.roleId,
+            sessionId: execution.sessionId,
+            question: approvalQuestion,
+            timestamp: Date.now(),
+          });
+          sendApprovalNotification(params.roleId, approvalQuestion);
+
+          // BUG-APPROVAL belt-and-suspenders: directly notify supervisor (don't rely solely on stream)
+          // This ensures approval state is set even if stream watcher was lost (e.g., stream closed by cleanup)
+          if (params.roleId === 'ceo') {
+            const session = getSession(execution.sessionId);
+            if (session?.waveId) {
+              import('./supervisor-heartbeat.js').then(({ supervisorHeartbeat }) => {
+                const state = supervisorHeartbeat.getState(session.waveId!);
+                if (state && state.status !== 'awaiting_approval') {
+                  console.log(`[Approval] Direct supervisor notification: wave ${session.waveId} → awaiting_approval`);
+                  state.status = 'awaiting_approval';
+                }
+              }).catch(() => { /* avoid circular import crash */ });
+            }
+          }
+        }
+
         if (hardLimitReached) {
           execution.status = 'awaiting_input';
           execution.targetRole = targetRole;
@@ -460,15 +568,32 @@ class ExecutionManager {
             targetRole,
             reason: 'turn_limit',
           });
+
+          // Auto-continue on turn limit: resume with --resume for context continuity
+          // Delay slightly to allow stream event to propagate
+          setTimeout(() => {
+            console.log(`[Harness] Auto-continuing ${params.roleId} (${execution.sessionId}) after turn limit`);
+            this.continueSession(execution.sessionId, '턴 한도에 도달했습니다. 이전 작업을 이어서 계속 진행하세요.');
+          }, 3_000);
         } else if (!params.isContinuation && hasQuestion(result.output)) {
-          execution.status = 'awaiting_input';
-          execution.targetRole = targetRole;
-          execution.stream.emit('msg:awaiting_input', params.roleId, {
-            ...doneData,
-            question: result.output.trim().split('\n').slice(-5).join('\n'),
-            awaitingInput: true,
-            targetRole,
-          });
+          // CEO supervisor should auto-continue instead of hanging on awaiting_input
+          // (subordinates may have completed while CEO was running — CEO needs to synthesize results)
+          const session = getSession(execution.sessionId);
+          if (session?.roleId === 'ceo' && session?.source === 'wave') {
+            console.log(`[Harness] CEO supervisor hasQuestion — auto-continuing to synthesize results`);
+            setTimeout(() => {
+              this.continueSession(execution.sessionId, 'All dispatched sessions have completed. Synthesize the results from your team and provide a final briefing.');
+            }, 3_000);
+          } else {
+            execution.status = 'awaiting_input';
+            execution.targetRole = targetRole;
+            execution.stream.emit('msg:awaiting_input', params.roleId, {
+              ...doneData,
+              question: result.output.trim().split('\n').slice(-5).join('\n'),
+              awaitingInput: true,
+              targetRole,
+            });
+          }
         } else {
           const changedMdFiles = result.toolCalls
             .filter(tc => (tc.name === 'write_file' || tc.name === 'edit_file') && tc.input && typeof tc.input.path === 'string')
@@ -503,6 +628,20 @@ class ExecutionManager {
             this.finalizeSessionMessage(execution, 'done', result);
           }
 
+          // Emit dispatch:done on parent's stream (monni VOC: parent needs completion signal)
+          if (params.parentSessionId) {
+            const parentExec = this.getActiveExecution(params.parentSessionId);
+            if (parentExec) {
+              parentExec.stream.emit('dispatch:done', parentExec.roleId, {
+                targetRoleId: params.roleId,
+                childSessionId: params.sessionId,
+                output: result.output.slice(-1000),
+                turns: result.turns,
+                tokens: result.totalTokens,
+              });
+            }
+          }
+
           if (!params.parentSessionId && result) {
             const totalTokens = (result.totalTokens?.input ?? 0) + (result.totalTokens?.output ?? 0);
             const bonus = Math.min(2000, Math.max(500, Math.round(totalTokens / 500)));
@@ -568,11 +707,18 @@ class ExecutionManager {
 
         // OOM prevention: remove completed execution from memory after delay
         // (delay allows getActiveExecution to find it briefly for multiplexer/recovery)
+        // BUG-APPROVAL fix: Don't close stream if a continuation is running on the same session
+        // (closing the stream kills watcher subscribers, breaking supervisor event delivery)
         setTimeout(() => {
           this.executions.delete(execution.id);
-          // Also close the ActivityStream to free subscribers + file handles
-          execution.stream.close();
-        }, 30_000).unref();
+          // Only close stream if no other active execution shares this session
+          const hasActiveSibling = [...this.executions.values()].some(
+            e => e.sessionId === execution.sessionId && e.id !== execution.id && (e.status === 'running' || e.status === 'awaiting_input'),
+          );
+          if (!hasActiveSibling) {
+            execution.stream.close();
+          }
+        }, 300_000).unref(); // 5 min — prevents HTTP 410 on dispatch --check
       });
   }
 
@@ -656,6 +802,11 @@ class ExecutionManager {
     if (session.roleId !== 'ceo' || session.source !== 'wave') {
       updateSession(execution.sessionId, { status: 'done' });
     }
+
+    // Process queued amendments (BUG-FORKBOMB: role당 1세션 invariant)
+    if (status === 'done') {
+      this.processPendingAmendments(execution.sessionId);
+    }
   }
 
   private cleanupOrphanedChildren(parentSessionId: string): void {
@@ -779,6 +930,19 @@ Your job: monitor progress, course-correct if needed, wait for completion, then
     return this.recoverExecutionFromStream(sessionId);
   }
 
+  /** Find the latest completed execution for a session (for auto-amend lookup) */
+  getCompletedExecution(sessionId: string): { task: string; cliSessionId?: string } | undefined {
+    let latest: Execution | undefined;
+    for (const exec of this.executions.values()) {
+      if (exec.sessionId === sessionId && exec.status === 'done') {
+        if (!latest || exec.createdAt > latest.createdAt) {
+          latest = exec;
+        }
+      }
+    }
+    return latest ? { task: latest.task, cliSessionId: latest.cliSessionId } : undefined;
+  }
+
   listExecutions(filter?: { status?: ExecStatus; roleId?: string; active?: boolean }): Array<{
     id: string;
     type: ExecType;
@@ -856,14 +1020,23 @@ Your job: monitor progress, course-correct if needed, wait for completion, then
     exec.stream.emit('msg:reply', exec.roleId, { response, responderRole: effectiveResponder, isFollowUp });
 
     const prevOutput = exec.result?.output ?? '';
-    const contextSummary = prevOutput.length > 2000
-      ? prevOutput.slice(-2000)
-      : prevOutput;
+    const hasCliSession = !!exec.cliSessionId;
 
     const responderLabel = effectiveResponder === 'ceo' ? 'CEO' : effectiveResponder.toUpperCase();
-    const continuationTask = isFollowUp
-      ? `[CEO Follow-up Directive]\n${response}\n\n[Previous context — your earlier report follows]\n${contextSummary}`
-      : `[Continuation — previous output follows]\n${contextSummary}\n\n[${responderLabel} Response]\n${response}`;
+    let continuationTask: string;
+    if (hasCliSession) {
+      // --resume preserves full conversation context — no need to repeat output
+      continuationTask = isFollowUp
+        ? `[CEO Follow-up Directive]\n${response}`
+        : `[${responderLabel} Response — continue where you left off]\n${response}`;
+    } else {
+      const contextSummary = prevOutput.length > 2000
+        ? prevOutput.slice(-2000)
+        : prevOutput;
+      continuationTask = isFollowUp
+        ? `[CEO Follow-up Directive]\n${response}\n\n[Previous context — your earlier report follows]\n${contextSummary}`
+        : `[Continuation — previous output follows]\n${contextSummary}\n\n[${responderLabel} Response]\n${response}`;
+    }
 
     const newExec = this.startExecution({
       type: exec.type,
@@ -873,11 +1046,44 @@ Your job: monitor progress, course-correct if needed, wait for completion, then
       parentSessionId: exec.parentSessionId,
       isContinuation: !isFollowUp,
       sessionId: exec.sessionId, // Same session → same stream
+      // Pass CLI session ID for --resume (preserves Claude conversation context)
+      cliSessionId: exec.cliSessionId,
     });
 
     return newExec;
   }
 
+  /**
+   * Queue an amendment for a running session.
+   * Will be processed when the current execution completes.
+   */
+  queueAmendment(sessionId: string, task: string): void {
+    const queue = this.pendingAmendments.get(sessionId) ?? [];
+    queue.push(task);
+    this.pendingAmendments.set(sessionId, queue);
+    console.log(`[Dispatch] Queued amendment for ${sessionId} (${queue.length} pending)`);
+  }
+
+  /**
+   * Process pending amendments after execution completes.
+   * Called from finalization logic.
+   */
+  processPendingAmendments(sessionId: string): void {
+    const queue = this.pendingAmendments.get(sessionId);
+    if (!queue || queue.length === 0) return;
+
+    const task = queue.shift()!;
+    if (queue.length === 0) {
+      this.pendingAmendments.delete(sessionId);
+    }
+
+    console.log(`[Dispatch] Processing queued amendment for ${sessionId} (${queue.length} remaining)`);
+    // Use setTimeout to avoid recursive call stack during finalization
+    setTimeout(() => {
+      this.continueSession(sessionId, task);
+    }, 100);
+  }
+
   getActiveExecutionForRole(roleId: string): Execution | undefined {
     for (const exec of this.executions.values()) {
       if (exec.roleId === roleId && isExecActive(exec.status)) {
@@ -957,7 +1163,7 @@ Your job: monitor progress, course-correct if needed, wait for completion, then
         setTimeout(() => {
           this.executions.delete(execution.id);
           execution.stream.close();
-        }, 30_000).unref();
+        }, 300_000).unref(); // 5 min — prevents HTTP 410 on dispatch --check
       }
 
       return execution;

package/{src → packages/server/src}/api/src/services/file-reader.ts

@@ -5,9 +5,12 @@ import { glob } from 'glob';
 
 function findCompanyRoot(): string {
   if (process.env.COMPANY_ROOT) return process.env.COMPANY_ROOT;
-  // Walk up from cwd to find knowledge/CLAUDE.md (project root marker)
+  // Walk up from cwd to find CLAUDE.md (supports both layouts)
+  //   - Claude Code standard: CLAUDE.md at project root
+  //   - Tycono scaffold: knowledge/CLAUDE.md
   let dir = process.cwd();
   while (dir !== path.dirname(dir)) {
+    if (fs.existsSync(path.join(dir, 'CLAUDE.md'))) return dir;
     if (fs.existsSync(path.join(dir, 'knowledge', 'CLAUDE.md'))) return dir;
     dir = path.dirname(dir);
   }