triflux 10.28.0 → 10.28.1

package/bin/tfx-live.mjs

@@ -42,6 +42,8 @@ function usage() {
     "  tfx-live converse --session NAME --prompts-file PATH [--cli codex|claude] [--remote HOST] [--cwd DIR] [--timeout 60] [--settle 1500]",
     "  tfx-live goal-driven --session NAME --goal TEXT [--cli codex|claude] [--remote HOST] [--cwd DIR] [--timeout 60] [--settle 1500] [--max-rounds 8] [--done-token DONE]",
     "  tfx-live peer [--cli-a codex] [--cli-b claude] [--session-a peerA] [--session-b peerB] [--transport-a tmux|uds|auto] [--transport-b tmux|uds|auto] [--short-a SHORT] [--short-b SHORT] [--session-id-a ID] [--session-id-b ID] [--bridge ABS] [--remote HOST] [--cwd DIR] [--rounds 4] [--mode counting|freeform] [--seed TEXT] [--timeout 60]",
+    "  tfx-live orchestrate --task TEXT [--mode peer|codex-led|claude-led] [--codex-transport exec|app-server-uds] [--cwd DIR] [--timeout 120]",
+    "    Runs the Claude(UDS)+Codex orchestration engine. --codex-transport app-server-uds drives a real `codex app-server` over WebSocket-over-UDS (experimental); default exec keeps the codex stdio one-shot path.",
   ].join("\n");
 }
 
@@ -1690,6 +1692,47 @@ async function peer(flags) {
   printJson(output);
 }
 
+const ORCHESTRATION_MODES = ["peer", "codex-led", "claude-led"];
+const CODEX_ORCH_TRANSPORTS = ["exec", "app-server-uds"];
+
+async function orchestrate(flags) {
+  const mode = flags.mode ?? "peer";
+  if (!ORCHESTRATION_MODES.includes(mode)) {
+    throw new Error(`--mode must be one of: ${ORCHESTRATION_MODES.join(", ")}`);
+  }
+  const task = requireFlag(flags, "task");
+  const codexTransport = flags["codex-transport"] ?? "exec";
+  if (!CODEX_ORCH_TRANSPORTS.includes(codexTransport)) {
+    throw new Error(
+      `--codex-transport must be one of: ${CODEX_ORCH_TRANSPORTS.join(", ")}`,
+    );
+  }
+  const cwd = flags.cwd ?? process.cwd();
+  const timeoutMs = secondsFlag(flags, "timeout", 120_000);
+
+  // Lazy import keeps the orchestration engine (and its hub/team deps) off the
+  // hot path for every other thin-CLI verb; only `orchestrate` pays the cost.
+  const orchestratorUrl = new URL(
+    "../hub/team/uds-orchestrator.mjs",
+    import.meta.url,
+  ).href;
+  const {
+    runUdsOrchestration,
+    createClaudeUdsEndpoint,
+    createCodexExecEndpoint,
+    createCodexAppServerUdsEndpoint,
+  } = await import(orchestratorUrl);
+
+  const claude = createClaudeUdsEndpoint({ cwd, timeoutMs });
+  const codex =
+    codexTransport === "app-server-uds"
+      ? createCodexAppServerUdsEndpoint({ cwd, timeoutMs })
+      : createCodexExecEndpoint({ workdir: cwd, timeout: timeoutMs });
+
+  const result = await runUdsOrchestration({ mode, task, claude, codex });
+  printJson({ codexTransport, ...result });
+}
+
 function printJson(value) {
   process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
 }
@@ -1718,6 +1761,8 @@ async function main() {
     await goalDriven(flags);
   } else if (command === "peer") {
     await peer(flags);
+  } else if (command === "orchestrate") {
+    await orchestrate(flags);
   } else {
     throw new Error(`Unknown subcommand: ${command}\n${usage()}`);
   }

package/hooks/pipeline-stop.mjs

@@ -142,7 +142,7 @@ function contextPercentsFromObject(value) {
   ];
 
   const currentUsage = value.current_usage ?? value.currentUsage ?? {};
-  const maxTokens =
+  const explicitMaxTokens =
     value.context_window_size ??
     value.contextWindowSize ??
     value.max_context_tokens ??
