tycono 0.1.93-beta.0 → 0.1.93-beta.2

package/package.json

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

package/src/api/src/engine/agent-loop.ts

@@ -595,6 +595,84 @@ export async function runAgentLoop(config: AgentConfig): Promise<AgentResult> {
 
           onTurnComplete?.(turns);
         }
+
+        // ── Post-Knowledging: ④⑤ 수행 프롬프트 (KP-008) ──
+        // Engineer/CTO가 구현 완료 후 The Loop 마무리 (Knowledge 업데이트 + Task 상태 갱신)를 수행하도록 유도
+        const postKPrompt = [
+          '[POST-KNOWLEDGING] 구현이 완료되었습니다. The Loop 마무리를 수행하세요:',
+          '',
+          '## ④ Knowledge 업데이트 (The Loop Step 4)',
+          '다음 중 해당하는 항목을 수행하세요:',
+          '- 본인 journal 업데이트 (`roles/' + roleId + '/journal/YYYY-MM-DD.md` — 오늘 날짜 파일)',
+          '- 구현 중 새로 발견한 패턴/아키텍처 결정이 있다면 관련 문서 업데이트',
+          '  (예: architecture/web-app-ia.md, architecture/session-worktree-isolation.md 등)',
+          '- 중요한 기술 결정은 operations/decisions/ 또는 architecture/ 반영',
+          '',
+          '## ⑤ Task 상태 갱신 (The Loop Step 5)',
+          '- `projects/tycono-platform/tasks.md` (또는 관련 tasks 파일)에서 완료한 태스크 상태를 DONE으로 변경',
+          '- 다음 작업이 있다면 식별하여 메모',
+          '',
+          '⛔ **필수**: ④와 ⑤를 모두 수행해야 The Loop이 완료됩니다.',
+          '이제 ④⑤를 수행하세요 (Read, Edit 도구 사용).',
+        ].join('\n');
+
+        messages.push({ role: 'user', content: postKPrompt });
+
+        // Run Post-K loop (최대 2턴 — C-Level의 3턴보다 짧게)
+        const maxPostKRounds = 2;
+        for (let round = 0; round < maxPostKRounds && turns < maxTurns; round++) {
+          if (abortSignal?.aborted) break;
+          turns++;
+
+          const postKResponse = await llm.chat(context.systemPrompt, messages, tools, abortSignal);
+          totalInput += postKResponse.usage.inputTokens;
+          totalOutput += postKResponse.usage.outputTokens;
+          config.tokenLedger?.record({
+            ts: new Date().toISOString(),
+            sessionId: config.sessionId,
+            roleId,
+            model: config.model ?? 'unknown',
+            inputTokens: postKResponse.usage.inputTokens,
+            outputTokens: postKResponse.usage.outputTokens,
+          });
+
+          messages.push({ role: 'assistant', content: postKResponse.content });
+          for (const block of postKResponse.content) {
+            if (block.type === 'text' && block.text) {
+              outputParts.push(block.text);
+              onText?.(block.text);
+            }
+          }
+
+          // If no tool calls, Post-K is done
+          if (postKResponse.stopReason !== 'tool_use') break;
+
+          // Execute Post-K tool calls
+          const postKToolCalls = postKResponse.content.filter(
+            (b): b is MessageContent & { type: 'tool_use' } => b.type === 'tool_use',
+          );
+          const postKResults: ToolResult[] = [];
+          for (const tc of postKToolCalls) {
+            allToolCalls.push({ name: tc.name, input: tc.input });
+            const result = await executeTool(
+              { id: tc.id, name: tc.name, input: tc.input },
+              toolExecOptions,
+            );
+            postKResults.push(result);
+          }
+
+          messages.push({
+            role: 'user',
+            content: postKResults.map((r) => ({
+              type: 'tool_result' as const,
+              tool_use_id: r.tool_use_id,
+              content: r.content,
+              is_error: r.is_error,
+            })) as unknown as MessageContent[],
+          });
+
+          onTurnComplete?.(turns);
+        }
       }
     }
   }

