triflux 10.61.2 → 10.63.0

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);
 
@@ -101,7 +108,10 @@ function usage(command) {
     "  tfx-live ask --cli codex --transport uds --thread ID|auto --prompt TEXT [--codex-socket PATH|default] [--cwd DIR] [--if-busy wait|fail|steer] [--busy-timeout 60] [--timeout 60] [--max-turn SECONDS]",
     "  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 compact --session NAME [--cli claude|codex] [--instructions TEXT] [--then PROMPT] [--no-wait] [--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) {
@@ -2930,7 +2941,10 @@ async function renameAgyConversation(session, name, timeoutMs, pollIntervalMs) {
   return false;
 }
 
-async function waitForTmuxIdle(adapter, opts) {
+async function waitForTmuxIdle(adapter, opts, deps = {}) {
+  const capture = deps.captureVisible ?? captureVisible;
+  const tmux = deps.runTmux ?? runTmux;
+  const pause = deps.sleep ?? sleep;
   const { session, remote, pollIntervalMs, busyTimeoutMs, ifBusy } = opts;
   if (
     ![
@@ -2947,7 +2961,7 @@ async function waitForTmuxIdle(adapter, opts) {
   const startedAt = Date.now();
   let interrupted = false;
   while (true) {
-    const visible = await captureVisible(remote, session);
+    const visible = await capture(remote, session);
     const elapsedMs = Date.now() - startedAt;
     const busy =
       adapter.isBusy(visible) ||
@@ -2960,16 +2974,20 @@ async function waitForTmuxIdle(adapter, opts) {
       );
     }
     if (ifBusy === "interrupt" && !interrupted) {
-      await runTmux(remote, ["send-keys", "-t", session, "Escape"]);
+      await tmux(remote, ["send-keys", "-t", session, "Escape"]);
       interrupted = true;
     }
-    await sleep(
+    await pause(
       Math.min(pollIntervalMs, Math.max(1, busyTimeoutMs - elapsedMs)),
     );
   }
 }
 
-async function doAskViaTmux(adapter, opts) {
+async function doAskViaTmux(adapter, opts, deps = {}) {
+  const tmux = deps.runTmux ?? runTmux;
+  const capture = deps.captureVisible ?? captureVisible;
+  const captureHistory = deps.capturePane ?? capturePane;
+  const pause = deps.sleep ?? sleep;
   const {
     session,
     prompt,
@@ -2982,17 +3000,22 @@ async function doAskViaTmux(adapter, opts) {
     busyTimeoutMs = timeoutMs,
   } = opts;
   const slashCommand = adapter.cli === "agy" && isSlashCommand(prompt);
-  const busyWaitedMs = await waitForTmuxIdle(adapter, {
-    session,
-    remote,
-    pollIntervalMs,
-    busyTimeoutMs,
-    ifBusy: slashCommand ? "queue" : ifBusy,
-  });
+  const busyWaitedMs = opts.skipBusyCheck
+    ? 0
+    : await waitForTmuxIdle(
+        adapter,
+        {
+          session,
+          remote,
+          pollIntervalMs,
+          busyTimeoutMs,
+          ifBusy: slashCommand ? "queue" : ifBusy,
+        },
+        deps,
+      );
   const queued =
-    adapter.cli === "agy" &&
-    adapter.isBusy(await captureVisible(remote, session));
-  const beforeRaw = await capturePane(remote, session);
+    adapter.cli === "agy" && adapter.isBusy(await capture(remote, session));
+  const beforeRaw = await captureHistory(remote, session);
   const contextPctBefore = adapter.contextPct(beforeRaw);
   const context =
     adapter.cli === "agy"
@@ -3015,8 +3038,8 @@ async function doAskViaTmux(adapter, opts) {
     };
 
   const bufferName = tmuxBufferName(session);
-  await runTmux(remote, ["set-buffer", "-b", bufferName, "--", prompt]);
-  await runTmux(remote, [
+  await tmux(remote, ["set-buffer", "-b", bufferName, "--", prompt]);
+  await tmux(remote, [
     "paste-buffer",
     "-b",
     bufferName,
@@ -3025,31 +3048,42 @@ async function doAskViaTmux(adapter, opts) {
     "-t",
     session,
   ]);
-  await sleep(settleMs);
+  await pause(settleMs);
 
-  let promptSubmitted = adapter.cli === "agy" ? false : !doneMarker;
+  let promptSubmitted =
+    adapter.cli === "agy" || opts.confirmSubmission ? false : !doneMarker;
   if (doneMarker || opts.noWait || adapter.cli === "agy") {
-    for (let attempt = 1; attempt <= PROMPT_SUBMIT_MAX_ATTEMPTS; attempt += 1) {
-      await runTmux(remote, ["send-keys", "-t", session, "Enter"]);
-      await sleep(PROMPT_SUBMIT_RETRY_DELAY_MS);
-      const submissionVisible = await captureVisible(remote, session);
-      if (!composerShowsPrompt(submissionVisible, prompt, adapter.cli)) {
+    for (
+      let attempt = 1;
+      attempt <= (opts.submitAttempts ?? PROMPT_SUBMIT_MAX_ATTEMPTS);
+      attempt += 1
+    ) {
+      await tmux(remote, ["send-keys", "-t", session, "Enter"]);
+      await pause(PROMPT_SUBMIT_RETRY_DELAY_MS);
+      const submissionVisible = await capture(remote, session);
+      if (
+        opts.confirmSubmission
+          ? await opts.confirmSubmission(submissionVisible)
+          : !composerShowsPrompt(submissionVisible, prompt, adapter.cli)
+      ) {
         promptSubmitted = true;
         break;
       }
     }
     if (!promptSubmitted) {
       throw new Error(
-        `Prompt did not submit after ${PROMPT_SUBMIT_MAX_ATTEMPTS} attempts`,
+        opts.confirmSubmission
+          ? "compact submission could not be confirmed (it may still have started, or /compact may remain in the composer); --then was not sent"
+          : `Prompt did not submit after ${PROMPT_SUBMIT_MAX_ATTEMPTS} attempts`,
       );
     }
   } else {
-    await runTmux(remote, ["send-keys", "-t", session, "Enter"]);
+    await tmux(remote, ["send-keys", "-t", session, "Enter"]);
   }
 
   let nameApplied;
   if (adapter.cli === "agy" && !slashCommand) {
-    const { stdout } = await runTmux(null, [
+    const { stdout } = await tmux(null, [
       "show-options",
       "-qv",
       "-t",
@@ -3082,7 +3116,7 @@ async function doAskViaTmux(adapter, opts) {
               pollIntervalMs,
             );
             if (nameApplied)
-              await runTmux(null, [
+              await tmux(null, [
                 "set-option",
                 "-u",
                 "-t",
@@ -3091,7 +3125,7 @@ async function doAskViaTmux(adapter, opts) {
               ]);
             break;
           }
-          await sleep(Math.min(pollIntervalMs, 200));
+          await pause(Math.min(pollIntervalMs, 200));
         }
       } catch {
         nameApplied = false;
@@ -3149,8 +3183,8 @@ async function doAskViaTmux(adapter, opts) {
 
   while (Date.now() - startedAt < timeoutMs) {
     visible = doneMarker
-      ? await capturePane(remote, session)
-      : await captureVisible(remote, session);
+      ? await captureHistory(remote, session)
+      : await capture(remote, session);
     contextPctAfter = adapter.contextPct(visible);
 
     quietPolls = visible === previousVisible ? quietPolls + 1 : 0;
@@ -3173,7 +3207,7 @@ async function doAskViaTmux(adapter, opts) {
       quietPolls >= FALLBACK_QUIET_POLLS &&
       hasTmuxAssistantResponseAfterCurrentPrompt(
         adapter,
-        await capturePane(remote, session),
+        await captureHistory(remote, session),
         prompt,
         beforeRaw,
       );
@@ -3182,10 +3216,10 @@ async function doAskViaTmux(adapter, opts) {
       break;
     }
 
-    await sleep(pollIntervalMs);
+    await pause(pollIntervalMs);
   }
 
-  raw = await capturePane(remote, session);
+  raw = await captureHistory(remote, session);
   const markerResponse = promptSubmitted
     ? extractResponseSinceMarker({
         beforeRaw,
@@ -3233,10 +3267,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 +3280,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 }
@@ -3395,11 +3435,15 @@ async function resolveCodexTmuxThread(session, deps = {}) {
 
 async function doAskViaQueue(adapter, opts, deps = {}) {
   // queue 를 못 쓰면 tmux 붙여넣기로 보내고 그 이유를 결과에 남긴다.
-  const fallback = async (reason) => ({
-    ...(await doAskViaTmux(adapter, { ...opts, transport: "tmux" })),
-    transportRequested: "queue",
-    fallbackReason: reason,
-  });
+  const fallback = async (reason) => {
+    if (opts.queueOnly)
+      throw new Error(`compact --then requires Codex queue: ${reason}`);
+    return {
+      ...(await doAskViaTmux(adapter, { ...opts, transport: "tmux" })),
+      transportRequested: "queue",
+      fallbackReason: reason,
+    };
+  };
   if (opts.remote) return fallback("remote-host");
   const thread = opts.threadId
     ? { threadId: opts.threadId, threadSource: "flag" }
@@ -3980,9 +4024,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"];
@@ -4351,70 +4401,521 @@ async function tmuxContext(adapter, opts) {
   }
 }
 
-async function compact(flags) {
-  if (flags.cli === "agy")
+async function doCompact(flags, deps = {}) {
+  const cli = flags.cli ?? "claude";
+  if (cli === "agy")
     throw new Error("agy has no compact; use /clear or a handoff");
   if (
-    (flags.cli ?? "claude") !== "claude" ||
+    !["claude", "codex"].includes(cli) ||
     flags.remote ||
     flags.short ||
     flags["session-id"] ||
     (flags.transport && flags.transport !== "tmux")
   )
     throw new Error(
-      "compact supports local --cli claude --session NAME only; UDS slash execution is unverified",
+      "compact supports local --cli claude|codex --session NAME only",
     );
+  if (cli === "codex" && flags.instructions)
+    throw new Error(
+      "Codex /compact does not accept --instructions; use --then for follow-up instructions",
+    );
+  const thenPrompt = flags.then?.trim();
+  if (flags.then !== undefined && !thenPrompt)
+    throw new Error("--then must not be blank");
+  if (isSlashCommand(thenPrompt))
+    throw new Error("--then accepts text instructions, not slash commands");
   const ifBusy = flags["if-busy"] ?? "fail";
   if (!["fail", "wait"].includes(ifBusy))
     throw new Error("compact --if-busy must be fail or wait");
+  const adapter = ADAPTERS[cli];
   const opts = askOpts(
     {
       ...flags,
-      cli: "claude",
+      cli,
       transport: "tmux",
       "if-busy": ifBusy,
       "no-wait": true,
       prompt: `/compact${flags.instructions ? ` ${flags.instructions}` : ""}`,
     },
-    ADAPTERS.claude,
+    adapter,
   );
-  if (ifBusy === "wait") await waitForTmuxIdle(ADAPTERS.claude, opts);
-  const transcriptPath = await claudeTmuxTranscript(
-    opts.session,
-    opts.configDir,
+  const pause = deps.sleep ?? sleep;
+  const capture = deps.captureVisible ?? captureVisible;
+  await waitForTmuxIdle(adapter, opts, deps);
+  let transcriptPath;
+  let threadId;
+  if (cli === "claude") {
+    transcriptPath = await (deps.claudeTmuxTranscript ?? claudeTmuxTranscript)(
+      opts.session,
+      opts.configDir,
+    );
+  } else {
+    const thread = await (
+      deps.resolveCodexTmuxThread ?? resolveCodexTmuxThread
+    )(opts.session, deps);
+    threadId = thread.threadId;
+    transcriptPath = await (deps.findCodexRollout ?? findCodexRollout)(
+      threadId,
+    );
+  }
+  const readSnapshot = () =>
+    cli === "claude"
+      ? readClaudeTranscript(transcriptPath)
+      : readCodexContext(transcriptPath, threadId);
+  const before = transcriptPath && (await readSnapshot());
+  if (!before || !Number.isInteger(before.compactCount))
+    throw new Error(
+      `compact requires a discoverable ${cli === "claude" ? "Claude transcript" : "Codex rollout"} for this tmux pane`,
+    );
+  let snapshot = before;
+  const done = () => snapshot?.compactCount > before.compactCount;
+  const deadline = Date.now() + opts.timeoutMs;
+  const confirmSubmission = async (visible) => {
+    const submissionDeadline = Math.min(
+      deadline,
+      Date.now() + (cli === "codex" ? 1000 : 5000),
+    );
+    do {
+      snapshot = await readSnapshot();
+      if (
+        done() ||
+        (cli === "claude"
+          ? /Compacting conversation/i.test(stripAnsi(visible))
+          : /Compacting context/i.test(stripAnsi(visible)))
+      )
+        return true;
+      await pause(
+        Math.min(
+          opts.pollIntervalMs,
+          Math.max(0, submissionDeadline - Date.now()),
+        ),
+      );
+      visible = await capture(null, opts.session);
+    } while (Date.now() < submissionDeadline);
+    return false;
+  };
+  await doAskViaTmux(
+    adapter,
+    {
+      ...opts,
+      skipBusyCheck: true,
+      skipContextGuard: true,
+      submitAttempts: cli === "codex" ? 2 : 1,
+      confirmSubmission,
+    },
+    deps,
   );
-  const before = await readClaudeTranscript(transcriptPath);
-  if (!before)
+  const result = {
+    cli,
+    session: opts.session,
+    compact: { submitted: true, done: done() },
+    compacted: done(),
+  };
+  if (thenPrompt) {
+    const requestId = randomBytes(6).toString("hex");
+    const thenOpts = {
+      ...opts,
+      prompt: `[tfx-live req=${requestId}]\n${thenPrompt}`,
+      requestId,
+      threadId,
+      noWait: true,
+      settleMs: 0,
+      transport: cli === "codex" ? "queue" : "tmux",
+      skipBusyCheck: true,
+      skipContextGuard: true,
+      queueOnly: true,
+    };
+    try {
+      if (cli === "codex") {
+        const queued = await doAskViaQueue(adapter, thenOpts, deps);
+        // biome-ignore lint/suspicious/noThenProperty: CLI 계약의 then은 함수가 아닌 큐 결과다.
+        result.then = {
+          ...queued,
+          requestId,
+          queued: queued.inputSent === true,
+        };
+        if (!result.then.queued) {
+          result.ok = false;
+          result.error =
+            queued.status === "unknown"
+              ? `${queued.error}; --then may already be queued, use wait --request-id and do not resend`
+              : queued.error;
+        }
+      } else {
+        await doAskViaTmux(adapter, thenOpts, deps);
+        const queueDeadline = Date.now() + Math.min(opts.timeoutMs, 5000);
+        let confirmedBy;
+        do {
+          const transcript = await readClaudeTranscript(transcriptPath, {
+            requestId,
+          });
+          if (transcript?.enqueued) confirmedBy = "enqueue";
+          else if (transcript?.userSeen) confirmedBy = "user";
+          else if (
+            /queued messages/i.test(
+              stripAnsi(await capture(null, opts.session)),
+            )
+          )
+            confirmedBy = "tui";
+          if (confirmedBy) break;
+          await pause(
+            Math.min(
+              opts.pollIntervalMs,
+              Math.max(0, queueDeadline - Date.now()),
+            ),
+          );
+        } while (Date.now() < queueDeadline);
+        // biome-ignore lint/suspicious/noThenProperty: CLI 계약의 then은 함수가 아닌 큐 결과다.
+        result.then = {
+          requestId,
+          queued: Boolean(confirmedBy) && confirmedBy !== "user",
+          transport: "tmux",
+          ...(confirmedBy === "user" ? { delivered: true } : {}),
+          ...(confirmedBy ? { confirmedBy } : {}),
+        };
+        if (!confirmedBy) {
+          result.ok = false;
+          result.error =
+            "Claude --then was sent but enqueue could not be confirmed; use wait --request-id, do not resend";
+        }
+      }
+    } catch (error) {
+      // compact 는 이미 제출됐으므로 그 정보를 지우지 않고 then 실패만 결과에 담는다.
+      // biome-ignore lint/suspicious/noThenProperty: CLI 계약의 then은 함수가 아닌 큐 결과다.
+      result.then = { requestId, queued: false, error: error.message };
+      result.ok = false;
+      result.error = `compact was submitted but --then failed: ${error.message}`;
+    }
+  }
+  if (!Object.hasOwn(flags, "no-wait")) {
+    do {
+      snapshot = await readSnapshot();
+      if (done()) break;
+      await pause(
+        Math.min(opts.pollIntervalMs, Math.max(0, deadline - Date.now())),
+      );
+    } while (Date.now() < deadline);
+    if (!done()) result.timedOut = true;
+  }
+  result.compacted = result.compact.done = done();
+  if (done()) {
+    Object.assign(result, snapshot.compact);
+    Object.assign(result.compact, snapshot.compact);
+  }
+  return result;
+}
+
+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(
-      "compact requires a discoverable Claude transcript for this tmux pane",
+      "--condition must not be blank or start with a reserved command (clear, pause, resume, edit)",
     );
-  await doAskViaTmux(ADAPTERS.claude, {
+  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() + opts.timeoutMs;
+  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 {
-    const snapshot = await readClaudeTranscript(transcriptPath);
-    if (snapshot?.compactCount > before.compactCount) {
-      printJson({
-        cli: "claude",
-        session: opts.session,
-        compacted: true,
-        ...snapshot.compact,
-      });
-      return;
-    }
-    await sleep(
-      Math.min(opts.pollIntervalMs, Math.max(0, deadline - Date.now())),
+    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);
-  printJson({
-    cli: "claude",
-    session: opts.session,
-    compacted: false,
-    timedOut: true,
-  });
+  return {
+    ...base,
+    ...(snapshot?.goal ?? unavailable),
+    transport: "tmux",
+    confirmed,
+    ...(!confirmed
+      ? { warning: "No new matching goal_status sentinel observed after input" }
+      : {}),
+  };
 }
 
 async function interrupt(flags) {
@@ -5343,7 +5844,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`);
@@ -5359,7 +5860,11 @@ async function main() {
   } else if (command === "queue") {
     await queue(flags);
   } else if (command === "compact") {
-    await compact(flags);
+    const result = await doCompact(flags);
+    printJson(result);
+    if (result.ok === false) process.exitCode = 1;
+  } else if (command === "goal") {
+    printJson(await goal(action, flags));
   } else if (command === "rename") {
     await rename(flags);
   } else if (command === "stop") {
@@ -5392,12 +5897,14 @@ export {
   buildTmuxCommand,
   callRemoteLive,
   classifyPeerExitReason,
+  codexGoal,
   composerShowsPrompt,
   createPeerSignalController,
   derivePeerStatus,
   discoverClaudeTmuxSessions,
   discoverCodexTmuxSessions,
   doAskViaTmux,
+  doCompact,
   extractAssistantResponse,
   extractClaudeCompletedTaskListResponse,
   extractResponseSinceMarker,
@@ -5405,6 +5912,7 @@ export {
   inspectCodexTmuxPane,
   inspectUnsetEnv,
   isCodexLoadingCapture,
+  isSlashCommand,
   parseCodexTmuxSessions,
   parsePeerClosure,
   parseRemoteLiveJson,