@triflux/remote 10.86.1 → 10.88.0

package/hub/team/pane.mjs

@@ -4,6 +4,7 @@ import { existsSync, unlinkSync, writeFileSync } from "node:fs";
 import { createRequire } from "node:module";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
+import { judgeComposerState } from "@triflux/core/hub/lib/jev-addon.mjs";
 import { privateTmpDir } from "@triflux/core/hub/lib/private-tmp.mjs";
 import { psmuxExec } from "./psmux.mjs";
 import { detectMultiplexer, tmuxExec } from "./session.mjs";
@@ -251,6 +252,104 @@ export function submitPromptWithVerification({
   }
 }
 
+/**
+ * 결정론적 컴포저 상태 판정이 모호할 때 Jev로 컴포저 상태를 판별해 Enter 재전송 여부를 결정한다.
+ */
+export async function submitPromptWithJevVerification({
+  cli = "claude",
+  prompt = "",
+  capture,
+  sendEnter,
+  sleep = sleepMs,
+  settleMs = PASTE_SETTLE_MS,
+  retryLimit = SUBMIT_RETRY_LIMIT,
+  jevOptions = {},
+} = {}) {
+  const strictVerification = isAntigravityCli(cli);
+  const promptPrefix = promptComposerNeedle(prompt);
+  const isConfirmedSubmitted = (text) => {
+    if (!promptPrefix) return true;
+    if (!text) return !strictVerification;
+    if (hasBusyMarkerOutsideComposer(text)) return true;
+    const state = composerPromptState(text, promptPrefix);
+    if (state === "absent") return true;
+    if (state === "unknown" && !strictVerification) return true;
+    return false;
+  };
+
+  try {
+    submitPromptWithVerification({
+      cli,
+      prompt,
+      capture,
+      sendEnter,
+      sleep,
+      settleMs,
+      retryLimit,
+    });
+  } catch (err) {
+    const capturedText =
+      typeof capture === "function" ? String(capture() ?? "") : "";
+    const verdict = await judgeComposerState(
+      { capturedText, promptPrefix },
+      jevOptions,
+    );
+    if (verdict?.state === "submitted_running") {
+      return { submitted: true, jevState: verdict.state };
+    }
+    if (
+      verdict?.state === "stuck_in_composer" &&
+      typeof sendEnter === "function"
+    ) {
+      sendEnter();
+      sleep(400);
+      const afterText =
+        typeof capture === "function" ? String(capture() ?? "") : "";
+      if (isConfirmedSubmitted(afterText)) {
+        return { submitted: true, jevState: "submitted_running" };
+      }
+      const postVerdict = await judgeComposerState(
+        { capturedText: afterText, promptPrefix },
+        jevOptions,
+      );
+      if (postVerdict?.state === "submitted_running") {
+        return { submitted: true, jevState: postVerdict.state };
+      }
+    }
+    throw err;
+  }
+  const capturedText =
+    typeof capture === "function" ? String(capture() ?? "") : "";
+  const verdict = await judgeComposerState(
+    { capturedText, promptPrefix },
+    jevOptions,
+  );
+  if (
+    verdict?.state === "stuck_in_composer" &&
+    typeof sendEnter === "function"
+  ) {
+    sendEnter();
+    sleep(400);
+    const afterText =
+      typeof capture === "function" ? String(capture() ?? "") : "";
+    if (isConfirmedSubmitted(afterText)) {
+      return { submitted: true, jevState: "submitted_running" };
+    }
+    const postVerdict = await judgeComposerState(
+      { capturedText: afterText, promptPrefix },
+      jevOptions,
+    );
+    return {
+      submitted: postVerdict?.state === "submitted_running",
+      jevState: postVerdict?.state || verdict.state,
+    };
+  }
+  return {
+    submitted: verdict?.state !== "modal_blocking",
+    jevState: verdict?.state || null,
+  };
+}
+
 function confirmSubmit(target, prompt, cli, sendEnter) {
   submitPromptWithVerification({
     cli,

package/hub/team/results-index.mjs

@@ -1,6 +1,7 @@
 // headless 세션 결과 색인. 화면의 HEADLESS_COMPLETE 문자열 대신 읽도록 세션당 JSON 하나를 둔다 (ADR-0034).
 import { renameSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
+import { judgeInstructionAck } from "@triflux/core/hub/lib/jev-addon.mjs";
 
 export const RESULTS_INDEX_VERSION = 1;
 
@@ -34,6 +35,9 @@ export function createResultsIndex(path, sessionName, workers, canWrite) {
       startedAt: null,
       finishedAt: null,
       resultFile: w.resultFile,
+      ackStatus: null,
+      semanticState: null,
+      ackConfidence: null,
     })),
   };
   const byPane = new Map(index.workers.map((w) => [w.paneName, w]));
@@ -88,5 +92,36 @@ export function createResultsIndex(path, sessionName, workers, canWrite) {
       index.completed = Boolean(completed);
       flush();
     },
+    recordInstructionAck(
+      paneName,
+      { ackStatus = null, semanticState = null, confidence = null } = {},
+    ) {
+      const w = byPane.get(paneName);
+      if (!w) return null;
+      w.ackStatus = ackStatus;
+      w.semanticState = semanticState;
+      w.ackConfidence = confidence;
+      flush();
+      return w;
+    },
+    async verifyInstructionAckWithJev(
+      paneName,
+      { instruction = "", recentOutput = "" } = {},
+      jevOptions = {},
+    ) {
+      const verdict = await judgeInstructionAck(
+        { instruction, recentOutput },
+        jevOptions,
+      );
+      if (!verdict) return null;
+      this.recordInstructionAck(paneName, {
+        ackStatus: verdict.ackStatus,
+        semanticState: verdict.acknowledged
+          ? "following_instruction"
+          : "unverified_instruction",
+        confidence: verdict.confidence,
+      });
+      return verdict;
+    },
   };
 }

