triflux 10.61.2 → 10.62.0

package/.claude/rules/tfx-routing.md

@@ -62,7 +62,7 @@ owner availability를 실제로 검출한 경우에만 `owner unavailable → tf
 | 분석 | 분석해, 어떻게 돌아가?, 구조가 뭐야 | tfx-auto (`--mode consensus --shape panel`) |
 | 계획 | 계획, 어떻게 하지, 설계해 | superpowers `writing-plans`; TFX 다중모델 계획·실행은 `tfx-auto --mode deep` |
 | 요구사항 명확화 | 요구사항, 인터뷰, 목표 구체화 | host `deep-interview`; 목표 변환은 Claude Code 기본 `/goal` |
-| Codex 프로필 관리 | 프로필, 모델, effort 변경 | `~/.codex/<프로필>.config.toml` 직접 관리 |
+| Codex 프로필 관리 | 프로필, 모델, effort 변경 | `~/.config/triflux/models.json` 가족별 고정 또는 자동 해석 |
 | 검색 | 찾아, 어디있어, 파일 찾아 | Claude 기본 Explore 에이전트 |
 | 리서치 (빠른) | 검색해줘, 찾아봐, 공식문서, 이거 뭐야 | tfx-research |
 | 리서치 (자율) | 자율 리서치, 검색하고 정리해, research and plan | tfx-research (Auto 모드) |
@@ -102,23 +102,28 @@ owner availability를 실제로 검출한 경우에만 `owner unavailable → tf
 
 ### 모델 배치
 
-> 근거(why): [ADR-0016](../../docs/adr/0016-codex-astra-top-tier-and-fable-escalation.md), [ADR-0017](../../docs/adr/0017-gpt6-sol-luna-lanes.md), [ADR-0019](../../docs/adr/0019-gpt61-sol-and-sonnet-55.md). 기준 문서는 OpenAI Codex 모델 페이지와 Anthropic 모델 개요(2026-09-30 확인)다.
+> 근거: [ADR-0037](../../docs/adr/0037-model-family-aliases.md). 모델 목록의 같은 가족에서 사용할 수 있는 최신 버전을 실행 때 해석한다.
 
-Codex 역할별 프로필의 SSOT는 `scripts/lib/agent-route-policy.mjs`이고, 모델 ID는 `~/.codex/<프로필>.config.toml`이 정한다. `designer`, `writer` 항목은 직접 Codex를 지정한 경우에만 적용하며 일반 실행의 provider는 `hub/team/agent-map.json`이 정한다.
+Codex 역할별 프로필의 SSOT는 `scripts/lib/agent-route-policy.mjs`이고, `scripts/lib/model-family-resolver.mjs`가 관리 파일 `~/.codex/<프로필>.config.toml`의 모델 ID를 갱신한다. `designer`, `writer` 항목은 직접 Codex를 지정한 경우에만 적용하며 일반 실행의 provider는 `hub/team/agent-map.json`이 정한다.
 
 | 프로필 | triflux lane |
 |---------|--------------|
-| `gpt6_astra_xhigh` | architect, planner, critic, analyst, debugger, deep-executor, security-reviewer, scientist-deep, designer(직접 지정) |
-| `gpt6_astra_max` / `gpt6_astra_ultra` | `TFX_CODEX_PROFILE=max/ultra`, 재시도 1단계 |
-| `gpt61_sol_high` | executor, codex, code-reviewer, quality-reviewer, verifier, test-engineer, qa-tester, scientist, document-specialist |
-| `gpt61_sol_med` | cleanup, deslop |
-| `gpt6_luna_high` | build-fixer, writer(직접 지정) |
-| `gpt6_luna_low` | spark, explore 재매핑, ChatGPT tier 폴백 |
+| `astra_xhigh` | architect, planner, critic, analyst, debugger, deep-executor, security-reviewer, scientist-deep, designer(직접 지정) |
+| `astra_max` / `astra_ultra` | `TFX_CODEX_PROFILE=max/ultra`, 재시도 1단계 |
+| `sol_high` | executor, codex, code-reviewer, quality-reviewer, verifier, test-engineer, qa-tester, scientist, document-specialist |
+| `sol_med` | cleanup, deslop |
+| `luna_high` | build-fixer, writer(직접 지정) |
+| `luna_low` | spark, explore 재매핑, ChatGPT tier 폴백 |
+| `flash_low` / `flash` / `flash_high` | Antigravity 분류·요약 / 생성·작성 / 검토·설계 |
 | `fable` | `--retry auto-escalate` 최종 단계 |
 | `opus` | 메타 라우팅, planning gate, 스킬의 `model="opus"` lane |
 | `sonnet` | Claude native test-engineer, qa-tester, verifier |
 | `haiku` | Claude native explore, claude |
 
