triflux 10.32.0 → 10.33.1

package/bin/triflux.mjs

@@ -23,6 +23,7 @@ import { homedir, tmpdir } from "os";
 import { basename, dirname, join, resolve } from "path";
 import { fileURLToPath } from "url";
 import { loadDelegatorSchemaBundle } from "../hub/delegator/tool-definitions.mjs";
+import { inspectClaudeRuntimeFlags } from "../hub/diagnostics/claude-runtime-flags.mjs";
 import {
   checkNetworkAvailability,
   validateRuntimeCachePaths,
@@ -2524,6 +2525,15 @@ function addDoctorCheck(report, entry) {
   report.checks.push(entry);
 }
 
+function readJsonIfExists(filePath) {
+  if (!existsSync(filePath)) return {};
+  try {
+    return JSON.parse(readFileSync(filePath, "utf8"));
+  } catch {
+    return {};
+  }
+}
+
 function toHookCoverageName(fileName, fallbackId = "") {
   if (typeof fileName === "string" && fileName.trim()) {
     return basename(fileName).replace(/\.mjs$/i, "");
@@ -3453,6 +3463,22 @@ async function cmdDoctor(options = {}) {
       issues++;
     }
 
+    const claudeSettings = readJsonIfExists(join(CLAUDE_DIR, "settings.json"));
+    const runtimeFlags = inspectClaudeRuntimeFlags({
+      env: process.env,
+      settings: claudeSettings,
+    });
+    addDoctorCheck(report, {
+      name: "claude-runtime-flags",
+      status: runtimeFlags.status,
+      safe_mode: runtimeFlags.safeMode,
+      disable_bundled_skills: runtimeFlags.disableBundledSkills,
+      managed_mcp_policy: runtimeFlags.managedMcpPolicy,
+      summary: runtimeFlags.summary,
+      ...(runtimeFlags.fix ? { fix: runtimeFlags.fix } : {}),
+    });
+    if (runtimeFlags.status === "warning") warn(runtimeFlags.summary);
+
     // 7. psmux (Windows only)
     if (process.platform === "win32") {
       section("psmux (터미널 멀티플렉서)");

package/hooks/claude-cwd-projection-refresh.mjs

@@ -0,0 +1,83 @@
+#!/usr/bin/env node
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { refreshClaudeSessionProjectionCwd } from "../hub/team/claude-session-projection.mjs";
+
+function readStdin() {
+  try {
+    return fs.readFile(0, "utf8");
+  } catch {
+    return Promise.resolve("");
+  }
+}
+
+export function resolveCwdChangedPayload(input = {}, env = process.env) {
+  const sessionId = String(
+    input.session_id ??
+      input.sessionId ??
+      input.session?.id ??
+      env.CLAUDE_CODE_SESSION_ID ??
+      env.CLAUDE_SESSION_ID ??
+      "",
+  ).trim();
+  const cwd = String(
+    input.cwd ??
+      input.new_cwd ??
+      input.newCwd ??
+      input.current_cwd ??
+      input.workspace?.cwd ??
+      input.source?.cwd ??
+      "",
+  ).trim();
+  const configDir = path.resolve(
+    env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), ".claude"),
+  );
+  return {
+    eventName: String(input.hook_event_name || ""),
+    sessionId,
+    cwd,
+    sessionsDir: path.join(configDir, "sessions"),
+  };
+}
+
+export async function handleCwdChangedHook(stdinText, env = process.env) {
+  let input = {};
+  try {
+    input = stdinText.trim() ? JSON.parse(stdinText) : {};
+  } catch {
+    return { code: 0, stdout: "" };
+  }
+  const payload = resolveCwdChangedPayload(input, env);
+  if (payload.eventName && payload.eventName !== "CwdChanged") {
+    return { code: 0, stdout: "" };
+  }
+  if (!payload.sessionId || !payload.cwd) return { code: 0, stdout: "" };
+
+  const result = await refreshClaudeSessionProjectionCwd({
+    sessionsDir: payload.sessionsDir,
+    sessionId: payload.sessionId,
+    cwd: payload.cwd,
+  });
+  if (!result.updated) return { code: 0, stdout: "" };
+  return {
+    code: 0,
+    stdout: JSON.stringify({
+      hookSpecificOutput: {
+        hookEventName: "CwdChanged",
+        additionalContext: `Triflux projection cwd refreshed: ${payload.cwd}`,
+      },
+    }),
+  };
+}
+
+if (
+  process.argv[1] &&
+  path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)
+) {
+  const result = await handleCwdChangedHook(await readStdin());
+  if (result.stdout) process.stdout.write(result.stdout);
+  process.exit(result.code);
+}

package/hooks/codex-session-hook.mjs

@@ -51,6 +51,33 @@ function normalizeMode(mode, payload) {
   return "";
 }
 
+function swallowStdoutWrite(_chunk, encodingOrCallback, callback) {
+  const done =
+    typeof encodingOrCallback === "function" ? encodingOrCallback : callback;
+  if (typeof done === "function") done();
+  return true;
+}
+
+async function runHookSideEffectsWithStdoutSuppressed(fn) {
+  const originalStdoutWrite = stdout.write;
+  const originalConsoleDebug = console.debug;
+  const originalConsoleInfo = console.info;
+  const originalConsoleLog = console.log;
+
+  stdout.write = swallowStdoutWrite;
+  console.debug = () => {};
+  console.info = () => {};
+  console.log = () => {};
+  try {
+    return await fn();
+  } finally {
+    stdout.write = originalStdoutWrite;
+    console.debug = originalConsoleDebug;
+    console.info = originalConsoleInfo;
+    console.log = originalConsoleLog;
+  }
+}
+
 export async function runCodexSessionHook(stdinData, opts = {}) {
   const output = "{}\n";
   const parsed = parsePayload(stdinData);
@@ -66,24 +93,26 @@ export async function runCodexSessionHook(stdinData, opts = {}) {
     opts.drainPendingSynapse || defaultDrainPendingSynapse;
 
   try {
-    if (mode === "register") {
-      try {
-        await hubEnsureRun(stdinData);
-      } catch {}
-      try {
-        registerInteractiveSession(stdinData);
-      } catch {}
-      try {
-        await drainPendingSynapse(1000);
-      } catch {}
-    } else if (mode === "heartbeat") {
-      try {
-        heartbeatInteractiveSession(stdinData);
-      } catch {}
-      try {
-        await drainPendingSynapse(500);
-      } catch {}
-    }
+    await runHookSideEffectsWithStdoutSuppressed(async () => {
+      if (mode === "register") {
+        try {
+          await hubEnsureRun(stdinData);
+        } catch {}
+        try {
+          registerInteractiveSession(stdinData);
+        } catch {}
+        try {
+          await drainPendingSynapse(1000);
+        } catch {}
+      } else if (mode === "heartbeat") {
+        try {
+          heartbeatInteractiveSession(stdinData);
+        } catch {}
+        try {
+          await drainPendingSynapse(500);
+        } catch {}
+      }
+    });
   } catch {
     // Codex session hooks are observational and must never block the session.
   }

package/hooks/hook-orchestrator.mjs

@@ -465,6 +465,28 @@ async function main() {
     }
   }
 
+  // ── Stop: interactive 세션 liveness heartbeat (턴 종료 시) ──
+  // UserPromptSubmit 은 턴 *시작* 에, Stop 은 매 어시스턴트 턴 *종료* 에 heartbeat
+  // 한다. 둘이 함께 "대화 중이지만 매 분 새 프롬프트를 보내지는 않는" 세션을 5분
+  // interactive TTL 위로 유지해, 대화 도중 stale 로 떨어져 `cto status`
+  // live_sessions / tray 에서 사라지는 것을 막는다. 진짜 완전 idle(턴 자체가 없음)
+  // 은 여전히 TTL 후 stale 로 가며 — 그게 의도된 dead-session 신호다. UserPromptSubmit
+  // 과 동일하게 fire-and-forget POST 직후 짧은 상한으로 drain 한다.
+  if (eventName === "Stop") {
+    try {
+      const { heartbeatInteractiveSession } = await import(
+        "./session-start-fast.mjs"
+      );
+      heartbeatInteractiveSession(stdinRaw);
+      const { drainPendingSynapse } = await import(
+        "../hub/team/synapse-http.mjs"
+      );
+      await drainPendingSynapse(500);
+    } catch {
+      /* best-effort — heartbeat 실패가 Stop 을 막지 않는다 */
+    }
+  }
+
   // 이벤트에 해당하는 훅 목록
   const hooks = registry.events[eventName];
   if (!hooks || hooks.length === 0) process.exit(0);

package/hooks/hook-registry.json

@@ -8,6 +8,19 @@
     "external_priority": 100
   },
   "events": {
+    "CwdChanged": [
+      {
+        "id": "tfx-claude-cwd-projection-refresh",
+        "source": "triflux",
+        "matcher": "*",
+        "command": "node \"${PLUGIN_ROOT}/hooks/claude-cwd-projection-refresh.mjs\"",
+        "priority": 0,
+        "enabled": true,
+        "timeout": 2,
+        "blocking": false,
+        "description": "Claude /cd CwdChanged 이벤트를 Triflux native-bridge projection cwd에 반영"
+      }
+    ],
     "PermissionRequest": [
       {
         "id": "tfx-permission-safe-allow",

package/hooks/hooks.json

@@ -13,6 +13,18 @@
         ]
       }
     ],
+    "CwdChanged": [
+      {
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/hook-orchestrator.mjs\"",
+            "timeout": 5
+          }
+        ]
+      }
+    ],
     "UserPromptSubmit": [
       {
         "matcher": "*",

package/hub/bridge.mjs

@@ -1207,6 +1207,7 @@ async function cmdDaemonProbe(args) {
     const payload = readBridgePayload(args);
     const {
       deriveClaudeDaemonPaths,
+      extractClaudeAgentSessions,
       findDaemonJobBySessionId,
       findDaemonJobByShort,
       sendClaudeControlRequest,
@@ -1224,11 +1225,12 @@ async function cmdDaemonProbe(args) {
       : payload.short
         ? findDaemonJobByShort(list, payload.short)
         : null;
+    const sessions = extractClaudeAgentSessions(list);
 
     return emitJson({
       ok: list?.ok !== false,
       controlSock: daemonPaths.controlSock,
-      sessions: list?.jobs || list?.sessions || [],
+      sessions,
       target: target || undefined,
       error: list?.ok === false ? list?.error : undefined,
     });

package/hub/diagnostics/claude-runtime-flags.mjs

@@ -0,0 +1,64 @@
+export function readBooleanRuntimeFlag(value) {
+  const text = String(value ?? "")
+    .trim()
+    .toLowerCase();
+  return text === "1" || text === "true" || text === "yes" || text === "on";
+}
+
+function countStringArray(value) {
+  return Array.isArray(value)
+    ? value.filter((entry) => String(entry ?? "").trim()).length
+    : 0;
+}
+
+export function inspectClaudeRuntimeFlags({
+  env = process.env,
+  settings = {},
+} = {}) {
+  const safeMode = readBooleanRuntimeFlag(env.CLAUDE_CODE_SAFE_MODE);
+  const disableBundledSkills =
+    readBooleanRuntimeFlag(env.CLAUDE_CODE_DISABLE_BUNDLED_SKILLS) ||
+    settings?.disableBundledSkills === true;
+  const allowedCount = countStringArray(settings?.allowedMcpServers);
+  const deniedCount = countStringArray(settings?.deniedMcpServers);
+  const managedMcpPolicy = {
+    active: allowedCount > 0 || deniedCount > 0,
+    allowedCount,
+    deniedCount,
+  };
+
+  const messages = [];
+  if (safeMode) {
+    messages.push(
+      "Claude Code safe mode is enabled; CLAUDE.md, plugins, skills, hooks, and MCP servers may be disabled.",
+    );
+  }
+  if (disableBundledSkills) {
+    messages.push(
+      "Claude bundled skills/workflows are disabled; slash-command and skill discovery may differ from normal sessions.",
+    );
+  }
+  if (managedMcpPolicy.active) {
+    messages.push(
+      `Claude managed MCP policy detected; allowed=${allowedCount}, denied=${deniedCount}.`,
+    );
+  }
+
+  return {
+    status: messages.length > 0 ? "warning" : "ok",
+    safeMode,
+    disableBundledSkills,
+    managedMcpPolicy,
+    summary:
+      messages.length > 0
+        ? messages.join(" ")
+        : "Claude Code runtime flags look normal.",
+    fix: safeMode
+      ? "Unset CLAUDE_CODE_SAFE_MODE or restart Claude Code without --safe-mode for normal Triflux hooks/skills/MCP behavior."
+      : disableBundledSkills
+        ? "Unset CLAUDE_CODE_DISABLE_BUNDLED_SKILLS or set disableBundledSkills=false if bundled skills are expected."
+        : managedMcpPolicy.active
+          ? "Review allowedMcpServers/deniedMcpServers in Claude managed settings if MCP tools are missing."
+          : undefined,
+  };
+}

package/hub/hub-lifecycle.mjs

@@ -0,0 +1,242 @@
+// hub/hub-lifecycle.mjs — Hub process lifecycle helpers
+
+import { execFileSync } from "node:child_process";
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+export const HUB_DEFAULT_PORT = 27888;
+
+const HUB_PID_FILE = join(homedir(), ".claude", "cache", "tfx-hub", "hub.pid");
+const EPHEMERAL_ENV_KEYS = [
+  "TFX_WORKER_SANDBOX_SCOPE",
+  "TFX_WORKER_INDEX",
+  "TFX_TEAM_TASK_ID",
+  "TFX_TEAM_AGENT_NAME",
+  "TFX_EPHEMERAL",
+];
+
+function parsePositiveInt(value) {
+  const parsed = Number.parseInt(String(value ?? ""), 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : null;
+}
+
+function parsePortFromUrl(value) {
+  try {
+    return parsePositiveInt(new URL(String(value)).port);
+  } catch {
+    return null;
+  }
+}
+
+export function isHubServerCommand(command) {
+  return /(^|[\\/,\s])hub[\\/]server\.mjs(?=$|[\s"'`])/i.test(
+    String(command || ""),
+  );
+}
+
+export function isWorktreeOrEphemeralHubContext({
+  cwd = process.cwd(),
+  env = process.env,
+} = {}) {
+  const normalizedCwd = String(cwd || "").replace(/\\/g, "/");
+  if (
+    normalizedCwd.includes("/.claude/worktrees/") ||
+    normalizedCwd.includes("/.worktrees/") ||
+    normalizedCwd.includes("/.codex-swarm/wt-") ||
+    /(^|\/)wt-[^/]+(?:\/|$)/u.test(normalizedCwd)
+  ) {
+    return true;
+  }
+  return EPHEMERAL_ENV_KEYS.some((key) => String(env?.[key] || "").length > 0);
+}
+
+export function resolveHubPortForContext({
+  port,
+  env = process.env,
+  cwd = process.cwd(),
+  defaultPort = HUB_DEFAULT_PORT,
+} = {}) {
+  const envPort = parsePositiveInt(port) ?? parsePositiveInt(env?.TFX_HUB_PORT);
+  const urlPort = parsePortFromUrl(env?.TFX_HUB_URL);
+  const resolvedPort = envPort ?? urlPort ?? defaultPort;
+  if (
+    resolvedPort !== defaultPort &&
+    isWorktreeOrEphemeralHubContext({ cwd, env })
+  ) {
+    return defaultPort;
+  }
+  return resolvedPort;
+}
+
+export function collectHubProcesses(
+  psOutput = "",
+  { currentPid = process.pid } = {},
+) {
+  const ownPid = Number(currentPid);
+  return String(psOutput)
+    .split(/\r?\n/u)
+    .flatMap((line) => {
+      const match = line.match(/^\s*(\d+)\s+(\d+)\s+(.+)$/u);
+      if (!match) return [];
+      const pid = Number.parseInt(match[1], 10);
+      const ppid = Number.parseInt(match[2], 10);
+      const command = match[3].trim();
+      if (!Number.isFinite(pid) || pid === ownPid) return [];
+      if (!/\bnode(?:\s|$)|\/node(?:\s|$)/u.test(command)) return [];
+      if (!isHubServerCommand(command)) return [];
+      return [{ pid, ppid, command }];
+    });
+}
+
+function readPidFilePid({
+  pidFilePath = HUB_PID_FILE,
+  readFile = readFileSync,
+} = {}) {
+  try {
+    const info = JSON.parse(readFile(pidFilePath, "utf8"));
+    const pid = Number(info?.pid);
+    return Number.isFinite(pid) && pid > 0 ? pid : null;
+  } catch {
+    return null;
+  }
+}
+
+function findListeningPidsForPort(
+  port = HUB_DEFAULT_PORT,
+  { execFileSyncFn = execFileSync } = {},
+) {
+  try {
+    const output = execFileSyncFn(
+      "lsof",
+      ["-nP", `-iTCP:${port}`, "-sTCP:LISTEN", "-t"],
+      {
+        encoding: "utf8",
+        timeout: 1000,
+        maxBuffer: 1024 * 1024,
+      },
+    );
+    return String(output)
+      .split(/\r?\n/u)
+      .map((line) => Number.parseInt(line.trim(), 10))
+      .filter((pid) => Number.isFinite(pid) && pid > 0);
+  } catch {
+    return [];
+  }
+}
+
+async function waitForExit(
+  pid,
+  { killFn = process.kill, graceMs = 5000, pollMs = 100 } = {},
+) {
+  const deadline = Date.now() + Math.max(0, graceMs);
+  while (Date.now() <= deadline) {
+    try {
+      killFn(pid, 0);
+    } catch {
+      return true;
+    }
+    await new Promise((resolve) => setTimeout(resolve, pollMs));
+  }
+  try {
+    killFn(pid, 0);
+    return false;
+  } catch {
+    return true;
+  }
+}
+
+export async function reapExistingHubProcesses({
+  currentPid = process.pid,
+  pidFilePath = HUB_PID_FILE,
+  execFileSyncFn = execFileSync,
+  killFn = process.kill,
+  readPidFileFn,
+  findListeningPidsForPortFn,
+  waitForExitFn,
+  graceMs = 5000,
+  pollMs = 100,
+} = {}) {
+  let output = "";
+  try {
+    output = execFileSyncFn("ps", ["-axo", "pid,ppid,command"], {
+      encoding: "utf8",
+      timeout: 1000,
+      maxBuffer: 1024 * 1024,
+    });
+  } catch {
+    return {
+      candidates: [],
+      reaped: [],
+      preserved: {
+        currentPid: Number(currentPid),
+        pidFilePid: null,
+        defaultPortPids: [],
+      },
+    };
+  }
+
+  const current = Number(currentPid);
+  const pidFileInfo =
+    typeof readPidFileFn === "function"
+      ? readPidFileFn()
+      : { pid: readPidFilePid({ pidFilePath }) };
+  const pidFilePid = parsePositiveInt(pidFileInfo?.pid);
+  const defaultPortPids = [
+    ...new Set(
+      (typeof findListeningPidsForPortFn === "function"
+        ? findListeningPidsForPortFn(HUB_DEFAULT_PORT)
+        : findListeningPidsForPort(HUB_DEFAULT_PORT, { execFileSyncFn })
+      ).map(Number),
+    ),
+  ].filter((pid) => Number.isFinite(pid) && pid > 0);
+
+  const preservedPids = new Set(
+    [current, pidFilePid, ...defaultPortPids].filter(
+      (pid) => Number.isFinite(pid) && pid > 0,
+    ),
+  );
+  const candidates = collectHubProcesses(output, { currentPid: current });
+  const reaped = [];
+  const failed = [];
+
+  for (const processInfo of candidates) {
+    if (preservedPids.has(processInfo.pid)) continue;
+    try {
+      killFn(processInfo.pid, "SIGTERM");
+      const exited =
+        typeof waitForExitFn === "function"
+          ? await waitForExitFn(processInfo.pid, { killFn, graceMs, pollMs })
+          : await waitForExit(processInfo.pid, { killFn, graceMs, pollMs });
+      if (!exited) {
+        try {
+          killFn(processInfo.pid, "SIGKILL");
+        } catch (error) {
+          failed.push({
+            pid: processInfo.pid,
+            signal: "SIGKILL",
+            error: String(error?.message || error),
+          });
+        }
+      }
+      reaped.push(processInfo);
+    } catch (error) {
+      failed.push({
+        pid: processInfo.pid,
+        signal: "SIGTERM",
+        error: String(error?.message || error),
+      });
+    }
+  }
+
+  return {
+    candidates,
+    reaped,
+    failed,
+    preserved: {
+      currentPid: current,
+      pidFilePid,
+      defaultPortPids,
+    },
+  };
+}

package/hub/mac-focus.mjs

@@ -0,0 +1,94 @@
+import { execFile } from "node:child_process";
+
+export const FOCUS_SCRIPT_TIMEOUT_MS = 5_000;
+
+const DEFAULT_FOCUS_CANDIDATES = [
+  "iTerm2",
+  "Terminal",
+  "Codex",
+  "Claude",
+  "Antigravity",
+  "Code",
+];
+
+function normalizeAgentId(value) {
+  const id = String(value || "")
+    .trim()
+    .toLowerCase();
+  if (id === "agy" || id === "anti") return "antigravity";
+  return id;
+}
+
+export function getFocusCandidates({ agentId } = {}) {
+  switch (normalizeAgentId(agentId)) {
+    case "codex":
+      return ["Codex", "iTerm2", "Terminal", "Code"];
+    case "claude":
+      return ["Claude", "iTerm2", "Terminal"];
+    case "antigravity":
+      return ["Antigravity", "iTerm2", "Terminal"];
+    default:
+      return [...DEFAULT_FOCUS_CANDIDATES];
+  }
+}
+
+function appleScriptList(values) {
+  return `{${values.map((value) => JSON.stringify(String(value))).join(", ")}}`;
+}
+
+export function buildFocusScript({ agentId, appCandidates } = {}) {
+  const candidates = Array.isArray(appCandidates)
+    ? appCandidates.map(String).filter(Boolean)
+    : getFocusCandidates({ agentId });
+  return `
+set appCandidates to ${appleScriptList(candidates)}
+tell application "System Events"
+  set runningNames to name of every process
+end tell
+repeat with appName in appCandidates
+  set appText to appName as text
+  if runningNames contains appText then
+    tell application appText to activate
+    return "activated " & appText
+  end if
+end repeat
+return "no focus candidate running"
+`;
+}
+
+export function focusSessionOnMac(target = {}, maybeUdsId = null) {
+  const normalizedTarget =
+    target && typeof target === "object"
+      ? target
+      : { sessionId: target, udsId: maybeUdsId };
+  const script = buildFocusScript({ agentId: normalizedTarget.agentId });
+  return new Promise((resolve) => {
+    execFile(
+      "osascript",
+      ["-e", script],
+      { timeout: FOCUS_SCRIPT_TIMEOUT_MS },
+      (err, stdout = "", stderr = "") => {
+        const output = String(stdout || stderr || "").trim();
+        if (err) {
+          console.error("mac-focus error:", err?.message || err);
+          resolve({
+            ok: false,
+            sessionId: normalizedTarget.sessionId || null,
+            pid: Number(normalizedTarget.pid) || null,
+            agentId: normalizedTarget.agentId || null,
+            error: err?.message || String(err),
+            output,
+          });
+          return;
+        }
+        resolve({
+          ok: true,
+          sessionId: normalizedTarget.sessionId || null,
+          pid: Number(normalizedTarget.pid) || null,
+          agentId: normalizedTarget.agentId || null,
+          output,
+        });
+      },
+    );
+  });
+}