@triflux/remote 10.87.0 → 10.88.1

package/hub/team/cli/commands/debug.mjs

@@ -1,3 +1,4 @@
+import { isJevEnabled, judgeWorkerHealth } from "@triflux/core/hub/lib/jev-addon.mjs";
 import {
   capturePaneOutput,
   detectMultiplexer,
@@ -47,10 +48,16 @@ export async function teamDebug(args = []) {
   if (!(state.members || []).length)
     console.log(`    ${DIM}(members 없음)${RESET}`);
   for (const member of state.members || []) {
-    console.log(`\n    [${member.name}] ${member.pane}`);
-    for (const line of (capturePaneOutput(member.pane, lines) || "(empty)")
-      .split("\n")
-      .slice(-lines)) {
+    const rawTail = capturePaneOutput(member.pane, lines) || "(empty)";
+    let jevLabel = "";
+    if (isJevEnabled() && rawTail !== "(empty)") {
+      const verdict = await judgeWorkerHealth({ stdoutTail: rawTail });
+      if (verdict?.status) {
+        jevLabel = ` ${DIM}[jev:${verdict.status}]${RESET}`;
+      }
+    }
+    console.log(`\n    [${member.name}] ${member.pane}${jevLabel}`);
+    for (const line of rawTail.split("\n").slice(-lines)) {
       console.log(`      ${line}`);
     }
   }

package/hub/team/handoff.mjs

@@ -2,6 +2,8 @@
 // HANDOFF 블록 파싱, 검증, fallback 생성, Lead 포맷팅
 // 설계: docs/design/handoff-schema-v7.md (PR #70 에서 삭제, c0722ecd 에 남아 있다)
 
+import { judgeHandoffQuality, judgeReviewGate } from "@triflux/core/hub/lib/jev-addon.mjs";
+
 // ── enum 허용 값 ──
 const STATUS_VALUES = ["ok", "partial", "failed"];
 const LEAD_ACTION_VALUES = ["accept", "needs_read", "retry", "reassign"];
@@ -305,3 +307,101 @@ export function processHandoff(rawText, context = {}) {
     fallback: false,
   };
 }
+
+/**
+ * Jev 애드온이 활성화된 경우 인계 파일의 lead_action과 가짜 성공 여부를 보정한다.
+ * 비활성 상태이거나 신뢰도 임계값 미만이면 processHandoff 결과를 그대로 반환한다.
+ */
+export async function processHandoffWithJev(
+  rawText,
+  context = {},
+  jevOptions = {},
+) {
+  const base = processHandoff(rawText, context);
+  const verdict = await judgeHandoffQuality(
+    {
+      rawText,
+      handoff: base.handoff,
+      exitCode: context.exitCode ?? 0,
+      gitDiffFiles: context.gitDiffFiles,
+      role: context.role,
+    },
+    jevOptions,
+  );
+  if (!verdict) return base;
+
+  const declaredFilesCount = Array.isArray(base.handoff.files_changed)
+    ? base.handoff.files_changed.filter(Boolean).length
+    : 0;
+  const hasEmptyGitDiff =
+    Array.isArray(context.gitDiffFiles) &&
+    context.gitDiffFiles.filter(Boolean).length === 0;
+  const canAccept =
+    base.handoff.status === "ok" &&
+    (context.exitCode ?? 0) === 0 &&
+    declaredFilesCount > 0 &&
+    !hasEmptyGitDiff &&
+    base.handoff.lead_action === "accept";
+
+  let effectiveAction = verdict.leadAction;
+  if (effectiveAction === "accept" && !canAccept) {
+    effectiveAction =
+      base.handoff.lead_action === "retry" ? "retry" : "needs_read";
+  }
+
+  const updatedHandoff = {
+    ...base.handoff,
+    lead_action: effectiveAction,
+    ...(effectiveAction === "retry" && base.handoff.status === "ok"
+      ? { status: "partial" }
+      : {}),
+    _jev: {
+      lead_action: verdict.leadAction,
+      effective_lead_action: effectiveAction,
+      confidence: verdict.confidence,
+    },
+  };
+  const warnings = [...base.warnings];
+  if (effectiveAction !== base.handoff.lead_action) {
+    warnings.push(
+      `jev overridden lead_action: ${base.handoff.lead_action} -> ${effectiveAction}`,
+    );
+  }
+  return {
+    ...base,
+    handoff: updatedHandoff,
+    formatted: formatHandoffForLead(updatedHandoff),
+    warnings,
+  };
+}
+
+/**
+ * 교차 리뷰 게이트 판정: Jev로 리뷰 생략, 교차 리뷰, 리드 에스컬레이션 및 리뷰 수렴 여부를 판단한다.
+ */
+export async function evaluateReviewGateWithJev(
+  {
+    diffStat = "",
+    handoffSummary = "",
+    previousReviews = "",
+    currentReview = "",
+  } = {},
+  jevOptions = {},
+) {
+  const verdict = await judgeReviewGate(
+    { diffStat, handoffSummary, previousReviews, currentReview },
+    jevOptions,
+  );
+  if (!verdict) {
+    return {
+      gate: "cross_review",
+      converged: false,
+      fallback: true,
+    };
+  }
+  return {
+    gate: verdict.gate,
+    converged: verdict.converged,
+    confidence: verdict.confidence,
+    fallback: false,
+  };
+}

package/hub/team/headless.mjs

@@ -15,6 +15,7 @@ import { delimiter, dirname, isAbsolute, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { resolveNestedCodexAgentProfile } from "../../scripts/lib/agent-route-policy.mjs";
 import { escapePwshSingleQuoted } from "@triflux/core/hub/cli-adapter-base.mjs";
+import { judgeWorkerHealth } from "@triflux/core/hub/lib/jev-addon.mjs";
 import { privateTmpDir } from "@triflux/core/hub/lib/private-tmp.mjs";
 import {
   createActivityLifecycle,
@@ -29,7 +30,7 @@ import { resolveDashboardLayout } from "./dashboard-layout.mjs";
 import {
   formatHandoffForLead,
   HANDOFF_INSTRUCTION_SHORT,
-  processHandoff,
+  processHandoffWithJev,
 } from "./handoff.mjs";
 import { createInterventionLadder } from "./intervention.mjs";
 import {
@@ -371,11 +372,47 @@ export function readResult(resultFile, paneId) {
   return capturePsmuxPane(paneId, 30);
 }
 
-function createHeadlessIntervention(dispatch, fallback) {
-  return async (context) => {
+export function createHeadlessIntervention(dispatch, fallback, deps = {}) {
+  return async (context = {}) => {
     if (typeof fallback === "function")
       return (await fallback(context)) === true;
 
+    const capturePane = deps.capturePsmuxPane || capturePsmuxPane;
+    const judgeHealth = deps.judgeWorkerHealth || judgeWorkerHealth;
+    const buildLadder =
+      deps.createInterventionLadder || createInterventionLadder;
+    const paneTarget = context.paneId || dispatch.paneId;
+    const paneSnap = (() => {
+      try {
+        return capturePane(paneTarget, 50) || "";
+      } catch {
+        return "";
+      }
+    })();
+    const errTail = (() => {
+      try {
+        const errPath = `${dispatch.resultFile}.err`;
+        return existsSync(errPath)
+          ? readFileSync(errPath, "utf8").slice(-2000)
+          : "";
+      } catch {
+        return "";
+      }
+    })();
+    const health = await judgeHealth({
+      stdoutTail: paneSnap.slice(-2000),
+      stderrTail: errTail,
+      elapsedSec: Math.round((Number(context.inactiveMs) || 0) / 1000),
+    });
+    if (health?.status === "progressing") return true;
+
+    const reinstructPrompt =
+      health?.status === "waiting_input"
+        ? "[triflux intervention] 대화형 입력 대기가 감지되었다. 사용자 확인을 기다리지 말고 기본값이나 자율 판단으로 남은 작업을 마쳐라."
+        : health?.status === "looping_error"
+          ? "[triflux intervention] 동일 오류 반복 루프가 감지되었다. 직전 실패 명령을 반복하지 말고 우회 경로를 택하거나 실패 원인을 HANDOFF 블록에 기록하고 종료하라."
+          : undefined;
+
     const readActivitySignature = () => {
       let mtime = 0;
       try {
@@ -383,24 +420,25 @@ function createHeadlessIntervention(dispatch, fallback) {
       } catch {
         /* result file has not been written yet */
       }
-      return `${capturePsmuxPane(context.paneId || dispatch.paneId, 50)}\0${mtime}`;
+      return `${capturePane(paneTarget, 50)}\0${mtime}`;
     };
-    const ladder = createInterventionLadder({
+    const ladder = buildLadder({
       target: {
         channel: "tmux-pane",
-        paneId: context.paneId || dispatch.paneId,
+        paneId: paneTarget,
         cli: dispatch.cli,
         sessionId: dispatch.sessionId,
       },
+      ...(reinstructPrompt ? { reinstructPrompt } : {}),
       readActivitySignature,
       deps: {
         // 이 트랙이 재실행 소유자다. pane 채널은 기존 completion wrapper를 다시
         // dispatch하여 token/result 계약을 보존한다.
         resumeHandler: async () => {
           if (!dispatch.command) return { ok: false };
-          const restarted = dispatchCommand(
+          const restarted = (deps.dispatchCommand || dispatchCommand)(
             context.sessionName,
-            context.paneId || dispatch.paneId,
+            paneTarget,
             dispatch.command,
           );
           return { ok: Boolean(restarted) };
@@ -823,11 +861,12 @@ async function collectResults(results) {
   return await Promise.all(
     results.map(async ({ d, completion, output }) => {
       const workerGitDiffFiles = collectGitDiffFiles(d.cwd);
-      const handoffResult = processHandoff(output, {
+      const handoffResult = await processHandoffWithJev(output, {
         exitCode: completion.exitCode,
         resultFile: d.resultFile,
         cli: d.cli,
         gitDiffFiles: workerGitDiffFiles,
+        role: d.role,
       });
       if (
         completion.exitCode === 0 &&
@@ -1745,7 +1784,7 @@ export async function runHeadlessInteractive(
   process.on("exit", exitHandler);
   // kill() 후 리스너 제거를 위해 참조 보관
   const originalKill = handle.kill.bind(handle);
-  handle.kill = function () {
+  handle.kill = () => {
     originalKill();
     process.removeListener("exit", exitHandler);
   };

package/hub/team/lead-launch.mjs

@@ -0,0 +1,186 @@
+// hub/team/lead-launch.mjs: `tfx lead <역할>` 로 리드 세션을 띄운다.
+// 리드는 사람이 직접 쓰는 세션이라 CLI 별 실행 명령을 사용자가 정한다(기본은 CLI 이름).
+// 워커는 tfx-live 가 기본 명령으로 띄우므로 이 설정과 무관하다.
+
+import { execFile } from "node:child_process";
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { basename, dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { promisify } from "node:util";
+import { modelFamilyPaths } from "../../scripts/lib/model-family-resolver.mjs";
+
+const execFileAsync = promisify(execFile);
+const PKG_ROOT = join(dirname(fileURLToPath(import.meta.url)), "..", "..");
+const TFX_LIVE = join(PKG_ROOT, "bin", "tfx-live.mjs");
+const LEAD_SKILL = join(PKG_ROOT, "skills", "tfx-lead", "SKILL.md");
+export const LEAD_CLIS = ["claude", "codex", "agy"];
+
+export function leadConfigPath() {
+  return join(modelFamilyPaths().stateDir, "lead.json");
+}
+
+/** lead.json 을 읽는다. 없으면 null. 10.85.0 의 `launcher` 한 칸은 Claude 실행 명령으로 읽는다. */
+export function readLeadConfig(path = leadConfigPath()) {
+  let text;
+  try {
+    text = readFileSync(path, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") return null;
+    throw error;
+  }
+  const config = JSON.parse(text);
+  const isObject = (value) =>
+    value !== null && typeof value === "object" && !Array.isArray(value);
+  if (
+    !isObject(config) ||
+    (config.launchers !== undefined && !isObject(config.launchers))
+  )
+    throw new Error(`${path} 는 {"launchers": {...}} 형식이어야 한다`);
+  const launchers = { ...config.launchers };
+  if (config.launcher !== undefined && launchers.claude === undefined)
+    launchers.claude = config.launcher;
+  for (const [cli, launcher] of Object.entries(launchers)) {
+    if (
+      typeof launcher !== "string" ||
+      !launcher.trim() ||
+      /[\r\n]/u.test(launcher)
+    )
+      throw new Error(`${path} 의 launchers.${cli} 는 한 줄 문자열이어야 한다`);
+    launchers[cli] = launcher.trim();
+  }
+  return { launchers };
+}
+
+export function writeLeadConfig(launchers, path = leadConfigPath()) {
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, `${JSON.stringify({ launchers }, null, 2)}\n`);
+}
+
+const CLI_LABELS = {
+  claude: "Claude",
+  codex: "Codex",
+  agy: "Antigravity(agy)",
+};
+
+/**
+ * setup 과 update 때 아직 정하지 않은 CLI 의 리드 실행 명령을 한 번 묻는다.
+ * 설치되지 않은 CLI 는 묻지 않고, 물을 수 없으면(비대화형) 다음 대화형 실행으로 미룬다.
+ */
+export async function offerLeadLaunchers({
+  interactive,
+  askText,
+  hasCommand,
+  notice = () => {},
+  configPath = leadConfigPath(),
+}) {
+  const launchers = { ...readLeadConfig(configPath)?.launchers };
+  const missing = LEAD_CLIS.filter(
+    (cli) => launchers[cli] === undefined && hasCommand(cli),
+  );
+  if (missing.length === 0) return "present";
+  if (!interactive) return "deferred";
+  notice(
+    "tfx lead 로 리드 세션을 띄울 때 쓸 실행 명령을 정한다. 래퍼, 별칭, 셸 함수로 켜면 그 명령을 적고, 그대로 쓰면 Enter. 워커에는 쓰지 않는다.",
+  );
+  for (const cli of missing) {
+    const answer = await askText(
+      `${CLI_LABELS[cli]} 를 켤 때 쓰는 명령 [${cli}]`,
+    );
+    launchers[cli] = answer.trim().split(/\r?\n/u)[0] || cli;
+  }
+  writeLeadConfig(launchers, configPath);
+  return "saved";
+}
+
+/** 실행 명령은 --launcher, lead.json 의 launchers.<cli>, CLI 이름 순으로 고른다. */
+export function resolveLauncher({ cli = "claude", flag, configPath } = {}) {
+  if (flag) return flag;
+  return readLeadConfig(configPath)?.launchers[cli] ?? cli;
+}
+
+/** tmux 대상 문법과 겹치는 문자(. :)와 공백만 바꿔 `<폴더>-lead` 로 만든다. */
+export function leadSessionName(cwd) {
+  return `${basename(resolve(cwd)).replace(/[.:\s]/gu, "-")}-lead`;
+}
+
+/** /tfx-lead 와 같은 규칙으로 이름을 정한다. 날짜로 시작하면 그대로 쓴다. */
+export function leadDisplayName(role, now = new Date()) {
+  if (/^\d{1,2}\.\d{1,2} \S/u.test(role)) return role;
+  return `${now.getMonth() + 1}.${now.getDate()} ${role}`;
+}
+
+/** Claude 는 mod 가 /tfx-lead 를 처리한다. Codex 와 agy 는 mod 가 없어 스킬 파일을 읽게 한다. */
+export function leadEntryPrompt(cli, role) {
+  if (cli === "claude") return `/tfx-lead ${role}`;
+  return `${LEAD_SKILL} 를 읽고 이 세션이 ${role} 리드를 맡는다. 그 스킬의 절차를 따른다.`;
+}
+
+async function runLive(args, run) {
+  let stdout;
+  try {
+    ({ stdout } = await run(process.execPath, [TFX_LIVE, ...args], {
+      encoding: "utf8",
+      maxBuffer: 1024 * 1024,
+    }));
+  } catch (error) {
+    // tfx-live 는 실패해도 원인을 담은 JSON 을 stdout 에 쓰고 exit 1 로 끝난다.
+    if (!error.stdout) throw error;
+    stdout = error.stdout;
+  }
+  return JSON.parse(stdout);
+}
+
+export async function launchLead(
+  {
+    cli = "claude",
+    role,
+    cwd = process.cwd(),
+    session,
+    model,
+    effort,
+    launcher,
+  },
+  { run = execFileAsync } = {},
+) {
+  if (!LEAD_CLIS.includes(cli))
+    throw new Error(`--cli 는 ${LEAD_CLIS.join(", ")} 중 하나여야 한다`);
+  if (!role?.trim()) throw new Error("역할이 필요하다: tfx lead <역할>");
+  const target = session || leadSessionName(cwd);
+  const name = leadDisplayName(role.trim());
+  const summary = { cli, session: target, name, launcher };
+  const start = await runLive(
+    [
+      "start",
+      "--cli",
+      cli,
+      "--session",
+      target,
+      "--name",
+      name,
+      "--launcher",
+      launcher,
+      "--cwd",
+      resolve(cwd),
+      ...(model ? ["--model", model] : []),
+      ...(effort ? ["--effort", effort] : []),
+    ],
+    run,
+  );
+  if (!start.ready) return { ok: false, ...summary, start };
+  // Claude 슬래시 명령은 tmux 입력으로만 실행되고, Claude 안에서 호출해도 SendMessage 로 바뀌지 않게 한다.
+  const ask = await runLive(
+    [
+      "ask",
+      "--cli",
+      cli,
+      "--session",
+      target,
+      "--prompt",
+      leadEntryPrompt(cli, role.trim()),
+      "--no-wait",
+      ...(cli === "claude" ? ["--via-tmux"] : []),
+    ],
+    run,
+  );
+  return { ok: Boolean(ask.ok), ...summary, start, ask };
+}

package/hub/team/native-peer.mjs

@@ -36,9 +36,15 @@ export function parsePeerArgs(args) {
     );
   if (target === "--session")
     return { sessionId: parsed["--session"], message: parsed["--message"] };
-  if (!/^(claude|codex):[^:]+$/.test(parsed["--to"]))
-    throw new Error("Use exact claude:NAME or codex:NAME target");
-  return { to: parsed["--to"], message: parsed["--message"] };
+  if (!/^(claude|codex|agy|antigravity):[^:]+$/i.test(parsed["--to"]))
+    throw new Error("Use exact claude:NAME, codex:NAME, or agy:NAME target");
+  const sep = parsed["--to"].indexOf(":");
+  const rawCli = parsed["--to"].slice(0, sep).toLowerCase();
+  const cli = rawCli === "antigravity" ? "agy" : rawCli;
+  return {
+    to: `${cli}:${parsed["--to"].slice(sep + 1)}`,
+    message: parsed["--message"],
+  };
 }
 
 export function validateCodexTarget(thread, id) {
@@ -468,3 +474,91 @@ export async function deliverClaude({
     } catch {}
   }
 }
+
+export function deliverAgy({
+  conversationId,
+  appDataDir: targetAppDataDir = null,
+  requireExisting = false,
+  message,
+  sender = "unknown",
+  env = process.env,
+  home = null,
+  fs: io = fs,
+} = {}) {
+  if (
+    typeof conversationId !== "string" ||
+    !/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(
+      conversationId,
+    )
+  )
+    throw new Error("Invalid agy conversationId");
+  const normalizedId = conversationId.toLowerCase();
+  const resolvedHome = home || env.HOME || os.homedir();
+  const appDataDir =
+    targetAppDataDir ||
+    (home
+      ? path.join(home, ".gemini", "antigravity-cli")
+      : env.ANTIGRAVITY_APP_DATA_DIR ||
+        path.join(resolvedHome, ".gemini", "antigravity-cli"));
+  if (requireExisting) {
+    const hasConversation = [
+      path.join(appDataDir, "presence", `${normalizedId}.lock`),
+      path.join(appDataDir, "conversations", `${normalizedId}.db`),
+      path.join(appDataDir, "brain", normalizedId),
+    ].some((p) => io.existsSync(p));
+    if (!hasConversation) {
+      throw new Error("agy target conversation not found in appDataDir");
+    }
+  }
+  const messagesDir = path.join(
+    appDataDir,
+    "brain",
+    normalizedId,
+    ".system_generated",
+    "messages",
+  );
+  const undeliveredDir = path.join(messagesDir, "undelivered");
+  io.mkdirSync(undeliveredDir, { recursive: true, mode: 0o700 });
+  const msgId = randomUUID();
+  const payload = {
+    id: msgId,
+    recipient: normalizedId,
+    sender,
+    priority: "MESSAGE_PRIORITY_HIGH",
+    timestamp: new Date().toISOString(),
+    renderDetails: {
+      messageTitle: `Message from ${sender}`,
+    },
+    content: message,
+  };
+  const jsonPath = path.join(messagesDir, `${msgId}.json`);
+  const markerPath = path.join(undeliveredDir, msgId);
+  try {
+    io.writeFileSync(jsonPath, JSON.stringify(payload, null, 2), {
+      mode: 0o600,
+    });
+  } catch (error) {
+    try {
+      io.unlinkSync?.(jsonPath);
+    } catch {}
+    throw error;
+  }
+  try {
+    io.writeFileSync(markerPath, "", { mode: 0o600 });
+  } catch (error) {
+    const markerExists = Boolean(io.existsSync?.(markerPath));
+    return {
+      status: markerExists ? "unknown" : "partial",
+      retrySafe: false,
+      modelReceipt: false,
+      msgId,
+      error: error.message,
+    };
+  }
+  return {
+    status: "written",
+    retrySafe: false,
+    modelReceipt: false,
+    msgId,
+  };
+}

package/hub/team/orchestrator.mjs

@@ -1,5 +1,6 @@
 // hub/team/orchestrator.mjs — 작업 분배 + 프롬프트 구성
 // 의존성: pane.mjs만 사용
+import { judgeTaskAssignment } from "@triflux/core/hub/lib/jev-addon.mjs";
 import { injectPrompt as defaultInjectPrompt } from "./pane.mjs";
 
 /**
@@ -39,6 +40,85 @@ export function decomposeTask(taskDescription, agentCount) {
   return parts;
 }
 
+/**
+ * Jev가 활성화된 경우 서브태스크별 최적 워커/CLI 매칭을 적용한다.
+ * 비활성 상태이거나 판정이 실패하면 결정론적 decomposeTask 순서대로 반환한다.
+ */
+export async function assignTasksWithJev(
+  taskDescription,
+  workers,
+  jevOptions = {},
+) {
+  if (!Array.isArray(workers) || workers.length === 0) return [];
+  const subtasks = decomposeTask(taskDescription, workers.length);
+  const base = workers.map((w, i) => ({
+    ...w,
+    subtask: subtasks[i] || subtasks[subtasks.length - 1],
+  }));
+  if (workers.length <= 1) return base;
+
+  const verdict = await judgeTaskAssignment({ subtasks, workers }, jevOptions);
+  if (
+    !verdict ||
+    !Array.isArray(verdict.assignments) ||
+    verdict.assignments.length !== workers.length
+  ) {
+    return base;
+  }
+  const usedSubtasks = new Set();
+  const workerAssignments = new Array(workers.length).fill(null);
+
+  for (let i = 0; i < workers.length; i += 1) {
+    const match = verdict.assignments.find(
+      (item) =>
+        item.workerIndex === i &&
+        Number.isInteger(item.subtaskIndex) &&
+        item.subtaskIndex >= 0 &&
+        item.subtaskIndex < subtasks.length &&
+        !usedSubtasks.has(item.subtaskIndex),
+    );
+    if (match) {
+      usedSubtasks.add(match.subtaskIndex);
+      workerAssignments[i] = {
+        subtaskIdx: match.subtaskIndex,
+        recommendedCli: match.recommendedCli || workers[i].cli,
+      };
+    }
+  }
+
+  for (let i = 0; i < workers.length; i += 1) {
+    if (workerAssignments[i]) continue;
+    let fallbackIdx = !usedSubtasks.has(i) && i < subtasks.length ? i : -1;
+    if (fallbackIdx === -1) {
+      for (let s = 0; s < subtasks.length; s += 1) {
+        if (!usedSubtasks.has(s)) {
+          fallbackIdx = s;
+          break;
+        }
+      }
+    }
+    if (fallbackIdx === -1) fallbackIdx = Math.min(i, subtasks.length - 1);
+    usedSubtasks.add(fallbackIdx);
+    workerAssignments[i] = {
+      subtaskIdx: fallbackIdx,
+      recommendedCli: workers[i].cli,
+    };
+  }
+
+  return workers.map((w, i) => {
+    const { subtaskIdx, recommendedCli } = workerAssignments[i];
+    return {
+      ...w,
+      subtask: subtasks[subtaskIdx] || subtasks[subtasks.length - 1],
+      _jev: {
+        subtaskIndex: subtaskIdx,
+        recommendedCli,
+        confidence: verdict.confidence,
+      },
+    };
+  });
+}
+
 /**
  * 리드(보통 claude) 초기 프롬프트 생성
  * @param {string} taskDescription