triflux 3.2.0-dev.9 → 3.3.0-dev.3

package/hub/team/native.mjs

@@ -3,11 +3,42 @@
 //
 // Claude Code 네이티브 Agent Teams (CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1)
 // 환경에서 teammate를 Codex/Gemini CLI 래퍼로 구성하는 유틸리티.
-// SKILL.md가 인라인 프롬프트를 사용하므로, 이 모듈은 CLI(tfx team --native)에서
+// SKILL.md가 인라인 프롬프트를 사용하므로, 이 모듈은 CLI(tfx multi --native)에서
 // 팀 설정을 프로그래밍적으로 생성할 때 사용한다.
 
 const ROUTE_SCRIPT = "~/.claude/scripts/tfx-route.sh";
 
+function inferWorkerIndex(agentName = "") {
+  const match = /(\d+)(?!.*\d)/.exec(agentName);
+  if (!match) return null;
+  const index = Number(match[1]);
+  return Number.isInteger(index) && index > 0 ? index : null;
+}
+
+function buildRouteEnvPrefix(agentName, workerIndex, searchTool) {
+  const effectiveWorkerIndex = Number.isInteger(workerIndex) && workerIndex > 0
+    ? workerIndex
+    : inferWorkerIndex(agentName);
+
+  let envPrefix = "";
+  if (effectiveWorkerIndex) envPrefix += ` TFX_WORKER_INDEX="${effectiveWorkerIndex}"`;
+  if (searchTool) envPrefix += ` TFX_SEARCH_TOOL="${searchTool}"`;
+  return envPrefix;
+}
+
+/**
+ * role/mcp_profile별 tfx-route.sh 기본 timeout (초)
+ * analyze/review 프로필이나 설계·분석 역할은 더 긴 timeout을 부여한다.
+ * @param {string} role — 워커 역할
+ * @param {string} mcpProfile — MCP 프로필
+ * @returns {number} timeout(초)
+ */
+function getRouteTimeout(role, mcpProfile) {
+  if (mcpProfile === "analyze" || mcpProfile === "review") return 3600;
+  if (role === "architect" || role === "analyst") return 3600;
+  return 1080; // 기본 18분
+}
+
 /**
  * v2.2 슬림 래퍼 프롬프트 생성
  * Agent spawn으로 네비게이션에 등록하되, 실제 작업은 tfx-route.sh가 수행.
@@ -22,35 +53,142 @@ const ROUTE_SCRIPT = "~/.claude/scripts/tfx-route.sh";
  * @param {string} [opts.agentName] — 워커 표시 이름
  * @param {string} [opts.leadName] — 리드 수신자 이름
  * @param {string} [opts.mcp_profile] — MCP 프로필
+ * @param {number} [opts.workerIndex] — 검색 힌트 회전에 사용할 워커 인덱스(1-based)
+ * @param {string} [opts.searchTool] — 전용 검색 도구 힌트(brave-search|tavily|exa)
+ * @param {number} [opts.bashTimeout] — Bash timeout(ms). 미지정 시 role/profile 기반 자동 산출.
  * @returns {string} 슬림 래퍼 프롬프트
  */
 export function buildSlimWrapperPrompt(cli, opts = {}) {
   const {
     subtask,
     role = "executor",
-    teamName = "tfx-team",
+    teamName = "tfx-multi",
     taskId = "",
     agentName = "",
     leadName = "team-lead",
     mcp_profile = "auto",
+    workerIndex,
+    searchTool = "",
+    pipelinePhase = "",
+    bashTimeout,
   } = opts;
 
+  // role/profile 기반 timeout 산출 (기본 timeout + 60초 여유, ms 변환)
+  const bashTimeoutMs = bashTimeout ?? (getRouteTimeout(role, mcp_profile) + 60) * 1000;
+
   // 셸 이스케이프
   const escaped = subtask.replace(/'/g, "'\\''");
+  const pipelineHint = pipelinePhase
+    ? `\n파이프라인 단계: ${pipelinePhase}`
+    : '';
+  const routeEnvPrefix = buildRouteEnvPrefix(agentName, workerIndex, searchTool);
+
+  const taskIdRef = taskId ? `taskId: "${taskId}"` : "";
+
+  return `인터럽트 프로토콜:
+1. TaskUpdate(${taskIdRef ? `${taskIdRef}, ` : ""}status: in_progress) — task claim
+2. SendMessage(to: ${leadName}, "작업 시작: ${agentName}") — 시작 보고 (턴 경계 생성)
+3. Bash(command, timeout: ${bashTimeoutMs}) — 아래 명령 1회 실행
+4. 결과 보고 후 반드시 종료${pipelineHint}
+
+[HARD CONSTRAINT] 너는 Bash, TaskUpdate, TaskGet, TaskList, SendMessage만 사용할 수 있다.
+Read, Edit, Write, Grep, Glob, Agent, WebSearch, WebFetch 등 다른 모든 도구 사용을 금지한다.
+코드를 직접 읽거나 수정하면 안 된다. 반드시 아래 Bash 명령(tfx-route.sh)을 통해 Codex/Gemini에 위임하라.
+이 규칙을 위반하면 작업 실패로 간주한다.
 
-  return `Bash 1회 실행 후 반드시 종료하라. 어떤 경우에도 hang하지 마라.
 gemini/codex를 직접 호출하지 마라. 반드시 tfx-route.sh를 거쳐야 한다.
 프롬프트를 파일로 저장하지 마라. tfx-route.sh가 인자로 받는다.
 
-TFX_TEAM_NAME="${teamName}" TFX_TEAM_TASK_ID="${taskId}" TFX_TEAM_AGENT_NAME="${agentName}" TFX_TEAM_LEAD_NAME="${leadName}" bash ${ROUTE_SCRIPT} "${role}" '${escaped}' ${mcp_profile}
+Bash(command: 'TFX_TEAM_NAME="${teamName}" TFX_TEAM_TASK_ID="${taskId}" TFX_TEAM_AGENT_NAME="${agentName}" TFX_TEAM_LEAD_NAME="${leadName}"${routeEnvPrefix} bash ${ROUTE_SCRIPT} "${role}" '"'"'${escaped}'"'"' ${mcp_profile}', timeout: ${bashTimeoutMs})
 
-성공 → TaskUpdate(status: completed, metadata: {result: "success"}) + SendMessage(to: ${leadName}).
-실패 → TaskUpdate(status: completed, metadata: {result: "failed", error: "에러 요약"}) + SendMessage(to: ${leadName}).
+성공 → TaskUpdate(${taskIdRef ? `${taskIdRef}, ` : ""}status: completed, metadata: {result: "success"}) + SendMessage(to: ${leadName}).
+실패 → TaskUpdate(${taskIdRef ? `${taskIdRef}, ` : ""}status: completed, metadata: {result: "failed", error: "에러 요약"}) + SendMessage(to: ${leadName}).
 
 중요: TaskUpdate의 status는 "completed"만 사용. "failed"는 API 미지원.
 실패 여부는 metadata.result로 구분. Bash 실패 시에도 반드시 TaskUpdate + SendMessage 후 종료.`;
 }
 
+/**
+ * v3 하이브리드 래퍼 프롬프트 생성
+ * psmux pane 기반 비동기 실행 + polling 패턴.
+ * Agent가 idle 상태를 유지하여 인터럽트 수신이 가능하다.
+ *
+ * @param {'codex'|'gemini'} cli — CLI 타입
+ * @param {object} opts
+ * @param {string} opts.subtask — 서브태스크 설명
+ * @param {string} [opts.role] — 역할
+ * @param {string} [opts.teamName] — 팀 이름
+ * @param {string} [opts.taskId] — Hub task ID
+ * @param {string} [opts.agentName] — 워커 표시 이름
+ * @param {string} [opts.leadName] — 리드 수신자 이름
+ * @param {string} [opts.mcp_profile] — MCP 프로필
+ * @param {number} [opts.workerIndex] — 검색 힌트 회전에 사용할 워커 인덱스(1-based)
+ * @param {string} [opts.searchTool] — 전용 검색 도구 힌트(brave-search|tavily|exa)
+ * @param {string} [opts.sessionName] — psmux 세션 이름
+ * @param {string} [opts.pipelinePhase] — 파이프라인 단계
+ * @param {string} [opts.psmuxPath] — psmux.mjs 경로
+ * @returns {string} 하이브리드 래퍼 프롬프트
+ */
+export function buildHybridWrapperPrompt(cli, opts = {}) {
+  const {
+    subtask,
+    role = "executor",
+    teamName = "tfx-multi",
+    taskId = "",
+    agentName = "",
+    leadName = "team-lead",
+    mcp_profile = "auto",
+    workerIndex,
+    searchTool = "",
+    sessionName = teamName,
+    pipelinePhase = "",
+    psmuxPath = "hub/team/psmux.mjs",
+  } = opts;
+
+  const escaped = subtask.replace(/'/g, "'\\''");
+  const pipelineHint = pipelinePhase ? `\n파이프라인 단계: ${pipelinePhase}` : "";
+  const taskIdRef = taskId ? `taskId: "${taskId}"` : "";
+  const taskIdArg = taskIdRef ? `${taskIdRef}, ` : "";
+  const routeEnvPrefix = buildRouteEnvPrefix(agentName, workerIndex, searchTool);
+
+  const routeCmd = `TFX_TEAM_NAME="${teamName}" TFX_TEAM_TASK_ID="${taskId}" TFX_TEAM_AGENT_NAME="${agentName}" TFX_TEAM_LEAD_NAME="${leadName}"${routeEnvPrefix} bash ${ROUTE_SCRIPT} "${role}" '${escaped}' ${mcp_profile}`;
+
+  return `하이브리드 psmux 워커 프로토콜:
+
+1. TaskUpdate(${taskIdArg}status: in_progress) + SendMessage(to: ${leadName}, "작업 시작: ${agentName}")
+
+2. pane 생성 (비동기 실행):
+   Bash: node ${psmuxPath} spawn --session "${sessionName}" --name "${agentName}" --cmd "${routeCmd}"
+
+3. 폴링 루프 (10초 간격, idle 유지 → 인터럽트 수신 가능):
+   Bash: node ${psmuxPath} status --session "${sessionName}" --name "${agentName}"
+   - status: "running" → 10초 대기 후 재확인
+   - status: "exited" → 5단계로
+
+4. 인터럽트 수신 시:
+   Bash: node ${psmuxPath} kill --session "${sessionName}" --name "${agentName}"
+   → SendMessage(to: ${leadName}, "인터럽트 수신, 방향 전환")
+   → 새 지시에 따라 2단계부터 재실행
+
+5. 완료 시:
+   Bash: node ${psmuxPath} output --session "${sessionName}" --name "${agentName}" --lines 100
+   → 결과를 TaskUpdate + SendMessage로 보고
+${pipelineHint}
+[HARD CONSTRAINT] 너는 Bash, TaskUpdate, TaskGet, TaskList, SendMessage만 사용할 수 있다.
+Read, Edit, Write, Grep, Glob, Agent, WebSearch, WebFetch 등 다른 모든 도구 사용을 금지한다.
+코드를 직접 읽거나 수정하면 안 된다. 반드시 아래 Bash 명령(tfx-route.sh)을 통해 Codex/Gemini에 위임하라.
+이 규칙을 위반하면 작업 실패로 간주한다.
+
+gemini/codex를 직접 호출하지 마라. psmux spawn이 tfx-route.sh를 통해 실행한다.
+프롬프트를 파일로 저장하지 마라. psmux spawn --cmd 인자로 전달된다.
+
+성공 → TaskUpdate(${taskIdArg}status: completed, metadata: {result: "success"}) + SendMessage(to: ${leadName}).
+실패 → TaskUpdate(${taskIdArg}status: completed, metadata: {result: "failed", error: "에러 요약"}) + SendMessage(to: ${leadName}).
+
+중요: TaskUpdate의 status는 "completed"만 사용. "failed"는 API 미지원.
+실패 여부는 metadata.result로 구분. pane 실패 시에도 반드시 TaskUpdate + SendMessage 후 종료.`;
+}
+
 /**
  * 팀 이름 생성 (타임스탬프 기반)
  * @returns {string}

package/hub/team/nativeProxy.mjs

@@ -4,8 +4,6 @@
 import {
   existsSync,
   mkdirSync,
-  readdirSync,
-  readFileSync,
   renameSync,
   statSync,
   unlinkSync,
@@ -13,6 +11,7 @@ import {
   openSync,
   closeSync,
 } from 'node:fs';
+import { readdir, stat, readFile } from 'node:fs/promises';
 import { basename, dirname, join } from 'node:path';
 import { homedir } from 'node:os';
 import { randomUUID } from 'node:crypto';
@@ -25,6 +24,7 @@ const TASKS_ROOT = join(CLAUDE_HOME, 'tasks');
 // ── 인메모리 캐시 (디렉토리 mtime 기반 무효화) ──
 const _dirCache = new Map(); // tasksDir → { mtimeMs, files: string[] }
 const _taskIdIndex = new Map(); // taskId → filePath
+const _taskContentCache = new Map(); // filePath → { mtimeMs, data }
 
 function _invalidateCache(tasksDir) {
   _dirCache.delete(tasksDir);
@@ -40,9 +40,9 @@ function validateTeamName(teamName) {
   }
 }
 
-function readJsonSafe(path) {
+async function readJsonSafe(path) {
   try {
-    return JSON.parse(readFileSync(path, 'utf8'));
+    return JSON.parse(await readFile(path, 'utf8'));
   } catch {
     return null;
   }
@@ -66,12 +66,11 @@ function atomicWriteJson(path, value) {
   }
 }
 
-function sleepMs(ms) {
-  // busy-wait를 피하고 Atomics.wait로 동기 대기 (CPU 점유 최소화)
-  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+async function sleepMs(ms) {
+  return new Promise((r) => setTimeout(r, ms));
 }
 
-function withFileLock(lockPath, fn, retries = 20, delayMs = 25) {
+async function withFileLock(lockPath, fn, retries = 20, delayMs = 25) {
   let fd = null;
   for (let i = 0; i < retries; i += 1) {
     try {
@@ -79,12 +78,12 @@ function withFileLock(lockPath, fn, retries = 20, delayMs = 25) {
       break;
     } catch (e) {
       if (e?.code !== 'EEXIST' || i === retries - 1) throw e;
-      sleepMs(delayMs);
+      await sleepMs(delayMs);
     }
   }
 
   try {
-    return fn();
+    return await fn();
   } finally {
     try { if (fd != null) closeSync(fd); } catch {}
     try { unlinkSync(lockPath); } catch {}
@@ -99,13 +98,13 @@ function getLeadSessionId(config) {
     || null;
 }
 
-export function resolveTeamPaths(teamName) {
+export async function resolveTeamPaths(teamName) {
   validateTeamName(teamName);
 
   const teamDir = join(TEAMS_ROOT, teamName);
   const configPath = join(teamDir, 'config.json');
   const inboxesDir = join(teamDir, 'inboxes');
-  const config = readJsonSafe(configPath);
+  const config = await readJsonSafe(configPath);
   const leadSessionId = getLeadSessionId(config);
 
   const byTeam = join(TASKS_ROOT, teamName);
@@ -131,19 +130,20 @@ export function resolveTeamPaths(teamName) {
   };
 }
 
-function collectTaskFiles(tasksDir) {
+async function collectTaskFiles(tasksDir) {
   if (!existsSync(tasksDir)) return [];
 
   // 디렉토리 mtime 기반 캐시 — O(N) I/O를 반복 호출 시 O(1)로 축소
   let dirMtime;
-  try { dirMtime = statSync(tasksDir).mtimeMs; } catch { return []; }
+  try { dirMtime = (await stat(tasksDir)).mtimeMs; } catch { return []; }
 
   const cached = _dirCache.get(tasksDir);
   if (cached && cached.mtimeMs === dirMtime) {
     return cached.files;
   }
 
-  const files = readdirSync(tasksDir)
+  const entries = await readdir(tasksDir);
+  const files = entries
     .filter((name) => name.endsWith('.json'))
     .filter((name) => !name.endsWith('.lock'))
     .filter((name) => name !== '.highwatermark')
@@ -153,7 +153,7 @@ function collectTaskFiles(tasksDir) {
   return files;
 }
 
-function locateTaskFile(tasksDir, taskId) {
+async function locateTaskFile(tasksDir, taskId) {
   const direct = join(tasksDir, `${taskId}.json`);
   if (existsSync(direct)) return direct;
 
@@ -162,13 +162,13 @@ function locateTaskFile(tasksDir, taskId) {
   if (indexed && existsSync(indexed)) return indexed;
 
   // 캐시된 collectTaskFiles로 풀 스캔
-  const files = collectTaskFiles(tasksDir);
+  const files = await collectTaskFiles(tasksDir);
   for (const file of files) {
     if (basename(file, '.json') === taskId) {
       _taskIdIndex.set(taskId, file);
       return file;
     }
-    const json = readJsonSafe(file);
+    const json = await readJsonSafe(file);
     if (json && String(json.id || '') === taskId) {
       _taskIdIndex.set(taskId, file);
       return file;
@@ -181,7 +181,7 @@ function isObject(v) {
   return !!v && typeof v === 'object' && !Array.isArray(v);
 }
 
-export function teamInfo(args = {}) {
+export async function teamInfo(args = {}) {
   const { team_name, include_members = true, include_paths = true } = args;
   try {
     validateTeamName(team_name);
@@ -189,7 +189,7 @@ export function teamInfo(args = {}) {
     return err('INVALID_TEAM_NAME', 'team_name 형식이 올바르지 않습니다');
   }
 
-  const paths = resolveTeamPaths(team_name);
+  const paths = await resolveTeamPaths(team_name);
   if (!existsSync(paths.team_dir)) {
     return err('TEAM_NOT_FOUND', `팀 디렉토리가 없습니다: ${paths.team_dir}`);
   }
@@ -224,7 +224,7 @@ export function teamInfo(args = {}) {
   };
 }
 
-export function teamTaskList(args = {}) {
+export async function teamTaskList(args = {}) {
   const {
     team_name,
     owner,
@@ -239,7 +239,7 @@ export function teamTaskList(args = {}) {
     return err('INVALID_TEAM_NAME', 'team_name 형식이 올바르지 않습니다');
   }
 
-  const paths = resolveTeamPaths(team_name);
+  const paths = await resolveTeamPaths(team_name);
   if (paths.tasks_dir_resolution === 'not_found') {
     return err('TASKS_DIR_NOT_FOUND', `task 디렉토리를 찾지 못했습니다: ${team_name}`);
   }
@@ -249,8 +249,22 @@ export function teamTaskList(args = {}) {
   let parseWarnings = 0;
 
   const tasks = [];
-  for (const file of collectTaskFiles(paths.tasks_dir)) {
-    const json = readJsonSafe(file);
+  for (const file of await collectTaskFiles(paths.tasks_dir)) {
+    // mtime 기반 task 콘텐츠 캐시 — 변경 없으면 파일 읽기 생략
+    let fileMtime = Date.now();
+    try { fileMtime = (await stat(file)).mtimeMs; } catch {}
+
+    const contentCached = _taskContentCache.get(file);
+    let json;
+    if (contentCached && contentCached.mtimeMs === fileMtime) {
+      json = contentCached.data;
+    } else {
+      json = await readJsonSafe(file);
+      if (json && isObject(json)) {
+        _taskContentCache.set(file, { mtimeMs: fileMtime, data: json });
+      }
+    }
+
     if (!json || !isObject(json)) {
       parseWarnings += 1;
       continue;
@@ -260,13 +274,10 @@ export function teamTaskList(args = {}) {
     if (owner && String(json.owner || '') !== String(owner)) continue;
     if (statusSet.size > 0 && !statusSet.has(String(json.status || ''))) continue;
 
-    let mtime = Date.now();
-    try { mtime = statSync(file).mtimeMs; } catch {}
-
     tasks.push({
       ...json,
       task_file: file,
-      mtime_ms: mtime,
+      mtime_ms: fileMtime,
     });
   }
 
@@ -288,7 +299,7 @@ export function teamTaskList(args = {}) {
 // status 화이트리스트 (Claude Code API 호환)
 const VALID_STATUSES = new Set(['pending', 'in_progress', 'completed', 'deleted']);
 
-export function teamTaskUpdate(args = {}) {
+export async function teamTaskUpdate(args = {}) {
   // "failed" → "completed" + metadata.result 자동 매핑
   if (String(args.status || '') === 'failed') {
     args = {
@@ -326,12 +337,12 @@ export function teamTaskUpdate(args = {}) {
     return err('INVALID_TASK_ID', 'task_id가 필요합니다');
   }
 
-  const paths = resolveTeamPaths(team_name);
+  const paths = await resolveTeamPaths(team_name);
   if (paths.tasks_dir_resolution === 'not_found') {
     return err('TASKS_DIR_NOT_FOUND', `task 디렉토리를 찾지 못했습니다: ${team_name}`);
   }
 
-  const taskFile = locateTaskFile(paths.tasks_dir, String(task_id));
+  const taskFile = await locateTaskFile(paths.tasks_dir, String(task_id));
   if (!taskFile) {
     return err('TASK_NOT_FOUND', `task를 찾지 못했습니다: ${task_id}`);
   }
@@ -339,14 +350,14 @@ export function teamTaskUpdate(args = {}) {
   const lockFile = `${taskFile}.lock`;
 
   try {
-    return withFileLock(lockFile, () => {
-      const before = readJsonSafe(taskFile);
+    return await withFileLock(lockFile, async () => {
+      const before = await readJsonSafe(taskFile);
       if (!before || !isObject(before)) {
         return err('INVALID_TASK_FILE', `task 파일 파싱 실패: ${taskFile}`);
       }
 
       let beforeMtime = Date.now();
-      try { beforeMtime = statSync(taskFile).mtimeMs; } catch {}
+      try { beforeMtime = (await stat(taskFile)).mtimeMs; } catch {}
 
       if (if_match_mtime_ms != null && Number(if_match_mtime_ms) !== Number(beforeMtime)) {
         return err('MTIME_CONFLICT', 'if_match_mtime_ms가 일치하지 않습니다', {
@@ -427,6 +438,8 @@ export function teamTaskUpdate(args = {}) {
       if (updated) {
         atomicWriteJson(taskFile, after);
         _invalidateCache(dirname(taskFile));
+        // 콘텐츠 캐시 무효화
+        _taskContentCache.delete(taskFile);
       }
 
       let afterMtime = beforeMtime;
@@ -453,7 +466,7 @@ function sanitizeRecipientName(v) {
   return String(v || 'team-lead').replace(/[\\/:*?"<>|]/g, '_');
 }
 
-export function teamSendMessage(args = {}) {
+export async function teamSendMessage(args = {}) {
   const {
     team_name,
     from,
@@ -472,7 +485,7 @@ export function teamSendMessage(args = {}) {
   if (!String(from || '').trim()) return err('INVALID_FROM', 'from이 필요합니다');
   if (!String(text || '').trim()) return err('INVALID_TEXT', 'text가 필요합니다');
 
-  const paths = resolveTeamPaths(team_name);
+  const paths = await resolveTeamPaths(team_name);
   if (!existsSync(paths.team_dir)) {
     return err('TEAM_NOT_FOUND', `팀 디렉토리가 없습니다: ${paths.team_dir}`);
   }
@@ -483,8 +496,8 @@ export function teamSendMessage(args = {}) {
   let message;
 
   try {
-    const unreadCount = withFileLock(lockFile, () => {
-      const queue = readJsonSafe(inboxFile);
+    const unreadCount = await withFileLock(lockFile, async () => {
+      const queue = await readJsonSafe(inboxFile);
       const list = Array.isArray(queue) ? queue : [];
 
       message = {

package/hub/team/orchestrator.mjs

@@ -58,6 +58,8 @@ export function buildLeadPrompt(taskDescription, config) {
 
   const workerIds = workers.map((w) => w.agentId).join(", ");
 
+  const bridgePath = "node hub/bridge.mjs";
+
   return `리드 에이전트: ${agentId}
 
 목표: ${taskDescription}
@@ -68,14 +70,13 @@ ${roster}
 
 규칙:
 - 가능한 짧고 핵심만 지시/요약(토큰 절약)
-- 워커 제어 메시지 표준:
-  publish(from="${agentId}", to="<worker-agent-id>", topic="lead.control", payload={command:"interrupt|stop|pause|resume", reason:"..."})
+- 워커 제어:
+  ${bridgePath} result --agent ${agentId} --topic lead.control
 - 워커 결과 수집:
-  poll_messages(agent_id="${agentId}", wait_ms=1000, max_messages=20)
+  ${bridgePath} context --agent ${agentId} --max 20
 - 최종 결과는 topic="task.result"를 모아 통합
 
-권장 워커 ID: ${workerIds || "(없음)"}
-Hub: ${hubUrl}
+워커 ID: ${workerIds || "(없음)"}
 지금 즉시 워커를 배정하고 병렬 진행을 관리하라.`;
 }
 
@@ -93,26 +94,20 @@ export function buildPrompt(subtask, config) {
 
   const hubBase = hubUrl.replace("/mcp", "");
 
+  const bridgePath = "node hub/bridge.mjs";
+
   return `워커: ${agentId} (${cli})
 작업: ${subtask}
 
 필수 규칙:
 1) 간결하게 작업(불필요한 장문 설명 금지)
-2) 시작 즉시 register 실행:
-   register(agent_id="${agentId}", cli="${cli}", capabilities=["code"], topics=["lead.control","task.result"], heartbeat_ttl_ms=600000)
+2) 시작 즉시 등록:
+   ${bridgePath} register --agent ${agentId} --cli ${cli} --topics lead.control,task.result
 3) 주기적으로 수신함 확인:
-   poll_messages(agent_id="${agentId}", wait_ms=1000, max_messages=10)
-4) lead.control 수신 시 즉시 반응
-   - interrupt: 즉시 중단, 진행상태 요약 publish
-   - stop: 작업 종료, 최종 요약 publish 후 대기
-   - pause: 작업 일시정지
-   - resume: 작업 재개
+   ${bridgePath} context --agent ${agentId} --max 10
+4) lead.control 수신 시 즉시 반응 (interrupt/stop/pause/resume)
 5) 완료 시 결과 발행:
-   publish(from="${agentId}", to="topic:task.result", topic="task.result", payload={summary:"..."})
-
-MCP가 없으면 REST 폴백:
-- POST ${hubBase}/bridge/register
-- POST ${hubBase}/bridge/result
+   ${bridgePath} result --agent ${agentId} --topic task.result --file <출력파일>
 
 지금 작업을 시작하라.`;
 }
@@ -149,7 +144,7 @@ export async function orchestrate(sessionName, assignments, opts = {}) {
       teammateMode,
       workers: workers.map((w) => ({ agentId: w.agentId, cli: w.cli, subtask: w.subtask })),
     });
-    injectPrompt(lead.target, leadPrompt);
+    injectPrompt(lead.target, leadPrompt, { useFileRef: true });
     await new Promise((r) => setTimeout(r, 100));
   }
 
@@ -160,7 +155,7 @@ export async function orchestrate(sessionName, assignments, opts = {}) {
       hubUrl,
       sessionName,
     });
-    injectPrompt(worker.target, prompt);
+    injectPrompt(worker.target, prompt, { useFileRef: true });
     await new Promise((r) => setTimeout(r, 100));
   }
 }