package/src/api/src/engine/runners/claude-cli.ts

@@ -6,6 +6,7 @@ import { assembleContext } from '../context-assembler.js';
 import { getSubordinates } from '../org-tree.js';
 import { readConfig, resolveCodeRoot } from '../../services/company-config.js';
 import { getTokenLedger } from '../../services/token-ledger.js';
+import { getSession } from '../../services/session-store.js';
 import type { ExecutionRunner, RunnerConfig, RunnerCallbacks, RunnerHandle, RunnerResult } from './types.js';
 
 /* ─── Dispatch Bridge Script (Python3) ────── */
@@ -65,13 +66,17 @@ def get_status(job_id):
 def start_job(role_id, task):
     parent_session = os.environ.get('DISPATCH_PARENT_SESSION', os.environ.get('DISPATCH_PARENT_JOB', ''))
     source_role = os.environ.get('DISPATCH_SOURCE_ROLE', 'ceo')
-    body = json.dumps({
+    wave_id = os.environ.get('DISPATCH_WAVE_ID', '')
+    payload = {
         'type': 'assign',
         'roleId': role_id,
         'task': task,
         'sourceRole': source_role,
         'parentSessionId': parent_session if parent_session else None,
-        }).encode()
+    }
+    if wave_id:
+        payload['waveId'] = wave_id
+    body = json.dumps(payload).encode()
     req = urllib.request.Request(f'{api}/api/jobs', body, {'Content-Type': 'application/json'})
     resp = json.loads(urllib.request.urlopen(req, timeout=10).read())
     return resp['jobId']
@@ -347,6 +352,11 @@ export class ClaudeCliRunner implements ExecutionRunner {
     cleanEnv.DISPATCH_SUBORDINATES = subordinates.join(', ');
     cleanEnv.DISPATCH_PARENT_SESSION = config.sessionId;
     cleanEnv.DISPATCH_PARENT_JOB = config.sessionId; // deprecated, kept for backward compat
+    // BUG-W02 fix: propagate waveId to child dispatches via env
+    if (config.sessionId) {
+      const parentSes = getSession(config.sessionId);
+      if (parentSes?.waveId) cleanEnv.DISPATCH_WAVE_ID = parentSes.waveId;
+    }
     // dispatch 명령어 경로를 PATH에 추가하지 않고 절대 경로로 사용
     cleanEnv.DISPATCH_CMD = dispatchScript;
     cleanEnv.CONSULT_CMD = consultScript;

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

@@ -10,6 +10,7 @@ import {
   createSession,
   addMessage,
   updateMessage,
+  listSessions,
   type Message,
   type ImageAttachment,
 } from '../services/session-store.js';
@@ -48,6 +49,28 @@ 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 if lost
+    const waves = waveMultiplexer.getActiveWaves();
+    if (waves.length === 0) {
+      const allSessions = listSessions();
+      const waveGroups = new Map<string, string[]>();
+      for (const ses of allSessions) {
+        if (ses.waveId) {
+          if (!waveGroups.has(ses.waveId)) waveGroups.set(ses.waveId, []);
+          waveGroups.get(ses.waveId)!.push(ses.id);
+        }
+      }
+      // BUG-W03 fix: register ALL wave sessions (including completed) for tree display
+      for (const [wid, sids] of waveGroups) {
+        for (const sid of sids) {
+          // getActiveExecution falls back to stream recovery for completed sessions
+          const exec = executionManager.getActiveExecution(sid);
+          if (exec) {
+            waveMultiplexer.registerSession(wid, exec);
+          }
+        }
+      }
+    }
     jsonResponse(res, 200, { waves: waveMultiplexer.getActiveWaves() });
     return;
   }
@@ -253,6 +276,7 @@ function handleStartJob(body: Record<string, unknown>, res: ServerResponse): voi
   const session = createSession(roleId, {
     mode: readOnly ? 'talk' : 'do',
     source: parentSessionId ? 'dispatch' : sessionSource,
+    ...(parentSessionId && { parentSessionId }),
     ...(waveId && { waveId }),
   });
   const sessionId = session.id;
