triflux 10.34.0 → 10.35.0

package/bin/tfx-live.mjs

@@ -34,11 +34,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]",
@@ -787,13 +787,19 @@ 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 };
   }
@@ -931,10 +937,11 @@ async function doAsk(adapter, opts) {
 }
 
 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 +963,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 +1034,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,
@@ -1052,26 +1089,23 @@ async function runTmuxFallback(adapter, opts, reason, udsResult) {
 async function doAskAuto(adapter, opts) {
   const probe = await probeDaemon(
     opts.bridgePath,
-    { short: opts.short, sessionId: opts.sessionId },
+    { short: opts.short, sessionId: opts.sessionId, configDir: opts.configDir },
     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 targetAttachable = daemonProbeTargetAttachable(probe, opts);
 
   if (targetAttachable) {
-    const udsResult = await doAskViaDaemon(opts, {
-      transportSelected: "uds",
-      transportProbe: "ok",
-    });
+    const daemonConfigDir = opts.configDir ?? probe.raw?.daemon?.configDir;
+    const udsResult = await doAskViaDaemon(
+      { ...opts, configDir: daemonConfigDir },
+      {
+        transportSelected: "uds",
+        transportProbe: "ok",
+      },
+    );
     if (udsResult.matchedCompletion) {
       return udsResult;
     }
@@ -1139,10 +1173,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,6 +1196,11 @@ 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,
   };
@@ -1269,6 +1309,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 +1336,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 +1368,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(

package/cto/status.mjs

@@ -29,7 +29,61 @@ function toIsoTime(value) {
   return null;
 }
 
+function shortHash(value) {
+  const str = String(value ?? "");
+  let h = 5381;
+  for (let i = 0; i < str.length; i++) {
+    h = (h * 33) ^ str.charCodeAt(i);
+  }
+  return (h >>> 0).toString(36);
+}
+
+function pathLabel(value) {
+  const str = String(value ?? "").replace(/[/\\]+$/u, "");
+  if (!str) return "";
+  const segments = str.split(/[/\\]+/u);
+  return segments[segments.length - 1] || "";
+}
+
+export function deriveRepoRootFromCwd(cwd) {
+  if (typeof cwd !== "string" || !cwd) return "";
+  if (cwd.includes("\\") || /^[A-Za-z]:/u.test(cwd)) return cwd;
+
+  const normalized = cwd.replace(/\/+$/u, "");
+  const claudeMarker = "/.claude/worktrees/";
+  const claudeIndex = normalized.indexOf(claudeMarker);
+  if (claudeIndex > 0) {
+    const suffix = normalized.slice(claudeIndex + claudeMarker.length);
+    if (/^[^/]+(?:\/|$)/u.test(suffix)) {
+      return normalized.slice(0, claudeIndex);
+    }
+  }
+
+  const codexMarker = "/.codex-swarm/";
+  const codexIndex = normalized.indexOf(codexMarker);
+  if (codexIndex > 0) {
+    const suffix = normalized.slice(codexIndex + codexMarker.length);
+    if (/^wt-[^/]+(?:\/|$)/u.test(suffix)) {
+      return normalized.slice(0, codexIndex);
+    }
+  }
+
+  return cwd;
+}
+
+function redactedCwdFields(cwd) {
+  if (typeof cwd !== "string" || !cwd) return {};
+  const repoRoot = deriveRepoRootFromCwd(cwd);
+  return {
+    cwdLabel: pathLabel(cwd),
+    cwdHash: shortHash(cwd),
+    repoRootLabel: pathLabel(repoRoot),
+    repoRootHash: shortHash(repoRoot),
+  };
+}
+
 function normalizeLiveSession(session) {
+  const cwd = typeof session?.cwd === "string" ? session.cwd : "";
   return {
     sessionId: String(session?.sessionId || ""),
     host: typeof session?.host === "string" ? session.host : "local",
@@ -48,6 +102,7 @@ function normalizeLiveSession(session) {
     started_at: toIsoTime(
       session?.started_at ?? session?.startedAt ?? session?.lastHeartbeat,
     ),
+    ...redactedCwdFields(cwd),
   };
 }
 
@@ -164,7 +219,27 @@ function deriveActiveShards(current, overlay) {
   return shards.map(normalizeActiveShard).filter((shard) => shard.shard_name);
 }
 
+function deriveLiveSessionGroups(liveSessions) {
+  const groups = new Map();
+  for (const session of liveSessions || []) {
+    if (!session?.repoRootHash) continue;
+    if (!groups.has(session.repoRootHash)) {
+      groups.set(session.repoRootHash, {
+        repoRootLabel: session.repoRootLabel || "",
+        repoRootHash: session.repoRootHash,
+        session_count: 0,
+        sessions: [],
+      });
+    }
+    const group = groups.get(session.repoRootHash);
+    group.session_count += 1;
+    group.sessions.push(session.sessionId);
+  }
+  return [...groups.values()];
+}
+
 function projectStatus(current, overlay) {
+  const liveSessions = overlay.live_sessions;
   return {
     schema_version: current?.schema_version || SCHEMA_VERSION,
     generated_at: current?.generated_at || null,
@@ -172,7 +247,8 @@ function projectStatus(current, overlay) {
     sources: current?.sources || {},
     summary: current?.summary || {},
     ledger_tail: Array.isArray(current?.ledger_tail) ? current.ledger_tail : [],
-    live_sessions: overlay.live_sessions,
+    live_sessions: liveSessions,
+    live_session_groups: deriveLiveSessionGroups(liveSessions),
     active_shards: deriveActiveShards(current, overlay),
   };
 }

package/hooks/agy-session-hook.mjs

@@ -0,0 +1,140 @@
+#!/usr/bin/env node
+
+import { argv, exit, stdin, stdout } from "node:process";
+import { pathToFileURL } from "node:url";
+import { drainPendingSynapse as defaultDrainPendingSynapse } from "../hub/team/synapse-http.mjs";
+import {
+  heartbeatInteractiveSession as defaultHeartbeatInteractiveSession,
+  registerInteractiveSession as defaultRegisterInteractiveSession,
+} from "./session-start-fast.mjs";
+
+// hub-ensure is loaded lazily so the byte-identical packages/core mirror of this
+// file loads cleanly. packages/core mirrors scripts/lib only (not scripts/*), so a
+// static `../scripts/hub-ensure.mjs` import would make the core copy throw
+// ERR_MODULE_NOT_FOUND at load time. Mirrors codex-session-hook.mjs's pattern.
+async function defaultHubEnsureRun(stdinData) {
+  const { run } = await import(
+    new URL("../scripts/hub-ensure.mjs", import.meta.url).href
+  );
+  return run(stdinData);
+}
+
+function parsePayload(stdinData) {
+  try {
+    const raw = typeof stdinData === "string" ? stdinData : "";
+    return raw.trim()
+      ? { ok: true, payload: JSON.parse(raw) }
+      : { ok: false, payload: {} };
+  } catch {
+    return { ok: false, payload: {} };
+  }
+}
+
+// Antigravity hook payloads use camelCase system metadata (conversationId,
+// workspacePaths) rather than Codex's session_id/cwd. registerInteractiveSession
+// and heartbeatInteractiveSession parse the Codex shape, so we adapt the agy
+// payload into that shape before delegating. conversationId is the stable
+// per-conversation UUID (== session identity); the first mounted workspace path
+// is the effective cwd.
+export function toSessionPayload(payload) {
+  const sessionId = String(payload?.conversationId || "").trim();
+  const workspacePaths = Array.isArray(payload?.workspacePaths)
+    ? payload.workspacePaths
+    : [];
+  const cwd =
+    typeof workspacePaths[0] === "string" && workspacePaths[0]
+      ? workspacePaths[0]
+      : process.cwd();
+  return JSON.stringify({ session_id: sessionId, cwd });
+}
+
+// agy has no distinct SessionStart / UserPromptSubmit events. PreInvocation
+// fires before every model call, so the per-conversation invocationNum gates
+// register (first call == session start) vs heartbeat (subsequent calls).
+// An explicit argv mode (register|heartbeat) overrides, mirroring the codex hook.
+export function normalizeMode(argvMode, payload) {
+  const direct = String(argvMode || "")
+    .trim()
+    .toLowerCase();
+  if (direct === "register" || direct === "heartbeat") return direct;
+
+  const invocationNum = Number(payload?.invocationNum);
+  if (Number.isFinite(invocationNum)) {
+    return invocationNum <= 1 ? "register" : "heartbeat";
+  }
+  // Unknown invocation index: register is idempotent and also ensures the hub,
+  // so it is the safe default for a first-contact payload.
+  return "register";
+}
+
+export async function runAgySessionHook(stdinData, opts = {}) {
+  const output = "{}\n";
+  const parsed = parsePayload(stdinData);
+  if (!parsed.ok) {
+    if (opts.writeStdout !== false) stdout.write(output);
+    return output;
+  }
+
+  const sessionPayload = toSessionPayload(parsed.payload);
+  const sessionId = JSON.parse(sessionPayload).session_id;
+  // No conversation id means nothing to register; stay a silent no-op.
+  if (!sessionId) {
+    if (opts.writeStdout !== false) stdout.write(output);
+    return output;
+  }
+
+  const mode = normalizeMode(opts.argvMode ?? argv[2], parsed.payload);
+  const hubEnsureRun = opts.hubEnsureRun || defaultHubEnsureRun;
+  const registerInteractiveSession =
+    opts.registerInteractiveSession || defaultRegisterInteractiveSession;
+  const heartbeatInteractiveSession =
+    opts.heartbeatInteractiveSession || defaultHeartbeatInteractiveSession;
+  const drainPendingSynapse =
+    opts.drainPendingSynapse || defaultDrainPendingSynapse;
+
+  try {
+    if (mode === "register") {
+      try {
+        await hubEnsureRun(sessionPayload);
+      } catch {}
+      try {
+        registerInteractiveSession(sessionPayload);
+      } catch {}
+      try {
+        await drainPendingSynapse(1000);
+      } catch {}
+    } else if (mode === "heartbeat") {
+      try {
+        heartbeatInteractiveSession(sessionPayload);
+      } catch {}
+      try {
+        await drainPendingSynapse(500);
+      } catch {}
+    }
+  } catch {
+    // agy session hooks are observational and must never block the session.
+  }
+
+  if (opts.writeStdout !== false) {
+    stdout.write(output);
+  }
+  return output;
+}
+
+function readStdin() {
+  return new Promise((resolve) => {
+    let data = "";
+    stdin.setEncoding("utf8");
+    stdin.on("data", (chunk) => {
+      data += chunk;
+    });
+    stdin.on("end", () => resolve(data));
+    stdin.on("error", () => resolve(data));
+  });
+}
+
+if (argv[1] && import.meta.url === pathToFileURL(argv[1]).href) {
+  const stdinData = await readStdin();
+  await runAgySessionHook(stdinData);
+  exit(0);
+}

package/hub/bridge.mjs

@@ -1186,6 +1186,36 @@ function daemonAttachErrorResult(error) {
   };
 }
 
+function daemonAttachProbeFailureResult(probe) {
+  return {
+    ok: false,
+    text: "",
+    raw: "",
+    responseRaw: "",
+    matchedCompletion: false,
+    timedOut: false,
+    closed: false,
+    inputSent: false,
+    error: probe?.error || probe?.reason || "Claude daemon unavailable",
+    reason: probe?.reason || "daemon-unavailable",
+    daemon: probe?.daemon ?? null,
+    daemons: probe?.daemons ?? [],
+    matches: probe?.matches ?? [],
+    candidateResults: probe?.candidateResults ?? [],
+    callerProvenance: probe?.callerProvenance ?? null,
+  };
+}
+
+function daemonProbeMetadata(probe) {
+  return {
+    daemon: probe?.daemon ?? null,
+    daemons: probe?.daemons ?? [],
+    matches: probe?.matches ?? [],
+    candidateResults: probe?.candidateResults ?? [],
+    callerProvenance: probe?.callerProvenance ?? null,
+  };
+}
+
 function daemonInterruptErrorResult(error) {
   return {
     ok: false,
@@ -1197,6 +1227,22 @@ function daemonInterruptErrorResult(error) {
   };
 }
 
+function daemonInterruptProbeFailureResult(probe) {
+  return {
+    ok: false,
+    done: false,
+    aborted: false,
+    reason: probe?.reason || "interrupt_failed",
+    inputSent: false,
+    error: probe?.error || probe?.reason || "Claude daemon unavailable",
+    daemon: probe?.daemon ?? null,
+    daemons: probe?.daemons ?? [],
+    matches: probe?.matches ?? [],
+    candidateResults: probe?.candidateResults ?? [],
+    callerProvenance: probe?.callerProvenance ?? null,
+  };
+}
+
 function numericOption(value, fallback) {
   const parsed = Number(value);
   return Number.isFinite(parsed) ? parsed : fallback;
@@ -1205,35 +1251,15 @@ function numericOption(value, fallback) {
 async function cmdDaemonProbe(args) {
   try {
     const payload = readBridgePayload(args);
-    const {
-      deriveClaudeDaemonPaths,
-      extractClaudeAgentSessions,
-      findDaemonJobBySessionId,
-      findDaemonJobByShort,
-      sendClaudeControlRequest,
-    } = await loadDaemonControl();
-    const daemonPaths = deriveClaudeDaemonPaths({
+    const { probeClaudeDaemonCandidates } = await loadDaemonControl();
+    const probe = await probeClaudeDaemonCandidates({
       configDir: payload.configDir,
+      env: process.env,
+      short: payload.short,
+      sessionId: payload.sessionId,
+      timeoutMs: numericOption(payload.timeoutMs, 6000),
     });
-    const list = await sendClaudeControlRequest(
-      daemonPaths.controlSock,
-      { proto: 1, op: "list" },
-      { timeoutMs: numericOption(payload.timeoutMs, 6000) },
-    );
-    const target = payload.sessionId
-      ? findDaemonJobBySessionId(list, payload.sessionId)
-      : payload.short
-        ? findDaemonJobByShort(list, payload.short)
-        : null;
-    const sessions = extractClaudeAgentSessions(list);
-
-    return emitJson({
-      ok: list?.ok !== false,
-      controlSock: daemonPaths.controlSock,
-      sessions,
-      target: target || undefined,
-      error: list?.ok === false ? list?.error : undefined,
-    });
+    return emitJson(probe);
   } catch (error) {
     return emitJson(daemonErrorResult(error));
   }
@@ -1246,33 +1272,49 @@ async function cmdDaemonAttach(args) {
 
     const {
       attachClaudeDaemonSession,
-      deriveClaudeDaemonPaths,
-      findDaemonJobBySessionId,
-      sendClaudeControlRequest,
+      buildDaemonControlAuth,
+      probeClaudeDaemonCandidates,
     } = await loadDaemonControl();
-    const daemonPaths = deriveClaudeDaemonPaths({
+    const probe = await probeClaudeDaemonCandidates({
       configDir: payload.configDir,
+      env: process.env,
+      short: payload.short,
+      sessionId: payload.sessionId,
+      timeoutMs: numericOption(payload.timeoutMs, 6000),
     });
-    let short = payload.short;
-    if (!short && payload.sessionId) {
-      const list = await sendClaudeControlRequest(
-        daemonPaths.controlSock,
-        { proto: 1, op: "list" },
-        { timeoutMs: numericOption(payload.timeoutMs, 6000) },
+    if (!probe.ok) return emitJson(daemonAttachProbeFailureResult(probe));
+    const short = payload.short ?? probe.target?.short;
+    if (!short) {
+      return emitJson(
+        daemonAttachProbeFailureResult({
+          ...probe,
+          ok: false,
+          reason: "target-not-found",
+          error: "short or resolvable sessionId is required",
+        }),
       );
-      const target = findDaemonJobBySessionId(list, payload.sessionId);
-      short = target?.short;
     }
-    if (!short) throw new Error("short or resolvable sessionId is required");
-
-    const result = await attachClaudeDaemonSession({
-      controlSock: daemonPaths.controlSock,
-      short,
-      input: payload.prompt,
-      cols: numericOption(payload.cols, undefined),
-      rows: numericOption(payload.rows, undefined),
-      timeoutMs: numericOption(payload.timeoutMs, 30_000),
-    });
+    const controlAuth = await buildDaemonControlAuth(
+      probe.daemon?.configDir ?? payload.configDir,
+    );
+
+    let result;
+    try {
+      result = await attachClaudeDaemonSession({
+        controlSock: probe.controlSock,
+        short,
+        input: payload.prompt,
+        ...controlAuth,
+        cols: numericOption(payload.cols, undefined),
+        rows: numericOption(payload.rows, undefined),
+        timeoutMs: numericOption(payload.timeoutMs, 30_000),
+      });
+    } catch (error) {
+      return emitJson({
+        ...daemonAttachErrorResult(error),
+        ...daemonProbeMetadata(probe),
+      });
+    }
 
     return emitJson({
       ok: result.matchedCompletion === true,
@@ -1285,6 +1327,7 @@ async function cmdDaemonAttach(args) {
       inputSent: result.inputSent === true,
       error:
         result.handshake?.ok === false ? result.handshake?.error : undefined,
+      ...daemonProbeMetadata(probe),
     });
   } catch (error) {
     return emitJson(daemonAttachErrorResult(error));
@@ -1296,33 +1339,49 @@ async function cmdDaemonInterrupt(args) {
     const payload = readBridgePayload(args);
 
     const {
-      deriveClaudeDaemonPaths,
-      findDaemonJobBySessionId,
+      buildDaemonControlAuth,
       interruptClaudeDaemonSession,
-      sendClaudeControlRequest,
+      probeClaudeDaemonCandidates,
     } = await loadDaemonControl();
-    const daemonPaths = deriveClaudeDaemonPaths({
+    const probe = await probeClaudeDaemonCandidates({
       configDir: payload.configDir,
+      env: process.env,
+      short: payload.short,
+      sessionId: payload.sessionId,
+      timeoutMs: numericOption(payload.timeoutMs, 6000),
     });
-    let short = payload.short;
-    if (!short && payload.sessionId) {
-      const list = await sendClaudeControlRequest(
-        daemonPaths.controlSock,
-        { proto: 1, op: "list" },
-        { timeoutMs: numericOption(payload.timeoutMs, 6000) },
+    if (!probe.ok) return emitJson(daemonInterruptProbeFailureResult(probe));
+    const short = payload.short ?? probe.target?.short;
+    if (!short) {
+      return emitJson(
+        daemonInterruptProbeFailureResult({
+          ...probe,
+          ok: false,
+          reason: "target-not-found",
+          error: "short or resolvable sessionId is required",
+        }),
       );
-      const target = findDaemonJobBySessionId(list, payload.sessionId);
-      short = target?.short;
     }
-    if (!short) throw new Error("short or resolvable sessionId is required");
-
-    const result = await interruptClaudeDaemonSession({
-      controlSock: daemonPaths.controlSock,
-      short,
-      cols: numericOption(payload.cols, undefined),
-      rows: numericOption(payload.rows, undefined),
-      timeoutMs: numericOption(payload.timeoutMs, 5000),
-    });
+    const controlAuth = await buildDaemonControlAuth(
+      probe.daemon?.configDir ?? payload.configDir,
+    );
+
+    let result;
+    try {
+      result = await interruptClaudeDaemonSession({
+        controlSock: probe.controlSock,
+        short,
+        ...controlAuth,
+        cols: numericOption(payload.cols, undefined),
+        rows: numericOption(payload.rows, undefined),
+        timeoutMs: numericOption(payload.timeoutMs, 5000),
+      });
+    } catch (error) {
+      return emitJson({
+        ...daemonInterruptErrorResult(error),
+        ...daemonProbeMetadata(probe),
+      });
+    }
     const aborted = result.inputSent === true;
 
     return emitJson({
@@ -1336,6 +1395,7 @@ async function cmdDaemonInterrupt(args) {
       inputSent: result.inputSent === true,
       error:
         result.handshake?.ok === false ? result.handshake?.error : undefined,
+      ...daemonProbeMetadata(probe),
     });
   } catch (error) {
     return emitJson(daemonInterruptErrorResult(error));