tycono 0.1.65 → 0.1.66

package/src/api/src/engine/knowledge-gate.ts

@@ -0,0 +1,335 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { glob } from 'glob';
+
+/* ─── Types ──────────────────────────────────── */
+
+export interface RelatedDoc {
+  path: string;
+  matches: number;
+  preview: string;
+}
+
+export interface KnowledgeDebtItem {
+  type: 'missing-crosslink' | 'missing-hub' | 'stale-doc' | 'orphan-doc' | 'broken-link';
+  file: string;
+  message: string;
+}
+
+export interface PostKnowledgingResult {
+  pass: boolean;
+  debt: KnowledgeDebtItem[];
+  newDocs: string[];
+  modifiedDocs: string[];
+}
+
+export interface DecayReport {
+  health: number;
+  orphanDocs: string[];
+  brokenLinks: Array<{ file: string; link: string }>;
+  totalDocs: number;
+  linkedDocs: number;
+}
+
+/* ─── Pre-Knowledging: Keyword Extraction ────── */
+
+/** Extract meaningful keywords from task directive for knowledge search */
+export function extractKeywords(text: string): string[] {
+  // Remove common stop words and short words
+  const stopWords = new Set([
+    // English
+    'the', 'a', 'an', 'is', 'are', 'was', 'were', 'be', 'been', 'being',
+    'have', 'has', 'had', 'do', 'does', 'did', 'will', 'would', 'could',
+    'should', 'may', 'might', 'shall', 'can', 'need', 'must', 'to', 'of',
+    'in', 'for', 'on', 'with', 'at', 'by', 'from', 'as', 'into', 'through',
+    'and', 'but', 'or', 'not', 'no', 'if', 'then', 'else', 'when', 'up',
+    'all', 'each', 'every', 'both', 'few', 'more', 'most', 'other', 'some',
+    'such', 'than', 'too', 'very', 'just', 'about', 'above', 'after',
+    'this', 'that', 'these', 'those', 'it', 'its', 'my', 'your', 'our',
+    'what', 'which', 'who', 'how', 'use', 'make', 'get', 'set',
+    // Korean common particles/verbs
+    '해', '하고', '하는', '해줘', '해라', '하세요', '합니다', '된', '되는',
+    '이', '그', '저', '것', '거', '을', '를', '에', '에서', '으로', '로',
+    '와', '과', '는', '은', '가', '의', '도', '만', '좀', '더',
+    // Task-specific
+    'ceo', 'wave', 'continuation', 'previous', 'context', 'response',
+    'read', 'write', 'file', 'update', 'check', 'implement',
+  ]);
+
+  // Strip markdown, brackets, special chars
+  const cleaned = text
+    .replace(/\[.*?\]/g, ' ')
+    .replace(/[#*`_\->\[\](){}|]/g, ' ')
+    .replace(/https?:\/\/\S+/g, ' ')
+    .replace(/[^\w\sㄱ-힣]/g, ' ');
+
+  const words = cleaned
+    .split(/\s+/)
+    .map(w => w.toLowerCase().trim())
+    .filter(w => w.length >= 3 && !stopWords.has(w));
+
+  // Deduplicate and take top keywords by frequency
+  const freq = new Map<string, number>();
+  for (const w of words) {
+    freq.set(w, (freq.get(w) ?? 0) + 1);
+  }
+
+  return [...freq.entries()]
+    .sort((a, b) => b[1] - a[1])
+    .slice(0, 8)
+    .map(([word]) => word);
+}
+
+/* ─── Pre-Knowledging: Related Doc Search ────── */
+
+/** Search knowledge/ and architecture/ for docs related to given keywords */
+export function searchRelatedDocs(companyRoot: string, keywords: string[]): RelatedDoc[] {
+  if (keywords.length === 0) return [];
+
+  const searchDirs = ['knowledge', 'architecture', 'projects'];
+  const results: RelatedDoc[] = [];
+
+  for (const dir of searchDirs) {
+    const dirPath = path.join(companyRoot, dir);
+    if (!fs.existsSync(dirPath)) continue;
+
+    const files = glob.sync('**/*.md', {
+      cwd: dirPath,
+      ignore: ['**/journal/**'],
+    });
+
+    for (const file of files) {
+      const filePath = path.join(dirPath, file);
+      try {
+        const content = fs.readFileSync(filePath, 'utf-8');
+        const lowerContent = content.toLowerCase();
+
+        let matches = 0;
+        for (const kw of keywords) {
+          // Count occurrences (case insensitive)
+          const regex = new RegExp(kw.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'gi');
+          const found = lowerContent.match(regex);
+          if (found) matches += found.length;
+        }
+
+        if (matches >= 2) {
+          // Extract title from first heading
+          const titleMatch = content.match(/^#\s+(.+)/m);
+          const title = titleMatch ? titleMatch[1].trim() : file;
+          const relativePath = path.join(dir, file);
+
+          results.push({
+            path: relativePath,
+            matches,
+            preview: title,
+          });
+        }
+      } catch {
+        // Skip unreadable files
+      }
+    }
+  }
+
+  // Sort by match count descending, take top 5
+  return results
+    .sort((a, b) => b.matches - a.matches)
+    .slice(0, 5);
+}
+
+/* ─── Knowledge Gate: Auto-search on new .md ─── */
+
+/** Build an enhanced AKB warning with auto-search results for a new .md file */
+export function buildKnowledgeGateWarning(
+  companyRoot: string,
+  filePath: string,
+  content: string,
+): string {
+  // Extract keywords from file name + first 5 lines
+  const fileName = path.basename(filePath, '.md').replace(/[-_]/g, ' ');
+  const firstLines = content.split('\n').slice(0, 5).join(' ');
+  const keywords = extractKeywords(`${fileName} ${firstLines}`);
+
+  const related = searchRelatedDocs(companyRoot, keywords);
+
+  let warning = '\n\n[AKB Knowledge Gate] 새 .md 파일입니다.\n';
+
+  if (related.length > 0) {
+    warning += '\n📚 관련 문서 발견:\n';
+    for (const doc of related) {
+      warning += `  - ${doc.path} — "${doc.preview}" (${doc.matches} matches)\n`;
+    }
+    warning += '\n→ 70%+ 중복이면 기존 문서에 추가하세요.\n';
+    warning += '→ 새 문서라면 반드시:\n';
+  } else {
+    warning += '\n관련 문서를 찾지 못했습니다. 새 문서 생성이 적절합니다.\n';
+    warning += '반드시:\n';
+  }
+
+  warning += '  (1) 관련 문서 섹션에 cross-link를 추가하세요\n';
+  warning += '  (2) 해당 폴더의 Hub 파일에 등록하세요\n';
+
+  return warning;
+}
+
+/* ─── Post-Knowledging: Verification ─────────── */
+
+/** Check if a .md file has a cross-link section with at least 1 link */
+export function hasCrossLinks(content: string): boolean {
+  // Look for "관련 문서" or "Related" section with markdown links
+  const crossLinkSection = content.match(/##\s*(관련 문서|Related|References|See Also)/i);
+  if (!crossLinkSection) return false;
+
+  // Check for at least one markdown link after the section header
+  const sectionStart = content.indexOf(crossLinkSection[0]);
+  const afterSection = content.slice(sectionStart);
+  return /\[.+?\]\(.+?\)/.test(afterSection);
+}
+
+/** Check if a file is registered in its folder's Hub document */
+export function isRegisteredInHub(companyRoot: string, filePath: string): boolean {
+  const dir = path.dirname(filePath);
+  const dirName = path.basename(dir);
+  const hubPath = path.join(companyRoot, dir, `${dirName}.md`);
+
+  if (!fs.existsSync(hubPath)) return true; // No hub = no enforcement
+
+  const hubContent = fs.readFileSync(hubPath, 'utf-8');
+  const fileName = path.basename(filePath);
+
+  // Check if the file is mentioned in the hub (by filename or relative path)
+  return hubContent.includes(fileName) || hubContent.includes(`./${fileName}`);
+}
+
+/** Run Post-Knowledging checks on changed files */
+export function postKnowledgingCheck(
+  companyRoot: string,
+  changedFiles: string[],
+): PostKnowledgingResult {
+  const debt: KnowledgeDebtItem[] = [];
+  const newDocs: string[] = [];
+  const modifiedDocs: string[] = [];
+
+  for (const file of changedFiles) {
+    // Only check .md files (skip journals)
+    if (!file.endsWith('.md') || file.includes('journal/')) continue;
+
+    const absolute = path.resolve(companyRoot, file);
+    if (!fs.existsSync(absolute)) continue;
+
+    const content = fs.readFileSync(absolute, 'utf-8');
+
+    // Categorize
+    // We can't tell new vs modified from just file list, so check if it's a knowledge/architecture doc
+    if (file.startsWith('knowledge/') || file.startsWith('architecture/') || file.startsWith('projects/')) {
+      modifiedDocs.push(file);
+    }
+
+    // Check cross-links
+    if (!hasCrossLinks(content)) {
+      debt.push({
+        type: 'missing-crosslink',
+        file,
+        message: `"${file}" has no cross-link section (## 관련 문서)`,
+      });
+    }
+
+    // Check Hub registration
+    if (!isRegisteredInHub(companyRoot, file)) {
+      debt.push({
+        type: 'missing-hub',
+        file,
+        message: `"${file}" is not registered in its Hub document`,
+      });
+    }
+  }
+
+  return {
+    pass: debt.length === 0,
+    debt,
+    newDocs,
+    modifiedDocs,
+  };
+}
+
+/* ─── Decay Detection ────────────────────────── */
+
+/** Scan for orphan docs (not registered in Hub) and broken links */
+export function detectDecay(companyRoot: string): DecayReport {
+  const searchDirs = ['knowledge', 'architecture'];
+  const orphanDocs: string[] = [];
+  const brokenLinks: Array<{ file: string; link: string }> = [];
+  let totalDocs = 0;
+  let linkedDocs = 0;
+
+  for (const dir of searchDirs) {
+    const dirPath = path.join(companyRoot, dir);
+    if (!fs.existsSync(dirPath)) continue;
+
+    const hubName = `${dir}.md`;
+    const hubPath = path.join(dirPath, hubName);
+    const hubContent = fs.existsSync(hubPath) ? fs.readFileSync(hubPath, 'utf-8') : '';
+
+    const files = glob.sync('*.md', { cwd: dirPath });
+
+    for (const file of files) {
+      if (file === hubName) continue; // Skip hub itself
+      totalDocs++;
+
+      // Check if registered in hub
+      if (hubContent && !hubContent.includes(file) && !hubContent.includes(`./${file}`)) {
+        orphanDocs.push(path.join(dir, file));
+      } else {
+        linkedDocs++;
+      }
+
+      // Check for broken links in the file
+      const filePath = path.join(dirPath, file);
+      try {
+        const content = fs.readFileSync(filePath, 'utf-8');
+        const linkRegex = /\[.*?\]\(\.\/(.*?\.md)\)/g;
+        let match;
+        while ((match = linkRegex.exec(content)) !== null) {
+          const linkedFile = match[1];
+          const linkedPath = path.join(dirPath, linkedFile);
+          if (!fs.existsSync(linkedPath)) {
+            // Also check if it's a relative path from parent
+            const parentLinkedPath = path.join(companyRoot, dir, linkedFile);
+            if (!fs.existsSync(parentLinkedPath)) {
+              brokenLinks.push({
+                file: path.join(dir, file),
+                link: linkedFile,
+              });
+            }
+          }
+        }
+
+        // Also check ../relative links
+        const parentLinkRegex = /\[.*?\]\(\.\.\/(.*?\.md)\)/g;
+        while ((match = parentLinkRegex.exec(content)) !== null) {
+          const linkedFile = match[1];
+          const linkedPath = path.join(companyRoot, linkedFile);
+          if (!fs.existsSync(linkedPath)) {
+            brokenLinks.push({
+              file: path.join(dir, file),
+              link: `../${linkedFile}`,
+            });
+          }
+        }
+      } catch {
+        // Skip unreadable
+      }
+    }
+  }
+
+  const health = totalDocs > 0
+    ? Math.round(((totalDocs - orphanDocs.length - brokenLinks.length) / totalDocs) * 100)
+    : 100;
+
+  return {
+    health: Math.max(0, Math.min(100, health)),
+    orphanDocs,
+    brokenLinks,
+    totalDocs,
+    linkedDocs,
+  };
+}

package/src/api/src/engine/llm-adapter.ts

@@ -52,12 +52,17 @@ export interface StreamCallbacks {
  *   - AnthropicProvider: @anthropic-ai/sdk 기반 (기본)
  *   - (향후) OpenAIProvider, OllamaProvider, MockProvider
  */
+export interface ChatOptions {
+  maxTokens?: number;
+}
+
 export interface LLMProvider {
   chat(
     systemPrompt: string,
     messages: LLMMessage[],
     tools?: ToolDefinition[],
     signal?: AbortSignal,
+    options?: ChatOptions,
   ): Promise<LLMResponse>;
 
   chatStream?(
@@ -89,10 +94,11 @@ export class AnthropicProvider implements LLMProvider {
     messages: LLMMessage[],
     tools?: ToolDefinition[],
     signal?: AbortSignal,
+    options?: ChatOptions,
   ): Promise<LLMResponse> {
     const params: Anthropic.MessageCreateParamsNonStreaming = {
       model: this.model,
-      max_tokens: 8192,
+      max_tokens: options?.maxTokens ?? 8192,
       system: systemPrompt,
       messages: messages.map((m) => ({
         role: m.role,

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

@@ -16,7 +16,7 @@ const DISPATCH_SCRIPT = `#!/usr/bin/env python3
 3가지 모드:
   dispatch <roleId> "<task>"           — Job 시작 (즉시 반환, 대기하지 않음)
   dispatch --check <jobId>             — Job 상태 및 결과 조회
-  dispatch --wait <roleId> "<task>"    — Job 시작 + 완료 대기 (최대 90초)
+  dispatch --wait <roleId> "<task>"    — Job 시작 + 완료 대기 (최대 300초)
 
 환경변수:
   DISPATCH_API_URL    — API 서버 URL (default: http://localhost:3001)
@@ -31,23 +31,35 @@ api = os.environ.get('DISPATCH_API_URL', 'http://localhost:3001')
 def log(msg):
     print(msg, flush=True)
 
-def get_result(job_id):
-    try:
-        history = json.loads(urllib.request.urlopen(f'{api}/api/jobs/{job_id}/history', timeout=10).read())
-        events = history.get('events', [])
-        text_parts = []
-        for e in events:
-            if e['type'] == 'text':
-                text_parts.append(e['data'].get('text', ''))
-            elif e['type'] == 'job:error':
-                text_parts.append('\\nERROR: ' + e['data'].get('message', ''))
-        return ''.join(text_parts) or '(No text output)'
-    except Exception as e:
-        return f'ERROR: Failed to get result: {e}'
+def get_result(job_id, retries=3):
+    for attempt in range(retries):
+        try:
+            history = json.loads(urllib.request.urlopen(f'{api}/api/jobs/{job_id}/history', timeout=10).read())
+            events = history.get('events', [])
+            text_parts = []
+            for e in events:
+                if e['type'] == 'text':
+                    text_parts.append(e['data'].get('text', ''))
+                elif e['type'] == 'job:error':
+                    text_parts.append('\\nERROR: ' + e['data'].get('message', ''))
+            result = ''.join(text_parts)
+            if result:
+                return result
+            if attempt < retries - 1:
+                log(f'  Result empty, retrying in 2s... (attempt {attempt + 1}/{retries})')
+                time.sleep(2)
+        except Exception as e:
+            if attempt == retries - 1:
+                return f'ERROR: Failed to get result: {e}'
+            time.sleep(2)
+    return '(No text output — activity stream may still be writing. Check again with --check)'
+
+def get_job_info(job_id):
+    info = json.loads(urllib.request.urlopen(f'{api}/api/jobs/{job_id}', timeout=5).read())
+    return info
 
 def get_status(job_id):
-    info = json.loads(urllib.request.urlopen(f'{api}/api/jobs/{job_id}', timeout=5).read())
-    return info.get('status', 'unknown')
+    return get_job_info(job_id).get('status', 'unknown')
 
 def start_job(role_id, task):
     parent_job = os.environ.get('DISPATCH_PARENT_JOB', '')
@@ -63,64 +75,38 @@ def start_job(role_id, task):
     resp = json.loads(urllib.request.urlopen(req, timeout=10).read())
     return resp['jobId']
 
-def poll_until_done(job_id, role_id, max_wait=90):
-    waited = 0
-    while waited < max_wait:
-        try:
-            status = get_status(job_id)
-            if status == 'done':
-                log('')
-                log(f'=== {role_id.upper()} Result (done) ===')
-                log(get_result(job_id))
-                return
-            elif status == 'error':
-                log('')
-                log(f'=== {role_id.upper()} Result (error) ===')
-                log(get_result(job_id))
-                return
-            elif status == 'awaiting_input':
-                log('')
-                log(f'{role_id.upper()} is asking a question (awaiting_input).')
-                log(f'Check details: python3 "$DISPATCH_CMD" --check {job_id}')
-                return
-        except Exception:
-            pass
-        time.sleep(5)
-        waited += 5
-        if waited % 15 == 0:
-            log(f'  ... {role_id} still working ({waited}s)')
-    log('')
-    log(f'{role_id.upper()} is still working after {waited}s.')
-    log(f'Check result later: python3 "$DISPATCH_CMD" --check {job_id}')
-
 # Mode: --check <jobId>
 if len(sys.argv) >= 3 and sys.argv[1] == '--check':
     job_id = sys.argv[2]
     try:
-        status = get_status(job_id)
+        info = get_job_info(job_id)
+        status = info.get('status', 'unknown')
         if status == 'running':
-            log(f'Job {job_id} is still running. Try again later.')
+            log(f'Status: RUNNING — {job_id} is still working. Check again in 10-30s.')
         elif status == 'awaiting_input':
-            log(f'Job {job_id} is awaiting input (subordinate asked a question).')
-            log(get_result(job_id))
+            log(f'Status: AWAITING_INPUT — subordinate has a question.')
+            log(info.get('output', '') or get_result(job_id))
+        elif status == 'done':
+            log(f'Status: DONE')
+            log(info.get('output', '') or get_result(job_id))
+        elif status == 'error':
+            log(f'Status: ERROR')
+            log(info.get('output', '') or get_result(job_id))
         else:
-            log(f'=== Job {job_id}: {status} ===')
-            log(get_result(job_id))
+            log(f'Status: {status}')
     except Exception as e:
         log(f'ERROR: {e}')
     sys.exit(0)
 
-# Mode: --wait <roleId> "<task>" (start + wait)
-wait_mode = False
+# Mode: dispatch <roleId> "<task>" (always immediate return)
 args = sys.argv[1:]
+# Accept --wait for backwards compat but ignore it (always async now)
 if args and args[0] == '--wait':
-    wait_mode = True
     args = args[1:]
 
 # Usage check
 if len(args) < 2:
-    log('Usage: dispatch <roleId> "<task>"          — Start job (immediate return)')
-    log('       dispatch --wait <roleId> "<task>"   — Start job + wait for result')
+    log('Usage: dispatch <roleId> "<task>"          — Start job (returns immediately)')
     log('       dispatch --check <jobId>            — Check job status/result')
     subs = os.environ.get('DISPATCH_SUBORDINATES', '')
     if subs:
@@ -140,14 +126,11 @@ except Exception as e:
 log(f'=== Dispatched to {role_id.upper()} ===')
 log(f'Task: {task[:120]}')
 log(f'Job ID: {job_id}')
-
-if wait_mode:
-    log(f'Waiting for completion...')
-    poll_until_done(job_id, role_id)
-else:
-    log('')
-    log(f'Job started. Check result with:')
-    log(f'  python3 "$DISPATCH_CMD" --check {job_id}')
+log(f'')
+log(f'⛔ Job is running async. Use --check to poll for result:')
+log(f'  python3 "$DISPATCH_CMD" --check {job_id}')
+log(f'')
+log(f'DO NOT re-dispatch the same task. Poll with --check every 10-30s until status is DONE.')
 `;
 
 /* ─── Consult Bridge Script (Python3) ────── */
@@ -172,37 +155,50 @@ api = os.environ.get('CONSULT_API_URL', os.environ.get('DISPATCH_API_URL', 'http
 def log(msg):
     print(msg, flush=True)
 
-def get_result(job_id):
-    try:
-        history = json.loads(urllib.request.urlopen(f'{api}/api/jobs/{job_id}/history', timeout=10).read())
-        events = history.get('events', [])
-        text_parts = []
-        for e in events:
-            if e['type'] == 'text':
-                text_parts.append(e['data'].get('text', ''))
-            elif e['type'] == 'job:error':
-                text_parts.append('\\nERROR: ' + e['data'].get('message', ''))
-        return ''.join(text_parts) or '(No text output)'
-    except Exception as e:
-        return f'ERROR: Failed to get result: {e}'
+def get_result(job_id, retries=3):
+    for attempt in range(retries):
+        try:
+            history = json.loads(urllib.request.urlopen(f'{api}/api/jobs/{job_id}/history', timeout=10).read())
+            events = history.get('events', [])
+            text_parts = []
+            for e in events:
+                if e['type'] == 'text':
+                    text_parts.append(e['data'].get('text', ''))
+                elif e['type'] == 'job:error':
+                    text_parts.append('\\nERROR: ' + e['data'].get('message', ''))
+            result = ''.join(text_parts)
+            if result:
+                return result
+            if attempt < retries - 1:
+                log(f'  Result empty, retrying in 2s... (attempt {attempt + 1}/{retries})')
+                time.sleep(2)
+        except Exception as e:
+            if attempt == retries - 1:
+                return f'ERROR: Failed to get result: {e}'
+            time.sleep(2)
+    return '(No text output — activity stream may still be writing. Check again with --check)'
+
+def get_job_info(job_id):
+    info = json.loads(urllib.request.urlopen(f'{api}/api/jobs/{job_id}', timeout=5).read())
+    return info
 
 def get_status(job_id):
-    info = json.loads(urllib.request.urlopen(f'{api}/api/jobs/{job_id}', timeout=5).read())
-    return info.get('status', 'unknown')
+    return get_job_info(job_id).get('status', 'unknown')
 
 # Mode: --check <jobId>
 if len(sys.argv) >= 3 and sys.argv[1] == '--check':
     job_id = sys.argv[2]
     try:
-        status = get_status(job_id)
+        info = get_job_info(job_id)
+        status = info.get('status', 'unknown')
         if status == 'running':
             log(f'Job {job_id} is still running. Try again later.')
         elif status == 'awaiting_input':
             log(f'Job {job_id} is awaiting input.')
-            log(get_result(job_id))
+            log(info.get('output', '') or get_result(job_id))
         else:
             log(f'=== Job {job_id}: {status} ===')
-            log(get_result(job_id))
+            log(info.get('output', '') or get_result(job_id))
     except Exception as e:
         log(f'ERROR: {e}')
     sys.exit(0)
@@ -240,37 +236,11 @@ except Exception as e:
 log(f'=== Consulting {role_id.upper()} ===')
 log(f'Question: {question[:120]}')
 log(f'Job ID: {job_id}')
-log(f'Waiting for answer...')
-
-# Wait for completion (max ~90s — consult is read-only, usually fast)
-waited = 0
-while waited < 90:
-    try:
-        status = get_status(job_id)
-        if status == 'done':
-            log('')
-            log(f'=== {role_id.upper()} Answer ===')
-            log(get_result(job_id))
-            sys.exit(0)
-        elif status == 'error':
-            log('')
-            log(f'=== {role_id.upper()} Error ===')
-            log(get_result(job_id))
-            sys.exit(1)
-        elif status == 'awaiting_input':
-            log('')
-            log(f'{role_id.upper()} needs clarification. Check: python3 "$CONSULT_CMD" --check {job_id}')
-            sys.exit(0)
-    except Exception:
-        pass
-    time.sleep(5)
-    waited += 5
-    if waited % 15 == 0:
-        log(f'  ... {role_id} still thinking ({waited}s)')
-
-log('')
-log(f'{role_id.upper()} is still thinking after {waited}s.')
-log(f'Check result later: python3 "$CONSULT_CMD" --check {job_id}')
+log(f'')
+log(f'Consult job started. Use --check to get the answer:')
+log(f'  python3 "$CONSULT_CMD" --check {job_id}')
+log(f'')
+log(f'Poll every 10s until status is DONE.')
 `;
 
 /* ─── Claude CLI Runner ──────────────────────── */
@@ -286,7 +256,7 @@ log(f'Check result later: python3 "$CONSULT_CMD" --check {job_id}')
  */
 export class ClaudeCliRunner implements ExecutionRunner {
   execute(config: RunnerConfig, callbacks: RunnerCallbacks): RunnerHandle {
-    const { companyRoot, roleId, task, sourceRole, orgTree, readOnly = false, teamStatus, attachments } = config;
+    const { companyRoot, roleId, task, sourceRole, orgTree, readOnly = false, teamStatus, attachments, targetRoles } = config;
 
     // Note: Claude CLI doesn't support inline image attachments.
     // Images will be ignored with a warning if passed.
@@ -295,7 +265,7 @@ export class ClaudeCliRunner implements ExecutionRunner {
     }
 
     // 1. Context Assembly
-    const context = assembleContext(companyRoot, roleId, task, sourceRole, orgTree, { teamStatus });
+    const context = assembleContext(companyRoot, roleId, task, sourceRole, orgTree, { teamStatus, targetRoles });
 
     // 2. System prompt를 임시 파일로 저장 (CLI arg 길이 제한 대비)
     const tmpDir = path.join(os.tmpdir(), 'tycono-engine');
@@ -354,6 +324,14 @@ export class ClaudeCliRunner implements ExecutionRunner {
       taskPrompt,
     ];
 
+    // Disallow Agent and Task tools to force use of dispatch bridge
+    // For roles with subordinates (C-Level), also disallow Edit/Write to enforce delegation
+    const disallowed = ['Agent', 'Task'];
+    if (subordinates.length > 0 && !readOnly) {
+      disallowed.push('Edit', 'Write', 'NotebookEdit');
+    }
+    args.push('--disallowed-tools', ...disallowed);
+
     // 7. 프로세스 생성 — 중첩 세션 방지를 위해 CLAUDECODE 환경변수 제거
     const cleanEnv = { ...process.env };
     delete cleanEnv.CLAUDECODE;
@@ -375,6 +353,10 @@ export class ClaudeCliRunner implements ExecutionRunner {
     // Use codeRoot as cwd if configured, otherwise fall back to companyRoot
     const companyConfig = readConfig(companyRoot);
     const cwd = companyConfig.codeRoot || companyRoot;
+
+    // Inject repo paths so agents never confuse repos
+    cleanEnv.TYCONO_CODE_ROOT = companyConfig.codeRoot || '';
+    cleanEnv.TYCONO_AKB_ROOT = companyRoot;
     console.log(`[Runner] Spawning claude -p: role=${roleId}, model=${modelName}, maxTurns=${maxTurns}, jobId=${config.jobId ?? 'none'}, cwd=${cwd}, subordinates=[${subordinates.join(',')}]`);
 
     const proc = spawn('claude', args, {