@@ -151,6 +151,18 @@ function contextPercentsFromObject(value) {
     value.maxTokens ??
     value.total_tokens ??
     value.totalTokens;
+  // Fall back to a 1M context window when the payload omits one — Opus 4.x
+  // [1M] and Codex gpt-5.5 both run on a 1M window, and assuming 200K there
+  // false-positives at ~15% real usage. Override via
+  // TFX_CONTEXT_DEFAULT_MAX_TOKENS for narrower setups.
+  const envFallback = Number(process.env.TFX_CONTEXT_DEFAULT_MAX_TOKENS);
+  const fallbackMaxTokens =
+    Number.isFinite(envFallback) && envFallback > 0 ? envFallback : 1_000_000;
+  const explicitNumeric = Number(explicitMaxTokens);
+  const maxTokens =
+    Number.isFinite(explicitNumeric) && explicitNumeric > 0
+      ? explicitNumeric
+      : fallbackMaxTokens;
   candidates.push(
     tokenPercent(value.used_tokens ?? value.usedTokens, maxTokens),
     tokenPercent(

package/hub/team/uds-orchestrator.mjs

@@ -1,7 +1,12 @@
+import { spawn } from "node:child_process";
 import crypto from "node:crypto";
+import { mkdtemp, rm, stat } from "node:fs/promises";
 import net from "node:net";
+import { tmpdir } from "node:os";
+import { join as pathJoin } from "node:path";
 
 import { execute as defaultExecuteCodex } from "../codex-adapter.mjs";
+import { JsonRpcWsUdsClient } from "../workers/lib/jsonrpc-ws-uds.mjs";
 import {
   buildClaudePromptDispatchPayload,
   deriveClaudeDaemonPaths,
@@ -10,6 +15,8 @@ import {
 } from "./claude-daemon-control.mjs";
 
 const DEFAULT_TIMEOUT_MS = 90_000;
+const DEFAULT_CODEX_APP_SERVER_UDS_TIMEOUT_MS = 120_000;
+const DEFAULT_CODEX_APP_SERVER_UDS_BOOTSTRAP_MS = 12_000;
 
 function requireEndpoint(endpoint, name) {
   if (!endpoint || typeof endpoint.ask !== "function") {
@@ -346,3 +353,255 @@ export function createCodexExecEndpoint({
     },
   };
 }
+
+function extractCodexThreadId(result) {
+  if (!result || typeof result !== "object") return null;
+  if (typeof result.threadId === "string") return result.threadId;
+  if (result.thread && typeof result.thread.id === "string") {
+    return result.thread.id;
+  }
+  return null;
+}
+
+async function waitForSocketFile(sockPath, deadlineMs) {
+  const start = Date.now();
+  while (Date.now() - start < deadlineMs) {
+    try {
+      if ((await stat(sockPath)).isSocket()) return true;
+    } catch {
+      /* not bound yet */
+    }
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+  return false;
+}
+
+/**
+ * SIGTERM a child, wait up to graceMs for it to actually exit, then SIGKILL if
+ * still alive. Liveness is `exitCode === null && signalCode === null` — NOT
+ * `child.killed`, which only means "a signal was sent" and would suppress the
+ * SIGKILL fallback when the child ignores SIGTERM.
+ * @param {import('node:child_process').ChildProcess} child
+ * @param {number} [graceMs]
+ */
+async function terminateChild(child, graceMs = 1000) {
+  if (child.exitCode !== null || child.signalCode !== null) return;
+  const exited = new Promise((resolve) => {
+    child.once("exit", () => resolve("exited"));
+  });
+  try {
+    child.kill("SIGTERM");
+  } catch {}
+  const outcome = await Promise.race([
+    exited,
+    new Promise((resolve) => setTimeout(() => resolve("timeout"), graceMs)),
+  ]);
+  if (
+    outcome !== "exited" &&
+    child.exitCode === null &&
+    child.signalCode === null
+  ) {
+    try {
+      child.kill("SIGKILL");
+    } catch {}
+  }
+}
+
+/**
+ * Experimental Codex endpoint that drives a real `codex app-server` over its
+ * WebSocket-over-Unix-Domain-Socket control plane (the symmetric peer of the
+ * Claude daemon `control.sock` path). Same `ask(prompt) -> {endpoint,text,done}`
+ * contract as `createCodexExecEndpoint`, so it is a drop-in for
+ * `runUdsOrchestration`'s `codex` slot — but it is NOT the default.
+ *
+ * Two modes:
+ *   - spawnServer (default): mkdtemp a private socket, spawn
+ *     `codex app-server --listen unix://PATH`, attach, run one turn, tear down.
+ *   - attach (socketPath + spawnServer=false): connect to an already-running
+ *     daemon socket (e.g. $CODEX_HOME/app-server-control/app-server-control.sock).
+ *
+ * Wire transport proven against codex-cli 0.135.0 — see
+ * experiments/native-bridge-feasibility/codex-app-server-uds-smoke.mjs.
+ *
+ * @param {object} [options]
+ * @param {string|null} [options.socketPath] Existing daemon socket to attach to.
+ * @param {boolean} [options.spawnServer] Spawn a private app-server (default true).
+ * @param {string} [options.codexBin]
+ * @param {string} [options.cwd]
+ * @param {string} [options.model]
+ * @param {number} [options.timeoutMs] Turn timeout.
+ * @param {number} [options.bootstrapTimeoutMs] Connect + handshake timeout.
+ * @param {(opts: object) => JsonRpcWsUdsClient} [options.clientFactory]
+ * @param {(command: string, args: string[], options: object) => import('node:child_process').ChildProcess} [options.spawnFn]
+ */
+export function createCodexAppServerUdsEndpoint({
+  socketPath = null,
+  spawnServer = true,
+  codexBin = process.env.CODEX_BIN || "codex",
+  cwd = process.cwd(),
+  model,
+  timeoutMs = DEFAULT_CODEX_APP_SERVER_UDS_TIMEOUT_MS,
+  bootstrapTimeoutMs = DEFAULT_CODEX_APP_SERVER_UDS_BOOTSTRAP_MS,
+  clientFactory = (opts) => new JsonRpcWsUdsClient(opts),
+  spawnFn = spawn,
+} = {}) {
+  return {
+    name: "codex-app-server-uds",
+    async ask(prompt, _meta = {}) {
+      if (typeof prompt !== "string" || !prompt.trim()) {
+        throw new Error(
+          "codex-app-server-uds endpoint requires a non-empty prompt",
+        );
+      }
+
+      let dir = null;
+      let child = null;
+      let client = null;
+      let resolvedSock = socketPath;
+
+      try {
+        if (spawnServer && !socketPath) {
+          dir = await mkdtemp(pathJoin(tmpdir(), "tfx-codex-appserver-uds-"));
+          resolvedSock = pathJoin(dir, "app-server.sock");
+          child = spawnFn(
+            codexBin,
+            ["app-server", "--listen", `unix://${resolvedSock}`],
+            { stdio: ["ignore", "pipe", "pipe"], cwd, env: process.env },
+          );
+          let stderr = "";
+          child.stderr?.on("data", (chunk) => {
+            stderr += String(chunk);
+            if (stderr.length > 8000) stderr = stderr.slice(-8000);
+          });
+          const earlyExit = new Promise((resolve) => {
+            child.once("error", (err) =>
+              resolve(`spawn error: ${err.message}`),
+            );
+            child.once("exit", (code, sig) =>
+              resolve(`exited early code=${code} sig=${sig || ""}`),
+            );
+          });
+          const ready = await Promise.race([
+            waitForSocketFile(resolvedSock, bootstrapTimeoutMs).then((ok) =>
+              ok ? "ready" : "no-socket",
+            ),
+            earlyExit,
+          ]);
+          if (ready !== "ready") {
+            throw new Error(
+              `codex app-server did not bind socket: ${ready}${
+                stderr ? ` — ${stderr.slice(-400)}` : ""
+              }`,
+            );
+          }
+        }
+        if (!resolvedSock) {
+          throw new Error(
+            "codex-app-server-uds endpoint needs socketPath or spawnServer=true",
+          );
+        }
+
+        client = clientFactory({
+          socketPath: resolvedSock,
+          connectTimeoutMs: bootstrapTimeoutMs,
+        });
+        await client.connect();
+        await client.request(
+          "initialize",
+          { clientInfo: { name: "triflux-tfx-live", version: "1.0.0" } },
+          bootstrapTimeoutMs,
+        );
+        client.notify("initialized", {});
+
+        const threadParams = {
+          sandbox: "read-only",
+          approvalPolicy: "never",
+          ephemeral: true,
+        };
+        if (typeof model === "string" && model) threadParams.model = model;
+        if (cwd) threadParams.cwd = cwd;
+        const threadStart = await client.request(
+          "thread/start",
+          threadParams,
+          bootstrapTimeoutMs,
+        );
+        const threadId = extractCodexThreadId(threadStart);
+        if (!threadId) {
+          throw new Error(
+            "codex app-server thread/start returned no thread id",
+          );
+        }
+
+        const parts = [];
+        let offDelta = () => {};
+        let offError = () => {};
+        let offDone = () => {};
+        const cleanup = () => {
+          offDelta();
+          offError();
+          offDone();
+        };
+        const completion = new Promise((resolve) => {
+          offDelta = client.onNotification(
+            "item/agentMessage/delta",
+            (params) => {
+              if (typeof params?.delta === "string") parts.push(params.delta);
+            },
+          );
+          offError = client.onNotification("error", (params) => {
+            cleanup();
+            resolve({
+              status: "failed",
+              message: params?.message || "codex app-server error",
+            });
+          });
+          offDone = client.onNotification("turn/completed", (params) => {
+            cleanup();
+            resolve({ status: params?.turn?.status || "unknown" });
+          });
+        });
+
+        await client.request(
+          "turn/start",
+          { threadId, input: [{ type: "text", text: prompt }] },
+          timeoutMs,
+        );
+        let timeoutHandle = null;
+        const timeoutPromise = new Promise((resolve) => {
+          timeoutHandle = setTimeout(() => {
+            cleanup();
+            resolve({ status: "timeout" });
+          }, timeoutMs);
+        });
+        let settled;
+        try {
+          settled = await Promise.race([completion, timeoutPromise]);
+        } finally {
+          // Clear the timer whichever side won, so a completed turn does not
+          // keep the event loop alive until timeoutMs.
+          if (timeoutHandle) clearTimeout(timeoutHandle);
+        }
+
+        return {
+          endpoint: "codex-app-server-uds",
+          text: parts.join("").trim(),
+          done: settled.status === "completed",
+          meta: {
+            threadId,
+            status: settled.status,
+            socketPath: resolvedSock,
+            spawned: Boolean(child),
+            ...(settled.message ? { error: settled.message } : {}),
+          },
+        };
+      } finally {
+        try {
+          client?.close();
+        } catch {}
+        if (child) await terminateChild(child);
+        if (dir)
+          await rm(dir, { recursive: true, force: true }).catch(() => {});
+      }
+    },
+  };
+}

package/hub/workers/codex-app-server-worker.mjs

@@ -160,8 +160,11 @@ export const KIND_MAP = Object.freeze({
   configWarning: "error",
 });
 
+// NOTE: codex 0.135.0 rejects `--skip-git-repo-check` as a global option (exit 2:
+// "unexpected argument"); it lives at `codex exec` subcommand scope, and the
+// `app-server` subcommand does not need it. Empirically verified against
+// codex-cli 0.135.0. Do not re-add it as a global flag here.
 export const DEFAULT_CODEX_APP_SERVER_ARGS = Object.freeze([
-  "--skip-git-repo-check",
   "app-server",
   "--listen",
   "stdio://",

package/hub/workers/lib/jsonrpc-ws-uds.mjs

@@ -0,0 +1,686 @@
+// hub/workers/lib/jsonrpc-ws-uds.mjs
+// JSON-RPC 2.0 client over WebSocket-over-Unix-Domain-Socket.
+//
+// codex `app-server --listen unix://PATH` does NOT speak newline-delimited JSON
+// on the socket — it speaks WebSocket (RFC 6455) after a standard HTTP/1.1
+// Upgrade handshake, one JSON-RPC message per text frame. Confirmed live against
+// codex-cli 0.135.0 (see experiments/native-bridge-feasibility/
+// codex-app-server-uds-probe.mjs). This is the UDS sibling of the stdio
+// `JsonRpcStdioClient`: same public surface (request/notify/onNotification/
+// close/isOpen), different framing.
+//
+// Wire framing notes:
+//   - client -> server frames MUST be masked (RFC 6455 §5.3).
+//   - server -> client frames are unmasked.
+//   - one JSON-RPC object per text frame; fragmented frames are reassembled.
+//   - outbound JSON-RPC omits the `"jsonrpc":"2.0"` header (OpenAI App Server
+//     JSONL variant), matching JsonRpcStdioClient.
+//
+// Zero new dependencies — minimal hand-rolled WS client (no `ws` package).
+
+import { createHash, randomBytes } from "node:crypto";
+import net from "node:net";
+
+import {
+  JsonRpcProtocolError,
+  JsonRpcTransportError,
+} from "./jsonrpc-stdio.mjs";
+
+const WS_GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
+const DEFAULT_MAX_FRAME_SIZE = 16 * 1024 * 1024; // 16 MiB
+const DEFAULT_CONNECT_TIMEOUT_MS = 10_000;
+// After a graceful close("closing") we wait this long for the peer's close/EOF
+// before force-destroying the socket so a silent peer cannot pin it open.
+const CLOSING_DEADLINE_MS = 2_000;
+const MAX_CONTROL_PAYLOAD = 125; // RFC 6455 §5.5: control frames <=125 bytes
+const CLOSED_MESSAGE = "JsonRpcWsUdsClient closed";
+
+// RFC 6455 opcodes
+const OP_CONTINUATION = 0x0;
+const OP_TEXT = 0x1;
+const OP_BINARY = 0x2;
+const OP_CLOSE = 0x8;
+const OP_PING = 0x9;
+const OP_PONG = 0xa;
+
+/**
+ * Encode a single client->server WebSocket frame (always masked).
+ * @param {number} opcode
+ * @param {Buffer} payload
+ * @returns {Buffer}
+ */
+function encodeClientFrame(opcode, payload) {
+  const len = payload.length;
+  const mask = randomBytes(4);
+  let header;
+  if (len < 126) {
+    header = Buffer.from([0x80 | opcode, 0x80 | len]);
+  } else if (len < 65536) {
+    header = Buffer.alloc(4);
+    header[0] = 0x80 | opcode;
+    header[1] = 0x80 | 126;
+    header.writeUInt16BE(len, 2);
+  } else {
+    header = Buffer.alloc(10);
+    header[0] = 0x80 | opcode;
+    header[1] = 0x80 | 127;
+    header.writeBigUInt64BE(BigInt(len), 2);
+  }
+  const masked = Buffer.allocUnsafe(len);
+  for (let i = 0; i < len; i++) masked[i] = payload[i] ^ mask[i % 4];
+  return Buffer.concat([header, mask, masked]);
+}
+
+/**
+ * JSON-RPC 2.0 client over WebSocket-over-UDS.
+ */
+export class JsonRpcWsUdsClient {
+  /**
+   * @param {object} options
+   * @param {string} options.socketPath Absolute path to the AF_UNIX socket.
+   * @param {(err: Error) => void} [options.onError]
+   * @param {number} [options.maxFrameSize] Max bytes per inbound frame payload.
+   * @param {number} [options.connectTimeoutMs]
+   */
+  constructor({
+    socketPath,
+    onError,
+    maxFrameSize = DEFAULT_MAX_FRAME_SIZE,
+    connectTimeoutMs = DEFAULT_CONNECT_TIMEOUT_MS,
+  } = {}) {
+    if (typeof socketPath !== "string" || !socketPath) {
+      throw new TypeError("JsonRpcWsUdsClient requires a socketPath string");
+    }
+    this._socketPath = socketPath;
+    this._onError = typeof onError === "function" ? onError : null;
+    this._maxFrameSize =
+      Number.isFinite(maxFrameSize) && maxFrameSize > 0
+        ? maxFrameSize
+        : DEFAULT_MAX_FRAME_SIZE;
+    this._connectTimeoutMs = Number.isFinite(connectTimeoutMs)
+      ? connectTimeoutMs
+      : DEFAULT_CONNECT_TIMEOUT_MS;
+
+    /** @type {'idle'|'running'|'closing'|'closed'} */
+    this._state = "idle";
+    this._socket = null;
+    this._nextRequestId = 1;
+    /** @type {Map<number, { resolve: Function, reject: Function, timer: any, method: string }>} */
+    this._pendingRequests = new Map();
+    /** @type {Map<string, Set<Function>>} */
+    this._notificationHandlers = new Map();
+
+    // RX framing state
+    this._rxBuf = Buffer.alloc(0);
+    /** @type {Buffer[]} accumulated payloads of a fragmented message */
+    this._fragmentChunks = [];
+    /** @type {number|null} opcode of the in-progress fragmented message */
+    this._fragmentOpcode = null;
+    this._fragmentSize = 0;
+    /** @type {ReturnType<typeof setTimeout>|null} */
+    this._closingTimer = null;
+  }
+
+  /**
+   * Open the socket and complete the WebSocket HTTP Upgrade handshake.
+   * Resolves once the connection is in the `running` state.
+   * @returns {Promise<void>}
+   */
+  connect() {
+    if (this._state !== "idle") {
+      return Promise.reject(
+        new Error(
+          `JsonRpcWsUdsClient.connect() invalid in state ${this._state}`,
+        ),
+      );
+    }
+    return new Promise((resolve, reject) => {
+      const key = randomBytes(16).toString("base64");
+      const expectedAccept = createHash("sha1")
+        .update(key + WS_GUID)
+        .digest("base64");
+      let handshakeBuf = Buffer.alloc(0);
+      let settled = false;
+
+      const socket = net.connect(this._socketPath);
+      this._socket = socket;
+
+      const timer = setTimeout(() => {
+        if (settled) return;
+        settled = true;
+        try {
+          socket.destroy();
+        } catch {}
+        this._state = "closed";
+        reject(
+          new JsonRpcTransportError(
+            `WebSocket-over-UDS connect timed out after ${this._connectTimeoutMs}ms: ${this._socketPath}`,
+          ),
+        );
+      }, this._connectTimeoutMs);
+
+      const onConnectError = (err) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        this._state = "closed";
+        reject(
+          new JsonRpcTransportError(
+            `WebSocket-over-UDS connect error: ${err?.message || err}`,
+            { cause: err },
+          ),
+        );
+      };
+
+      socket.once("error", onConnectError);
+      socket.on("connect", () => {
+        const req =
+          "GET / HTTP/1.1\r\n" +
+          "Host: localhost\r\n" +
+          "Upgrade: websocket\r\n" +
+          "Connection: Upgrade\r\n" +
+          `Sec-WebSocket-Key: ${key}\r\n` +
+          "Sec-WebSocket-Version: 13\r\n\r\n";
+        socket.write(req);
+      });
+
+      const onHandshakeData = (chunk) => {
+        if (settled) return;
+        handshakeBuf = Buffer.concat([handshakeBuf, chunk]);
+        const sep = handshakeBuf.indexOf("\r\n\r\n");
+        if (sep < 0) {
+          if (handshakeBuf.length > 64 * 1024) {
+            settled = true;
+            clearTimeout(timer);
+            socket.removeListener("error", onConnectError);
+            socket.removeListener("data", onHandshakeData);
+            try {
+              socket.destroy();
+            } catch {}
+            this._state = "closed";
+            reject(
+              new JsonRpcProtocolError(
+                "WebSocket handshake response headers exceeded 64 KiB",
+              ),
+            );
+          }
+          return;
+        }
+        const rawHeaders = handshakeBuf.subarray(0, sep).toString("utf8");
+        const leftover = handshakeBuf.subarray(sep + 4);
+
+        const lines = rawHeaders.split("\r\n");
+        const ok101 = /^HTTP\/1\.\d 101/.test(lines[0] || "");
+        const headerMap = new Map();
+        for (let i = 1; i < lines.length; i++) {
+          const idx = lines[i].indexOf(":");
+          if (idx < 0) continue;
+          headerMap.set(
+            lines[i].slice(0, idx).trim().toLowerCase(),
+            lines[i].slice(idx + 1).trim(),
+          );
+        }
+        const acceptOk =
+          headerMap.get("sec-websocket-accept") === expectedAccept;
+
+        if (!ok101 || !acceptOk) {
+          settled = true;
+          clearTimeout(timer);
+          socket.removeListener("error", onConnectError);
+          socket.removeListener("data", onHandshakeData);
+          try {
+            socket.destroy();
+          } catch {}
+          this._state = "closed";
+          reject(
+            new JsonRpcProtocolError(
+              `WebSocket upgrade rejected (status101=${ok101}, acceptValid=${acceptOk})`,
+            ),
+          );
+          return;
+        }
+
+        // Handshake complete — switch to running and wire frame handling.
+        settled = true;
+        clearTimeout(timer);
+        socket.removeListener("error", onConnectError);
+        socket.removeListener("data", onHandshakeData);
+        this._state = "running";
+
+        socket.on("data", (buf) => this._onSocketData(buf));
+        socket.on("error", (err) => this._handleStreamError("socket", err));
+        socket.on("close", () => {
+          if (this._state === "running") {
+            const err = new JsonRpcTransportError(
+              "WebSocket-over-UDS closed unexpectedly (EOF during running)",
+            );
+            this._emitError(err);
+            this._closeWith("closed", err);
+          } else if (this._state !== "closed") {
+            this._closeWith("closed");
+          }
+        });
+
+        if (leftover.length > 0) {
+          this._rxBuf = Buffer.concat([this._rxBuf, leftover]);
+          this._drainFrames();
+        }
+        resolve();
+      };
+
+      socket.on("data", onHandshakeData);
+    });
+  }
+
+  /**
+   * Issue a JSON-RPC request and resolve with the server's `result`.
+   * @param {string} method
+   * @param {unknown} params
+   * @param {number} [timeoutMs=60000]
+   * @returns {Promise<any>}
+   */
+  request(method, params, timeoutMs = 60000) {
+    if (this._state !== "running") {
+      return Promise.reject(new Error(CLOSED_MESSAGE));
+    }
+    const id = this._nextRequestId++;
+    const frame = { id, method };
+    if (params !== undefined) frame.params = params;
+
+    return new Promise((resolve, reject) => {
+      let timer = null;
+      if (Number.isFinite(timeoutMs) && timeoutMs > 0) {
+        timer = setTimeout(() => {
+          const pending = this._pendingRequests.get(id);
+          if (!pending) return;
+          this._pendingRequests.delete(id);
+          reject(
+            new Error(
+              `JSON-RPC request timed out after ${timeoutMs}ms: ${method}`,
+            ),
+          );
+        }, timeoutMs);
+      }
+      this._pendingRequests.set(id, { resolve, reject, timer, method });
+      try {
+        this._sendText(JSON.stringify(frame));
+      } catch (err) {
+        this._pendingRequests.delete(id);
+        if (timer) clearTimeout(timer);
+        reject(err);
+      }
+    });
+  }
+
+  /**
+   * Send a JSON-RPC notification (no id, no response).
+   * @param {string} method
+   * @param {unknown} [params]
+   */
+  notify(method, params) {
+    if (this._state !== "running") return;
+    const frame = { method };
+    if (params !== undefined) frame.params = params;
+    try {
+      this._sendText(JSON.stringify(frame));
+    } catch (err) {
+      this._emitError(err instanceof Error ? err : new Error(String(err)));
+    }
+  }
+
+  /**
+   * Subscribe to inbound notifications. `"*"` = catch-all receiving
+   * `(params, method)`; targeted handlers receive `(params)`.
+   * @param {string} method
+   * @param {(params: any, method?: string) => void} callback
+   * @returns {() => void} unsubscribe
+   */
+  onNotification(method, callback) {
+    if (typeof callback !== "function") {
+      throw new TypeError("onNotification requires a callback function");
+    }
+    let set = this._notificationHandlers.get(method);
+    if (!set) {
+      set = new Set();
+      this._notificationHandlers.set(method, set);
+    }
+    set.add(callback);
+    return () => {
+      const handlers = this._notificationHandlers.get(method);
+      if (!handlers) return;
+      handlers.delete(callback);
+      if (handlers.size === 0) this._notificationHandlers.delete(method);
+    };
+  }
+
+  /**
+   * Close the client. `reason === "closing"` transitions to an intermediate
+   * graceful state where a subsequent EOF is treated as normal. Idempotent.
+   * @param {string} [reason]
+   */
+  close(reason) {
+    if (this._state === "closed") return;
+    if (reason === "closing" && this._state === "running") {
+      this._state = "closing";
+      // best-effort WS close frame
+      try {
+        this._socket?.write(encodeClientFrame(OP_CLOSE, Buffer.alloc(0)));
+      } catch {}
+      // Arm a deadline so a peer that never replies with close/EOF cannot pin
+      // the socket + pending requests open forever.
+      this._closingTimer = setTimeout(() => {
+        if (this._state === "closing") this._closeWith("closed");
+      }, CLOSING_DEADLINE_MS);
+      if (typeof this._closingTimer.unref === "function") {
+        this._closingTimer.unref();
+      }
+      return;
+    }
+    this._closeWith("closed");
+  }
+
+  /** @returns {boolean} */
+  isOpen() {
+    return this._state === "running";
+  }
+
+  /** @returns {'idle'|'running'|'closing'|'closed'} */
+  getState() {
+    return this._state;
+  }
+
+  // --- internals ---------------------------------------------------------
+
+  _sendText(text) {
+    if (this._state === "closed") throw new Error(CLOSED_MESSAGE);
+    const frame = encodeClientFrame(OP_TEXT, Buffer.from(text, "utf8"));
+    this._socket.write(frame, (err) => {
+      if (err) this._handleStreamError("socket-write", err);
+    });
+  }
+
+  _onSocketData(chunk) {
+    if (this._state === "closed") return;
+    this._rxBuf = Buffer.concat([this._rxBuf, chunk]);
+    this._drainFrames();
+  }
+
+  /**
+   * Parse as many complete WebSocket frames as are buffered. Control frames
+   * (ping/pong/close) are handled inline; text/continuation frames are
+   * reassembled into a full JSON-RPC message before dispatch.
+   */
+  _drainFrames() {
+    while (this._rxBuf.length >= 2) {
+      const b0 = this._rxBuf[0];
+      const b1 = this._rxBuf[1];
+      const fin = (b0 & 0x80) !== 0;
+      const opcode = b0 & 0x0f;
+      const masked = (b1 & 0x80) !== 0;
+      let len = b1 & 0x7f;
+      let cursor = 2;
+
+      if (len === 126) {
+        if (this._rxBuf.length < cursor + 2) return;
+        len = this._rxBuf.readUInt16BE(cursor);
+        cursor += 2;
+      } else if (len === 127) {
+        if (this._rxBuf.length < cursor + 8) return;
+        const big = this._rxBuf.readBigUInt64BE(cursor);
+        if (big > BigInt(this._maxFrameSize)) {
+          const err = new JsonRpcProtocolError(
+            `WebSocket frame payload ${big} exceeds max ${this._maxFrameSize}`,
+          );
+          this._emitError(err);
+          this._closeWith("closed", err);
+          return;
+        }
+        len = Number(big);
+        cursor += 8;
+      }
+
+      if (len > this._maxFrameSize) {
+        const err = new JsonRpcProtocolError(
+          `WebSocket frame payload ${len} exceeds max ${this._maxFrameSize}`,
+        );
+        this._emitError(err);
+        this._closeWith("closed", err);
+        return;
+      }
+
+      // RFC 6455 §5.1: server -> client frames MUST NOT be masked.
+      if (masked) {
+        this._protocolClose("WebSocket server frame is masked (RFC 6455 §5.1)");
+        return;
+      }
+      if (this._rxBuf.length < cursor + len) return; // wait for full payload
+
+      // Detach from rxBuf before we slice it off.
+      const payload = Buffer.from(this._rxBuf.subarray(cursor, cursor + len));
+      this._rxBuf = this._rxBuf.subarray(cursor + len);
+
+      this._handleFrame(fin, opcode, payload);
+      if (this._state === "closed") return;
+    }
+  }
+
+  _handleFrame(fin, opcode, payload) {
+    // Control frames (>=0x8): must be FIN and <=125 bytes (RFC 6455 §5.5).
+    if (opcode >= 0x8) {
+      if (!fin || payload.length > MAX_CONTROL_PAYLOAD) {
+        this._protocolClose(
+          `Invalid control frame (opcode 0x${opcode.toString(16)}, fin=${fin}, len=${payload.length})`,
+        );
+        return;
+      }
+      if (opcode === OP_PING) {
+        try {
+          this._socket?.write(encodeClientFrame(OP_PONG, payload));
+        } catch {}
+        return;
+      }
+      if (opcode === OP_PONG) return;
+      if (opcode === OP_CLOSE) {
+        if (this._state === "running") {
+          const err = new JsonRpcTransportError(
+            "WebSocket server sent close frame",
+          );
+          this._emitError(err);
+          this._closeWith("closed", err);
+        } else {
+          this._closeWith("closed");
+        }
+        return;
+      }
+      this._protocolClose(`Unknown control opcode 0x${opcode.toString(16)}`);
+      return;
+    }
+
+    // Data frames: text / binary (message start) or continuation.
+    if (opcode === OP_TEXT || opcode === OP_BINARY) {
+      if (this._fragmentOpcode !== null) {
+        this._protocolClose(
+          "New data frame received while a fragmented message is active",
+        );
+        return;
+      }
+      if (opcode === OP_BINARY) {
+        this._protocolClose(
+          "Binary frames are not supported (expected text JSON-RPC)",
+        );
+        return;
+      }
+      if (fin) {
+        this._handleMessage(payload.toString("utf8"));
+        return;
+      }
+      this._fragmentOpcode = opcode;
+      this._fragmentChunks = [payload];
+      this._fragmentSize = payload.length;
+      return;
+    }
+
+    if (opcode === OP_CONTINUATION) {
+      if (this._fragmentOpcode === null) {
+        this._protocolClose(
+          "Continuation frame with no active fragmented message",
+        );
+        return;
+      }
+      this._fragmentSize += payload.length;
+      if (this._fragmentSize > this._maxFrameSize) {
+        this._protocolClose(
+          `Fragmented message ${this._fragmentSize} exceeds max ${this._maxFrameSize}`,
+        );
+        return;
+      }
+      this._fragmentChunks.push(payload);
+      if (!fin) return;
+      const full = Buffer.concat(this._fragmentChunks);
+      this._fragmentChunks = [];
+      this._fragmentOpcode = null;
+      this._fragmentSize = 0;
+      this._handleMessage(full.toString("utf8"));
+      return;
+    }
+
+    this._protocolClose(`Unknown WebSocket opcode 0x${opcode.toString(16)}`);
+  }
+
+  _protocolClose(message) {
+    const err = new JsonRpcProtocolError(message);
+    this._emitError(err);
+    this._closeWith("closed", err);
+  }
+
+  _handleMessage(line) {
+    if (this._state === "closed") return;
+    if (line.length === 0) return;
+
+    let frame;
+    try {
+      frame = JSON.parse(line);
+    } catch (err) {
+      const pErr = new JsonRpcProtocolError(
+        `JSON-RPC parse error: ${err instanceof Error ? err.message : String(err)}`,
+        { cause: err },
+      );
+      this._emitError(pErr);
+      if (this._state === "running") this._closeWith("closed", pErr);
+      return;
+    }
+
+    if (!frame || typeof frame !== "object") {
+      const pErr = new JsonRpcProtocolError(
+        "JSON-RPC protocol error: frame is not an object",
+      );
+      this._emitError(pErr);
+      if (this._state === "running") this._closeWith("closed", pErr);
+      return;
+    }
+
+    if (
+      Object.hasOwn(frame, "id") &&
+      frame.id !== null &&
+      (Object.hasOwn(frame, "result") || Object.hasOwn(frame, "error"))
+    ) {
+      this._dispatchResponse(frame);
+      return;
+    }
+
+    if (typeof frame.method === "string" && !Object.hasOwn(frame, "id")) {
+      this._dispatchNotification(frame);
+      return;
+    }
+
+    this._emitError(
+      new JsonRpcProtocolError(
+        "JSON-RPC protocol error: unrecognized frame shape",
+      ),
+    );
+  }
+
+  _dispatchResponse(frame) {
+    const pending = this._pendingRequests.get(frame.id);
+    if (!pending) return;
+    this._pendingRequests.delete(frame.id);
+    if (pending.timer) clearTimeout(pending.timer);
+
+    if (Object.hasOwn(frame, "error") && frame.error) {
+      const { code, message, data } = frame.error;
+      const err = new Error(
+        `JSON-RPC error${typeof code === "number" ? ` ${code}` : ""}: ${message || "unknown"}`,
+      );
+      if (code !== undefined) err.code = code;
+      if (data !== undefined) err.data = data;
+      pending.reject(err);
+      return;
+    }
+    pending.resolve(frame.result);
+  }
+
+  _dispatchNotification(frame) {
+    const { method, params } = frame;
+    const targeted = this._notificationHandlers.get(method);
+    if (targeted && targeted.size > 0) {
+      for (const cb of targeted) {
+        try {
+          cb(params);
+        } catch (err) {
+          this._emitError(err instanceof Error ? err : new Error(String(err)));
+        }
+      }
+    }
+    const wildcard = this._notificationHandlers.get("*");
+    if (wildcard && wildcard.size > 0) {
+      for (const cb of wildcard) {
+        try {
+          cb(params, method);
+        } catch (err) {
+          this._emitError(err instanceof Error ? err : new Error(String(err)));
+        }
+      }
+    }
+  }
+
+  _handleStreamError(which, err) {
+    if (this._state === "closed") return;
+    const base = err instanceof Error ? err : new Error(String(err));
+    const wrapped = new JsonRpcTransportError(
+      `WebSocket-over-UDS stream error on ${which}: ${base.message}`,
+      { cause: base },
+    );
+    this._emitError(wrapped);
+    this._closeWith("closed", wrapped);
+  }
+
+  _closeWith(target, rejectReason = null) {
+    if (this._state === "closed") return;
+    this._state = target;
+    if (this._closingTimer) {
+      clearTimeout(this._closingTimer);
+      this._closingTimer = null;
+    }
+    const rejectErr =
+      rejectReason instanceof Error ? rejectReason : new Error(CLOSED_MESSAGE);
+    for (const [, pending] of this._pendingRequests) {
+      if (pending.timer) clearTimeout(pending.timer);
+      pending.reject(rejectErr);
+    }
+    this._pendingRequests.clear();
+    try {
+      this._socket?.destroy();
+    } catch {}
+  }
+
+  _emitError(err) {
+    if (!this._onError) return;
+    try {
+      this._onError(err);
+    } catch {
+      /* never throw out of the dispatch loop */
+    }
+  }
+}
+
+export default JsonRpcWsUdsClient;

package/hud/context-monitor.mjs

@@ -288,11 +288,16 @@ export function buildContextUsageView(stdin, snapshot = null) {
   const modelHintLimit = resolveModelLimit(modelId);
   const monitorLimit = Number(monitor?.limitTokens || 0);
   const stdinLimit = stdinUsage?.limitTokens;
+  // When a model id is known it is the authoritative per-model ceiling: the
+  // monitor's cached limitTokens is just a default-derived accumulator (now 1M
+  // by default) and must not override a known model's real window in either
+  // direction — it would inflate a 200K model (Sonnet 4.5 / Haiku) up to 1M.
+  // The model hint already upgrades a stale-low monitor on its own (#88).
   const limitTokens =
     stdinLimit != null && stdinLimit > 0
       ? Math.max(1, stdinLimit)
       : modelId
-        ? Math.max(1, monitorLimit, modelHintLimit)
+        ? Math.max(1, modelHintLimit)
         : Math.max(1, monitorLimit || modelHintLimit);
 
   const usedTokens = stdinUsage?.usedTokens ?? Number(monitor?.usedTokens || 0);
@@ -324,7 +329,19 @@ export function buildContextUsageView(stdin, snapshot = null) {
 }
 
 export function createContextMonitor(options = {}) {
-  const limitTokens = Number(options.limitTokens || DEFAULT_CONTEXT_LIMIT);
+  // Default to a 1M context window (Opus 4.x [1M] / Codex gpt-5.5 both run on
+  // a 1M window) when no explicit limit is supplied, so the cached percent the
+  // Stop hook reads is not inflated against a 200K assumption — assuming 200K
+  // there false-positives at ~15% real usage and blocks legitimate stops.
+  // Narrower setups override via TFX_CONTEXT_DEFAULT_MAX_TOKENS.
+  const explicitLimit = Number(options.limitTokens);
+  const envLimit = Number(process.env.TFX_CONTEXT_DEFAULT_MAX_TOKENS);
+  const limitTokens =
+    Number.isFinite(explicitLimit) && explicitLimit > 0
+      ? explicitLimit
+      : Number.isFinite(envLimit) && envLimit > 0
+        ? envLimit
+        : MILLION_CONTEXT_LIMIT;
   const cachePath = options.cachePath || CONTEXT_MONITOR_CACHE_PATH;
   const logsDir = options.logsDir || CONTEXT_MONITOR_LOG_DIR;
   const sessionId = options.sessionId || randomUUID().slice(0, 8);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "triflux",
-  "version": "10.28.0",
+  "version": "10.28.1",
   "description": "CLI-first multi-model orchestrator for Claude Code — route tasks to Codex, Antigravity, and Claude",
   "type": "module",
   "bin": {

package/scripts/release/prepare.mjs

@@ -15,10 +15,10 @@ import {
 const TEST_TIMEOUT_MS = 10 * 60 * 1000;
 const STALE_LOCK = join(ROOT, ".test-lock", "pid.lock");
 
-export function cleanupStaleTestLock() {
-  if (!existsSync(STALE_LOCK)) return;
+export function cleanupStaleTestLock(lockPath = STALE_LOCK) {
+  if (!existsSync(lockPath)) return;
   try {
-    rmSync(STALE_LOCK, { force: true });
+    rmSync(lockPath, { force: true });
     console.log("[prepare] cleaned stale .test-lock/pid.lock");
   } catch (e) {
     console.warn(`[prepare] failed to clean test-lock: ${e.message}`);
@@ -41,7 +41,10 @@ export async function prepareRelease({
   skipTests = false,
   execFileSyncFn,
 } = {}) {
-  cleanupStaleTestLock();
+  // Derive the preflight lock from rootDir so tests that pass a temp rootDir
+  // never delete the live repo-root .test-lock/pid.lock owned by the running
+  // test-lock.mjs wrapper. Production (rootDir = ROOT) is unchanged.
+  cleanupStaleTestLock(join(rootDir, ".test-lock", "pid.lock"));
   const logStep = createStepLogger();
   logStep("version-sync");
   const sync = assertVersionSync({ rootDir });

package/skills/tfx-live/SKILL.md

@@ -76,6 +76,25 @@ tfx-live peer --cli-a codex --cli-b claude \
 
 In `peer`, every hop sends the previous response as the next prompt to the opposite agent; the final JSON is only the transcript.
 
+## Orchestrate (Claude UDS + Codex)
+
+`orchestrate` exposes the `runUdsOrchestration` engine as a formal verb: Claude is driven over the daemon control socket (UDS) and Codex over a selectable transport, in one of three shapes.
+
+```bash
+# default: Codex over the stdio one-shot path (codex exec)
+tfx-live orchestrate --task "이 변경의 위험을 한 줄로" --mode peer
+
+# experimental: Codex over a real `codex app-server` WebSocket-over-UDS daemon
+tfx-live orchestrate --task "이 변경의 위험을 한 줄로" \
+  --mode codex-led --codex-transport app-server-uds --timeout 120
+```
+
+- `--mode` = `peer` (default) | `codex-led` | `claude-led`.
+- `--codex-transport` = `exec` (default, `codex exec` stdio) | `app-server-uds` (experimental).
+  - `app-server-uds` spawns a private `codex app-server --listen unix://<tmp>`, attaches over WebSocket-over-UDS (RFC 6455, masked client frames), runs `initialize`→`thread/start`→`turn/start`, and resolves on `turn/completed`. Transport proven against codex-cli 0.135.0 (see `experiments/native-bridge-feasibility/codex-app-server-uds-smoke.mjs`).
+  - It is NOT the default — the existing `codex exec` path is unchanged.
+- Requires a live Claude daemon (same as the UDS `ask` path) for the Claude side.
+
 ## Useful diagnostics
 
 ```bash

package/skills/tfx-research/SKILL.md

@@ -1,7 +1,7 @@
 ---
 internal: true
 name: tfx-research
-description: "웹 검색/리서치가 필요할 때 사용한다. '검색해줘', '찾아봐', '최신 정보', '이거 뭐야', '심층 조사', '자세히 알아봐', 'deep research', '전면 리서치', '자율 리서치', '조사해', 'research and plan' 같은 요청에 반드시 사용. 추가로 'X 있나?', 'X 쓸 수 있나?', 'X 풀려있어?', 'X 어떻게 쓰는지', 'X 가능한가?', '방법 있나?', 'X 살아있나?' 같은 도구·기능 존재/사용법/상태 의문문에도 사용. 기본값은 3-CLI 멀티소스(Exa+Brave+Tavily) 합의 딥 리서치. 빠른 Antigravity Google Search 는 --quick. 자율 쿼리생성+보고서 모드는 --auto."
+description: "웹 검색/리서치가 필요할 때 사용한다. '검색해줘', '찾아봐', '최신 정보', '이거 뭐야', '심층 조사', '자세히 알아봐', 'deep research', '전면 리서치', '자율 리서치', '조사해', 'research and plan' 같은 요청에 반드시 사용. 추가로 'X 있나?', 'X 쓸 수 있나?', 'X 풀려있어?', 'X 어떻게 쓰는지', 'X 가능한가?', '방법 있나?', 'X 살아있나?' 같은 도구·기능 존재/사용법/상태 의문문에도 사용. 기본값은 2-CLI 멀티소스(Exa+Brave) 합의 딥 리서치. 빠른 Antigravity Google Search 는 --quick. 자율 쿼리생성+보고서 모드는 --auto."
 triggers:
   - tfx-research
   - 리서치
@@ -23,7 +23,7 @@ argument-hint: "<주제> [--quick | --auto] [--depth quick|standard|deep]"
 
 > **ARGUMENTS 처리**: `--quick` → Quick. `--auto` → Auto. 그 외 → Deep (기본).
 
-> AI makes completeness near-free. 기본은 Claude(Exa/학술) + Codex(Brave/실용) + Antigravity(Tavily/DX) 3-CLI 멀티소스 교차검증 합의.
+> AI makes completeness near-free. 기본은 Claude(Exa/학술) + Codex(Brave/실용) 2-CLI 멀티소스 교차검증 합의 (Antigravity/Tavily는 agy --print idle 미도달 행으로 Deep 제외; Quick 단일 검색만 유지).
 > 빠른 단일 Google Search 는 `--quick`. 자율 쿼리생성+구조화 보고서 는 `--auto`.
 
 ---
@@ -32,7 +32,7 @@ argument-hint: "<주제> [--quick | --auto] [--depth quick|standard|deep]"
 
 | 플래그 | 모드 | 특징 |
 |--------|------|------|
-| (없음) | **Deep** (기본) | 3-CLI 멀티소스 교차검증, consensus score |
+| (없음) | **Deep** (기본) | 2-CLI 멀티소스 교차검증, consensus score |
 | `--quick` | Quick | Antigravity 단일 Google Search |
 | `--auto` | Auto | 자율 쿼리생성(3-5개) + 검색 + 구조화 보고서 |
 
@@ -52,7 +52,6 @@ argument-hint: "<주제> [--quick | --auto] [--depth quick|standard|deep]"
 |-----|-----|------|
 | Claude | Exa (neural semantic) | 학술/기술 깊이, 공식 문서, 벤치마크 |
 | Codex | Brave Search | 실용/구현/산업 사례 |
-| Antigravity | Tavily | 비용/운영/DX |
 
 ### Depth 모드 (`--depth` 플래그)
 
@@ -71,7 +70,7 @@ argument-hint: "<주제> [--quick | --auto] [--depth quick|standard|deep]"
 - depth 에 따른 서브쿼리 생성
 - 각 쿼리에 관점(학술/실용/DX) 매핑
 
-#### Step 2: 3-CLI 독립 병렬 검색 (Anti-Herding) — Bash + Agent 동시 호출
+#### Step 2: 2-CLI 독립 병렬 검색 (Anti-Herding) — Bash + Agent 동시 호출
 
 **Agent (Claude + Exa):**
 ```
@@ -83,11 +82,10 @@ Agent(
 )
 ```
 
-**Bash (Codex + Brave, Antigravity + Tavily):**
+**Bash (Codex + Brave):**  *(Antigravity/agy 제외 — agy --print 는 무거운 리서치에서 idle 미도달 시 5분 행; route 에서 --print-timeout 180s 로 bound)*
 ```
 Bash("tfx multi --teammate-mode headless --auto-attach --dashboard \
   --assign 'codex:서브쿼리를 Brave Search 로 검색. 서브쿼리: {sub_queries}. 관점: 실용/산업. brave_web_search + brave_news_search, freshness=pw. 각 쿼리 상위 5개 구조화.:researcher' \
-  --assign 'antigravity:서브쿼리를 Tavily 로 검색. {sub_queries}. 관점: 비용/운영/DX. tavily_search search_depth=advanced, max_results=5, include_raw_content=false. 구조화.:researcher' \
   --timeout 600")
 ```
 

package/skills/tfx-research/skill.json

@@ -1,6 +1,6 @@
 {
   "name": "tfx-research",
-  "description": "웹 검색/리서치가 필요할 때 사용한다. '검색해줘', '찾아봐', '최신 정보', '이거 뭐야', '심층 조사', '자세히 알아봐', 'deep research', '전면 리서치', '자율 리서치', '조사해', 'research and plan' 같은 요청에 반드시 사용. 추가로 'X 있나?', 'X 쓸 수 있나?', 'X 풀려있어?', 'X 어떻게 쓰는지', 'X 가능한가?', '방법 있나?', 'X 살아있나?' 같은 도구·기능 존재/사용법/상태 의문문에도 사용. 기본값은 3-CLI 멀티소스(Exa+Brave+Tavily) 합의 딥 리서치. 빠른 Antigravity Google Search 는 --quick. 자율 쿼리생성+보고서 모드는 --auto.",
+  "description": "웹 검색/리서치가 필요할 때 사용한다. '검색해줘', '찾아봐', '최신 정보', '이거 뭐야', '심층 조사', '자세히 알아봐', 'deep research', '전면 리서치', '자율 리서치', '조사해', 'research and plan' 같은 요청에 반드시 사용. 추가로 'X 있나?', 'X 쓸 수 있나?', 'X 풀려있어?', 'X 어떻게 쓰는지', 'X 가능한가?', '방법 있나?', 'X 살아있나?' 같은 도구·기능 존재/사용법/상태 의문문에도 사용. 기본값은 2-CLI 멀티소스(Exa+Brave) 합의 딥 리서치. 빠른 Antigravity Google Search 는 --quick. 자율 쿼리생성+보고서 모드는 --auto.",
   "triggers": [
     "tfx-research",
     "리서치",