@triflux/core 10.32.0 → 10.33.1

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",
@@ -158,6 +171,17 @@
         "timeout": 5,
         "blocking": false,
         "description": "키워드 매칭 → 스킬 자동 라우팅"
+      },
+      {
+        "id": "tfx-cto-north-star-brief",
+        "source": "triflux",
+        "matcher": "*",
+        "command": "node \"${PLUGIN_ROOT}/hooks/cto-north-star-brief.mjs\"",
+        "priority": 2,
+        "enabled": true,
+        "timeout": 2,
+        "blocking": false,
+        "description": "CTO north-star brief를 UserPromptSubmit additionalContext로 변경 시 주입"
       }
     ],
     "SessionStart": [
@@ -227,6 +251,17 @@
         "blocking": false,
         "description": "이전 세션의 stale tfx-multi 상태 파일 정리 (#62)"
       },
+      {
+        "id": "tfx-session-lake",
+        "source": "triflux",
+        "matcher": "*",
+        "command": "node \"${PLUGIN_ROOT}/hooks/session-start-lake.mjs\"",
+        "priority": 6,
+        "enabled": true,
+        "timeout": 3,
+        "blocking": false,
+        "description": "CTO north-star brief를 SessionStart additionalContext로 주입"
+      },
       {
         "id": "ext-session-vault-start",
         "source": "session-vault",

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/codex-adapter.mjs

@@ -101,6 +101,9 @@ export function buildLaunchScript(opts = {}) {
 
 // ── Exec args builder ───────────────────────────────────────────
 
+// CTO boundary: this adapter assembles Codex prompts outside
+// scripts/tfx-route.sh. Keep north-star injection in tfx-route.sh until
+// launcher/circuit-broker workdir contracts have focused coverage.
 export function buildExecArgs(opts = {}) {
   const prompt = typeof opts.prompt === "string" ? opts.prompt : "";
   const command = buildExecCommand(prompt, opts.resultFile || null, {

package/hub/lib/tfx-route-args.mjs

@@ -7,7 +7,7 @@
 //        maxIterations, task, warnings}.
 //
 // 기존 플래그 (Phase 2 v10.9.33+):
-//   --cli {auto|codex|gemini|claude}
+//   --cli {auto|codex|antigravity|claude}
 //   --mode {quick|deep|consensus}
 //   --parallel {1|N|swarm}
 //   --retry {0|1|ralph|auto-escalate}    (Phase 3 에서 ralph/auto-escalate 신규)
@@ -34,7 +34,7 @@ export const DEFAULT_OPTIONS = Object.freeze({
 });
 
 const VALID_VALUES = Object.freeze({
-  cli: ["auto", "codex", "gemini", "claude"],
+  cli: ["auto", "codex", "antigravity", "claude"],
   mode: ["quick", "deep", "consensus"],
   retry: ["0", "1", "ralph", "auto-escalate"],
   isolation: ["none", "worktree"],
@@ -158,7 +158,14 @@ function applyBool(opts, flag) {
 function applyValue(opts, flag, value, warnings) {
   switch (flag) {
     case "--cli":
-      opts.cli = value;
+      if (value === "gemini") {
+        opts.cli = "antigravity";
+        warnings.push(
+          "--cli gemini is deprecated; using --cli antigravity instead",
+        );
+      } else {
+        opts.cli = value;
+      }
       break;
     case "--mode":
       opts.mode = value;

package/hub/team/claude-agent-session-normalizer.mjs

@@ -0,0 +1,53 @@
+function firstString(...values) {
+  for (const value of values) {
+    const text = String(value ?? "").trim();
+    if (text) return text;
+  }
+  return "";
+}
+
+function maybeAssign(target, key, value) {
+  if (value !== "" && value != null) target[key] = value;
+}
+
+export function normalizeClaudeAgentSession(row = {}) {
+  const short = firstString(row.short, row.id, row.jobId, row.job_id);
+  const sessionId = firstString(
+    row.sessionId,
+    row.session_id,
+    row.dispatch?.sessionId,
+    row.dispatch?.session_id,
+    row.d?.sessionId,
+    row.d?.session_id,
+    row.session?.id,
+  );
+  const state = firstString(row.state, row.status, row.tempo, "unknown");
+  const status = firstString(row.status, row.state, row.tempo, "unknown");
+
+  const normalized = {
+    ...row,
+    short,
+    id: firstString(row.id, short),
+    sessionId,
+    session_id: sessionId,
+    state,
+    status,
+  };
+  maybeAssign(normalized, "cwd", row.cwd);
+  maybeAssign(normalized, "name", row.name);
+  maybeAssign(normalized, "kind", row.kind);
+  maybeAssign(normalized, "waitingFor", row.waitingFor ?? row.waiting_for);
+  maybeAssign(normalized, "startedAt", row.startedAt ?? row.started_at);
+  maybeAssign(normalized, "updatedAt", row.updatedAt ?? row.updated_at);
+  maybeAssign(normalized, "pid", row.pid);
+  return normalized;
+}
+
+export function extractClaudeAgentSessions(listResponse = {}) {
+  const rows = Array.isArray(listResponse.jobs)
+    ? listResponse.jobs
+    : Array.isArray(listResponse.sessions)
+      ? listResponse.sessions
+      : [];
+  return rows.map((row) => normalizeClaudeAgentSession(row));
+}

package/hub/team/claude-daemon-control.mjs

@@ -4,6 +4,10 @@ import fs from "node:fs/promises";
 import net from "node:net";
 import os from "node:os";
 import path from "node:path";
+import {
+  extractClaudeAgentSessions,
+  normalizeClaudeAgentSession,
+} from "./claude-agent-session-normalizer.mjs";
 import {
   buildClaudeSessionProjection,
   removeClaudeSessionProjection,
@@ -1055,27 +1059,27 @@ export function buildClaudePromptDispatchPayload({
 }
 
 export function findDaemonJobByShort(listResponse, short) {
-  if (!Array.isArray(listResponse?.jobs)) return null;
-  return listResponse.jobs.find((job) => job?.short === short) || null;
+  const expected = String(short || "").trim();
+  if (!expected) return null;
+  return (
+    extractClaudeAgentSessions(listResponse).find(
+      (job) => job.short === expected || job.id === expected,
+    ) || null
+  );
 }
 
 export function findDaemonJobBySessionId(listResponse, sessionId) {
-  if (!Array.isArray(listResponse?.jobs)) return null;
-  const expected = String(sessionId || "");
+  const expected = String(sessionId || "").trim();
   if (!expected) return null;
   return (
-    listResponse.jobs.find((job) => {
-      const candidate =
-        job?.sessionId ??
-        job?.session_id ??
-        job?.dispatch?.sessionId ??
-        job?.d?.sessionId ??
-        "";
-      return String(candidate) === expected;
-    }) || null
+    extractClaudeAgentSessions(listResponse).find(
+      (job) => String(job.sessionId || job.session_id || "") === expected,
+    ) || null
   );
 }
 
+export { extractClaudeAgentSessions, normalizeClaudeAgentSession };
+
 export async function waitForDaemonJobPid(
   controlSock,
   short,

package/hub/team/claude-session-projection.mjs

@@ -69,6 +69,63 @@ export async function updateClaudeSessionProjection(sessionPath, patch) {
   return next;
 }
 
+function projectionSessionId(projection) {
+  return String(
+    projection?.sessionId ?? projection?.session_id ?? projection?.id ?? "",
+  ).trim();
+}
+
+export async function findClaudeSessionProjectionBySessionId(
+  sessionsDir,
+  sessionId,
+) {
+  const expected = String(sessionId || "").trim();
+  if (!sessionsDir || !expected) return null;
+  let entries;
+  try {
+    entries = await fs.readdir(sessionsDir, { withFileTypes: true });
+  } catch (error) {
+    if (error?.code === "ENOENT") return null;
+    throw error;
+  }
+
+  for (const entry of entries) {
+    if (!entry.isFile() || !entry.name.endsWith(".json")) continue;
+    const filePath = path.join(sessionsDir, entry.name);
+    try {
+      const projection = JSON.parse(await fs.readFile(filePath, "utf8"));
+      if (projectionSessionId(projection) === expected) {
+        return { path: filePath, projection };
+      }
+    } catch (error) {
+      if (error instanceof SyntaxError) continue;
+      if (error?.code === "ENOENT") continue;
+      throw error;
+    }
+  }
+  return null;
+}
+
+export async function refreshClaudeSessionProjectionCwd({
+  sessionsDir,
+  sessionId,
+  cwd,
+  updatedAt = Date.now(),
+} = {}) {
+  const nextCwd = String(cwd || "").trim();
+  if (!nextCwd) return { updated: false, reason: "missing_cwd" };
+  const found = await findClaudeSessionProjectionBySessionId(
+    sessionsDir,
+    sessionId,
+  );
+  if (!found) return { updated: false, reason: "projection_not_found" };
+  const projection = await updateClaudeSessionProjection(found.path, {
+    cwd: nextCwd,
+    updatedAt,
+  });
+  return { updated: true, path: found.path, projection };
+}
+
 export async function removeClaudeSessionProjection(sessionPath) {
   await fs.rm(sessionPath, { force: true });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@triflux/core",
-  "version": "10.32.0",
+  "version": "10.33.1",
   "description": "triflux core — CLI routing, pipeline, adapters. Zero native dependencies.",
   "type": "module",
   "main": "hub/index.mjs",

package/scripts/lib/env-probe.mjs

@@ -4,6 +4,7 @@ import { existsSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
+import { resolveHubPortForContext } from "../../hub/hub-lifecycle.mjs";
 import { whichCommand, whichCommandAsync } from "../../hub/platform.mjs";
 
 const HUB_DEFAULT_PORT = 27888;
@@ -37,13 +38,36 @@ function fetchHubStatus({
   };
 }
 
-export function resolveDefaultStatusUrl(env = process.env) {
-  const envPort = Number.parseInt(String(env?.TFX_HUB_PORT ?? ""), 10);
-  const port =
-    Number.isFinite(envPort) && envPort > 0 ? envPort : HUB_DEFAULT_PORT;
+export function resolveDefaultStatusUrl(env = process.env, cwd = process.cwd()) {
+  const port = resolveHubPortForContext({
+    env,
+    cwd,
+    defaultPort: HUB_DEFAULT_PORT,
+  });
   return `http://127.0.0.1:${port}/status`;
 }
 
+function resolveStatusUrlForContext({
+  statusUrl,
+  env = process.env,
+  cwd = process.cwd(),
+} = {}) {
+  try {
+    const url = new URL(String(statusUrl));
+    url.port = String(
+      resolveHubPortForContext({
+        port: url.port,
+        env,
+        cwd,
+        defaultPort: HUB_DEFAULT_PORT,
+      }),
+    );
+    return url.toString();
+  } catch {
+    return resolveDefaultStatusUrl(env, cwd);
+  }
+}
+
 function normalizeCliName(name) {
   return String(name ?? "").trim() || null;
 }
@@ -212,8 +236,10 @@ export function detectCodexPlan(options = {}) {
 }
 
 export function checkHub({
+  env = process.env,
+  cwd = process.cwd(),
   pkgRoot = DEFAULT_PKG_ROOT,
-  statusUrl = resolveDefaultStatusUrl(),
+  statusUrl = resolveDefaultStatusUrl(env, cwd),
   restart = true,
   requestTimeoutMs = 3000,
   pollAttempts = 8,
@@ -223,10 +249,11 @@ export function checkHub({
   existsSyncFn = existsSync,
   sleepSyncFn = sleepSync,
 } = {}) {
+  const guardedStatusUrl = resolveStatusUrlForContext({ statusUrl, env, cwd });
   try {
     return fetchHubStatus({
       execSyncFn,
-      statusUrl,
+      statusUrl: guardedStatusUrl,
       timeout: requestTimeoutMs,
     });
   } catch {}
@@ -239,7 +266,7 @@ export function checkHub({
 
   try {
     const child = spawnFn(process.execPath, [serverPath], {
-      env: { ...process.env, TFX_HUB_PORT: String(new URL(statusUrl).port) },
+      env: { ...env, TFX_HUB_PORT: String(new URL(guardedStatusUrl).port) },
       detached: true,
       stdio: "ignore",
       windowsHide: true,
@@ -254,7 +281,7 @@ export function checkHub({
     try {
       const status = fetchHubStatus({
         execSyncFn,
-        statusUrl,
+        statusUrl: guardedStatusUrl,
         timeout: Math.min(requestTimeoutMs, 1000),
       });
       if (status.state === "healthy") {