+Codex는 `models_cache.json`의 공개 모델 중 effort를 지원하는 후보를 숫자 버전순으로 고른다. 캐시가 없으면 `codex debug models`를 읽는다. agy는 `agy models`의 Flash 목록을 하루 동안 캐시한다. setup과 update도 같은 해석기를 쓴다. 옛 버전 프로필 이름은 가족 별칭으로 정규화한다.
+
+`~/.config/triflux/models.json`에 `{"sol":"gpt-6-sol","flash":"gemini-3.7-flash"}`처럼 적으면 해당 가족을 고정한다. Windows는 `%APPDATA%\triflux`를 쓴다. 해석 기록과 agy 목록도 이 상태 디렉터리에 보관한다. 목록 조회 실패 시 마지막 성공 결과, 그다음 내장 기본값을 사용한다. Claude 별칭 라우팅은 유지한다.
+
 ## CLI 라우팅
 
 `codex exec`와 `agy --print`를 직접 호출하지 않고 tfx 스킬을 거친다. headless-guard 훅은 제거되었으므로 호출자가 지킨다.

package/README.ko.md

@@ -14,7 +14,7 @@
   <a href="https://www.npmjs.com/package/triflux"><img src="https://img.shields.io/npm/v/triflux?style=flat-square&color=FFAF00&label=npm" alt="npm version"></a>
   <a href="https://www.npmjs.com/package/triflux"><img src="https://img.shields.io/npm/dm/triflux?style=flat-square&color=F5C242" alt="npm downloads"></a>
   <a href="https://github.com/tellang/triflux/stargazers"><img src="https://img.shields.io/github/stars/tellang/triflux?style=flat-square&color=FFAF00" alt="GitHub stars"></a>
-  <img src="https://img.shields.io/badge/node-%3E%3D20-374151?style=flat-square" alt="Node >= 20">
+  <img src="https://img.shields.io/badge/node-%3E%3D22-374151?style=flat-square" alt="Node >= 22">
   <a href="https://opensource.org/licenses/MIT"><img src="https://img.shields.io/badge/License-MIT-374151?style=flat-square" alt="License: MIT"></a>
 </p>
 
@@ -109,15 +109,17 @@ Codex 프로필은 `~/.codex/<프로필>.config.toml`에서 직접 관리한다.
 ## 모델과 프로필
 
 Codex는 이름 붙은 프로필로 실행한다. 모델 ID는 `~/.codex/<프로필>.config.toml`이, 역할별 프로필
-배정은 [`scripts/lib/agent-route-policy.mjs`](scripts/lib/agent-route-policy.mjs)가 정한다. Claude는
-별칭으로 부르므로 등급마다 가장 새 모델이 자동으로 잡힌다.
+배정은 [`scripts/lib/agent-route-policy.mjs`](scripts/lib/agent-route-policy.mjs)가 정한다. 실행·setup·update 때 Codex와 Antigravity 가족 프로필을 사용 가능한 최신 버전으로 갱신한다. Codex는 로컬 모델 캐시에서 effort 지원 여부를 확인하고, Antigravity는 `agy models` 결과를 하루 동안 캐시한다. 옛 프로필 이름도 계속 동작한다. Claude는 기존 별칭을 유지한다.
+
+`~/.config/triflux/models.json`에 `{"sol":"gpt-6-sol","flash":"gemini-3.7-flash"}`처럼 적으면 가족별로 고정한다(Windows: `%APPDATA%\triflux`). 목록을 읽지 못하면 마지막 해석 결과, 그다음 내장 기본값을 쓴다.
 
 | 프로필 / 별칭 | 레인 |
 | --- | --- |
-| `gpt6_astra_xhigh` | 아키텍처, 계획, 비평, 디버깅, 보안 리뷰, 깊은 실행 |
-| `gpt6_astra_max`, `gpt6_astra_ultra` | 가장 어려운 단일 작업(`TFX_CODEX_PROFILE=max\|ultra`). `max`는 `auto-escalate` 첫 단계 |
-| `gpt61_sol_high` / `gpt61_sol_med` | 기본 구현, 리뷰, 검증, 테스트, 문서 / 정리 작업 |
-| `gpt6_luna_high` / `gpt6_luna_low` | 빌드 수정, 글쓰기 / 지연 우선 조회 |
+| `astra_xhigh` | 아키텍처, 계획, 비평, 디버깅, 보안 리뷰, 깊은 실행 |
+| `astra_max`, `astra_ultra` | 가장 어려운 단일 작업(`TFX_CODEX_PROFILE=max\|ultra`). `max`는 `auto-escalate` 첫 단계 |
+| `sol_high` / `sol_med` | 기본 구현, 리뷰, 검증, 테스트, 문서 / 정리 작업 |
+| `luna_high` / `luna_low` | 빌드 수정, 글쓰기 / 지연 우선 조회 |
+| `flash_low` / `flash` / `flash_high` | Antigravity 분류 / 생성 / 검토 |
 | Claude `fable` | `--retry auto-escalate` 마지막 단계 |
 | Claude `opus` / `sonnet` / `haiku` | 메타 라우팅과 계획 게이트 / Claude 네이티브 QA·검증 / 빠른 탐색 |
 