@@ -301,9 +325,18 @@ function handleStartJob(body: Record<string, unknown>, res: ServerResponse): voi
 
 function handleSaveWave(body: Record<string, unknown>, res: ServerResponse): void {
   const directive = body.directive as string;
-  const sessionIds = (body.sessionIds ?? body.jobIds) as string[];
+  let sessionIds = (body.sessionIds ?? body.jobIds) as string[] | undefined;
   const waveId = body.waveId as string | undefined;
 
+  // BUG-W01 fix: auto-collect sessionIds from session-store when waveId is present
+  if (waveId && (!sessionIds || sessionIds.length === 0)) {
+    const allSessions = listSessions();
+    sessionIds = allSessions
+      .filter(s => s.waveId === waveId)
+      .map(s => s.id);
+    console.log(`[WaveSave] Auto-collected ${sessionIds.length} sessionIds for wave ${waveId}`);
+  }
+
   if (!directive || !sessionIds || sessionIds.length === 0) {
     jsonResponse(res, 400, { error: 'directive and sessionIds are required' });
     return;
@@ -399,7 +432,23 @@ function handleWaveStream(waveId: string, url: string, res: ServerResponse, req:
   const fromMatch = url.match(/[?&]from=(\d+)/);
   const fromWaveSeq = fromMatch ? parseInt(fromMatch[1], 10) : 0;
 
-  const sessionIds = waveMultiplexer.getWaveSessionIds(waveId);
+  let sessionIds = waveMultiplexer.getWaveSessionIds(waveId);
+
+  // Recovery: if wave→session mapping was lost (e.g. server restart),
+  // rebuild from session-store (sessions have waveId) + executionManager
+  if (sessionIds.length === 0) {
+    const allSessions = listSessions();
+    const waveSessions = allSessions.filter(s => s.waveId === waveId);
+    for (const ses of waveSessions) {
+      // getActiveExecution recovers from stream files for completed sessions too
+      const exec = executionManager.getActiveExecution(ses.id);
+      if (exec) {
+        waveMultiplexer.registerSession(waveId, exec);
+      }
+    }
+    sessionIds = waveMultiplexer.getWaveSessionIds(waveId);
+  }
+
   if (sessionIds.length === 0) {
     res.writeHead(404, { 'Content-Type': 'application/json' });
     res.end(JSON.stringify({ error: `No sessions found for wave: ${waveId}` }));
@@ -681,9 +730,56 @@ function handleWave(body: Record<string, unknown>, req: IncomingMessage, res: Se
 function handleStatus(res: ServerResponse): void {
   const statuses: Record<string, string> = {};
 
-  const activeExecs = executionManager.listExecutions({ active: true });
+  let activeExecs = executionManager.listExecutions({ active: true });
+
+  // Recovery: if in-memory map is empty (e.g. after server restart),
+  // rebuild active executions from persisted session-store + activity-streams
+  if (activeExecs.length === 0) {
+    const allSessions = listSessions();
+    const activeSessions = allSessions.filter(s =>
+      s.status === 'active' &&
+      (s.source === 'wave' || s.source === 'dispatch' || s.source === 'chat')
+    );
+
+    const recovered: typeof activeExecs = [];
+    for (const ses of activeSessions) {
+      // Check activity-stream for actual running state
+      if (!ActivityStream.exists(ses.id)) continue;
+      const events = ActivityStream.readFrom(ses.id, 0);
+      if (events.length === 0) continue;
+
+      const startEvent = events.find(e => e.type === 'msg:start');
+      if (!startEvent) continue;
+
+      const doneEvent = events.find(e => e.type === 'msg:done');
+      const errorEvent = events.find(e => e.type === 'msg:error');
+
+      // Only include sessions that haven't finished yet
+      if (doneEvent || errorEvent) continue;
+
+      const task = (startEvent.data?.task as string) ?? ses.title ?? '';
+      recovered.push({
+        id: `recovered-${ses.id}`,
+        type: (startEvent.data?.type as string ?? 'assign') as 'assign' | 'wave' | 'consult',
+        roleId: ses.roleId,
+        task,
+        status: 'running',
+        childSessionIds: [],
+        createdAt: ses.createdAt,
+      });
+    }
+
+    if (recovered.length > 0) {
+      activeExecs = recovered;
+      console.log(`[ExecStatus] Recovered ${recovered.length} active executions from session-store`);
+    }
+  }
+
   for (const exec of activeExecs) {
-    statuses[exec.roleId] = messageStatusToRoleStatus(exec.status as MessageStatus);
+    // ExecStatus 'running' → RoleStatus 'working' (not MessageStatus 'streaming')
+    statuses[exec.roleId] = exec.status === 'running' ? 'working'
+      : exec.status === 'awaiting_input' ? 'awaiting_input'
+      : 'done';
   }
 
   const activeExecutions = activeExecs.map((e) => ({

package/src/api/src/routes/git.ts

@@ -1,9 +1,12 @@
 import { Router, Request, Response, NextFunction } from 'express';
 import { execSync } from 'node:child_process';
 import { COMPANY_ROOT } from '../services/file-reader.js';
+import { resolveCodeRoot } from '../services/company-config.js';
 
 export const gitRouter = Router();
 
+type RepoType = 'akb' | 'code';
+
 interface WorktreeInfo {
   path: string;
   branch: string;
@@ -17,17 +20,42 @@ interface LastCommit {
   date: string;
 }
 
-function git(cmd: string): string {
-  return execSync(`git ${cmd}`, { cwd: COMPANY_ROOT, encoding: 'utf-8', timeout: 5000 }).trim();
+/**
+ * Resolve repository root based on repo type
+ */
+function resolveRepoRoot(repo: RepoType = 'akb'): string {
+  if (repo === 'akb') {
+    return COMPANY_ROOT;
+  }
+  return resolveCodeRoot(COMPANY_ROOT);
 }
 
-// GET /api/git/status
-gitRouter.get('/status', (_req: Request, res: Response, next: NextFunction) => {
+function git(cmd: string, cwd: string): string {
+  return execSync(`git ${cmd}`, { cwd, encoding: 'utf-8', timeout: 5000 }).trim();
+}
+
+// GET /api/git/status?repo=akb|code
+gitRouter.get('/status', (req: Request, res: Response, next: NextFunction) => {
   try {
+    const repoParam = (req.query.repo as string) ?? 'akb';
+    const repo: RepoType = repoParam === 'code' ? 'code' : 'akb';
+
+    let repoRoot: string;
+    try {
+      repoRoot = resolveRepoRoot(repo);
+    } catch (err) {
+      res.status(400).json({
+        error: repo === 'code'
+          ? 'Code root not configured or inaccessible'
+          : 'Company root not found'
+      });
+      return;
+    }
+
     // Current branch
     let currentBranch: string;
     try {
-      currentBranch = git('rev-parse --abbrev-ref HEAD');
+      currentBranch = git('rev-parse --abbrev-ref HEAD', repoRoot);
     } catch {
       res.status(500).json({ error: 'Not a git repository or git is not available' });
       return;
@@ -36,7 +64,7 @@ gitRouter.get('/status', (_req: Request, res: Response, next: NextFunction) => {
     // Worktrees
     let worktrees: WorktreeInfo[] = [];
     try {
-      const raw = git('worktree list --porcelain');
+      const raw = git('worktree list --porcelain', repoRoot);
       const blocks = raw.split('\n\n').filter(Boolean);
       for (const block of blocks) {
         const lines = block.split('\n');
@@ -44,13 +72,13 @@ gitRouter.get('/status', (_req: Request, res: Response, next: NextFunction) => {
         const commitHash = lines.find(l => l.startsWith('HEAD '))?.replace('HEAD ', '') ?? '';
         const branchLine = lines.find(l => l.startsWith('branch '));
         const branch = branchLine ? branchLine.replace('branch refs/heads/', '') : '(detached)';
-        const isMain = lines.some(l => l === 'worktree ' + COMPANY_ROOT) ||
+        const isMain = lines.some(l => l === 'worktree ' + repoRoot) ||
           (!branchLine && lines.some(l => l === 'bare'));
         worktrees.push({
           path: wtPath,
           branch,
           commitHash,
-          isMain: wtPath === COMPANY_ROOT,
+          isMain: wtPath === repoRoot,
         });
       }
     } catch {
@@ -60,7 +88,7 @@ gitRouter.get('/status', (_req: Request, res: Response, next: NextFunction) => {
     // Stale (unmerged) branches
     let staleBranches: string[] = [];
     try {
-      const raw = git('branch --no-merged develop');
+      const raw = git('branch --no-merged develop', repoRoot);
       staleBranches = raw
         .split('\n')
         .map(b => b.trim().replace(/^\*\s*/, ''))
@@ -72,7 +100,7 @@ gitRouter.get('/status', (_req: Request, res: Response, next: NextFunction) => {
     // Unsaved changes count
     let unsavedChanges = 0;
     try {
-      const raw = git('status --porcelain');
+      const raw = git('status --porcelain', repoRoot);
       unsavedChanges = raw ? raw.split('\n').filter(Boolean).length : 0;
     } catch {
       unsavedChanges = 0;
@@ -81,7 +109,7 @@ gitRouter.get('/status', (_req: Request, res: Response, next: NextFunction) => {
     // Last commit
     let lastCommit: LastCommit | null = null;
     try {
-      const raw = git('log -1 --format=%H%n%s%n%aI');
+      const raw = git('log -1 --format=%H%n%s%n%aI', repoRoot);
       const [hash, message, date] = raw.split('\n');
       if (hash) {
         lastCommit = { hash, message: message ?? '', date: date ?? '' };
@@ -113,10 +141,12 @@ gitRouter.delete('/worktree/{*path}', (req: Request, res: Response, next: NextFu
     }
 
     try {
-      git(`worktree remove ${JSON.stringify(worktreePath)}`);
+      const repoRoot = resolveRepoRoot('code');
+      git(`worktree remove ${JSON.stringify(worktreePath)}`, repoRoot);
     } catch {
       // Try force remove if normal remove fails
-      git(`worktree remove --force ${JSON.stringify(worktreePath)}`);
+      const repoRoot = resolveRepoRoot('code');
+      git(`worktree remove --force ${JSON.stringify(worktreePath)}`, repoRoot);
     }
 
     res.json({ success: true, removed: worktreePath });
@@ -146,7 +176,8 @@ gitRouter.delete('/branch/{*name}', (req: Request, res: Response, next: NextFunc
 
     // Delete local branch
     try {
-      git(`branch -d ${JSON.stringify(branchName)}`);
+      const repoRoot = resolveRepoRoot('code');
+      git(`branch -d ${JSON.stringify(branchName)}`, repoRoot);
     } catch (err) {
       const msg = err instanceof Error ? err.message : 'Unknown error';
       // If branch is not fully merged, report but continue to try remote
@@ -159,7 +190,8 @@ gitRouter.delete('/branch/{*name}', (req: Request, res: Response, next: NextFunc
 
     // Delete remote branch
     try {
-      git(`push origin --delete ${JSON.stringify(branchName)}`);
+      const repoRoot = resolveRepoRoot('code');
+      git(`push origin --delete ${JSON.stringify(branchName)}`, repoRoot);
     } catch (err) {
       const msg = err instanceof Error ? err.message : 'Unknown error';
       if (!msg.includes('remote ref does not exist')) {

package/src/api/src/routes/save.ts

@@ -32,9 +32,15 @@ saveRouter.post('/', (req: Request, res: Response, next: NextFunction) => {
     const result = gitSave(COMPANY_ROOT, message, getRepo(req));
     res.json({ ok: true, ...result });
   } catch (err) {
-    if (err instanceof Error && err.message === 'No changes to save') {
-      res.status(400).json({ error: err.message });
-      return;
+    if (err instanceof Error) {
+      if (err.message === 'No changes to save') {
+        res.status(400).json({ error: err.message });
+        return;
+      }
+      if (err.message.includes('Not a git repository') || err.message.includes('codeRoot')) {
+        res.status(400).json({ error: 'Repository not initialized. Run git init first.' });
+        return;
+      }
     }
     next(err);
   }
@@ -64,7 +70,7 @@ saveRouter.post('/init', (req: Request, res: Response, next: NextFunction) => {
   }
 });
 
-// POST /api/save/restore
+// POST /api/save/restore?repo=akb|code
 saveRouter.post('/restore', (req: Request, res: Response, next: NextFunction) => {
   try {
     const { sha, paths } = req.body ?? {};
@@ -72,9 +78,13 @@ saveRouter.post('/restore', (req: Request, res: Response, next: NextFunction) =>
       res.status(400).json({ error: 'sha is required' });
       return;
     }
-    const result = gitRestore(COMPANY_ROOT, sha, paths);
+    const result = gitRestore(COMPANY_ROOT, sha, paths, getRepo(req));
     res.json({ ok: true, ...result });
   } catch (err) {
+    if (err instanceof Error && (err.message.includes('Not a git repository') || err.message.includes('codeRoot'))) {
+      res.status(400).json({ error: 'Repository not initialized. Run git init first.' });
+      return;
+    }
     next(err);
   }
 });

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

@@ -287,9 +287,15 @@ class ExecutionManager {
             }
           }
 
+          // BUG-W02 fix: propagate waveId from parent session to child
+          const parentSession = getSession(execution.sessionId);
+          const parentWaveId = parentSession?.waveId;
+
           const childSession = createSession(subRoleId, {
             mode: 'do',
             source: 'dispatch',
+            parentSessionId: execution.sessionId,
+            ...(parentWaveId && { waveId: parentWaveId }),
           });
           const dispatchMsg: Message = {
             id: `msg-${Date.now()}-dispatch-${subRoleId}`,
@@ -761,7 +767,7 @@ class ExecutionManager {
         const status: ExecStatus = awaitingEvent && !doneEvent ? 'awaiting_input'
           : doneEvent ? 'done'
           : errorEvent ? 'error'
-          : 'done';
+          : 'running';  // No done/error event = still running
 
         const candidate = {
           streamId,
@@ -816,7 +822,7 @@ class ExecutionManager {
     const status: ExecStatus = awaitingEvent && !doneEvent ? 'awaiting_input'
       : doneEvent ? 'done'
       : errorEvent ? 'error'
-      : 'done';
+      : 'running';  // No done/error event = still running
 
     const stream = ActivityStream.getOrCreate(sessionId, startEvent.roleId);
     const execution: Execution = {

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

@@ -1,5 +1,6 @@
 import { ActivityStream, type ActivityEvent, type ActivitySubscriber } from './activity-stream.js';
 import type { Execution } from './execution-manager.js';
+import { getSession } from './session-store.js';
 import type { Response } from 'express';
 
 /* ─── Types ──────────────────────────────── */
@@ -181,7 +182,19 @@ class WaveMultiplexer {
   }
 
   onExecutionCreated(execution: Execution): void {
-    const waveId = this.findWaveIdForSession(execution.sessionId) ?? this.findWaveIdForSession(execution.parentSessionId ?? '');
+    // Check multiplexer's in-memory map first
+    let waveId = this.findWaveIdForSession(execution.sessionId) ?? this.findWaveIdForSession(execution.parentSessionId ?? '');
+
+    // BUG-W02 fix: also check session-store for waveId (propagated from parent)
+    if (!waveId) {
+      const session = getSession(execution.sessionId);
+      if (session?.waveId) waveId = session.waveId;
+    }
+    if (!waveId && execution.parentSessionId) {
+      const parentSession = getSession(execution.parentSessionId);
+      if (parentSession?.waveId) waveId = parentSession.waveId;
+    }
+
     if (!waveId) return;
 
     this.registerSession(waveId, execution);