tycono-server 0.1.0-beta.0

package/src/api/src/engine/context-assembler.ts

@@ -0,0 +1,912 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { readPreferences } from '../services/preferences.js';
+import { readConfig, resolveCodeRoot } from '../services/company-config.js';
+import {
+  type OrgTree,
+  type OrgNode,
+  getSubordinates,
+  getChainOfCommand,
+  formatOrgChart,
+  canConsult,
+} from './org-tree.js';
+import { extractKeywords, searchRelatedDocs } from './knowledge-gate.js';
+
+/* ─── Types ──────────────────────────────────── */
+
+export interface AssembledContext {
+  systemPrompt: string;
+  task: string;
+  sourceRole: string;
+  targetRole: string;
+  metadata: {
+    orgPath: string[];
+    knowledgeScope: string[];
+    authorityLevel: string;
+    subordinates: string[];
+  };
+}
+
+/* ─── Context Assembly ───────────────────────── */
+
+/**
+ * 9단계 시스템 프롬프트 조립 파이프라인
+ *
+ * 1. CLAUDE.md (전사 규칙)
+ * 2. Org Context (현재 조직도, 이 Role의 위치)
+ * 3. Role Persona
+ * 4. Authority Rules
+ * 5. Knowledge Scope
+ * 6. SKILL.md
+ * 7. Hub Docs (라우팅 테이블의 "먼저 읽기" 경로)
+ * 8. CEO Decisions (전사 공지 — Approved 결정만)
+ * 9. Task
+ */
+export type { TeamStatus } from '../../../shared/types.js';
+import { type RoleStatus, type TeamStatus, isRoleActive } from '../../../shared/types.js';
+
+export function assembleContext(
+  companyRoot: string,
+  roleId: string,
+  task: string,
+  sourceRole: string,
+  orgTree: OrgTree,
+  options?: { teamStatus?: TeamStatus; targetRoles?: string[]; presetId?: string },
+): AssembledContext {
+  const node = orgTree.nodes.get(roleId);
+  if (!node) {
+    throw new Error(`Role not found in org tree: ${roleId}`);
+  }
+
+  const sections: string[] = [];
+
+  // 1. Company Rules (CLAUDE.md + custom-rules.md + company.md)
+  const companyRules = loadCompanyRules(companyRoot);
+  if (companyRules) {
+    sections.push(companyRules);
+  }
+
+  // 2. Org Context
+  sections.push(buildOrgContextSection(orgTree, node));
+
+  // 3. Role Persona
+  sections.push(buildPersonaSection(node));
+
+  // 4. Authority Rules
+  sections.push(buildAuthoritySection(node));
+
+  // 5. Knowledge Scope
+  sections.push(buildKnowledgeSection(node));
+
+  // 6. SKILL.md (Role-specific + equipped shared skills)
+  const skillContent = loadSkillMd(companyRoot, roleId);
+  if (skillContent) {
+    sections.push('# Skills & Tools\n\n' + skillContent);
+  }
+
+  // 6b. Shared Skills (from role.yaml skills field)
+  const sharedSkills = loadSharedSkills(companyRoot, node.skills);
+  if (sharedSkills) {
+    sections.push('# Equipped Skills\n\n' + sharedSkills);
+  }
+
+  // 7. Hub Docs (요약)
+  const hubSummary = loadHubSummaries(companyRoot, node);
+  if (hubSummary) {
+    sections.push('# Reference Documents\n\n' + hubSummary);
+  }
+
+  // 8. CEO Decisions (전사 공지)
+  const ceoDecisions = loadCeoDecisions(companyRoot);
+  if (ceoDecisions) {
+    sections.push('# CEO Decisions (전사 공지)\n\n' + ceoDecisions);
+  }
+
+  // 9. Code Root (코드 프로젝트 경로)
+  const codeRoot = resolveCodeRoot(companyRoot);
+  sections.push(`# Code Project
+
+The code repository is located at: \`${codeRoot}\` (env: $TYCONO_CODE_ROOT)
+The AKB (knowledge) directory is at: \`${companyRoot}\` (env: $TYCONO_AKB_ROOT)
+
+Use the code repository path for all source code work (reading, writing, building, testing).
+
+## Git Worktree Rules (CRITICAL)
+- Your cwd is already set to the code repository. When creating worktrees, use relative paths or \`$TYCONO_CODE_ROOT\`.
+- **NEVER run \`git worktree add\` in \`$TYCONO_AKB_ROOT\`** — the AKB directory is not a code repository.
+- Recommended worktree path: \`$TYCONO_CODE_ROOT/.worktrees/{branch-name}\`
+- Example: \`git worktree add .worktrees/feature-xyz -b feature/xyz\` (from cwd, which is already code repo)`);
+
+  // 10. Pre-Knowledging: 작업 관련 문서 자동 탐색
+  const preKSection = buildPreKnowledgingSection(companyRoot, task);
+  if (preKSection) {
+    sections.push(preKSection);
+  }
+
+  // 11. Preset Knowledge (wave-scoped preset docs)
+  if (options?.presetId && options.presetId !== 'default') {
+    const presetKnowledge = loadPresetKnowledge(companyRoot, options.presetId);
+    if (presetKnowledge) {
+      sections.push('# Preset Knowledge\n\n' + presetKnowledge);
+    }
+  }
+
+  // Task는 별도 필드로 분리
+  let subordinates = getSubordinates(orgTree, roleId);
+
+  // Filter subordinates by targetRoles ONLY for CEO (wave dispatch scope)
+  // C-Level roles should always see their own subordinates regardless of targetRoles
+  if (options?.targetRoles && options.targetRoles.length > 0 && roleId === 'ceo') {
+    subordinates = subordinates.filter(id => options.targetRoles!.includes(id));
+  }
+
+  // Supervision prompt (SV-11, SV-12: C-Level heartbeat mode)
+  const heartbeatEnabled = node.heartbeat?.enabled === true;
+  if (heartbeatEnabled && subordinates.length > 0) {
+    sections.push(buildSupervisionSection(node));
+  }
+
+  // Knowledge consistency management (C-Level responsibility)
+  if (node.level === 'c-level') {
+    sections.push(buildKnowledgeManagementSection(roleId));
+  }
+
+  // Dispatch 도구 안내 (하위 Role이 있는 경우)
+  if (subordinates.length > 0) {
+    sections.push(buildDispatchSection(orgTree, roleId, subordinates, options?.teamStatus));
+  } else if (node.level === 'c-level') {
+    // C-level with no subordinates — clarify authority boundaries
+    sections.push(`# Team Structure
+
+⚠️ **You have no direct reports.** You are an individual contributor at the C-level.
+
+- You CANNOT dispatch tasks to other roles (no subordinates)
+- You CAN consult other roles for information (see Consult section below)
+- You MUST do the work yourself — research, analyze, write, decide
+- If implementation requires another role (e.g., engineering work), recommend it to CEO
+- Make decisions within your authority autonomously — do NOT ask CEO for decisions you can make yourself`);
+  }
+
+  // Consult 도구 안내 (상담 가능한 Role이 있는 경우)
+  const consultSection = buildConsultSection(orgTree, roleId);
+  if (consultSection) {
+    sections.push(consultSection);
+  }
+
+  // Language preference (default: English)
+  const prefs = readPreferences(companyRoot);
+  const lang = prefs.language && prefs.language !== 'auto' ? prefs.language : 'en';
+  const langNames: Record<string, string> = { en: 'English', ko: 'Korean (한국어)', ja: 'Japanese (日本語)' };
+  const langName = langNames[lang] ?? lang;
+  sections.push(`# Language (CRITICAL)
+
+You MUST respond in **${langName}**.
+
+This applies to ALL output without exception:
+- Status updates, reports, and analysis
+- Journal entries and standup notes
+- Decision logs and knowledge documents
+- User-facing messages and explanations
+- Git commit messages and PR descriptions
+
+Code (variable names, comments in code) may remain in English for readability.
+Everything else MUST be in ${langName}.`);
+
+  // Execution behavior rules (prevents infinite exploration loops in -p mode)
+  sections.push(`# Execution Rules (CRITICAL)
+
+## Interpreting Tasks
+- A [CEO Wave] is a directive from the CEO. Interpret it based on your role's expertise.
+- If the directive is vague, focus on what YOUR ROLE can contribute. Don't try to cover everything.
+- Break ambiguous directives into concrete actions within your authority scope.
+- If you truly cannot determine what to do, state your interpretation and proceed with it.
+- **If you have subordinates, your FIRST action should be decomposing the task and dispatching.** Do NOT attempt implementation yourself — delegate to the appropriate team member.
+- Review the "Available Team Members" section to understand each subordinate's capabilities before dispatching.
+
+## Efficiency
+- Read ONLY files directly relevant to your task. Do NOT explore the codebase broadly.
+- If a file doesn't exist at the expected path, try at most 2 alternatives, then move on.
+- Do NOT use \`find\` or \`ls\` to scan entire directory trees. Use the Project Structure above.
+- Never \`sleep\` or poll in loops. If something isn't ready, report it and move on.
+
+## When Stuck
+- If you cannot find what you need after 3 search attempts, STOP searching immediately.
+- Do NOT retry the same failing command or approach.
+- Summarize what you found, what you couldn't find, and deliver your best answer with what you have.
+
+## Output
+- Always produce a concrete deliverable: code change, report, analysis, or clear status update.
+- End with a brief summary of what you did and any unresolved items.
+
+## Sub-task Efficiency (when dispatched by a superior)
+- Focus ONLY on the assigned task — nothing else.
+- Do NOT update journals, knowledge docs, or tasks.md — your superior handles that.
+- Do NOT read CLAUDE.md or explore unrelated files — go straight to the target file.
+- If tsc/tests fail, fix the specific error. Do NOT refactor surrounding code.
+
+## Commit Rule (when you modify code files)
+- After completing code changes, you MUST commit your work.
+- Use a descriptive commit message: \`git commit -m "type(scope): description"\`
+- Common types: feat, fix, refactor, test, chore
+- This ensures your work is not lost in uncommitted changes.
+- Do NOT push — just commit locally. Your superior or the system handles push/PR.`);
+
+  const systemPrompt = sections.join('\n\n---\n\n');
+
+  return {
+    systemPrompt,
+    task,
+    sourceRole,
+    targetRole: roleId,
+    metadata: {
+      orgPath: getChainOfCommand(orgTree, roleId),
+      knowledgeScope: [...node.knowledge.reads, ...node.knowledge.writes],
+      authorityLevel: node.level,
+      subordinates,
+    },
+  };
+}
+
+/* ─── Section Builders ───────────────────────── */
+
+function buildPreKnowledgingSection(companyRoot: string, task: string): string | null {
+  // Extract keywords from the task directive
+  const keywords = extractKeywords(task);
+  if (keywords.length < 2) return null; // Too few keywords to be meaningful
+
+  const related = searchRelatedDocs(companyRoot, keywords);
+  if (related.length === 0) return null;
+
+  const docList = related
+    .map(doc => `- \`${doc.path}\` — ${doc.preview} (relevance: ${doc.matches})`)
+    .join('\n');
+
+  return `# 📚 Pre-Knowledging: Related Documents
+
+The following existing documents are related to this task. **Read relevant ones before starting work** to avoid duplicating knowledge or missing existing context.
+
+${docList}
+
+> **Knowledging Rule**: Check these documents first. If your work produces new knowledge, update existing docs or create new ones with cross-links.`;
+}
+
+/**
+ * Load knowledge docs from a preset's knowledge/ directory.
+ * Returns concatenated content (capped at 2000 chars per doc).
+ */
+function loadPresetKnowledge(companyRoot: string, presetId: string): string | null {
+  const knowledgeDir = path.join(companyRoot, 'knowledge', 'presets', presetId, 'knowledge');
+  if (!fs.existsSync(knowledgeDir)) return null;
+
+  const parts: string[] = [];
+  try {
+    const entries = fs.readdirSync(knowledgeDir).filter(f => f.endsWith('.md'));
+    for (const file of entries.slice(0, 10)) { // Cap at 10 docs
+      const content = fs.readFileSync(path.join(knowledgeDir, file), 'utf-8');
+      const preview = content.slice(0, 2000);
+      parts.push(`## ${file}\n\n${preview}${content.length > 2000 ? '\n\n... (truncated)' : ''}`);
+    }
+  } catch { /* ignore */ }
+
+  return parts.length > 0 ? parts.join('\n\n---\n\n') : null;
+}
+
+function loadCompanyRules(companyRoot: string): string | null {
+  const parts: string[] = [];
+
+  // 1. System rules (CLAUDE.md — Tycono managed)
+  const claudeMdPath = path.join(companyRoot, 'CLAUDE.md');
+  if (fs.existsSync(claudeMdPath)) {
+    parts.push(fs.readFileSync(claudeMdPath, 'utf-8'));
+  }
+
+  // 2. User custom rules (knowledge/custom-rules.md — user owned, git tracked)
+  const customPath = path.join(companyRoot, 'knowledge', 'custom-rules.md');
+  if (fs.existsSync(customPath)) {
+    const custom = fs.readFileSync(customPath, 'utf-8').trim();
+    if (custom) {
+      parts.push('---\n\n## Company Custom Rules\n\n' + custom);
+    }
+  }
+
+  // 3. Company info (knowledge/company.md — user owned)
+  const companyMdPath = path.join(companyRoot, 'knowledge', 'company.md');
+  if (fs.existsSync(companyMdPath)) {
+    const companyInfo = fs.readFileSync(companyMdPath, 'utf-8').trim();
+    if (companyInfo) {
+      parts.push('---\n\n## Company Info\n\n' + companyInfo);
+    }
+  }
+
+  return parts.length > 0 ? parts.join('\n\n') : null;
+}
+
+function buildOrgContextSection(orgTree: OrgTree, node: OrgNode): string {
+  const chart = formatOrgChart(orgTree, node.id);
+  const chain = getChainOfCommand(orgTree, node.id);
+
+  return `# Organization
+
+## Org Chart
+\`\`\`
+${chart}
+\`\`\`
+
+## Your Position
+- **Role**: ${node.name} (${node.id})
+- **Level**: ${node.level}
+- **Reports To**: ${node.reportsTo}
+- **Chain of Command**: ${chain.join(' → ')}
+- **Direct Reports**: ${node.children.length > 0 ? node.children.join(', ') : 'None'}`;
+}
+
+function buildPersonaSection(node: OrgNode): string {
+  return `# Persona
+
+You are **${node.name}** of this company.
+
+${node.persona}`;
+}
+
+function buildAuthoritySection(node: OrgNode): string {
+  const autoList = node.authority.autonomous.map((a) => `- ✅ ${a}`).join('\n');
+  const approvalList = node.authority.needsApproval.map((a) => `- ⚠️ ${a}`).join('\n');
+
+  return `# Authority
+
+## Autonomous Actions (proceed without approval)
+${autoList || '- None defined'}
+
+## Requires Approval from ${node.reportsTo || 'CEO'}
+${approvalList || '- None defined'}
+
+**Important**: Actions outside your authority must be tagged with [APPROVAL_NEEDED].`;
+}
+
+function buildKnowledgeSection(node: OrgNode): string {
+  const reads = node.knowledge.reads.map((p) => `- \`${p}\``).join('\n');
+  const writes = node.knowledge.writes.map((p) => `- \`${p}\``).join('\n');
+
+  const hasKnowledgeWrite = node.knowledge.writes.some((p) =>
+    p === '*' || p.startsWith('knowledge') || p === 'knowledge/*'
+  );
+
+  return `# Knowledge Scope
+
+## Readable Paths
+${reads || '- None'}
+
+## Writable Paths
+${writes || '- None'}
+
+Only access files within your knowledge scope. For information outside your scope, ask your manager.${hasKnowledgeWrite ? `
+
+## Knowledge Base 문서 작성 규칙
+
+보고서, 분석 결과, 리서치 등 **공유 가치가 있는 문서**는 반드시 \`knowledge/\` 디렉토리에 작성하세요.
+
+\`\`\`yaml
+---
+title: "문서 제목"
+akb_type: node
+status: active
+tags: ["tag1", "tag2"]
+domain: tech|market|process|strategy|financial|competitor|general
+---
+\`\`\`
+
+- 파일 경로: \`knowledge/{category}/{filename}.md\`
+- 반드시 위 YAML frontmatter를 포함할 것
+- journal/에는 일지만, knowledge/에는 공유 문서를 작성` : ''}`;
+}
+
+function loadSkillMd(companyRoot: string, roleId: string): string | null {
+  const skillPath = path.join(companyRoot, 'knowledge', '.claude', 'skills', roleId, 'SKILL.md');
+  if (!fs.existsSync(skillPath)) return null;
+  return fs.readFileSync(skillPath, 'utf-8');
+}
+
+function loadSharedSkills(companyRoot: string, skillIds?: string[]): string | null {
+  if (!skillIds?.length) return null;
+
+  const sections: string[] = [];
+  for (const skillId of skillIds) {
+    const skillPath = path.join(companyRoot, 'knowledge', '.claude', 'skills', '_shared', skillId, 'SKILL.md');
+    if (!fs.existsSync(skillPath)) continue;
+    const content = fs.readFileSync(skillPath, 'utf-8');
+    // Extract just the key sections (skip frontmatter)
+    const body = content.replace(/^---[\s\S]*?---\n*/, '').trim();
+    sections.push(`## [Skill: ${skillId}]\n\n${body}`);
+  }
+
+  return sections.length > 0 ? sections.join('\n\n---\n\n') : null;
+}
+
+function loadHubSummaries(companyRoot: string, node: OrgNode): string | null {
+  const hubPaths = new Set<string>();
+
+  // Determine which hub docs to include based on knowledge scope
+  for (const readPath of node.knowledge.reads) {
+    const base = readPath.replace(/\*$/, '').replace(/\/$/, '');
+    const hubFile = path.join(companyRoot, base, `${path.basename(base)}.md`);
+    if (fs.existsSync(hubFile)) {
+      hubPaths.add(hubFile);
+    }
+  }
+
+  if (hubPaths.size === 0) return null;
+
+  const summaries: string[] = [];
+  for (const hubPath of hubPaths) {
+    const content = fs.readFileSync(hubPath, 'utf-8');
+    // Extract TL;DR or first 500 chars
+    const tldr = content.match(/## TL;DR[\s\S]*?(?=\n## [^#])/);
+    const summary = tldr ? tldr[0] : content.slice(0, 500);
+    const relativePath = path.relative(companyRoot, hubPath);
+    summaries.push(`### ${relativePath}\n${summary.trim()}`);
+  }
+
+  return summaries.join('\n\n');
+}
+
+function loadCeoDecisions(companyRoot: string): string | null {
+  const decisionsDir = path.join(companyRoot, 'knowledge', 'decisions');
+  if (!fs.existsSync(decisionsDir)) return null;
+
+  const files = fs.readdirSync(decisionsDir)
+    .filter((f) => f.endsWith('.md') && f !== 'decisions.md')
+    .sort();
+
+  if (files.length === 0) return null;
+
+  const summaries: string[] = [];
+
+  for (const file of files) {
+    const content = fs.readFileSync(path.join(decisionsDir, file), 'utf-8');
+
+    // Only include Approved decisions
+    const statusMatch = content.match(/>\s*Status:\s*(.+)/i);
+    if (!statusMatch || !statusMatch[1].toLowerCase().includes('approved')) continue;
+
+    // Extract title from first heading
+    const titleMatch = content.match(/^#\s+(.+)/m);
+    const title = titleMatch ? titleMatch[1].trim() : file;
+
+    // Extract Decision section (first paragraph after ## Decision)
+    const decisionMatch = content.match(/## Decision\s*\n\n([^\n]+)/);
+    const summary = decisionMatch ? decisionMatch[1].trim() : '';
+
+    if (summary) {
+      summaries.push(`- **${title}**: ${summary}`);
+    } else {
+      // Fallback: use first 3 content lines after front matter
+      const lines = content.split('\n').filter((l) => l.trim() && !l.startsWith('>') && !l.startsWith('#'));
+      summaries.push(`- **${title}**: ${lines.slice(0, 1).join(' ').trim() || '(상세 내용은 파일 참조)'}`);
+    }
+  }
+
+  if (summaries.length === 0) return null;
+
+  return `아래는 CEO가 승인한 전사 결정 사항입니다. 모든 Role은 이 결정을 인지하고 준수해야 합니다.\n\n${summaries.join('\n')}`;
+}
+
+function buildDispatchSection(orgTree: OrgTree, roleId: string, subordinates: string[], teamStatus?: TeamStatus): string {
+  const node = orgTree.nodes.get(roleId);
+  const isCLevel = node?.level === 'c-level';
+
+  const subInfo = subordinates.map((id) => {
+    const sub = orgTree.nodes.get(id);
+    if (!sub) return `- ${id} — (unknown role)`;
+
+    const lines: string[] = [];
+
+    // Header: name, id, persona summary
+    const st = teamStatus?.[id];
+    const status = st?.status && isRoleActive(st.status)
+      ? `🔴 Working${st.task ? ` — "${st.task.slice(0, 60)}"` : ''}`
+      : '🟢 Idle';
+    lines.push(`### ${sub.name} (\`${id}\`) — ${status}`);
+    lines.push(`> ${sub.persona.split('\n')[0]}`);
+
+    // Level & model
+    lines.push(`- **Level**: ${sub.level} | **Model**: ${sub.model ?? 'default'}`);
+
+    // Skills
+    if (sub.skills && sub.skills.length > 0) {
+      lines.push(`- **Skills**: ${sub.skills.join(', ')}`);
+    }
+
+    // Authority — what they can do autonomously
+    if (sub.authority.autonomous.length > 0) {
+      lines.push(`- **Can do**: ${sub.authority.autonomous.join(', ')}`);
+    }
+
+    // Knowledge scope — what they can read/write
+    if (sub.knowledge.reads.length > 0) {
+      lines.push(`- **Reads**: ${sub.knowledge.reads.join(', ')}`);
+    }
+    if (sub.knowledge.writes.length > 0) {
+      lines.push(`- **Writes**: ${sub.knowledge.writes.join(', ')}`);
+    }
+
+    // Their own subordinates (for chain delegation visibility)
+    const grandchildren = orgTree.nodes.get(id)?.children ?? [];
+    if (grandchildren.length > 0) {
+      const gcNames = grandchildren.map(gc => {
+        const gcNode = orgTree.nodes.get(gc);
+        return gcNode ? `${gcNode.name} (${gc})` : gc;
+      });
+      lines.push(`- **Their reports**: ${gcNames.join(', ')}`);
+    }
+
+    return lines.join('\n');
+  }).join('\n\n');
+
+  const exampleSubId = subordinates[0] ?? 'engineer';
+
+  let section = `# Dispatch (Team Management)
+
+⛔ **YOU HAVE SUBORDINATES. YOU MUST USE THEM.**
+⛔ **For ANY directive — whether it's "do X", "review Y", or even "what do you think about Z" — dispatch to your team first, THEN synthesize their input into your response.**
+⛔ **Reading files and giving your own opinion WITHOUT dispatching is NEVER acceptable when you have a team.**
+
+Even for opinion/analysis requests:
+- Dispatch to relevant subordinates: "Analyze X from your perspective and report findings"
+- Poll for results → Synthesize their input with your own analysis
+- Your value is ORCHESTRATION, not solo work
+
+## Available Team Members
+${subInfo}
+
+## How to Dispatch
+
+**Dispatch is async: start a job → supervise with watch → review → next task.**
+
+\`\`\`bash
+# Step 1: Dispatch (returns immediately with session ID)
+python3 "$DISPATCH_CMD" ${exampleSubId} "Task description here"
+# → Session ID: ses-xxx
+
+# Step 2: Supervise with watch (preferred) or poll with --check
+# Option A (preferred): Supervision watch — blocks server-side, returns digest
+python3 "$SUPERVISION_CMD" watch ses-xxx --duration 120
+# Option B (fallback): Poll for result
+python3 "$DISPATCH_CMD" --check ses-xxx
+\`\`\`
+
+⛔ **NEVER use the Agent tool or Task tool to spawn sub-agents.** Those bypass the job tracking system. Use ONLY the dispatch command.
+
+### The Pattern: Dispatch → Watch → Analyze → Act
+
+\`\`\`bash
+# 1. Dispatch tasks (save all session IDs)
+python3 "$DISPATCH_CMD" ${exampleSubId} "Task A"
+# → Session ID: ses-aaa
+${subordinates.length > 1 ? `python3 "$DISPATCH_CMD" ${subordinates[1]} "Task B"\n# → Session ID: ses-bbb` : ''}
+
+# 2. Enter supervision loop — watch ALL dispatched sessions
+python3 "$SUPERVISION_CMD" watch ses-aaa${subordinates.length > 1 ? ',ses-bbb' : ''} --duration 120
+# → Returns digest with significance score + activity summary
+
+# 3. Analyze digest → decide:
+#    - On track → watch again
+#    - Off track → amend: python3 "$SUPERVISION_CMD" amend ses-aaa "Fix: use adapter pattern"
+#    - Failed → abort: python3 "$SUPERVISION_CMD" abort ses-aaa --reason "wrong approach"
+#    - Need input → consult: python3 "$CONSULT_CMD" cbo "Is this direction right?"
+
+# 4. Repeat watch until ALL sessions complete
+\`\`\`
+
+### --check Status Values
+- **RUNNING** — Subordinate still working → poll again in 10-30s
+- **DONE** — Task completed, result is printed
+- **ERROR** — Task failed (re-dispatch with different instructions or report)
+- **AWAITING_INPUT** — Subordinate has a question for you
+
+### ⛔ CRITICAL Rules
+- **NEVER re-dispatch the same task.** If --check shows RUNNING, just keep polling.
+- **NEVER dispatch and immediately finish.** The dispatch→check→review loop must continue until ALL work is complete.
+- **Save the job ID** from each dispatch to use with --check.`;
+
+  // C-level roles get mandatory delegation rules
+  if (isCLevel) {
+    section += `
+
+## C-Level Delegation Protocol (MANDATORY)
+
+⛔ **You are a MANAGER. You do NOT write code, tests, or implementation yourself.**
+⛔ **Your job is to PLAN, DELEGATE, REVIEW, and UPDATE KNOWLEDGE.**
+
+### Core Rule: Always Delegate Down
+
+When you receive a directive:
+1. **Analyze** — Break it into sub-tasks appropriate for each subordinate
+2. **Dispatch** — Assign tasks to subordinates with clear acceptance criteria
+3. **Monitor** — Poll for results, review quality
+4. **Verify** — Check git status: did subordinate commit? What files changed?
+5. **Follow up** — If output doesn't meet criteria, dispatch back with feedback
+6. **Report** — Synthesize results with change summary (files, commits, branch)
+
+### What You Do vs What Subordinates Do
+
+| YOU (C-Level) | SUBORDINATES (Members) |
+|---------------|----------------------|
+| Plan & decompose tasks | Implement code/design/tests |
+| Dispatch with clear specs | Execute and return results |
+| Review output quality | Fix issues when told |
+| Update knowledge & tasks | Update their own journals |
+| Report to superior | Report to you |
+
+### The Supervision Loop (CRITICAL — DO NOT SKIP)
+
+⛔ **You MUST keep running until ALL planned tasks are dispatched, reviewed, and completed.**
+⛔ **NEVER dispatch once and stop. That leaves work half-done.**
+
+The loop:
+\`\`\`
+PLAN TASKS → DISPATCH → SUPERVISION WATCH → ANALYZE DIGEST → DECIDE
+                                                               ├── On track → Watch again
+                                                               ├── Off track → Amend session
+                                                               ├── Failed → Abort + re-dispatch
+                                                               └── ALL DONE → Update knowledge → Report
+\`\`\`
+
+### ⛔ CRITICAL: No Duplicate Dispatch
+
+**NEVER dispatch the same or similar task to the same role twice.**
+- If watch shows sessions still running, keep watching — do NOT re-dispatch
+- If a subordinate completed a task, accept the result — do NOT re-dispatch
+- If the result is unsatisfactory, re-dispatch with SPECIFIC different instructions
+- Track dispatched session IDs — never repeat the same task
+- After 2 dispatches to the same role, accept the result or report to CEO
+
+**Example: Full supervision session**
+\`\`\`bash
+# Task 1: Dispatch to engineer
+python3 "$DISPATCH_CMD" engineer "Implement feature X. Read tasks.md first."
+# → Session ID: ses-001
+
+# Supervision watch (blocks 120s, returns digest)
+python3 "$SUPERVISION_CMD" watch ses-001 --duration 120
+# → Digest: Engineer creating auth module (significance: 3, no anomalies)
+# Judgment: On track, continue watching
+
+python3 "$SUPERVISION_CMD" watch ses-001 --duration 120
+# → Digest: Engineer importing external API directly (significance: 7, anomaly: scope_creep)
+# Judgment: Wrong approach — amend!
+python3 "$SUPERVISION_CMD" amend ses-001 "Use our adapter pattern, not direct API import"
+
+python3 "$SUPERVISION_CMD" watch ses-001 --duration 120
+# → Digest: Engineer completed (msg:done)
+
+# Review result... looks good. Task 2 (QA):
+python3 "$DISPATCH_CMD" qa "Test feature X that engineer just implemented."
+# → Session ID: ses-002
+python3 "$SUPERVISION_CMD" watch ses-002 --duration 120
+# → Digest: QA found bugs (significance: 6)
+
+# Re-dispatch with SPECIFIC fix:
+python3 "$DISPATCH_CMD" engineer "Fix BUG: null check missing in auth.ts line 42"
+# → Session ID: ses-003
+python3 "$SUPERVISION_CMD" watch ses-003 --duration 120
+# → DONE — all good. Update knowledge and report.
+\`\`\`
+
+⚠️ Do NOT use curl or other methods to create jobs — always use the dispatch command.
+
+### Dispatch Quality Requirements
+
+Every dispatch MUST include:
+- **Context**: What documents/files to read first (CLAUDE.md + relevant Hub + SKILL.md)
+- **Task**: Specific deliverable with acceptance criteria
+- **Constraints**: File paths, standards, what NOT to do
+- **AKB instruction**: "⛔ AKB Rule: Read CLAUDE.md before starting work."
+
+### Anti-Patterns (NEVER do these)
+
+- ❌ **Dispatching once and stopping** — you MUST keep working until directive is complete
+- ❌ **Dispatching and NOT polling with --check** — you must poll for results
+- ❌ **Re-dispatching when --check shows RUNNING** — just poll again
+- ❌ Writing code yourself instead of dispatching to engineer
+- ❌ Dispatching without acceptance criteria
+- ❌ Accepting output without reviewing it
+- ❌ Forgetting to update knowledge/tasks after work completes
+- ❌ Doing only 1 dispatch when you should chain multiple (Engineer → QA)
+- ❌ Reporting to superior without synthesizing subordinate outputs
+
+### Post-Dispatch Verification (CRITICAL)
+
+After a subordinate completes a code task, you MUST verify the work is preserved:
+
+\`\`\`bash
+# 1. Check if subordinate committed their work
+git log --oneline -3
+
+# 2. If NOT committed (changes are unstaged), commit on their behalf
+git add -A && git commit -m "feat(scope): description of subordinate's work"
+
+# 3. Include in your report to CEO:
+#    - What files were changed
+#    - Commit hash (if committed)
+#    - Whether the changes compile (tsc --noEmit)
+\`\`\`
+
+⛔ **Uncommitted work = lost work.** If the subordinate didn't commit, YOU must commit before reporting.
+Your final report MUST include a **Change Summary** with files changed and commit status.`;
+  } else {
+    section += `
+
+## Delegation Rules (MANDATORY)
+
+⛔ **You have subordinates — USE THEM before doing work yourself.**
+
+- **Always dispatch first.** Break the directive into sub-tasks and assign to your team.
+- Only do work yourself if NO subordinate can handle it (e.g., cross-cutting decisions).
+- Include clear task description, acceptance criteria, and relevant file paths in every dispatch.
+- After receiving results, synthesize and report back.
+- Your output should reference subordinate findings, not just your own file reads.`;
+  }
+
+  return section;
+}
+
+function buildSupervisionSection(node: OrgNode): string {
+  const hb = node.heartbeat ?? { enabled: true, intervalSec: 120, maxTicks: 60 };
+  return `# Supervision Mode (Heartbeat)
+
+⛔ **After dispatching subordinates, you MUST enter supervision mode.**
+⛔ **Use \`python3 "$SUPERVISION_CMD" watch\` — it blocks server-side at zero LLM cost and returns a digest.**
+⛔ **Do NOT use sleep + \`--check\` polling. The supervision watch command is cheaper and gives better information.**
+
+## Supervision Protocol
+
+1. **Dispatch** subordinates with clear task descriptions. Save returned session IDs.
+2. **Watch** with the supervision command:
+   \`\`\`bash
+   python3 "$SUPERVISION_CMD" watch <ses-id1>,<ses-id2> --duration ${hb.intervalSec}
+   \`\`\`
+   This blocks for ${hb.intervalSec}s (or until an alert event) and returns a digest summary.
+3. **Analyze the digest** — each tick, you must think critically:
+   - ✅ **Direction check**: Are subordinates on track with the plan?
+   - ✅ **Quality check**: Is the approach correct? (e.g., right patterns, right tools)
+   - ✅ **Peer consult**: Unsure about business/market direction? → \`python3 "$CONSULT_CMD" cbo "question"\`
+   - ⚠️ **Course correct**: Wrong direction → \`python3 "$SUPERVISION_CMD" amend <ses-id> "new instruction"\`
+   - 🛑 **Abort**: Seriously wrong → \`python3 "$SUPERVISION_CMD" abort <ses-id> --reason "why"\`
+   - ✅ **All done?** → Before reporting done, **verify deliverables** (see Quality Gate below)
+4. **Repeat** watch until all subordinates complete. Do NOT stop after one tick.
+5. **Quality Gate**: When subordinates report done, **run and test** the output:
+   - For web apps/games: start a local server and open in browser to verify it actually works
+   - Try the core user interactions — if basic things don't work, it's NOT done
+   - Check that required libraries/tools mentioned in the task are actually used
+   - If gaps found → re-dispatch with **specific, actionable** feedback (not "improve quality")
+   - There is NO time limit. Non-working code is worse than less code that works.
+
+## Supervision Commands
+
+| Command | Description |
+|---------|-------------|
+| \`python3 "$SUPERVISION_CMD" watch <ids> --duration ${hb.intervalSec}\` | Watch sessions (blocks ${hb.intervalSec}s, returns digest) |
+| \`python3 "$SUPERVISION_CMD" amend <ses-id> "instruction"\` | Inject new instructions into running session |
+| \`python3 "$SUPERVISION_CMD" abort <ses-id> --reason "why"\` | Kill a session going wrong |
+| \`python3 "$SUPERVISION_CMD" peers --wave <waveId> --role <roleId>\` | Discover peer C-Level sessions |
+| \`python3 "$CONSULT_CMD" <peer-role> "question"\` | Ask a peer C-Level for input |
+
+## Digest Response
+
+The watch command returns a JSON digest with:
+- **significanceScore** (0-10): How much attention this tick needs
+- **anomalies**: Errors, stalls (3min+ no events), sessions awaiting input
+- **text**: Human-readable summary of per-session activity
+
+Score 0-1 = quiet (all normal). Score 5+ = needs attention. Score 8+ = likely needs intervention.
+
+## Tick Quality (CRITICAL)
+
+⛔ **Each tick, you must make a REAL judgment — not just "still running, continuing".**
+
+Good tick response:
+\`\`\`
+Digest: Engineer working on auth module (seq 45), QA waiting.
+Judgment: Engineer is importing external API directly — should use our adapter pattern.
+Action: amend engineer session with instruction to use adapter.
+\`\`\`
+
+Bad tick response (DO NOT DO THIS):
+\`\`\`
+"Sessions are still running. Continuing to watch."
+\`\`\`
+
+## Budget
+
+- Max ticks: ${hb.maxTicks} (${Math.round(hb.maxTicks * hb.intervalSec / 60)} minutes total)
+- Quiet tick cost: ~$0.001 | Alert tick cost: ~$0.02-0.05
+
+## ⛔ Anti-Patterns
+
+- ❌ Using \`sleep\` + \`--check\` to poll — use supervision watch instead
+- ❌ Saying "still RUNNING, continuing to wait" without real analysis
+- ❌ Ignoring digest anomalies — always address errors and stalls
+- ❌ Stopping supervision after one tick — keep watching until ALL done
+- ❌ Not consulting peers when business/market judgment is needed`;
+}
+
+function buildKnowledgeManagementSection(roleId: string): string {
+  const domainScope = roleId === 'cto'
+    ? '`architecture/`, `knowledge/` (technical docs)'
+    : roleId === 'cbo'
+      ? '`knowledge/` (business docs)'
+      : '`knowledge/` (your domain docs)';
+
+  return `# Knowledge Consistency Management (C-Level Responsibility)
+
+⛔ **You are responsible for keeping your domain's knowledge current and consistent.**
+
+## When to Check
+
+- After completing any task (The Loop step ④)
+- During supervision ticks when subordinates are progressing normally
+- When you notice conflicting information during work
+
+## Knowledge Gate
+
+1. Check if changes conflict with existing documents (grep 3+ keywords)
+2. Update or deprecate stale references — do NOT leave legacy docs pretending to be current
+3. Verify new docs are registered in their Hub
+4. Ensure cross-links between related documents
+
+## AKB Linting
+
+| Check | Description |
+|-------|-------------|
+| Orphan docs | Every document reachable from a Hub? |
+| Stale content | Deprecated designs still described as current? Mark ⚠️ |
+| Term consistency | Same concept called different names across docs? |
+| Date freshness | Old dates/status without warning? |
+
+**Your scope**: ${domainScope}`;
+}
+
+function buildConsultSection(orgTree: OrgTree, roleId: string): string | null {
+  // Build list of roles this agent can consult
+  const consultable: string[] = [];
+  for (const [id] of orgTree.nodes) {
+    if (id !== roleId && canConsult(orgTree, roleId, id)) {
+      consultable.push(id);
+    }
+  }
+
+  if (consultable.length === 0) return null;
+
+  const roleList = consultable.map((id) => {
+    const n = orgTree.nodes.get(id);
+    if (!n) return `- \`${id}\``;
+    const firstLine = n.persona.split('\n')[0] || n.name;
+    return `- **${n.name}** (\`${id}\`): ${firstLine}`;
+  }).join('\n');
+
+  return `# Consult (Ask Colleagues)
+
+You can ask questions to other roles using the \`consult\` tool:
+
+${roleList}
+
+## How to Consult
+
+Use the \`consult\` tool:
+\`\`\`json
+{ "roleId": "designer", "question": "What color scheme are you using for the dashboard?" }
+\`\`\`
+
+The consulted role will answer your question in read-only mode and return the response to you.
+
+## When to Use
+- Need technical decisions or clarifications from your manager
+- Need design/implementation details from a peer
+- Need domain expertise from another team member
+- Unsure about architecture or conventions — ask before guessing
+
+## Rules
+- The consulted role answers in **read-only mode** (no file modifications)
+- Keep questions specific and concise for better answers
+- Don't consult for tasks that should be dispatched (use dispatch for work assignments)`;
+}