package/hub/team/retry-state-machine.mjs

@@ -24,7 +24,14 @@ import {
 import { dirname, join } from "node:path";
 
 import { normalizeCodexProfileName } from "../../scripts/lib/codex-profile-config.mjs";
-import { CODEX_FAMILY_PROFILES } from "../../scripts/lib/model-family-resolver.mjs";
+import {
+  EFFORT_ORDER,
+  modelEffortFromProfile,
+  profileFromModelEffort,
+  resolveCodexModelEffort,
+} from "../../scripts/lib/model-effort.mjs";
+import { AGY_FAMILY_PROFILES } from "../../scripts/lib/model-family-resolver.mjs";
+import { judgeSameFailureCause } from "@triflux/core/hub/lib/jev-addon.mjs";
 
 export const STATES = Object.freeze({
   PLANNING: "PLANNING",
@@ -50,7 +57,8 @@ const DEFAULT_CLAUDE_MODEL = "fable";
 const DEFAULT_ESCALATION_CHAIN = Object.freeze([
   Object.freeze({
     cli: "codex",
-    profile: "astra_max",
+    family: "astra",
+    effort: "max",
   }),
   Object.freeze({ cli: "claude", model: DEFAULT_CLAUDE_MODEL }),
 ]);
@@ -119,10 +127,14 @@ export function createRetryStateMachine(options = {}) {
     return transition(STATES.DONE);
   }
 
-  function reportVerifyFail(failureReason) {
+  function reportVerifyFail(failureReason, failOptions = {}) {
     const reason = String(failureReason || "unknown");
-    if (reason === state.lastFailureReason) {
+    const isSameCause =
+      reason === state.lastFailureReason ||
+      (Boolean(state.lastFailureReason) && failOptions.sameCause === true);
+    if (isSameCause) {
       state.stuckCounter += 1;
+      state.lastFailureReason = reason;
     } else {
       state.stuckCounter = 1;
       state.lastFailureReason = reason;
@@ -148,6 +160,20 @@ export function createRetryStateMachine(options = {}) {
     return transition(STATES.DIAGNOSING, { reason });
   }
 
+  async function reportVerifyFailAsync(failureReason, jevOptions = {}) {
+    const reason = String(failureReason || "unknown");
+    let sameCause = false;
+    if (state.lastFailureReason && reason !== state.lastFailureReason) {
+      const verdict = await judgeSameFailureCause(
+        state.lastFailureReason,
+        reason,
+        jevOptions,
+      );
+      sameCause = verdict?.sameCause === true;
+    }
+    return reportVerifyFail(reason, { sameCause });
+  }
+
   function escalate() {
     if (state.cliIndex + 1 >= state.cliChain.length) {
       return transition(STATES.BUDGET_EXCEEDED, {
@@ -155,6 +181,39 @@ export function createRetryStateMachine(options = {}) {
         chain: state.cliChain,
       });
     }
+    const current = state.cliChain[state.cliIndex];
+    const next = state.cliChain[state.cliIndex + 1];
+    if (
+      current.cli === "codex" &&
+      next.cli === "codex" &&
+      current.family &&
+      next.family
+    ) {
+      try {
+        const base = resolveCodexModelEffort(current, options);
+        const promoted = resolveCodexModelEffort(next, options);
+        if (
+          promoted.effort !== next.effort &&
+          base.model === promoted.model &&
+          base.effort === promoted.effort
+        ) {
+          return transition(STATES.BUDGET_EXCEEDED, {
+            reason: "escalation-not-promoted",
+            escalated: false,
+            model: promoted.model,
+            requestedEffort: next.effort,
+            effort: promoted.effort,
+          });
+        }
+      } catch (error) {
+        if (error.code !== "unsupported-effort") throw error;
+        return transition(STATES.BUDGET_EXCEEDED, {
+          reason: "unsupported-escalation-effort",
+          escalated: false,
+          error: error.message,
+        });
+      }
+    }
     state.cliIndex += 1;
     state.iterations = 0;
     state.stuckCounter = 0;
@@ -231,6 +290,7 @@ export function createRetryStateMachine(options = {}) {
     startIteration,
     reportVerifySuccess,
     reportVerifyFail,
+    reportVerifyFailAsync,
     escalate,
     on,
     serialize,
@@ -306,11 +366,34 @@ function normalizeEscalationChainEntry(entry, index, source) {
   }
   const profile = typeof entry.profile === "string" ? entry.profile.trim() : "";
   const normalizedProfile = normalizeEscalationProfile(profile);
-  if (
-    entry.cli === "codex" &&
-    Object.hasOwn(CODEX_FAMILY_PROFILES, normalizedProfile)
-  ) {
-    return { cli: entry.cli, profile: normalizedProfile };
+  const provider = entry.cli === "agy" ? "antigravity" : entry.cli;
+  if (provider === "codex" || provider === "antigravity") {
+    const explicit = entry.family !== undefined || entry.effort !== undefined;
+    let spec = explicit
+      ? typeof entry.family === "string" && typeof entry.effort === "string"
+        ? modelEffortFromProfile(provider, entry.family, entry.effort)
+        : null
+      : modelEffortFromProfile(
+          provider,
+          provider === "codex" ? normalizedProfile : profile,
+        );
+    if (explicit && !spec)
+      throw new Error(`${source}: chain[${index}] has invalid family/effort`);
+    if (spec) {
+      if (provider === "codex" && spec.effort === "ultra")
+        spec = { family: "astra", effort: "max" };
+      const legacy = profileFromModelEffort(provider, spec);
+      const normalized = { cli: entry.cli, ...spec };
+      if (legacy) normalized.profile = legacy;
+      if (provider === "antigravity" && legacy) {
+        normalized.model = entry.model || AGY_FAMILY_PROFILES[legacy]?.model;
+        if (typeof normalized.model !== "string" || !normalized.model.trim())
+          throw new Error(
+            `${source}: chain[${index}].model must be a non-empty string`,
+          );
+      }
+      return normalized;
+    }
   }
   if (typeof entry.model !== "string" || entry.model.trim() === "") {
     throw new Error(
@@ -319,6 +402,11 @@ function normalizeEscalationChainEntry(entry, index, source) {
   }
   const normalized = { cli: entry.cli, model: entry.model };
   if (profile) normalized.profile = profile;
+  if (entry.effort !== undefined) {
+    if (!EFFORT_ORDER.includes(entry.effort))
+      throw new Error(`${source}: chain[${index}] has invalid effort`);
+    normalized.effort = entry.effort;
+  }
   return normalized;
 }
 

package/hub/team/uds-orchestrator.mjs

@@ -1,5 +1,6 @@
 import { realpath } from "node:fs/promises";
 import { resolve as pathResolve } from "node:path";
+import { judgeBusyAction } from "@triflux/core/hub/lib/jev-addon.mjs";
 import {
   createActivityLifecycle,
   isActivityLifecycleEnabled,
@@ -299,12 +300,13 @@ export async function askCodexAppServerThread({
   noWait = false,
   warnContextPct,
   maxContextPct,
+  jevOptions,
   clientFactory = (opts) => new JsonRpcWsUdsClient(opts),
 } = {}) {
   if (typeof prompt !== "string" || !prompt.trim())
     throw new Error("codex UDS ask requires a non-empty prompt");
   if (!threadId) throw new Error("codex UDS ask requires --thread <id|auto>");
-  if (!["wait", "fail", "steer"].includes(ifBusy))
+  if (!["wait", "fail", "steer", "auto"].includes(ifBusy))
     throw new Error(`invalid --if-busy: ${ifBusy}`);
   const client = codexClient(
     socketPath,
@@ -327,11 +329,13 @@ export async function askCodexAppServerThread({
         throw new Error(
           "no loaded Codex threads; open the TUI and send its first message before using --thread auto",
         );
-      if (candidates.length !== 1)
+      if (candidates.length === 1) {
+        selectedId = candidates[0].threadId;
+      } else {
         throw new Error(
           `multiple loaded Codex threads; pass --thread ID: ${JSON.stringify(candidates)}`,
         );
-      selectedId = candidates[0].threadId;
+      }
     }
     const busyStarted = Date.now();
     let thread = await readCodexThread(
@@ -340,14 +344,30 @@ export async function askCodexAppServerThread({
       DEFAULT_CODEX_APP_SERVER_UDS_BOOTSTRAP_MS,
     );
     const initiallyBusy = thread.status?.type === "active";
-    if (thread.status?.type === "active" && ifBusy === "fail")
+    let effectiveIfBusy = ifBusy;
+    if (initiallyBusy && ifBusy === "auto") {
+      const latestTurnSummary =
+        thread.turns
+          ?.slice(-2)
+          .map((t) => JSON.stringify(t))
+          .join("\n")
+          .slice(0, 800) || "";
+      const verdict = await judgeBusyAction(
+        { prompt, threadSummary: latestTurnSummary },
+        jevOptions,
+      );
+      effectiveIfBusy = verdict?.action ?? "wait";
+    } else if (ifBusy === "auto") {
+      effectiveIfBusy = "wait";
+    }
+    if (thread.status?.type === "active" && effectiveIfBusy === "fail")
       throw new Error(`target busy (--if-busy fail): ${selectedId}`);
     const busyDeadline = busyStarted + busyTimeoutMs;
     const busyError = () =>
       new Error(
         `target busy after ${Math.ceil(busyTimeoutMs / 1000)}s (--if-busy wait)`,
       );
-    while (thread.status?.type === "active" && ifBusy === "wait") {
+    while (thread.status?.type === "active" && effectiveIfBusy === "wait") {
       const waitMs = Math.min(
         pollIntervalMs,
         Math.max(0, busyDeadline - Date.now()),
@@ -373,7 +393,9 @@ export async function askCodexAppServerThread({
         throw busyError();
     }
     const busyWaitedMs =
-      ifBusy === "wait" && initiallyBusy ? Date.now() - busyStarted : 0;
+      effectiveIfBusy === "wait" && initiallyBusy
+        ? Date.now() - busyStarted
+        : 0;
     const resumed = await client.request(
       "thread/resume",
       { threadId: selectedId, excludeTurns: true },
@@ -405,7 +427,7 @@ export async function askCodexAppServerThread({
     else if (!resumed?.thread && thread.status?.type === "active")
       activeTurns = thread.turns;
     const expectedTurnId =
-      ifBusy === "steer"
+      effectiveIfBusy === "steer"
         ? activeTurns?.findLast((turn) => turn.status === "inProgress")?.id
         : undefined;
     const turn = await runCodexAppServerTurn({
@@ -434,7 +456,7 @@ export async function askCodexAppServerThread({
       status: turn.status,
       commentary: turn.commentary,
       meta: { retries: turn.retries },
-      ifBusy,
+      ifBusy: effectiveIfBusy,
       busyWaitedMs,
       steered: turn.steered,
       socketPath,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@triflux/remote",
-  "version": "10.86.1",
+  "version": "10.88.0",
   "description": "triflux remote — team mode, psmux, MCP workers.",
   "type": "module",
   "main": "hub/index.mjs",

package/scripts/lib/agent-route-policy.mjs

@@ -9,130 +9,134 @@ import {
   resolveCodexProfileConfigValues,
 } from "./codex-profile-config.mjs";
 import { resolveGeminiProfileForPurpose } from "./gemini-profiles.mjs";
+import {
+  modelEffortFromProfile,
+  profileFromModelEffort,
+} from "./model-effort.mjs";
 
 const policy = {
   executor: {
-    profile: "sol_high",
+    codex: { family: "sol", effort: "high" },
     timeoutSec: 1080,
     mcpHint: "implement",
     subcommand: "exec",
   },
   codex: {
-    profile: "sol_high",
+    codex: { family: "sol", effort: "high" },
     timeoutSec: 1080,
     mcpHint: "implement",
     subcommand: "exec",
   },
   "build-fixer": {
-    profile: "luna_high",
+    codex: { family: "luna", effort: "high" },
     timeoutSec: 540,
     mcpHint: "implement",
     subcommand: "exec",
   },
   cleanup: {
-    profile: "sol_med",
+    codex: { family: "sol", effort: "medium" },
     timeoutSec: 540,
     mcpHint: "implement",
     subcommand: "exec",
   },
   deslop: {
-    profile: "sol_med",
+    codex: { family: "sol", effort: "medium" },
     timeoutSec: 540,
     mcpHint: "implement",
     subcommand: "exec",
   },
   debugger: {
-    profile: "astra_xhigh",
+    codex: { family: "astra", effort: "xhigh" },
     timeoutSec: 900,
     mcpHint: "implement",
     subcommand: "exec",
   },
   "deep-executor": {
-    profile: "astra_xhigh",
+    codex: { family: "astra", effort: "xhigh" },
     timeoutSec: 3600,
     mcpHint: "implement",
     subcommand: "exec",
   },
   architect: {
-    profile: "astra_xhigh",
+    codex: { family: "astra", effort: "xhigh" },
     timeoutSec: 3600,
     mcpHint: "analyze",
     subcommand: "exec",
   },
   critic: {
-    profile: "astra_xhigh",
+    codex: { family: "astra", effort: "xhigh" },
     timeoutSec: 3600,
     mcpHint: "analyze",
     subcommand: "exec",
   },
   planner: {
-    profile: "astra_xhigh",
+    codex: { family: "astra", effort: "xhigh" },
     timeoutSec: 3600,
     mcpHint: "analyze",
     subcommand: "exec",
   },
   analyst: {
-    profile: "astra_xhigh",
+    codex: { family: "astra", effort: "xhigh" },
     timeoutSec: 3600,
     mcpHint: "analyze",
     subcommand: "exec",
   },
   "code-reviewer": {
-    profile: "sol_high",
+    codex: { family: "sol", effort: "high" },
     timeoutSec: 1800,
     mcpHint: "review",
     subcommand: "review",
   },
   "quality-reviewer": {
-    profile: "sol_high",
+    codex: { family: "sol", effort: "high" },
     timeoutSec: 1800,
     mcpHint: "review",
     subcommand: "review",
   },
   "security-reviewer": {
-    profile: "astra_xhigh",
+    codex: { family: "astra", effort: "xhigh" },
     timeoutSec: 1800,
     mcpHint: "review",
     subcommand: "review",
   },
   scientist: {
-    profile: "sol_high",
+    codex: { family: "sol", effort: "high" },
     timeoutSec: 1440,
     mcpHint: "analyze",
     subcommand: "exec",
   },
   "document-specialist": {
-    profile: "terra_high",
+    codex: { family: "terra", effort: "high" },
     timeoutSec: 1440,
     mcpHint: "analyze",
     subcommand: "exec",
   },
   "scientist-deep": {
-    profile: "astra_xhigh",
+    codex: { family: "astra", effort: "xhigh" },
     timeoutSec: 3600,
     mcpHint: "analyze",
     subcommand: "exec",
   },
   verifier: {
-    profile: "sol_high",
+    codex: { family: "sol", effort: "high" },
     timeoutSec: 1200,
     mcpHint: "review",
     subcommand: "review",
   },
   "test-engineer": {
-    profile: "sol_high",
+    codex: { family: "sol", effort: "high" },
     timeoutSec: 1200,
     mcpHint: "implement",
     subcommand: "exec",
   },
   "qa-tester": {
-    profile: "sol_high",
+    codex: { family: "sol", effort: "high" },
     timeoutSec: 1200,
     mcpHint: "review",
     subcommand: "review",
   },
   spark: {
-    profile: "luna_low",
+    codex: { family: "luna", effort: "low" },
     timeoutSec: 180,
     mcpHint: "implement",
     subcommand: "exec",
@@ -140,13 +144,13 @@ const policy = {
   // These entries are only for explicit direct-Codex overrides. agent-map.json
   // remains the provider-selection authority for their normal execution.
   designer: {
-    profile: "astra_xhigh",
+    codex: { family: "astra", effort: "xhigh" },
     timeoutSec: 900,
     mcpHint: "implement",
     subcommand: "exec",
   },
   writer: {
-    profile: "terra_high",
+    codex: { family: "terra", effort: "high" },
     timeoutSec: 900,
     mcpHint: "implement",
     subcommand: "exec",
@@ -154,7 +158,11 @@ const policy = {
 };
 
 function freezePolicy(entry) {
-  return Object.freeze({ ...entry });
+  return Object.freeze({
+    ...entry,
+    codex: Object.freeze({ ...entry.codex }),
+    profile: profileFromModelEffort("codex", entry.codex),
+  });
 }
 
 const CODEX_AGENT_POLICY = Object.freeze(
@@ -264,16 +272,16 @@ export function resolveNestedCodexAgentProfile(
       : NESTED_GLOBAL_PROFILE_OVERRIDES.has(globalOverride)
         ? globalOverride
         : "auto";
-  const fallback = resolveCodexAgentProfile(agent);
   const candidate = resolveCodexAgentProfile(agent, {
     profileOverride: effectiveOverride,
     retryProfile,
     nested: true,
     allowCustom: true,
   });
-  const { effort } = resolveCodexProfileConfigValues(candidate, { codexHome });
-  if (!effort) return fallback;
-  return effort.toLowerCase() === "ultra" ? "astra_max" : candidate;
+  const { effort } =
+    modelEffortFromProfile("codex", candidate) ||
+    resolveCodexProfileConfigValues(candidate, { codexHome });
+  return effort?.toLowerCase() === "ultra" ? "astra_max" : candidate;
 }
 
 const EXPECTED_DURATION_BY_AGENT = Object.freeze({
@@ -365,6 +373,7 @@ export function resolveAgentRoute(
       );
     }
   }
+  const { family, effort } = modelEffortFromProfile("codex", resolvedOverride);
   return [
     provider,
     policy.profile,
@@ -378,6 +387,8 @@ export function resolveAgentRoute(
     NATIVE_CODEX_AGENTS.has(agent),
     byAuthor ? reviewAuthor : "",
     usageSwitch,
+    effort,
+    family,
   ];
 }