triflux 10.33.1 → 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/config/mcp-registry.json

@@ -41,15 +41,6 @@
       "targets": ["claude", "gemini", "codex", "antigravity"],
       "description": "Exa neural/semantic web search — 학술/기술 깊이. Key 발급: https://exa.ai/dashboard → secrets.env의 EXA_API_KEY"
     },
-    "serena": {
-      "policy": "gateway-http",
-      "transport": "http",
-      "gateway_port": 8105,
-      "gateway_path": "/mcp",
-      "safe": true,
-      "targets": ["claude", "gemini", "codex", "antigravity"],
-      "description": "Serena MCP — local supergateway stateful Streamable HTTP endpoint (:8105/mcp)"
-    },
     "brave-search": {
       "policy": "gateway-http",
       "transport": "http",

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/hooks/session-start-fast.mjs

@@ -10,7 +10,7 @@
 //
 // external source 훅 (session-vault 등)은 여전히 execFile로 실행된다.
 
-import { execFile } from "node:child_process";
+import { execFile, execFileSync } from "node:child_process";
 import { dirname, join } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import {
@@ -40,6 +40,55 @@ function parseStartPayload(stdinData) {
   }
 }
 
+function readAncestorCommands(pid = process.ppid, maxDepth = 6) {
+  if (process.platform === "win32") return [];
+  const commands = [];
+  let currentPid = Number(pid);
+  for (let depth = 0; depth < maxDepth; depth++) {
+    if (!Number.isInteger(currentPid) || currentPid <= 1) break;
+    try {
+      const output = execFileSync(
+        "ps",
+        ["-o", "ppid=", "-o", "command=", "-p", String(currentPid)],
+        {
+          encoding: "utf8",
+          timeout: 200,
+          windowsHide: true,
+        },
+      ).trim();
+      const match = output.match(/^(\d+)\s+([\s\S]+)$/);
+      if (!match) break;
+      commands.push(match[2]);
+      currentPid = Number(match[1]);
+    } catch {
+      break;
+    }
+  }
+  return commands;
+}
+
+function commandUsesClaudePrintMode(command) {
+  return /\bclaude(?:\s+\S+)*\s+(?:--print|-p)(?:\s|=|$)/u.test(
+    String(command || ""),
+  );
+}
+
+function shouldSkipInteractiveRegistration(payload, seams = {}) {
+  const declaredKind = String(
+    payload?.sessionKind || payload?.session_kind || "",
+  )
+    .trim()
+    .toLowerCase();
+  if (declaredKind === "headless") return true;
+
+  const ancestorCommands = Array.isArray(seams.ancestorCommands)
+    ? seams.ancestorCommands
+    : readAncestorCommands(seams.parentPid);
+  return ancestorCommands.some((command) =>
+    commandUsesClaudePrintMode(command),
+  );
+}
+
 /**
  * cwd 기준 git 컨텍스트(worktree root / branch)를 best-effort, 비동기로 수집.
  * execFileSync 와 달리 호출자(BACKGROUND)를 블로킹하지 않는다. 각 git 호출은
@@ -107,6 +156,7 @@ export function registerInteractiveSession(stdinData, seams = {}) {
     const payload = parseStartPayload(stdinData);
     const sessionId = String(payload?.session_id || "").trim();
     if (!sessionId) return;
+    if (shouldSkipInteractiveRegistration(payload, seams)) return;
     const cwd = typeof payload?.cwd === "string" ? payload.cwd : process.cwd();
 
     // 1) cwd 만으로 즉시 minimal register (블로킹 git 없음, latency 0).