triflux 10.34.0 → 10.35.1

package/bin/tfx-live.mjs

@@ -2,9 +2,15 @@
 import { execFile } from "node:child_process";
 import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
 import { homedir, tmpdir } from "node:os";
-import { join as pathJoin } from "node:path";
+import { join as pathJoin, resolve as pathResolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { promisify } from "node:util";
+import {
+  escapePwshSingleQuoted as escapeRemotePwshSingleQuoted,
+  probeRemoteEnv as probeRemoteHostEnv,
+  shellQuote as remoteShellQuote,
+  validateHost as validateRemoteHost,
+} from "../hub/team/remote-session.mjs";
 
 const execFileAsync = promisify(execFile);
 
@@ -23,6 +29,7 @@ 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"]);
 // uds-fallback diagnostics land here, written async so a failed daemon attach
 // never blocks the tmux fallback path (see writeUdsBugReport / doAskAuto).
 const BUG_REPORT_DIR =
@@ -34,11 +41,11 @@ function usage() {
     "Usage:",
     "  tfx-live start --session NAME [--cli codex|claude] [--cwd DIR] [--remote HOST] [--resume ID] [--resume-last 1] [--ready-timeout 30] [--poll-interval 1500]",
     "  tfx-live ask --session NAME --prompt TEXT [--cli codex|claude] [--timeout 60] [--remote HOST] [--settle 1500] [--poll-interval 1500]",
-    "  tfx-live ask --transport uds|auto (--short SHORT | --session-id ID) --prompt TEXT [--bridge ABS] [--session NAME (auto fallback)] [--timeout 60]",
+    "  tfx-live ask --transport uds|auto (--short SHORT | --session-id ID) --prompt TEXT [--config-dir DIR] [--bridge ABS] [--session NAME (auto fallback)] [--timeout 60]",
     "    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] [--bridge ABS] [--timeout 5]",
+    "  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 probe [--short SHORT] [--session-id ID] [--bridge ABS] [--timeout 10]",
+    "  tfx-live probe [--short SHORT] [--session-id ID] [--config-dir DIR] [--bridge ABS] [--timeout 10]",
     "  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]",
@@ -65,6 +72,11 @@ function parseCli(argv) {
       throw new Error("Empty flag is not valid");
     }
 
+    if (BOOLEAN_FLAGS.has(key)) {
+      flags[key] = "1";
+      continue;
+    }
+
     const value = rest[index + 1];
     if (value === undefined) {
       throw new Error(`Missing value for --${key}`);
@@ -168,6 +180,152 @@ function buildTmuxCommand(remote, tmuxArgs) {
   };
 }
 
+function timeoutSeconds(timeoutMs) {
+  return String(Math.max(1, Math.ceil((timeoutMs ?? 1000) / 1000)));
+}
+
+function buildRemoteLiveArgv(verb, opts) {
+  const args = [
+    "tfx-live",
+    verb,
+    "--cli",
+    "claude",
+    "--transport",
+    opts.transport ?? "uds",
+  ];
+  if (opts.short) args.push("--short", opts.short);
+  if (opts.sessionId) args.push("--session-id", opts.sessionId);
+  if (opts.session) args.push("--session", opts.session);
+  if (opts.configDir) args.push("--config-dir", opts.configDir);
+  if (verb === "ask") args.push("--prompt", opts.prompt ?? "");
+  args.push("--timeout", timeoutSeconds(opts.timeoutMs));
+  if (verb === "ask" && opts.settleMs) {
+    args.push("--settle", String(opts.settleMs));
+  }
+  if (verb === "ask" && opts.pollIntervalMs) {
+    args.push("--poll-interval", String(opts.pollIntervalMs));
+  }
+  return args;
+}
+
+function buildRemoteLiveCommand(host, verb, opts, env = {}) {
+  validateRemoteHost(host);
+  const argv = buildRemoteLiveArgv(verb, opts);
+  if (env.os === "win32") {
+    const [commandPath, ...args] = argv;
+    const command = [
+      `& '${escapeRemotePwshSingleQuoted(commandPath)}'`,
+      ...args.map((arg) => `'${escapeRemotePwshSingleQuoted(arg)}'`),
+    ].join(" ");
+    // Live-unverified for Windows remotes; apply the same SSH single-argument
+    // contract proven on darwin so the remote login shell does not re-split it.
+    const remoteCmd = `pwsh -NoProfile -Command ${remoteShellQuote(command)}`;
+    return {
+      command: "ssh",
+      args: [host, remoteCmd],
+    };
+  }
+
+  const shell = env.os === "darwin" && env.shell === "zsh" ? "zsh" : "sh";
+  const inner = argv.map(remoteShellQuote).join(" ");
+  const remoteCmd = `${shell} -lc ${remoteShellQuote(inner)}`;
+  return {
+    command: "ssh",
+    args: [host, remoteCmd],
+  };
+}
+
+function tryParseJsonObject(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+
+function parseRemoteLiveJson(stdout) {
+  const text = String(stdout).trim();
+  if (!text) {
+    throw new Error("remote tfx-live returned empty output");
+  }
+
+  const direct = tryParseJsonObject(text);
+  if (direct && typeof direct === "object" && !Array.isArray(direct)) {
+    return direct;
+  }
+
+  let parsed = null;
+  for (let start = 0; start < text.length; start += 1) {
+    if (text[start] !== "{") continue;
+    let depth = 0;
+    let inString = false;
+    let escaped = false;
+    for (let end = start; end < text.length; end += 1) {
+      const char = text[end];
+      if (inString) {
+        if (escaped) {
+          escaped = false;
+        } else if (char === "\\") {
+          escaped = true;
+        } else if (char === '"') {
+          inString = false;
+        }
+        continue;
+      }
+      if (char === '"') {
+        inString = true;
+      } else if (char === "{") {
+        depth += 1;
+      } else if (char === "}") {
+        depth -= 1;
+        if (depth === 0) {
+          const candidate = tryParseJsonObject(text.slice(start, end + 1));
+          if (
+            candidate &&
+            typeof candidate === "object" &&
+            !Array.isArray(candidate)
+          ) {
+            parsed = candidate;
+          }
+          break;
+        }
+      }
+    }
+  }
+
+  if (parsed) return parsed;
+  throw new Error(`remote tfx-live output is not JSON: ${text.slice(0, 200)}`);
+}
+
+async function callRemoteLive(verb, opts, deps = {}) {
+  const host = validateRemoteHost(opts.remote);
+  const probeRemoteEnv = deps.probeRemoteEnv ?? probeRemoteHostEnv;
+  const execRemote = deps.sshExec ?? execFileAsync;
+  const env = await probeRemoteEnv(host);
+  const plan = buildRemoteLiveCommand(host, verb, opts, env);
+  const execOptions = {
+    timeout: (opts.timeoutMs ?? DEFAULT_ANSWER_TIMEOUT_MS) + 30_000,
+    maxBuffer: MAX_BUFFER,
+  };
+
+  try {
+    const { stdout } = await execRemote(plan.command, plan.args, execOptions);
+    return parseRemoteLiveJson(stdout);
+  } catch (error) {
+    if (error?.stdout) {
+      try {
+        return parseRemoteLiveJson(error.stdout);
+      } catch {
+        // stdout was not a tfx-live JSON result; fall through.
+      }
+    }
+    const stderr = error?.stderr ? String(error.stderr).trim() : "";
+    throw new Error(
+      `remote tfx-live ${verb} failed: ${stderr || error.message}`,
+    );
+  }
+}
+
 async function runTmux(remote, tmuxArgs, options = {}) {
   const { command, args } = buildTmuxCommand(remote, tmuxArgs);
   try {
@@ -397,6 +555,144 @@ function extractAssistantResponse(adapter, text, prompt = null) {
   return response.join("\n").trim();
 }
 
+function normalizeClaudeTaskText(text) {
+  return String(text)
+    .replace(/[.…]+/g, " ")
+    .replace(/\s+/g, " ")
+    .trim()
+    .toLowerCase();
+}
+
+function isTaskListBoundary(line) {
+  const trimmed = line.trim();
+  return (
+    !trimmed ||
+    trimmed === "Working" ||
+    trimmed === "Completed" ||
+    /^[─-]{8,}$/.test(trimmed) ||
+    hasClaudeComposerPrompt(line) ||
+    /enter to open|space to reply|ctrl\+x to delete|\? for shortcuts/i.test(
+      trimmed,
+    )
+  );
+}
+
+function parseClaudeCompletedTaskListEntries(text) {
+  const lines = String(text)
+    .split("\n")
+    .map((line) => line.replace(/\s+$/g, ""));
+  const entries = [];
+  let inCompleted = false;
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed === "Completed") {
+      inCompleted = true;
+      continue;
+    }
+    if (!inCompleted) {
+      continue;
+    }
+    if (isTaskListBoundary(line)) {
+      if (trimmed) {
+        inCompleted = false;
+      }
+      continue;
+    }
+    if (!/^\s*✻\s+/.test(line)) {
+      continue;
+    }
+
+    const body = trimmed.replace(/^✻\s+/, "");
+    const columns = body
+      .split(/\s{2,}/)
+      .map((column) => column.trim())
+      .filter(Boolean);
+    if (columns.length < 2) {
+      continue;
+    }
+
+    let responseIndex = columns.length - 1;
+    const tail = columns[responseIndex];
+    if (/^(?:\d+\s*[smhdw]|now|just now)$/i.test(tail)) {
+      responseIndex -= 1;
+    }
+    if (responseIndex <= 0) {
+      continue;
+    }
+
+    const summary = columns.slice(0, responseIndex).join(" ").trim();
+    const response = columns[responseIndex].trim();
+    if (!summary || !response) {
+      continue;
+    }
+    entries.push({
+      summary,
+      response,
+      key: `${normalizeClaudeTaskText(summary)}\0${normalizeClaudeTaskText(
+        response,
+      )}`,
+    });
+  }
+
+  return entries;
+}
+
+function claudeTaskMatchesPrompt(entry, prompt) {
+  if (!prompt) {
+    return true;
+  }
+  const summary = normalizeClaudeTaskText(entry.summary);
+  const normalizedPrompt = normalizeClaudeTaskText(prompt);
+  return (
+    Boolean(summary && normalizedPrompt) &&
+    (summary.includes(normalizedPrompt) || normalizedPrompt.includes(summary))
+  );
+}
+
+function extractClaudeCompletedTaskListResponse(text, options = {}) {
+  const beforeEntries = parseClaudeCompletedTaskListEntries(options.beforeText);
+  const beforeKeys = new Set(beforeEntries.map((entry) => entry.key));
+  const newEntries = parseClaudeCompletedTaskListEntries(text).filter(
+    (entry) => !beforeKeys.has(entry.key),
+  );
+  if (newEntries.length === 0) {
+    return "";
+  }
+  const promptMatches = options.prompt
+    ? newEntries.filter((entry) =>
+        claudeTaskMatchesPrompt(entry, options.prompt),
+      )
+    : [];
+  if (promptMatches.length > 0) {
+    return promptMatches[0].response;
+  }
+  if (newEntries.length === 1) {
+    return newEntries[0].response;
+  }
+  return newEntries.at(-1).response;
+}
+
+function hasClaudeCompletedTaskListResponse(text, options = {}) {
+  return extractClaudeCompletedTaskListResponse(text, options).length > 0;
+}
+
+function hasTmuxAssistantResponseAfterPrompt(
+  adapter,
+  text,
+  prompt,
+  beforeText,
+) {
+  return (
+    hasAssistantResponseAfterPrompt(adapter, text, prompt) ||
+    (adapter.cli === "claude" &&
+      hasClaudeCompletedTaskListResponse(text, {
+        beforeText,
+        prompt,
+      }))
+  );
+}
+
 async function capturePane(remote, session) {
   const { stdout } = await runTmux(remote, [
     "capture-pane",
@@ -787,18 +1083,81 @@ async function probeDaemon(bridgePath, ref, timeoutMs) {
     const payload = {};
     if (ref?.short) payload.short = ref.short;
     if (ref?.sessionId) payload.sessionId = ref.sessionId;
+    if (ref?.configDir) payload.configDir = ref.configDir;
     const result = await callBridgeVerb(
       bridgePath,
       "daemon-probe",
       payload,
       timeoutMs,
     );
-    return { ok: result?.ok === true, sessions: result?.sessions, raw: result };
+    return {
+      ok: result?.ok === true,
+      reason: result?.reason,
+      sessions: result?.sessions,
+      raw: result,
+    };
   } catch (error) {
     return { ok: false, reason: error.message };
   }
 }
 
+async function hasTmuxSession(adapter, opts) {
+  if (!opts.session) return false;
+  try {
+    await runTmux(opts.remote, ["has-session", "-t", opts.session]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function daemonProbeUnavailableReason(probe, targetAttachable) {
+  if (targetAttachable) return null;
+  if (!probe?.ok) return probe?.reason ?? "probe-failed";
+  return "target-not-found";
+}
+
+async function resolveAskTransport(adapter, opts, deps = {}) {
+  const transport = opts.transport ?? "tmux";
+  if (transport !== "auto") {
+    return {
+      transport,
+      transportSelected: transport,
+      transportProbe: null,
+    };
+  }
+
+  const tmuxProbe = deps.hasTmuxSession ?? hasTmuxSession;
+  const daemonProbe = deps.probeDaemon ?? probeDaemon;
+  const [tmux, probe] = await Promise.all([
+    tmuxProbe(adapter, opts),
+    daemonProbe(
+      opts.bridgePath,
+      {
+        short: opts.short,
+        sessionId: opts.sessionId,
+        configDir: opts.configDir,
+      },
+      opts.timeoutMs,
+    ),
+  ]);
+  const daemon = daemonProbeTargetAttachable(probe, opts);
+  const daemonReason = daemonProbeUnavailableReason(probe, daemon);
+  const transportProbe = {
+    tmux: tmux === true,
+    daemon,
+    ...(daemonReason ? { daemonReason } : {}),
+  };
+
+  return {
+    transport: "auto",
+    transportSelected: daemon ? "uds" : tmux ? "tmux" : "none",
+    transportProbe,
+    daemonProbe: probe,
+    daemonConfigDir: opts.configDir ?? probe?.raw?.daemon?.configDir ?? null,
+  };
+}
+
 async function doStart(adapter, opts) {
   const {
     session,
@@ -874,7 +1233,7 @@ async function doAskViaTmux(adapter, opts) {
     const doneSignal =
       !adapter.isBusy(visible) &&
       ready &&
-      hasAssistantResponseAfterPrompt(adapter, visible, prompt);
+      hasTmuxAssistantResponseAfterPrompt(adapter, visible, prompt, beforeRaw);
     if (doneSignal && quietPolls >= FALLBACK_QUIET_POLLS) {
       done = true;
       break;
@@ -885,6 +1244,15 @@ async function doAskViaTmux(adapter, opts) {
 
   raw = await capturePane(remote, session);
   response = extractAssistantResponse(adapter, raw, prompt);
+  if (!response && adapter.cli === "claude") {
+    response = extractClaudeCompletedTaskListResponse(raw, {
+      beforeText: beforeRaw,
+      prompt,
+    });
+    if (response) {
+      done = true;
+    }
+  }
   contextPctAfter = adapter.contextPct(raw);
 
   return addLoginGuard(adapter, raw, {
@@ -895,6 +1263,7 @@ async function doAskViaTmux(adapter, opts) {
     response,
     contextPctBefore,
     contextPctAfter,
+    matchedCompletion: done,
     done,
     raw,
   });
@@ -918,6 +1287,10 @@ async function doAsk(adapter, opts) {
     );
   }
 
+  if (opts.remote) {
+    return doAskViaRemoteLive(adapter, opts);
+  }
+
   if (transport === "uds") {
     if (!opts.bridgePath) {
       throw new Error(
@@ -930,11 +1303,22 @@ async function doAsk(adapter, opts) {
   return doAskAuto(adapter, opts);
 }
 
+async function doAskViaRemoteLive(adapter, opts, deps = {}) {
+  const result = await callRemoteLive("ask", opts, deps);
+  return {
+    ...result,
+    cli: result.cli ?? adapter.cli,
+    remote: opts.remote,
+    remoteRelay: true,
+  };
+}
+
 async function doAskViaDaemon(opts, meta = {}) {
-  const { bridgePath, prompt, timeoutMs, short, sessionId } = opts;
+  const { bridgePath, prompt, timeoutMs, short, sessionId, configDir } = opts;
   const payload = { prompt, timeoutMs };
   if (short) payload.short = short;
   if (sessionId) payload.sessionId = sessionId;
+  if (configDir) payload.configDir = configDir;
 
   const result = await callBridgeVerb(
     bridgePath,
@@ -956,12 +1340,35 @@ async function doAskViaDaemon(opts, meta = {}) {
     timedOut: result?.timedOut === true,
     closed: result?.closed === true,
     inputSent: result?.inputSent === true,
+    daemon: result?.daemon ?? null,
+    daemons: result?.daemons ?? [],
+    matches: result?.matches ?? [],
+    candidateResults: result?.candidateResults ?? [],
+    callerProvenance: result?.callerProvenance ?? null,
     done: matchedCompletion,
     ...(result?.error ? { error: result.error } : {}),
     ...meta,
   };
 }
 
+function daemonProbeTargetAttachable(probe, opts) {
+  if (!probe?.ok) return false;
+  // New bridge responses carry `target`; daemon-control owns selection policy.
+  if (probe.raw?.target) return true;
+  // Compatibility only for older bridge binaries that list sessions but do not
+  // expose `target` yet. Do not add new selection semantics here.
+  if (!Array.isArray(probe.sessions)) return false;
+  return probe.sessions.some(
+    (entry) =>
+      (opts.short && entry?.short === opts.short) ||
+      (opts.sessionId &&
+        (entry?.sessionId === opts.sessionId ||
+          entry?.session_id === opts.sessionId ||
+          entry?.dispatch?.sessionId === opts.sessionId ||
+          entry?.d?.sessionId === opts.sessionId)),
+  );
+}
+
 async function ensureTmuxSession(adapter, opts) {
   if (!opts.session) return false;
   try {
@@ -1004,6 +1411,13 @@ function writeUdsBugReport(reason, context) {
                 .map((entry) => entry?.short)
                 .filter(Boolean)
             : [],
+          // Diagnostic-only bridge metadata; callers should not depend on this
+          // shape as a versioned control contract.
+          daemon: context.probe.raw?.daemon ?? null,
+          daemons: context.probe.raw?.daemons ?? [],
+          matches: context.probe.raw?.matches ?? [],
+          candidateResults: context.probe.raw?.candidateResults ?? [],
+          callerProvenance: context.probe.raw?.callerProvenance ?? null,
         }
       : null,
     attachError: context.attachError ?? null,
@@ -1050,28 +1464,28 @@ async function runTmuxFallback(adapter, opts, reason, udsResult) {
 }
 
 async function doAskAuto(adapter, opts) {
-  const probe = await probeDaemon(
-    opts.bridgePath,
-    { short: opts.short, sessionId: opts.sessionId },
-    opts.timeoutMs,
-  );
-  // daemon-probe returns the full session list (it does not filter by the
-  // requested short), so confirm the target is actually attachable here rather
-  // than firing a doomed attach at a missing short.
-  const targetAttachable =
-    probe.ok &&
-    Array.isArray(probe.sessions) &&
-    probe.sessions.some(
-      (entry) =>
-        (opts.short && entry?.short === opts.short) ||
-        (opts.sessionId && entry?.sessionId === opts.sessionId),
-    );
+  const resolution = await resolveAskTransport(adapter, opts);
+  const probe = resolution.daemonProbe;
 
-  if (targetAttachable) {
-    const udsResult = await doAskViaDaemon(opts, {
-      transportSelected: "uds",
-      transportProbe: "ok",
-    });
+  if (resolution.transportSelected === "tmux") {
+    const tmuxResult = await doAskViaTmux(adapter, opts);
+    return {
+      ...tmuxResult,
+      transport: "auto",
+      transportSelected: "tmux",
+      transportProbe: resolution.transportProbe,
+    };
+  }
+
+  if (resolution.transportSelected === "uds") {
+    const daemonConfigDir = resolution.daemonConfigDir;
+    const udsResult = await doAskViaDaemon(
+      { ...opts, configDir: daemonConfigDir },
+      {
+        transportSelected: "uds",
+        transportProbe: resolution.transportProbe,
+      },
+    );
     if (udsResult.matchedCompletion) {
       return udsResult;
     }
@@ -1089,27 +1503,48 @@ async function doAskAuto(adapter, opts) {
       probe,
       attachError,
     });
-    const fallback = await runTmuxFallback(
-      adapter,
-      opts,
-      "uds-attach-incomplete",
-      udsResult,
-    );
+    const fallback =
+      resolution.transportProbe?.tmux === true
+        ? await runTmuxFallback(
+            adapter,
+            opts,
+            "uds-attach-incomplete",
+            udsResult,
+          )
+        : {
+            cli: adapter.cli,
+            transport: "auto",
+            transportSelected: "none",
+            transportProbe: resolution.transportProbe,
+            response: "",
+            done: false,
+            error:
+              "uds unavailable (uds-attach-incomplete) and no tmux session for fallback",
+            udsError: udsResult.error ?? attachError,
+          };
     await reportPromise.catch(() => {});
     return fallback;
   }
 
   // uds is unavailable: daemon unreachable, or reachable but target not listed.
-  const reason = !probe.ok
-    ? (probe.reason ?? "probe-failed")
-    : "target-not-found";
+  const reason = resolution.transportProbe?.daemonReason ?? "target-not-found";
   const reportPromise = writeUdsBugReport(reason, {
     short: opts.short,
     sessionId: opts.sessionId,
     bridgePath: opts.bridgePath,
     probe,
   });
-  const fallback = await runTmuxFallback(adapter, opts, reason, null);
+  const fallback = {
+    cli: adapter.cli,
+    transport: "auto",
+    transportSelected: "none",
+    transportProbe: resolution.transportProbe,
+    response: "",
+    done: false,
+    error: opts.session
+      ? `uds unavailable (${reason}) and tmux session unavailable`
+      : `uds unavailable (${reason}) and no --session for tmux fallback`,
+  };
   await reportPromise.catch(() => {});
   return fallback;
 }
@@ -1139,10 +1574,11 @@ async function doInterruptViaTmux(adapter, opts) {
 }
 
 async function doInterruptViaDaemon(opts, meta = {}) {
-  const { bridgePath, timeoutMs, short, sessionId } = opts;
+  const { bridgePath, timeoutMs, short, sessionId, configDir } = opts;
   const payload = { timeoutMs };
   if (short) payload.short = short;
   if (sessionId) payload.sessionId = sessionId;
+  if (configDir) payload.configDir = configDir;
   const result = await callBridgeVerb(
     bridgePath,
     "daemon-interrupt",
@@ -1161,11 +1597,26 @@ async function doInterruptViaDaemon(opts, meta = {}) {
     inputSent: result?.inputSent === true,
     timedOut: result?.timedOut === true,
     closed: result?.closed === true,
+    daemon: result?.daemon ?? null,
+    daemons: result?.daemons ?? [],
+    matches: result?.matches ?? [],
+    candidateResults: result?.candidateResults ?? [],
+    callerProvenance: result?.callerProvenance ?? null,
     ...(result?.error ? { error: result.error } : {}),
     ...meta,
   };
 }
 
+async function doInterruptViaRemoteLive(adapter, opts, deps = {}) {
+  const result = await callRemoteLive("interrupt", opts, deps);
+  return {
+    ...result,
+    cli: result.cli ?? adapter.cli,
+    remote: opts.remote,
+    remoteRelay: true,
+  };
+}
+
 async function doInterrupt(adapter, opts) {
   const transport = opts.transport ?? "tmux";
   if (transport === "tmux") {
@@ -1181,6 +1632,9 @@ async function doInterrupt(adapter, opts) {
       `--transport ${transport} requires --short or --session-id`,
     );
   }
+  if (opts.remote) {
+    return doInterruptViaRemoteLive(adapter, opts);
+  }
   if (!opts.bridgePath) {
     throw new Error(
       `--transport ${transport} requires a bridge path (--bridge, TFX_BRIDGE, or TFX_REPO_ROOT)`,
@@ -1269,6 +1723,7 @@ function askOpts(flags, adapter) {
       transport === "tmux" ? requireFlag(flags, "session") : flags.session,
     short,
     sessionId,
+    configDir: flags["config-dir"],
     transport,
     bridgePath: resolveBridgePath(flags),
     prompt: requireFlag(flags, "prompt"),
@@ -1295,6 +1750,7 @@ function interruptOpts(flags, adapter) {
       transport === "tmux" ? requireFlag(flags, "session") : flags.session,
     short,
     sessionId,
+    configDir: flags["config-dir"],
     transport,
     bridgePath: resolveBridgePath(flags),
     remote: flags.remote,
@@ -1326,6 +1782,7 @@ async function probe(flags) {
   const payload = {};
   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"];
   const timeoutMs = secondsFlag(flags, "timeout", 10_000);
   printJson(
     await callBridgeVerb(
@@ -1768,10 +2225,27 @@ async function main() {
   }
 }
 
-main().catch((error) => {
-  printJson({
-    ok: false,
-    error: error.message,
+export {
+  ADAPTERS,
+  buildRemoteLiveCommand,
+  callRemoteLive,
+  extractAssistantResponse,
+  extractClaudeCompletedTaskListResponse,
+  hasClaudeCompletedTaskListResponse,
+  parseRemoteLiveJson,
+  resolveAskTransport,
+};
+
+const isDirectRun =
+  process.argv[1] &&
+  fileURLToPath(import.meta.url) === pathResolve(process.argv[1]);
+
+if (isDirectRun) {
+  main().catch((error) => {
+    printJson({
+      ok: false,
+      error: error.message,
+    });
+    process.exitCode = 1;
   });
-  process.exitCode = 1;
-});
+}