triflux 10.49.0 → 10.50.0

package/bin/tfx-live.mjs

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 import { execFile } from "node:child_process";
+import { randomBytes } from "node:crypto";
 import { mkdirSync, realpathSync, statSync, writeFileSync } from "node:fs";
 import {
   mkdir,
@@ -21,6 +22,10 @@ import {
   registryDir,
 } from "../hub/lib/codex-session-registry.mjs";
 import { resolveHardCeilingMs } from "../hub/lib/worker-lifecycle.mjs";
+import {
+  findClaudeTranscript,
+  readClaudeTranscript,
+} from "../hub/team/claude-transcript.mjs";
 import { createNotifier } from "../hub/team/notify.mjs";
 import {
   escapePwshSingleQuoted as escapeRemotePwshSingleQuoted,
@@ -28,6 +33,12 @@ import {
   shellQuote as remoteShellQuote,
   validateHost as validateRemoteHost,
 } from "../hub/team/remote-session.mjs";
+import {
+  CONTEXT_THRESHOLDS,
+  contextGuard,
+  modelContext,
+  readCodexContext,
+} from "../hub/team/session-context.mjs";
 
 const execFileAsync = promisify(execFile);
 
@@ -51,7 +62,13 @@ const BRIDGE_TIMEOUT_BUFFER_MS = 15_000;
 // spill the JSON to a temp file and pass --payload-file instead.
 const PAYLOAD_FILE_THRESHOLD = 96 * 1024;
 const VALID_TRANSPORTS = ["tmux", "uds", "auto"];
-const BOOLEAN_FLAGS = new Set(["json", "attach-a", "attach-b"]);
+const BOOLEAN_FLAGS = new Set([
+  "json",
+  "attach-a",
+  "attach-b",
+  "no-wait",
+  "no-relay-tag",
+]);
 const PEER_HOP_DONE_MARKER = "<<<TFX_PEER_HOP_DONE>>>";
 // uds-fallback diagnostics land here, written async so a failed daemon attach
 // never blocks the tmux fallback path (see writeUdsBugReport / doAskAuto).
@@ -59,16 +76,21 @@ const BUG_REPORT_DIR =
   process.env.TFX_LIVE_BUG_REPORT_DIR ??
   pathJoin(homedir(), ".claude", "cache", "triflux", "tfx-live", "bug-reports");
 
-function usage() {
-  return [
+function usage(command) {
+  const lines = [
     "Usage:",
-    "  tfx-live start --session NAME [--cli codex|claude] [--model ID] [--effort TIER] [--cwd DIR] [--remote HOST] [--resume ID] [--resume-last 1] [--ready-timeout 30] [--poll-interval 1500]",
+    "  tfx-live start --session NAME [--name NAME] [--cli codex|claude] [--model ID] [--effort TIER] [--cwd DIR] [--remote HOST] [--resume ID] [--resume-last 1] [--ready-timeout 30] [--poll-interval 1500]",
     "  tfx-live ask --session NAME[:WINDOW.PANE] --prompt TEXT [--cli codex|claude] [--if-busy wait|fail|interrupt] [--busy-timeout 60] [--timeout 60] [--remote HOST] [--settle 1500] [--poll-interval 1500]",
     "  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 wait --cli claude (--short SHORT | --session-id ID) [--request-id ID] [--config-dir DIR] [--bridge ABS] [--timeout 60] [--poll-interval 1500]",
+    "  tfx-live rename --cli codex --transport uds --thread ID --name NAME [--codex-socket PATH|default]",
     "    transport: auto is the default for Claude when --short/--session-id is present; otherwise tmux. bridge path: --bridge > $TFX_BRIDGE > $TFX_REPO_ROOT/hub/bridge.mjs > bundled Triflux hub/bridge.mjs.",
     "  tfx-live interrupt --session NAME [--cli codex|claude] [--transport tmux|uds|auto] [--short SHORT | --session-id ID] [--config-dir DIR] [--bridge ABS] [--timeout 5]",
     "  tfx-live stop --session NAME [--cli codex|claude] [--remote HOST]",
+    "  tfx-live stop --cli claude (--short SHORT | --session-id ID) [--config-dir DIR]",
     "  tfx-live probe [--short SHORT] [--session-id ID] [--config-dir DIR] [--bridge ABS] [--timeout 10]",
     "  tfx-live list-sessions --cli codex|claude [--transport tmux|uds] [--codex-socket PATH|default] [--cwd DIR] [--remote HOST (codex tmux only)]",
     "    Claude list-sessions supports local tmux only; --transport uds requires --cli codex.",
@@ -80,10 +102,22 @@ function usage() {
     "    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.",
     "  tfx-live cto-hygiene-notify --root DIR --state-file PATH [--json]",
     "    One-shot CTO hygiene dry-run notification: sends only when actionable hygiene state changes; no polling or apply/steward lock.",
-  ].join("\n");
+  ];
+  if (!command) return lines.join("\n");
+  const selected = lines.filter(
+    (line) =>
+      line.startsWith(`  tfx-live ${command} `) ||
+      (command === "ask" && line.startsWith("    ask options:")),
+  );
+  return selected.length
+    ? ["Usage:", ...selected].join("\n")
+    : lines.join("\n");
 }
 
 function parseCli(argv) {
+  if (argv.some((arg) => arg === "--help" || arg === "-h")) {
+    return { command: "help", flags: { subcommand: argv[0] } };
+  }
   const [command, ...rest] = argv;
   if (!command || command === "--help" || command === "-h") {
     return { command: "help", flags: {} };
@@ -158,6 +192,28 @@ function integerFlag(flags, name, defaultValue) {
   return value;
 }
 
+function contextPctFlag(flags, name, defaultValue) {
+  const value = flags[name] === undefined ? defaultValue : Number(flags[name]);
+  if (!Number.isFinite(value) || value < 0 || value > 100)
+    throw new Error(`--${name} must be between 0 and 100`);
+  return value;
+}
+
+function contextOpts(flags, cli) {
+  return {
+    warnContextPct: contextPctFlag(
+      flags,
+      "warn-context-pct",
+      CONTEXT_THRESHOLDS[cli].warnContextPct,
+    ),
+    maxContextPct: contextPctFlag(
+      flags,
+      "max-context-pct",
+      CONTEXT_THRESHOLDS[cli].maxContextPct,
+    ),
+  };
+}
+
 function selectAdapter(flags) {
   const cli = flags.cli ?? "codex";
   const adapter = ADAPTERS[cli];
@@ -233,7 +289,16 @@ function buildRemoteLiveArgv(verb, opts) {
   if (opts.busyTimeoutMs)
     args.push("--busy-timeout", String(opts.busyTimeoutMs / 1000));
   if (opts.maxTurnMs) args.push("--max-turn", String(opts.maxTurnMs / 1000));
-  if (verb === "ask") args.push("--prompt", opts.prompt ?? "");
+  if (verb === "ask") {
+    args.push("--prompt", opts.prompt ?? "");
+    if (opts.noWait) args.push("--no-wait");
+    if (opts.noRelayTag) args.push("--no-relay-tag");
+    if (opts.requestId) args.push("--request-id", opts.requestId);
+    if (opts.maxContextPct !== undefined)
+      args.push("--max-context-pct", String(opts.maxContextPct));
+    if (opts.warnContextPct !== undefined)
+      args.push("--warn-context-pct", String(opts.warnContextPct));
+  }
   args.push("--timeout", timeoutSeconds(opts.timeoutMs));
   if (verb === "ask" && opts.settleMs) {
     args.push("--settle", String(opts.settleMs));
@@ -1665,10 +1730,10 @@ const ADAPTERS = {
   },
 };
 
-function buildLaunchKeys(adapter, { model, effort } = {}) {
+function buildLaunchKeys(adapter, { model, effort, name } = {}) {
   const hasModel = model !== undefined;
   const hasEffort = effort !== undefined;
-  if (!hasModel && !hasEffort) {
+  if (!hasModel && !hasEffort && !(adapter.cli === "claude" && name)) {
     return adapter.launchKeys;
   }
 
@@ -1684,6 +1749,7 @@ function buildLaunchKeys(adapter, { model, effort } = {}) {
       );
     }
   } else if (adapter.cli === "claude") {
+    if (name) overrideArgs.push("-n", name);
     if (hasModel) {
       overrideArgs.push("--model", model);
     }
@@ -1971,12 +2037,23 @@ async function doStart(adapter, opts) {
   } = opts;
   if (session.includes(":"))
     throw new Error("start --session accepts only a session name without ':'");
+  const now = new Date();
+  const resumed = Boolean(resume || resumeLast);
+  const name =
+    opts.name ??
+    (resumed ? null : `${now.getMonth() + 1}.${now.getDate()} ${session}`);
+  if (
+    name !== null &&
+    (!/^\d{1,2}\.\d{1,2} \S/u.test(name) || /[\r\n]/u.test(name))
+  )
+    throw new Error("--name must use '<month>.<day> <topic>' on one line");
   const launchKeys = resume
     ? [adapter.resumeById(resume), "Enter"]
     : resumeLast
       ? [adapter.resumeLast(), "Enter"]
-      : buildLaunchKeys(adapter, { model, effort });
-  const resumed = Boolean(resume || resumeLast);
+      : buildLaunchKeys(adapter, { model, effort, name });
+  if (resumed && name && adapter.cli === "claude")
+    launchKeys[0] += ` ${shellQuote(["-n", name])}`;
   const resumeTarget = resume ?? (resumeLast ? "last" : null);
 
   await runTmux(remote, [
@@ -2006,6 +2083,34 @@ async function doStart(adapter, opts) {
     readyTimeoutMs,
     pollIntervalMs,
   );
+  let nameApplied = Boolean(name) && adapter.cli === "claude" && ready;
+  if (name && adapter.cli === "codex" && ready) {
+    try {
+      await runTmux(remote, [
+        "send-keys",
+        "-t",
+        session,
+        "-l",
+        "--",
+        `/rename ${name}`,
+      ]);
+      await runTmux(remote, ["send-keys", "-t", session, "Enter"]);
+      const deadline = Date.now() + Math.min(readyTimeoutMs, 2000);
+      do {
+        const discovery = await discoverCodexTmuxSessions({ remote });
+        nameApplied =
+          discovery.sessions?.some(
+            (entry) =>
+              entry.session === session &&
+              entry.panes.some((pane) => pane.name === name),
+          ) === true;
+        if (nameApplied || remote) break;
+        await sleep(Math.min(pollIntervalMs, 200));
+      } while (Date.now() < deadline);
+    } catch {
+      nameApplied = false;
+    }
+  }
   return addLoginGuard(adapter, raw, {
     cli: adapter.cli,
     session,
@@ -2013,6 +2118,15 @@ async function doStart(adapter, opts) {
     resumed,
     resumeTarget,
     ready,
+    name,
+    nameGenerated: !resumed && opts.name === undefined,
+    nameApplied,
+    ...(name && adapter.cli === "codex" && !nameApplied
+      ? {
+          nameWarning:
+            "name update could not be confirmed from the Codex session registry",
+        }
+      : {}),
     raw,
   });
 }
@@ -2068,6 +2182,19 @@ async function doAskViaTmux(adapter, opts) {
   });
   const beforeRaw = await capturePane(remote, session);
   const contextPctBefore = adapter.contextPct(beforeRaw);
+  const context = opts.skipContextGuard ? {} : await tmuxContext(adapter, opts);
+  const guard = opts.skipContextGuard
+    ? {}
+    : contextGuard(adapter.cli, context, opts);
+  if (guard.ok === false)
+    return {
+      ...guard,
+      status: "failed",
+      done: false,
+      cli: adapter.cli,
+      session,
+      transport: "tmux",
+    };
 
   const bufferName = tmuxBufferName(session);
   await runTmux(remote, ["set-buffer", "-b", bufferName, "--", prompt]);
@@ -2076,13 +2203,14 @@ async function doAskViaTmux(adapter, opts) {
     "-b",
     bufferName,
     "-d",
+    "-p",
     "-t",
     session,
   ]);
   await sleep(settleMs);
 
   let promptSubmitted = !doneMarker;
-  if (doneMarker) {
+  if (doneMarker || opts.noWait) {
     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);
@@ -2101,6 +2229,25 @@ async function doAskViaTmux(adapter, opts) {
     await runTmux(remote, ["send-keys", "-t", session, "Enter"]);
   }
 
+  if (opts.noWait) {
+    return {
+      ...context,
+      ...guard,
+      ok: true,
+      cli: adapter.cli,
+      transport: "tmux",
+      session,
+      remote: remote ?? null,
+      status: "submitted",
+      inputSent: true,
+      done: false,
+      submittedAt: new Date().toISOString(),
+      target: session,
+      ifBusy,
+      busyWaitedMs,
+    };
+  }
+
   const startedAt = Date.now();
   let raw = "";
   let visible = "";
@@ -2184,6 +2331,8 @@ async function doAskViaTmux(adapter, opts) {
     response,
     contextPctBefore,
     contextPctAfter,
+    ...context,
+    ...guard,
     matchedCompletion: done,
     done,
     raw,
@@ -2191,6 +2340,24 @@ async function doAskViaTmux(adapter, opts) {
 }
 
 async function doAsk(adapter, opts) {
+  const requestId = opts.requestId ?? randomBytes(6).toString("hex");
+  const tag = `[tfx-live req=${requestId}]`;
+  const prompt =
+    opts.noRelayTag || opts.prompt.startsWith(`${tag}\n`)
+      ? opts.prompt
+      : `${tag}\n${opts.prompt}`;
+  try {
+    return {
+      ...(await dispatchAsk(adapter, { ...opts, prompt, requestId })),
+      requestId,
+    };
+  } catch (error) {
+    error.requestId = requestId;
+    throw error;
+  }
+}
+
+async function dispatchAsk(adapter, opts) {
   const transport = opts.transport ?? "tmux";
   if (transport === "tmux") {
     return doAskViaTmux(adapter, opts);
@@ -2211,6 +2378,9 @@ async function doAsk(adapter, opts) {
       ifBusy: opts.ifBusy,
       busyTimeoutMs: opts.busyTimeoutMs,
       pollIntervalMs: opts.pollIntervalMs,
+      noWait: opts.noWait,
+      maxContextPct: opts.maxContextPct,
+      warnContextPct: opts.warnContextPct,
     });
   }
 
@@ -2262,6 +2432,11 @@ async function doAskViaDaemon(opts, meta = {}) {
   if (short) payload.short = short;
   if (sessionId) payload.sessionId = sessionId;
   if (configDir) payload.configDir = configDir;
+  if (opts.noWait) payload.noWait = true;
+  if (opts.maxContextPct !== undefined)
+    payload.maxContextPct = opts.maxContextPct;
+  if (opts.warnContextPct !== undefined)
+    payload.warnContextPct = opts.warnContextPct;
 
   const result = await callBridgeVerb(
     bridgePath,
@@ -2273,6 +2448,14 @@ async function doAskViaDaemon(opts, meta = {}) {
   // are surfaced but never counted as done.
   const matchedCompletion = result?.matchedCompletion === true;
   return {
+    ...result,
+    status:
+      result?.status ??
+      (matchedCompletion
+        ? "completed"
+        : result?.inputSent === false
+          ? "failed"
+          : "unknown"),
     cli: "claude",
     transport: "uds",
     short: short ?? null,
@@ -2280,9 +2463,11 @@ async function doAskViaDaemon(opts, meta = {}) {
     response: result?.text ?? "",
     raw: result?.raw ?? result?.responseRaw ?? "",
     matchedCompletion,
-    timedOut: result?.timedOut === true,
+    ...(result?.status === "submitted"
+      ? {}
+      : { timedOut: result?.timedOut === true }),
     closed: result?.closed === true,
-    inputSent: result?.inputSent === true,
+    inputSent: result?.inputSent ?? null,
     daemon: result?.daemon ?? null,
     daemons: result?.daemons ?? [],
     matches: result?.matches ?? [],
@@ -2431,11 +2616,21 @@ async function doAskAuto(adapter, opts) {
       {
         transportSelected: "uds",
         transportProbe: resolution.transportProbe,
+        ...(probe?.raw?.recoveredFrom
+          ? { recoveredFrom: probe.raw.recoveredFrom }
+          : {}),
       },
     );
-    if (udsResult.matchedCompletion) {
+    if (
+      udsResult.matchedCompletion ||
+      udsResult.status === "submitted" ||
+      udsResult.errorCode === "context-limit"
+    ) {
       return udsResult;
     }
+    if (udsResult.inputSent !== false) {
+      return { ...udsResult, status: "unknown", done: false };
+    }
     // Daemon was reachable but the attach round did not complete (error,
     // timeout, or socket close). File a report async, then keep the user moving
     // on tmux instead of returning a dead uds result.
@@ -2497,6 +2692,34 @@ async function doAskAuto(adapter, opts) {
 }
 
 async function doStop(adapter, opts) {
+  if (opts.short || opts.sessionId) {
+    let sessionId = opts.sessionId;
+    let configDir = opts.configDir;
+    if (!sessionId) {
+      const probe = await callBridgeVerb(
+        opts.bridgePath,
+        "daemon-probe",
+        {
+          short: opts.short,
+          configDir: opts.configDir,
+        },
+        10_000,
+      );
+      if (!probe.ok || !probe.target?.sessionId)
+        throw new Error(
+          probe.error || probe.reason || "Claude session not found",
+        );
+      sessionId = probe.target.sessionId;
+      configDir = probe.daemon?.configDir ?? configDir;
+    }
+    await execFileAsync("claude", ["stop", sessionId], {
+      timeout: 15_000,
+      env: configDir
+        ? { ...process.env, CLAUDE_CONFIG_DIR: configDir }
+        : process.env,
+    });
+    return { cli: "claude", sessionId, stopped: true, conversationKept: true };
+  }
   const { session, remote } = opts;
   if (/[:.]|^[%@]\d+$/.test(session))
     throw new Error(
@@ -2630,6 +2853,7 @@ function startOpts(flags) {
     resumeLast: Object.hasOwn(flags, "resume-last"),
     model: flags.model,
     effort: flags.effort,
+    name: flags.name,
     readyTimeoutMs: secondsFlag(
       flags,
       "ready-timeout",
@@ -2701,6 +2925,10 @@ function askOpts(flags, adapter) {
     ),
     bridgePath: resolveBridgePath(flags),
     prompt: requireFlag(flags, "prompt"),
+    requestId: flags["request-id"],
+    noWait: Object.hasOwn(flags, "no-wait"),
+    noRelayTag: Object.hasOwn(flags, "no-relay-tag"),
+    ...contextOpts(flags, adapter.cli),
     remote: flags.remote,
     timeoutMs: secondsFlag(flags, "timeout", DEFAULT_ANSWER_TIMEOUT_MS),
     maxTurnMs: codexUds
@@ -2716,8 +2944,22 @@ function askOpts(flags, adapter) {
 }
 
 function stopOpts(flags) {
+  const targetCount = [flags.session, flags.short, flags["session-id"]].filter(
+    Boolean,
+  ).length;
+  if (targetCount !== 1)
+    throw new Error("stop requires one of --session, --short, or --session-id");
+  if (
+    (flags.short || flags["session-id"]) &&
+    (flags.remote || (flags.cli && flags.cli !== "claude"))
+  )
+    throw new Error("stop --short/--session-id supports local Claude only");
   return {
-    session: requireFlag(flags, "session"),
+    session: flags.session,
+    short: flags.short,
+    sessionId: flags["session-id"],
+    configDir: flags["config-dir"],
+    bridgePath: flags.short ? resolveBridgePath(flags) : undefined,
     remote: flags.remote,
   };
 }
@@ -2755,18 +2997,186 @@ async function ask(flags) {
   printJson(await doAsk(adapter, askOpts(flags, adapter)));
 }
 
+async function wait(flags) {
+  if ((flags.cli ?? "claude") !== "claude")
+    throw new Error(
+      "wait supports Claude UDS only; Codex UDS wait is unavailable",
+    );
+  if (!flags.short && !flags["session-id"])
+    throw new Error("wait requires --short or --session-id");
+  if (flags.remote || (flags.transport && flags.transport !== "uds"))
+    throw new Error("wait supports local Claude UDS only");
+  const timeoutMs = secondsFlag(flags, "timeout", DEFAULT_ANSWER_TIMEOUT_MS);
+  printJson(
+    await callBridgeVerb(
+      resolveBridgePath(flags),
+      "daemon-wait",
+      {
+        short: flags.short,
+        sessionId: flags["session-id"],
+        configDir: flags["config-dir"],
+        requestId: flags["request-id"],
+        timeoutMs,
+        pollIntervalMs: msFlag(
+          flags,
+          "poll-interval",
+          DEFAULT_POLL_INTERVAL_MS,
+        ),
+      },
+      timeoutMs,
+    ),
+  );
+}
+
+async function rename(flags) {
+  if (flags.cli !== "codex" || flags.transport !== "uds" || flags.remote)
+    throw new Error("rename requires local --cli codex --transport uds");
+  const name = requireFlag(flags, "name").trim();
+  if (!name) throw new Error("--name must not be blank");
+  const threadId = requireFlag(flags, "thread");
+  if (threadId === "auto")
+    throw new Error("rename requires an explicit --thread ID");
+  const { renameCodexAppServerThread } = await import(
+    "../hub/team/uds-orchestrator.mjs"
+  );
+  printJson(
+    await renameCodexAppServerThread({
+      socketPath: resolveCodexDaemonSocket(flags["codex-socket"] ?? "default"),
+      threadId,
+      name,
+    }),
+  );
+}
+
 async function stop(flags) {
-  const adapter = selectAdapter(flags);
+  const adapter = selectAdapter({
+    ...flags,
+    cli: flags.cli ?? (flags.short || flags["session-id"] ? "claude" : "codex"),
+  });
   printJson(await doStop(adapter, stopOpts(flags)));
 }
 
+async function claudeTmuxTranscript(session, configDir) {
+  const { stdout: paneId } = await runTmux(null, [
+    "display-message",
+    "-p",
+    "-t",
+    session,
+    "#{pane_id}",
+  ]);
+  const discovery = await discoverClaudeTmuxSessions();
+  const target = discovery.sessions.find(
+    (entry) => entry.paneId === paneId.trim(),
+  );
+  return findClaudeTranscript({
+    configDir:
+      configDir ||
+      process.env.CLAUDE_CONFIG_DIR ||
+      pathJoin(homedir(), ".claude"),
+    sessionId: target?.sessionId,
+    cwd: target?.cwd,
+  });
+}
+
+async function tmuxContext(adapter, opts) {
+  const unknown = modelContext(adapter.cli, null);
+  if (opts.remote) return unknown;
+  try {
+    if (adapter.cli === "claude") {
+      const transcript = await claudeTmuxTranscript(
+        opts.session,
+        opts.configDir,
+      );
+      return (await readClaudeTranscript(transcript))?.context ?? unknown;
+    }
+    const { stdout: target } = await runTmux(null, [
+      "display-message",
+      "-p",
+      "-t",
+      opts.session,
+      "#{session_name}:#{window_index}.#{pane_index}",
+    ]);
+    const discovery = await discoverCodexTmuxSessions();
+    const pane = discovery.sessions
+      .flatMap((entry) => entry.panes)
+      .find((entry) => entry.target === target.trim());
+    return await readCodexContext(null, pane?.threadId);
+  } catch {
+    return unknown;
+  }
+}
+
+async function compact(flags) {
+  if (
+    (flags.cli ?? "claude") !== "claude" ||
+    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",
+    );
+  const ifBusy = flags["if-busy"] ?? "fail";
+  if (!["fail", "wait"].includes(ifBusy))
+    throw new Error("compact --if-busy must be fail or wait");
+  const opts = askOpts(
+    {
+      ...flags,
+      cli: "claude",
+      transport: "tmux",
+      "if-busy": ifBusy,
+      "no-wait": true,
+      prompt: `/compact${flags.instructions ? ` ${flags.instructions}` : ""}`,
+    },
+    ADAPTERS.claude,
+  );
+  if (ifBusy === "wait") await waitForTmuxIdle(ADAPTERS.claude, opts);
+  const transcriptPath = await claudeTmuxTranscript(
+    opts.session,
+    opts.configDir,
+  );
+  const before = await readClaudeTranscript(transcriptPath);
+  if (!before)
+    throw new Error(
+      "compact requires a discoverable Claude transcript for this tmux pane",
+    );
+  await doAskViaTmux(ADAPTERS.claude, {
+    ...opts,
+    ifBusy: "fail",
+    skipContextGuard: true,
+  });
+  const deadline = Date.now() + opts.timeoutMs;
+  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())),
+    );
+  } while (Date.now() < deadline);
+  printJson({
+    cli: "claude",
+    session: opts.session,
+    compacted: false,
+    timedOut: true,
+  });
+}
+
 async function interrupt(flags) {
   const adapter = selectAdapter(flags);
   printJson(await doInterrupt(adapter, interruptOpts(flags, adapter)));
 }
 
 async function probe(flags) {
-  const payload = {};
+  const payload = { includeContext: true };
   if (flags.short) payload.short = flags.short;
   if (flags["session-id"]) payload.sessionId = flags["session-id"];
   if (flags["config-dir"]) payload.configDir = flags["config-dir"];
@@ -2822,6 +3232,7 @@ async function listSessions(flags) {
 function startOptsForSession(flags, session, side) {
   return {
     session,
+    ...(!side ? { name: flags.name } : {}),
     remote: flags.remote,
     cwd: flags.cwd,
     ...(side
@@ -2839,10 +3250,12 @@ function startOptsForSession(flags, session, side) {
   };
 }
 
-function askOptsForSession(flags, session, prompt) {
+function askOptsForSession(flags, session, prompt, cli) {
   return {
     session,
     prompt,
+    ...contextOpts(flags, cli),
+    noRelayTag: Object.hasOwn(flags, "no-relay-tag"),
     remote: flags.remote,
     timeoutMs: secondsFlag(flags, "timeout", DEFAULT_ANSWER_TIMEOUT_MS),
     settleMs: msFlag(flags, "settle", DEFAULT_SETTLE_MS),
@@ -2894,6 +3307,7 @@ async function stopAfterLifecycle(stopSpecs, primaryError = null) {
 
 function turnFromAsk(prompt, result) {
   return {
+    requestId: result.requestId,
     prompt,
     response: result.response,
     done: result.done,
@@ -2924,7 +3338,7 @@ async function converse(flags) {
     for (const prompt of prompts) {
       const result = await doAsk(
         adapter,
-        askOptsForSession(flags, session, prompt),
+        askOptsForSession(flags, session, prompt, adapter.cli),
       );
       turns.push(turnFromAsk(prompt, result));
     }
@@ -2965,7 +3379,7 @@ async function goalDriven(flags) {
           : `Continue. Reply with only ${doneToken} on its own line when fully complete.`;
       const result = await doAsk(
         adapter,
-        askOptsForSession(flags, session, prompt),
+        askOptsForSession(flags, session, prompt, adapter.cli),
       );
       turns.push(turnFromAsk(prompt, result));
       if (hasDoneToken(result.response, doneToken)) {
@@ -3344,6 +3758,8 @@ function peerSideBaseOpts(flags, side, adapter, session) {
   }
   return {
     session,
+    noRelayTag: Object.hasOwn(flags, "no-relay-tag"),
+    ...contextOpts(flags, adapter.cli),
     short,
     sessionId,
     threadId,
@@ -3592,6 +4008,7 @@ async function peer(flags) {
 
       hops.push({
         hop: hopIndex + 1,
+        requestId: result.requestId,
         from: isA ? "a" : "b",
         cli: adapter.cli,
         transport: result.transport ?? base.transport,
@@ -3767,7 +4184,7 @@ async function main() {
   const { command, flags } = parseCli(process.argv.slice(2));
 
   if (command === "help") {
-    process.stdout.write(`${usage()}\n`);
+    process.stdout.write(`${usage(flags.subcommand)}\n`);
     return;
   }
 
@@ -3775,6 +4192,12 @@ async function main() {
     await start(flags);
   } else if (command === "ask") {
     await ask(flags);
+  } else if (command === "wait") {
+    await wait(flags);
+  } else if (command === "compact") {
+    await compact(flags);
+  } else if (command === "rename") {
+    await rename(flags);
   } else if (command === "stop") {
     await stop(flags);
   } else if (command === "interrupt") {
@@ -3825,6 +4248,7 @@ export {
   resolveAskTransport,
   resolveCodexDaemonSocket,
   splitTmuxTarget,
+  stopOpts,
   tmuxBufferName,
   verifyAttachedPeerSide,
 };
@@ -3846,6 +4270,7 @@ if (isMainModule()) {
     printJson({
       ok: false,
       error: error.message,
+      ...(error.requestId ? { requestId: error.requestId } : {}),
     });
     process.exitCode = 1;
   });