@@ -155,7 +157,7 @@ Claude Code Bash 도구의 600초 제한에 걸리지 않는다. 이후 `--job-s
 행에서 Enter를 누르면 그 워커가 도는 tmux pane이 열린다. 끄려면 `--no-native-bridge-ui`를 준다.
 
 **재시도와 승격.** `--retry ralph`는 끝나거나 막힐 때(같은 실패 3회 연속)까지 반복한다.
-`--retry auto-escalate`는 Codex `gpt6_astra_max`에서 Claude `fable`로 올라간다. 체인은
+`--retry auto-escalate`는 Codex `astra_max`에서 Claude `fable`로 올라간다. 체인은
 `.triflux/config/escalation-chain.json`으로 바꿀 수 있다.
 
 **머신 프로파일.** setup은 이 머신에서 쓸 CLI와 timeout 정책을
@@ -218,7 +220,7 @@ graph TD
 
 ## 기여
 
-Node 20 이상이 필요하다. 테스트, 린트, 패키지 경계, 미러·릴리즈 점검, 상태 스냅샷은
+Node 22 이상이 필요하다. 테스트, 린트, 패키지 경계, 미러·릴리즈 점검, 상태 스냅샷은
 [CONTRIBUTING.md](CONTRIBUTING.md)에 있다. 릴리즈는 자동이다. 버전을 올린 커밋이 `main`에
 머지되면 CI 통과 뒤 `release.yml`이 태그, GitHub 릴리즈, OIDC Trusted Publishing을 통한 npm 게시까지 진행한다.
 결정 기록은 [docs/adr/](docs/adr/README.md)에 있다.

package/README.md

@@ -14,7 +14,7 @@
   <a href="https://www.npmjs.com/package/triflux"><img src="https://img.shields.io/npm/v/triflux?style=flat-square&color=FFAF00&label=npm" alt="npm version"></a>
   <a href="https://www.npmjs.com/package/triflux"><img src="https://img.shields.io/npm/dm/triflux?style=flat-square&color=F5C242" alt="npm downloads"></a>
   <a href="https://github.com/tellang/triflux/stargazers"><img src="https://img.shields.io/github/stars/tellang/triflux?style=flat-square&color=FFAF00" alt="GitHub stars"></a>
-  <img src="https://img.shields.io/badge/node-%3E%3D20-374151?style=flat-square" alt="Node >= 20">
+  <img src="https://img.shields.io/badge/node-%3E%3D22-374151?style=flat-square" alt="Node >= 22">
   <a href="https://opensource.org/licenses/MIT"><img src="https://img.shields.io/badge/License-MIT-374151?style=flat-square" alt="License: MIT"></a>
 </p>
 
@@ -112,14 +112,17 @@ The full contract, including `--lead`, `--options`, `--experts`, and conflict ru
 
 Codex runs through named profiles; model IDs live in `~/.codex/<profile>.config.toml`, and the
 role → profile map lives in [`scripts/lib/agent-route-policy.mjs`](scripts/lib/agent-route-policy.mjs).
-Claude is called by alias, so the newest model in each tier is picked up automatically.
+Codex and Antigravity family profiles select the newest available model at dispatch, setup, and update. Codex reads its local model cache and checks supported effort; Antigravity caches `agy models` for one day. Old profile names remain compatible. Claude keeps its existing aliases.
+
+Pin a family in `~/.config/triflux/models.json`, for example `{"sol":"gpt-6-sol","flash":"gemini-3.7-flash"}` (Windows: `%APPDATA%\triflux`). Without a usable catalog, resolution keeps the last result or the built-in default.
 
 | Profile / alias | Lanes |
 | --- | --- |
-| `gpt6_astra_xhigh` | Architecture, planning, critique, debugging, security review, deep execution |
-| `gpt6_astra_max`, `gpt6_astra_ultra` | Hardest single tasks (`TFX_CODEX_PROFILE=max\|ultra`); `max` is the first `auto-escalate` step |
-| `gpt61_sol_high` / `gpt61_sol_med` | Default implementation, review, verification, tests, docs / cleanup |
-| `gpt6_luna_high` / `gpt6_luna_low` | Build fixes, writing / latency-first lookups |
+| `astra_xhigh` | Architecture, planning, critique, debugging, security review, deep execution |
+| `astra_max`, `astra_ultra` | Hardest single tasks (`TFX_CODEX_PROFILE=max\|ultra`); `max` is the first `auto-escalate` step |
+| `sol_high` / `sol_med` | Default implementation, review, verification, tests, docs / cleanup |
+| `luna_high` / `luna_low` | Build fixes, writing / latency-first lookups |
+| `flash_low` / `flash` / `flash_high` | Antigravity classification / generation / review |
 | Claude `fable` | Final `--retry auto-escalate` step |
 | Claude `opus` / `sonnet` / `haiku` | Meta routing and planning gates / Claude-native QA and verification / fast exploration |
 
@@ -158,7 +161,7 @@ the `claude agents` panel unless you pass `--no-native-bridge-ui`. Press Enter o
 tmux pane the worker runs in.
 
 **Retry and escalation.** `--retry ralph` loops until done or stuck (three identical failures).
-`--retry auto-escalate` steps from Codex `gpt6_astra_max` to Claude `fable`; override the chain in
+`--retry auto-escalate` steps from Codex `astra_max` to Claude `fable`; override the chain in
 `.triflux/config/escalation-chain.json`.
 
 **Machine profile.** Setup records which CLIs this machine may use and its timeout policy in
@@ -219,7 +222,7 @@ Windows) and `hub/team/wt-manager.mjs`. Agent rules:
 
 ## Contributing
 
-Node 20 or newer. See [CONTRIBUTING.md](CONTRIBUTING.md) for tests, lint, package boundaries,
+Node 22 or newer. See [CONTRIBUTING.md](CONTRIBUTING.md) for tests, lint, package boundaries,
 mirror and release checks, and state snapshots. Releases are automated: merging a version-bump
 commit to `main` runs `release.yml` after CI passes; it tags, creates the GitHub release, and publishes to npm
 through OIDC Trusted Publishing. Decisions are recorded in [docs/adr/](docs/adr/README.md).

package/adapters/codex/skills/tfx-live/SKILL.md

@@ -3,7 +3,7 @@ name: tfx-live
 description: >
   Claude·Codex·agy 세션을 실시간으로 생성·질의·대기·압축·종료하거나,
   tmux/daemon UDS 연결과 peer 중계를 운영할 때 사용한다.
-argument-hint: "<start|ask|wait|queue|compact|stop|rename|interrupt|probe|list-sessions|peer|converse|goal-driven> [--cli codex|claude|agy] ..."
+argument-hint: "<start|ask|wait|queue|goal|compact|stop|rename|interrupt|probe|list-sessions|peer|converse|goal-driven> [--cli codex|claude|agy] ..."
 ---
 
 # tfx-live
@@ -84,6 +84,23 @@ tfx-live queue --cli codex --thread <UUID> --delete <queuedMessageId>
 
 `queue`는 TUI가 아직 가져가지 않은 항목을 보고 지운다. Codex app-server의 실험 API `thread/queue/list`·`thread/queue/delete`를 stdio로 호출하며 큐 저장소 파일은 건드리지 않는다. 목록 항목은 `id`(ask 결과의 `queuedMessageId`와 같다), `requestId`, `text`다. 삭제 결과의 `missing`은 이미 TUI가 가져갔거나 없는 항목이다. 유휴 TUI는 쌓인 항목을 곧 가져가므로 지울 수 있는 것은 사실상 바쁜 세션과 닫힌 세션의 항목이다. 가져간 뒤의 처리 여부는 `wait`로 확인한다.
 
+### 네이티브 goal
+
+```bash
+tfx-live goal set --session cl1 --condition "관련 단위 테스트가 모두 통과한다"
+tfx-live goal set --session cx1 --cli codex --condition "관련 단위 테스트가 모두 통과한다" --budget 100000
+tfx-live goal status --session cx1
+tfx-live goal clear --session cx1
+```
+
+`--cli`를 생략하면 세션 프로세스에서 추정한다. 로컬 Claude와 Codex만 지원하며 `--remote`와 agy는 거부한다. `--budget`은 Codex set의 daemon 경로에서만 받고 Claude와 tmux 폴백에서는 오류로 거부한다.
+
+Claude는 tmux로 `/goal <조건>`과 `/goal clear`를 보내고 transcript의 마지막 `goal_status`로 상태를 읽는다. 별도 평가자의 완료는 `complete`, 수동 해제는 `none`이며 `judgedBy: "evaluator"`와 평가 이유를 보고한다. transcript를 찾지 못하면 상태는 `null`이고 경고를 남긴다. set/clear 뒤 새 sentinel을 최대 15초 확인하며 없으면 `confirmed: false`와 경고를 반환한다. 이미 해제된 goal의 clear는 입력 없이 `alreadyCleared: true`로 답한다. set은 기본 `--if-busy wait`, clear는 미충족 goal이 턴을 계속 이어 가도 끊을 수 있게 기본 `--if-busy interrupt`다. 평가자가 해제하지 않고 멈춘 goal은 `active`로 남으므로 리드가 `goal clear`로 정리한다.
+
+Codex는 공유 daemon UDS의 `thread/goal/*`를 우선 쓴다. `--codex-socket PATH|default`로 소켓을 고르고 기존 thread 해석 순서와 `--thread UUID`를 따른다. 새 goal은 `origin: "user"`로 clear 후 active set한다. 소켓이 없거나 thread가 미적재면 set/clear는 tmux 슬래시로, status는 `$CODEX_HOME/goals_1.sqlite`의 읽기 전용 조회로 폴백한다. `node:sqlite`를 지원하지 않는 Node에서는 상태를 `null`로 두고 경고한다. 결과에 `transport: "daemon"|"tmux"|"sqlite"`와 폴백 이유를 남긴다. tmux 폴백의 set/clear는 sqlite로 최대 15초 확인하고, 확인하지 못하면 재전송을 막으려고 오류 대신 `confirmed: false`와 경고를 반환한다. Codex의 `judgedBy: "model"`, `complete`는 모델 자기 판정이므로 리드의 교차 검증이 필요하다.
+
+Claude와 Codex는 네이티브 goal을 우선 쓰고, goal-driven은 agy처럼 네이티브 goal이 없을 때 쓰는 방식이다. 현재 agy의 goal-driven 실행은 지원하지 않는다.
+
 ### 컨텍스트 판단
 
 분모는 공식 모델 창이고 실행 한도가 더 작으면 그 한도 아래에서 운영한다. 아래 비율은 공식 권고가 아닌 **[추론] 운영값**이다. 모델 문서가 바뀌면 한도도 갱신한다.
@@ -124,7 +141,7 @@ tfx-live ask --cli codex --session cx1 --prompt "진행 상황을 보고해줘"
 tfx-live wait --cli codex --session cx1 --request-id <requestId> --timeout 120
 ```
 
-`ask --no-wait`는 Claude와 tmux에서 `status: "submitted"`, Codex queue에서 `status: "queued"`와 함께 `inputSent: true`, `done: false`, `submittedAt`, `target`, `requestId`를 반환한다. `ask`, `peer`, `converse`, `goal-driven`은 `[tfx-live req=<requestId>]`를 프롬프트 앞에 붙인다. `--no-relay-tag`로 제거하면 `wait --request-id`가 해당 요청을 찾을 수 없다.
+`ask --no-wait`는 Claude와 tmux에서 `status: "submitted"`, Codex queue에서 `status: "queued"`와 함께 `inputSent: true`, `done: false`, `submittedAt`, `target`, `requestId`를 반환한다. `ask`, `peer`, `converse`, `goal-driven`은 `[tfx-live req=<requestId>]`를 프롬프트 앞에 붙인다. `--no-relay-tag`로 제거하면 `wait --request-id`가 해당 요청을 찾을 수 없다. 슬래시 명령(`/rename`, `/clear` 등)은 CLI와 상관없이 표식 없이 보낸다. 응답 턴이 없는 Claude 내장 명령(`/rename`, `/clear`, `/compact`, `/model`, `/effort`, `/color`)은 기다리지 않고 `status: "submitted"`로 반환한다. 압축 완료까지 기다리려면 `compact` 명령을 쓴다.
 
 `wait`는 Claude transcript에서 표식을 user 메시지, `queue-operation`의 `enqueue` content, queued command attachment에서 찾는다. 표식이 소비된 턴이 끝난 뒤 마지막 assistant 텍스트를 응답으로 쓴다. 표식 없는 `wait`는 최신 user turn을 본다. `isSidechain`과 합성 API 오류 메시지는 정상 응답에서 제외한다. 요청을 소비한 턴에서 합성 오류가 나타나면 오류 문구와 `status: "failed"`를 반환한다. daemon의 `idle`만으로 완료를 단정하지 않는다. timeout은 `status: "working"`, `timedOut: true`, `done: false`다.
 

package/bin/tfx-live.mjs

@@ -1,7 +1,13 @@
 #!/usr/bin/env node
 import { execFile } from "node:child_process";
 import { randomBytes } from "node:crypto";
-import { mkdirSync, realpathSync, statSync, writeFileSync } from "node:fs";
+import {
+  existsSync,
+  mkdirSync,
+  realpathSync,
+  statSync,
+  writeFileSync,
+} from "node:fs";
 import {
   chmod,
   mkdir,
@@ -53,6 +59,7 @@ import {
   modelContext,
   readCodexContext,
 } from "../hub/team/session-context.mjs";
+import { JsonRpcWsUdsClient } from "../hub/workers/lib/jsonrpc-ws-uds.mjs";
 
 const execFileAsync = promisify(execFile);
 
@@ -102,6 +109,9 @@ function usage(command) {
     "  tfx-live ask --transport uds|auto (--short SHORT | --session-id ID) --prompt TEXT [--config-dir DIR] [--bridge ABS] [--session NAME (auto fallback)] [--timeout 60]",
     "    ask options: --no-wait --no-relay-tag --warn-context-pct N --max-context-pct N (0 disables; Claude 60/90, Codex 15/22).",
     "  tfx-live compact --cli claude --session NAME [--instructions TEXT] [--if-busy fail|wait] [--timeout 60]",
+    "  tfx-live goal set --session NAME [--cli claude|codex] --condition TEXT [--budget N]",
+    "  tfx-live goal status --session NAME [--cli claude|codex]",
+    "  tfx-live goal clear --session NAME [--cli claude|codex]",
     "  tfx-live wait --cli claude (--short SHORT | --session-id ID | --session NAME[:WINDOW.PANE]) [--request-id ID] [--config-dir DIR] [--bridge ABS] [--timeout 60] [--poll-interval 1500]",
     "  tfx-live wait --cli codex (--session NAME[:WINDOW.PANE] | --thread UUID) --request-id ID [--timeout 60] [--poll-interval 1500]",
     "  tfx-live wait --cli agy --session NAME[:WINDOW.PANE] [--request-id ID] [--timeout 60] [--poll-interval 1500]",
@@ -141,6 +151,7 @@ function parseCli(argv) {
   }
 
   const flags = {};
+  const action = command === "goal" ? rest.shift() : undefined;
   for (let index = 0; index < rest.length; index += 1) {
     const arg = rest[index];
     if (!arg.startsWith("--")) {
@@ -165,7 +176,7 @@ function parseCli(argv) {
     index += 1;
   }
 
-  return { command, flags };
+  return { command, flags, action };
 }
 
 function requireFlag(flags, name) {
@@ -3233,10 +3244,8 @@ async function doAsk(adapter, opts) {
   const requestId = opts.requestId ?? randomBytes(6).toString("hex");
   const tag = `[tfx-live req=${requestId}]`;
   // Codex 는 접힌 발신자 표시가 없어 첫 줄 머리말로 보낸 세션을 드러낸다.
-  // 슬래시 명령은 첫 글자가 / 여야 실행되므로 표식을 붙이지 않는다.
-  const bare =
-    opts.noRelayTag ||
-    (["codex", "agy"].includes(adapter.cli) && isSlashCommand(opts.prompt));
+  // 슬래시 명령은 CLI 와 상관없이 첫 글자가 / 여야 실행되므로 표식을 붙이지 않는다.
+  const bare = opts.noRelayTag || isSlashCommand(opts.prompt);
   const from =
     adapter.cli === "codex" && !bare
       ? (opts.from ?? (await resolveSenderName()))
@@ -3248,7 +3257,15 @@ async function doAsk(adapter, opts) {
       : `${header}\n${opts.prompt}`;
   try {
     return {
-      ...(await dispatchAsk(adapter, { ...opts, prompt, requestId })),
+      ...(await dispatchAsk(adapter, {
+        ...opts,
+        prompt,
+        requestId,
+        noRelayTag: bare,
+        noWait:
+          opts.noWait ||
+          (adapter.cli === "claude" && CLAUDE_SILENT_SLASH.test(opts.prompt)),
+      })),
       requestId,
       ...(opts.transportReason
         ? { transportReason: opts.transportReason }
@@ -3980,9 +3997,15 @@ function transportFlag(flags, adapter, short, sessionId) {
 
 // 절대 경로로 시작하는 프롬프트는 슬래시 명령이 아니다.
 function isSlashCommand(prompt) {
-  return /^\/[a-z][\w-]*(?:\s|$)/i.test(String(prompt ?? ""));
+  const word = String(prompt ?? "").match(/^\/[a-z][\w-]*(?=\s|$)/i)?.[0];
+  // `/tmp 를 확인해` 처럼 이 기기에 실제로 있는 경로로 시작하는 문장은 명령이 아니다.
+  return Boolean(word) && !existsSync(word);
 }
 
+// 응답 턴을 만들지 않는 Claude 내장 명령. 스킬 명령은 응답을 만드므로 기다린다.
+const CLAUDE_SILENT_SLASH =
+  /^\/(?:rename|clear|compact|model|effort|color)(?:\s|$)/i;
+
 function askOpts(flags, adapter) {
   const short = flags.short;
   const sessionId = flags["session-id"];
@@ -4417,6 +4440,319 @@ async function compact(flags) {
   });
 }
 
+function codexGoalStatus(goal) {
+  return {
+    state: goal
+      ? ({ usageLimited: "usage_limited", budgetLimited: "budget_limited" }[
+          goal.status
+        ] ?? goal.status)
+      : "none",
+    objective: goal?.objective ?? null,
+    judgedBy: "model",
+    ...(goal
+      ? {
+          tokensUsed: goal.tokensUsed,
+          tokenBudget: goal.tokenBudget ?? null,
+          updatedAt: new Date(goal.updatedAt * 1000).toISOString(),
+        }
+      : {}),
+  };
+}
+
+async function readCodexGoal(threadId) {
+  let db;
+  try {
+    const [major, minor] = process.versions.node.split(".").map(Number);
+    if (
+      major < 22 ||
+      (major === 22 && minor < 13) ||
+      (major === 23 && minor < 4)
+    )
+      throw new Error("Node 22.13+ with read-only node:sqlite is required");
+    const { DatabaseSync } = await import("node:sqlite");
+    db = new DatabaseSync(
+      pathJoin(
+        process.env.CODEX_HOME ?? pathJoin(homedir(), ".codex"),
+        "goals_1.sqlite",
+      ),
+      { readOnly: true },
+    );
+    const row = db
+      .prepare(
+        "SELECT objective, status, token_budget AS tokenBudget, tokens_used AS tokensUsed, updated_at_ms / 1000.0 AS updatedAt FROM thread_goals WHERE thread_id = ?",
+      )
+      .get(threadId);
+    return codexGoalStatus(row);
+  } catch (error) {
+    // Node >=22 전체에서 sqlite 를 지원하지는 않으므로 미확인을 none 으로 보고하지 않는다.
+    return {
+      state: null,
+      objective: null,
+      judgedBy: "model",
+      warning: `Goal status unavailable (read-only node:sqlite): ${error.message}`,
+    };
+  } finally {
+    db?.close();
+  }
+}
+
+async function codexGoal(action, opts, deps = {}) {
+  const { threadId, objective, tokenBudget } = opts;
+  let fallbackReason;
+  let client;
+  try {
+    const socketPath = (deps.resolveSocket ?? resolveCodexDaemonSocket)(
+      opts.codexSocket,
+    );
+    client = (
+      deps.clientFactory ?? ((options) => new JsonRpcWsUdsClient(options))
+    )({ socketPath, connectTimeoutMs: 5000 });
+    await client.connect();
+    await client.request(
+      "initialize",
+      {
+        clientInfo: { name: "triflux-tfx-live", version: "1.0.0" },
+        capabilities: { experimentalApi: true },
+      },
+      5000,
+    );
+    client.notify("initialized", {});
+    let cursor;
+    let loaded = false;
+    do {
+      const page = await client.request(
+        "thread/loaded/list",
+        cursor ? { cursor } : {},
+        5000,
+      );
+      loaded = page.data.includes(threadId);
+      cursor = page.nextCursor;
+    } while (!loaded && cursor);
+    if (!loaded) fallbackReason = "thread-not-loaded";
+  } catch (error) {
+    fallbackReason = `daemon-unavailable: ${error.message}`;
+  }
+  try {
+    if (fallbackReason) {
+      if (tokenBudget !== undefined)
+        throw new Error(
+          `--budget requires a loaded Codex daemon thread; tmux fallback cannot set a budget (${fallbackReason})`,
+        );
+      return {
+        ...(action === "status"
+          ? await (deps.readGoal ?? readCodexGoal)(threadId)
+          : {}),
+        transport: action === "status" ? "sqlite" : "tmux",
+        fallbackReason,
+      };
+    }
+    const params = { threadId, origin: "user" };
+    // 쓰기를 시도한 뒤의 오류는 폴백하지 않는다. 성공 여부가 불명확한 명령을 중복 전송할 수 있다.
+    if (action !== "status") {
+      const cleared = await client.request("thread/goal/clear", params, 10000);
+      if (action === "clear")
+        return {
+          ...codexGoalStatus(null),
+          ...cleared,
+          confirmed: true,
+          transport: "daemon",
+        };
+    }
+    const result =
+      action === "set"
+        ? await client
+            .request(
+              "thread/goal/set",
+              {
+                ...params,
+                objective,
+                status: "active",
+                ...(tokenBudget !== undefined ? { tokenBudget } : {}),
+              },
+              10000,
+            )
+            .catch((error) => {
+              throw new Error(
+                `${error.message}; clear was applied and there is currently no goal`,
+              );
+            })
+        : await client.request("thread/goal/get", { threadId }, 10000);
+    return {
+      ...codexGoalStatus(result.goal),
+      ...(action === "set" ? { confirmed: true } : {}),
+      transport: "daemon",
+    };
+  } finally {
+    client?.close();
+  }
+}
+
+async function goal(action, flags) {
+  if (!["set", "status", "clear"].includes(action))
+    throw new Error("goal requires set, status, or clear");
+  if (flags.remote !== undefined)
+    throw new Error("goal does not support --remote");
+  const session = splitTmuxTarget(requireFlag(flags, "session")).target;
+  let cli = flags.cli;
+  if (!cli) {
+    for (const candidate of ["claude", "codex", "agy"]) {
+      if (await paneCliProcess(session, candidate)) {
+        cli = candidate;
+        break;
+      }
+    }
+    if (!cli)
+      throw new Error("Cannot infer session CLI; specify --cli claude|codex");
+  }
+  if (cli === "agy") throw new Error("agy has no native goal");
+  const adapter = selectAdapter({ ...flags, cli });
+  if (flags.budget !== undefined && (cli !== "codex" || action !== "set"))
+    throw new Error("--budget is supported only by goal set --cli codex");
+  const tokenBudget = integerFlag(flags, "budget", undefined);
+  if (tokenBudget !== undefined && !Number.isSafeInteger(tokenBudget))
+    throw new Error("--budget must be a safe positive integer");
+  const objective =
+    action === "set"
+      ? requireFlag(flags, "condition").replace(/\s+/gu, " ").trim()
+      : null;
+  if (
+    action === "set" &&
+    (!objective || /^(clear|pause|resume|edit)(?: |$)/i.test(objective))
+  )
+    throw new Error(
+      "--condition must not be blank or start with a reserved command (clear, pause, resume, edit)",
+    );
+  const base = { cli, session };
+  let codexResult;
+  let threadId;
+  if (cli === "codex") {
+    ({ threadId } = await codexThreadFromFlags(flags));
+    codexResult = await codexGoal(action, {
+      threadId,
+      objective,
+      tokenBudget,
+      codexSocket: flags["codex-socket"],
+    });
+    if (codexResult.transport !== "tmux") return { ...base, ...codexResult };
+  }
+  const transcriptPath =
+    cli === "claude"
+      ? await claudeTmuxTranscript(session, flags["config-dir"])
+      : null;
+  let snapshot =
+    cli === "claude" ? await readClaudeTranscript(transcriptPath) : null;
+  const unavailable = {
+    state: null,
+    objective: null,
+    judgedBy: "evaluator",
+    warning: "Claude transcript unavailable for this tmux pane",
+  };
+  if (action === "status")
+    return {
+      ...base,
+      ...(snapshot?.goal ?? unavailable),
+      transport: "tmux",
+    };
+  // 달성 뒤 자동 해제됐거나 없던 goal 은 /goal clear 가 기록을 남기지 않아 확인할 수 없다.
+  if (action === "clear" && snapshot?.goal && snapshot.goal.state !== "active")
+    return {
+      ...base,
+      ...snapshot.goal,
+      transport: "tmux",
+      confirmed: true,
+      alreadyCleared: true,
+    };
+  const opts = askOpts(
+    {
+      ...flags,
+      cli,
+      "if-busy":
+        flags["if-busy"] ?? (action === "clear" ? "interrupt" : "wait"),
+      transport: "tmux",
+      "no-wait": true,
+      "no-relay-tag": true,
+      prompt: `/goal ${action === "set" ? objective : "clear"}`,
+    },
+    adapter,
+  );
+  let interrupted = false;
+  if (action === "clear" && opts.ifBusy === "interrupt") {
+    const visible = await captureVisible(null, session);
+    // Claude 반복 턴은 화면에 esc 안내가 없어도 active goal 을 계속 실행할 수 있다.
+    if (
+      snapshot?.goal?.state === "active" ||
+      adapter.isBusy(visible) ||
+      (cli === "codex" && isCodexLoadingCapture(visible))
+    ) {
+      await doInterruptViaTmux(adapter, opts);
+      await sleep(opts.pollIntervalMs);
+      interrupted = true;
+    }
+  }
+  await waitForTmuxIdle(adapter, opts);
+  // Esc 가 직전 입력을 복원해도 clear 명령 앞에 붙지 않게 비운다.
+  if (interrupted) await runTmux(null, ["send-keys", "-t", session, "C-u"]);
+  snapshot =
+    cli === "claude" ? await readClaudeTranscript(transcriptPath) : null;
+  const beforeCount = snapshot?.goalSentinel?.count ?? 0;
+  const inputStartedAt = Date.now();
+  await doAskViaTmux(adapter, {
+    ...opts,
+    ifBusy: "fail",
+    skipContextGuard: true,
+  });
+  const deadline = Date.now() + Math.min(opts.timeoutMs, 15_000);
+  let confirmed = false;
+  if (cli === "codex") {
+    do {
+      snapshot = await readCodexGoal(threadId);
+      confirmed =
+        action === "set"
+          ? snapshot.state === "active" &&
+            snapshot.objective === objective &&
+            Date.parse(snapshot.updatedAt) >= inputStartedAt
+          : snapshot.state === "none";
+      if (confirmed || snapshot.state === null || Date.now() >= deadline) break;
+      await sleep(Math.min(opts.pollIntervalMs, deadline - Date.now()));
+    } while (Date.now() < deadline);
+    // 입력은 이미 들어갔으므로 오류로 끝내면 재전송을 부른다. 미확인으로만 알린다.
+    return {
+      ...base,
+      ...codexResult,
+      ...snapshot,
+      inputSent: true,
+      confirmed,
+      ...(!confirmed && snapshot.state !== null
+        ? { warning: "No matching Codex goal observed after input" }
+        : {}),
+    };
+  }
+  // 갓 띄운 세션은 첫 입력 뒤에야 자기 transcript 가 생기므로 매번 경로를 다시 찾는다.
+  do {
+    snapshot = await readClaudeTranscript(
+      await claudeTmuxTranscript(session, flags["config-dir"]),
+    );
+    const sentinel = snapshot?.goalSentinel;
+    confirmed =
+      sentinel?.count > beforeCount &&
+      Date.parse(sentinel.updatedAt) >= inputStartedAt &&
+      (action === "set"
+        ? sentinel.met === false && sentinel.condition === objective
+        : sentinel.met === true);
+    if (confirmed || Date.now() >= deadline) break;
+    await sleep(Math.min(opts.pollIntervalMs, deadline - Date.now()));
+  } while (Date.now() < deadline);
+  return {
+    ...base,
+    ...(snapshot?.goal ?? unavailable),
+    transport: "tmux",
+    confirmed,
+    ...(!confirmed
+      ? { warning: "No new matching goal_status sentinel observed after input" }
+      : {}),
+  };
+}
+
 async function interrupt(flags) {
   const adapter = selectAdapter(flags);
   printJson(await doInterrupt(adapter, interruptOpts(flags, adapter)));
@@ -5343,7 +5679,7 @@ function printJson(value) {
 }
 
 async function main() {
-  const { command, flags } = parseCli(process.argv.slice(2));
+  const { command, flags, action } = parseCli(process.argv.slice(2));
 
   if (command === "help") {
     process.stdout.write(`${usage(flags.subcommand)}\n`);
@@ -5360,6 +5696,8 @@ async function main() {
     await queue(flags);
   } else if (command === "compact") {
     await compact(flags);
+  } else if (command === "goal") {
+    printJson(await goal(action, flags));
   } else if (command === "rename") {
     await rename(flags);
   } else if (command === "stop") {
@@ -5392,6 +5730,7 @@ export {
   buildTmuxCommand,
   callRemoteLive,
   classifyPeerExitReason,
+  codexGoal,
   composerShowsPrompt,
   createPeerSignalController,
   derivePeerStatus,
@@ -5405,6 +5744,7 @@ export {
   inspectCodexTmuxPane,
   inspectUnsetEnv,
   isCodexLoadingCapture,
+  isSlashCommand,
   parseCodexTmuxSessions,
   parsePeerClosure,
   parseRemoteLiveJson,