@triflux/core 10.53.0 → 10.55.0

package/hub/lib/process-utils.mjs

@@ -11,7 +11,7 @@ import {
 } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { IS_WINDOWS, killProcess } from "../platform.mjs";
+import { IS_WINDOWS } from "../platform.mjs";
 
 const CLEANUP_SCRIPT_DIR = join(tmpdir(), "tfx-process-utils");
 const SCAN_SCRIPT_PATH = join(CLEANUP_SCRIPT_DIR, "scan-processes.ps1");
@@ -54,80 +54,6 @@ export function isPidAlive(pid) {
   }
 }
 
-/**
- * 동기적 sleep. Atomics.wait 우선, 불가 시 busy-wait 폴백.
- */
-function sleepSyncMs(ms) {
-  try {
-    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
-  } catch {
-    const end = Date.now() + ms;
-    while (Date.now() < end) {
-      /* spin */
-    }
-  }
-}
-
-/**
- * 고아 PID 목록에 SIGTERM → 3초 대기 → SIGKILL 에스컬레이션을 적용한다.
- * PID 재사용 레이스 방어: SIGTERM 전 alive 확인, SIGKILL 전 재검증.
- * @param {number[]} orphanPids
- * @param {Map<number, {ppid: number, name: string}>} [procMap] PID 재사용 감지용 스냅샷
- * @returns {number} killed count
- */
-function killWithEscalation(orphanPids, procMap) {
-  if (orphanPids.length === 0) return 0;
-
-  // SIGTERM 전 alive 스냅샷 — 이미 죽은 PID는 카운트에서 제외
-  const aliveBeforeKill = new Set(orphanPids.filter((pid) => isPidAlive(pid)));
-
-  for (const pid of aliveBeforeKill) {
-    killProcess(pid, { signal: "SIGTERM" });
-  }
-
-  sleepSyncMs(3000);
-
-  let killed = 0;
-  for (const pid of aliveBeforeKill) {
-    if (isPidAlive(pid)) {
-      // PID 재사용 방어: procMap이 있으면 스캔 시점의 ppid와 현재 ppid 비교
-      // ppid가 변경되었으면 PID가 재사용된 것이므로 kill하지 않���
-      if (procMap) {
-        const snapshot = procMap.get(pid);
-        if (snapshot) {
-          try {
-            const current = execSync(
-              IS_WINDOWS
-                ? `powershell -NoProfile -WindowStyle Hidden -Command "(Get-CimInstance Win32_Process -Filter 'ProcessId=${pid}' -ErrorAction SilentlyContinue).ParentProcessId"`
-                : `ps -o ppid= -p ${pid}`,
-              {
-                encoding: "utf8",
-                timeout: 3000,
-                stdio: ["pipe", "pipe", "pipe"],
-                windowsHide: true,
-              },
-            );
-            const currentPpid = Number.parseInt(current.trim(), 10);
-            if (Number.isFinite(currentPpid) && currentPpid !== snapshot.ppid) {
-              continue; // PID 재사용 감지 — skip
-            }
-          } catch {
-            // 조회 실패 시 안전하게 skip
-            continue;
-          }
-        }
-      }
-      killProcess(pid, {
-        signal: "SIGKILL",
-        force: true,
-        tree: IS_WINDOWS,
-      });
-    }
-    if (!isPidAlive(pid)) killed++;
-  }
-  return killed;
-}
-
 /**
  * PowerShell 헬퍼 스크립트를 임시 디렉토리에 생성한다.
  * bash의 $_ 이스케이핑 문제를 피하기 위해 -File로 실행.
@@ -261,12 +187,12 @@ function hasLiveCliDescendant(pid, procMap) {
 }
 
 /**
- * Legacy wrapper for scoped orphan node runtime cleanup.
+ * `tfx doctor --fix` 가 쓰는 이름. cleanupOrphanRuntimeProcesses 와 같다.
  * @param {Parameters<typeof cleanupOrphanRuntimeProcesses>[0]} opts
- * @returns {{ killed: number, remaining: number, killedProcesses: Array<{pid: number, ppid: number, name: string, commandLine: string, killReason: string}> }}
+ * @returns {ReturnType<typeof cleanupOrphanRuntimeProcesses>}
  */
 export function cleanupOrphanNodeProcesses(opts = {}) {
-  return cleanupOrphanRuntimeProcesses({ ...opts, legacy: true });
+  return cleanupOrphanRuntimeProcesses(opts);
 }
 
 function normalizePowerShellJson(output) {
@@ -297,10 +223,6 @@ function normalizeName(name) {
   return String(name || "").toLowerCase();
 }
 
-function normalizeCommandLine(commandLine) {
-  return String(commandLine || "").replace(/\//g, "\\");
-}
-
 function processRecordFromCim(record) {
   const pid = normalizePid(record?.ProcessId ?? record?.pid);
   if (!pid) return null;
@@ -460,16 +382,6 @@ function matchesPattern(commandLine, pattern, { exact = false } = {}) {
   return exact ? commandLine === text : commandLine.includes(text);
 }
 
-function hasExactGbrainServe(commandLine) {
-  const normalized = commandLine.trim();
-  return (
-    /^("?[^"\s]*bun(?:\.exe)?"?\s+)?gbrain\s+serve$/i.test(normalized) ||
-    /^("?[^"\s]*bun(?:\.exe)?"?\s+)"?[^"]*gbrain[\\/]+src[\\/]+cli\.ts"?\s+serve$/i.test(
-      normalized,
-    )
-  );
-}
-
 /**
  * Return a process tree rooted at `rootPid`.
  *
@@ -651,75 +563,41 @@ export function findProcessesByCommandLine(
 }
 
 /**
- * Cleanup narrowly gated orphan runtime processes.
+ * Windows 고아 node/bash/cmd/uvx 런타임을 정리한다.
  *
- * Windows scans node/bash/bun and optional conhost command lines. POSIX is a
- * best-effort fallback. `legacy: true` preserves `cleanupOrphanNodeProcesses`
- * behavior by targeting scoped orphan node runtimes only.
+ * 조상 체인이 살아 있거나 Claude/Codex/Gemini 자손이 있으면 건드리지 않는다.
+ * 운영 호출자가 Windows `tfx doctor --fix` 하나라 다른 OS 에서는 아무것도 하지 않는다.
  *
- * @param {{legacy?: boolean, includeConhost?: boolean, sessionIds?: string[], isWindows?: boolean, spawnSyncFn?: typeof spawnSync, killFn?: typeof process.kill, protectedPids?: Set<number>}} opts
+ * @param {{isWindows?: boolean, spawnSyncFn?: typeof spawnSync, killFn?: typeof process.kill, protectedPids?: Set<number>}} opts
  * @returns {{killed: number, remaining: number, killedProcesses: Array<{pid: number, ppid: number, name: string, commandLine: string, killReason: string}>}}
  */
 export function cleanupOrphanRuntimeProcesses({
-  legacy = false,
-  includeConhost = false,
-  sessionIds = [],
   isWindows = IS_WINDOWS,
   spawnSyncFn = spawnSync,
   killFn = process.kill,
   protectedPids,
 } = {}) {
-  if (!isWindows) return cleanupOrphansUnix();
+  if (!isWindows) return { killed: 0, remaining: 0, killedProcesses: [] };
 
   const protectedSet = getProtectedPids({
     protectedPids,
     isWindows,
     spawnSyncFn,
-    includeAncestorScan: legacy,
+    includeAncestorScan: true,
   });
   const processes = getProcessSnapshot({ isWindows, spawnSyncFn });
+  const procMap = new Map(processes.map((proc) => [proc.pid, proc]));
   let killed = 0;
   const killedProcesses = [];
-  const procMap = legacy
-    ? new Map(processes.map((proc) => [proc.pid, proc]))
-    : new Map(processes.map((proc) => [proc.pid, proc]));
 
   for (const proc of processes) {
-    if (protectedSet.has(proc.pid)) continue;
-    const name = normalizeName(proc.name);
-    const commandLine = normalizeCommandLine(proc.commandLine);
-    let shouldKill = false;
-    let killReason = null;
-
-    if (legacy) {
-      if (
-        LEGACY_ORPHAN_KILLABLE_NAMES.has(name) &&
-        !hasLiveAncestorChain(proc.pid, procMap, protectedSet) &&
-        !hasLiveCliDescendant(proc.pid, procMap)
-      ) {
-        shouldKill = true;
-        killReason = "legacy_orphan_ancestor_chain_dead";
-      }
-    } else if (name === "bun.exe") {
-      if (
-        hasExactGbrainServe(proc.commandLine) &&
-        !hasLiveAncestorChain(proc.pid, procMap, protectedSet) &&
-        !hasLiveCliDescendant(proc.pid, procMap)
-      ) {
-        shouldKill = true;
-        killReason = "bun_gbrain_serve_orphan";
-      }
-    } else if (includeConhost && name === "conhost.exe") {
-      if (
-        sessionIds.length > 0 &&
-        sessionIds.some((id) => id && commandLine.includes(id))
-      ) {
-        shouldKill = true;
-        killReason = "conhost_session_match";
-      }
-    }
-
-    if (!shouldKill) continue;
+    if (
+      protectedSet.has(proc.pid) ||
+      !LEGACY_ORPHAN_KILLABLE_NAMES.has(normalizeName(proc.name)) ||
+      hasLiveAncestorChain(proc.pid, procMap, protectedSet) ||
+      hasLiveCliDescendant(proc.pid, procMap)
+    )
+      continue;
     try {
       killFn(proc.pid, "SIGKILL");
       killed++;
@@ -728,7 +606,7 @@ export function cleanupOrphanRuntimeProcesses({
         ppid: proc.ppid,
         name: proc.name,
         commandLine: String(proc.commandLine || "").slice(0, 200),
-        killReason,
+        killReason: "legacy_orphan_ancestor_chain_dead",
       });
     } catch {}
   }
@@ -818,82 +696,3 @@ export function cleanupStaleFsmonitorDaemons({
 
   return { killed, stale };
 }
-
-/**
- * Unix/macOS 고아 프로세스 정리.
- * `ps -eo pid,ppid,comm` 기반 프로세스 맵 → 동일한 조상 체인 판정 → SIGKILL 에스컬레이션.
- * @returns {{ killed: number, remaining: number }}
- */
-function cleanupOrphansUnix() {
-  const myPid = process.pid;
-
-  const protectedPids = new Set();
-  protectedPids.add(myPid);
-
-  // 현재 프로세스의 조상 트리 보호
-  try {
-    let current = myPid;
-    for (let i = 0; i < 10; i++) {
-      protectedPids.add(current);
-      const output = execSync(`ps -o ppid= -p ${current}`, {
-        encoding: "utf8",
-        timeout: 3000,
-        stdio: ["pipe", "pipe", "pipe"],
-      });
-      const ppid = Number.parseInt(output.trim(), 10);
-      if (!Number.isFinite(ppid) || ppid <= 1) break;
-      current = ppid;
-    }
-  } catch {}
-
-  // 프로세스 맵 구축 (런타임 + CLI — 체인 추적 정확도를 위해 CLI도 포함)
-  const procMap = new Map();
-  try {
-    const output = execSync("ps -eo pid,ppid,comm", {
-      encoding: "utf8",
-      timeout: 10000,
-      stdio: ["pipe", "pipe", "pipe"],
-    });
-    for (const line of output.split("\n").slice(1)) {
-      const parts = line.trim().split(/\s+/);
-      if (parts.length < 3) continue;
-      const pid = Number.parseInt(parts[0], 10);
-      const ppid = Number.parseInt(parts[1], 10);
-      const name = parts.slice(2).join(" ");
-      if (
-        Number.isFinite(pid) &&
-        pid > 0 &&
-        /^(node|bash|sh|python|codex|claude|gemini|uvx)/.test(name)
-      ) {
-        procMap.set(pid, { ppid, name });
-      }
-    }
-  } catch {}
-
-  // kill 대상: node, python, codex, claude, uvx — bash/sh는 사용자 인터랙티브 쉘 가능성
-  const killableUnix = /^(node|python|codex|claude|gemini|uvx)/;
-
-  // 고아 판정 + SIGKILL 에스컬레이션
-  const orphanPids = [];
-  for (const [pid, info] of procMap) {
-    if (protectedPids.has(pid)) continue;
-    if (!killableUnix.test(info.name)) continue;
-    if (hasLiveAncestorChain(pid, procMap, protectedPids)) continue;
-    if (hasLiveCliDescendant(pid, procMap)) continue;
-    orphanPids.push(pid);
-  }
-
-  const killed = killWithEscalation(orphanPids, procMap);
-
-  let remaining = 0;
-  try {
-    const output = execSync("ps -eo comm | grep -c '^node$'", {
-      encoding: "utf8",
-      timeout: 3000,
-      stdio: ["pipe", "pipe", "pipe"],
-    });
-    remaining = Number.parseInt(output.trim(), 10) || 0;
-  } catch {}
-
-  return { killed, remaining };
-}

package/hub/lib/prompt-tmp.mjs

@@ -1,33 +1,15 @@
-// hub/lib/prompt-tmp.mjs
-//
-// macOS `codex exec` 회귀 fix 보조 helper. codex CLI v0.130.0 의 macOS hook
-// lifecycle (oh-my-codex/codex-native-hook.js) 이 매우 긴 argv inline prompt
-// (4KB+) 를 받으면 SessionStart Failed 로 즉시 exit. PR #243 의 stdin EAGAIN
-// async stream fix 후속 회귀로 추정.
-//
-// 대안: prompt 를 임시 파일에 쓰고 `< /tmp/...` stdin redirect 로 전달.
-// Manual `echo prompt | codex exec ...` (stdin pipe) 가 정상 작동하는 fact 와
-// 정합.
-//
-// cleanup 정책: best-effort. OS `/tmp` 가 자동 cleanup 하고, 이 모듈은
-// 매 호출마다 unique path 사용 (timestamp + pid + counter). orphan 파일은
-// 추후 doctor 가 prune.
+// 프롬프트를 argv 로 넘기면 ps 에 보이므로 stdin 리다이렉트용 파일로 넘긴다.
+// 파일은 매번 새 이름이고 정리는 OS 임시 디렉터리 정리에 맡긴다.
 
-import { mkdirSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
+import { writeFileSync } from "node:fs";
 import { join } from "node:path";
+import { privateTmpDir } from "./private-tmp.mjs";
 
-const PROMPT_TMP_DIR = join(tmpdir(), "triflux-codex-prompt");
 let counter = 0;
 
 export function writePromptToTmpFile(prompt) {
-  mkdirSync(PROMPT_TMP_DIR, { recursive: true });
   const id = `${Date.now()}-${process.pid}-${counter++}`;
-  const file = join(PROMPT_TMP_DIR, `prompt-${id}.txt`);
-  writeFileSync(file, String(prompt ?? ""), "utf8");
+  const file = join(privateTmpDir("triflux-codex-prompt"), `prompt-${id}.txt`);
+  writeFileSync(file, String(prompt ?? ""), { encoding: "utf8", mode: 0o600 });
   return file;
 }
-
-export function getPromptTmpDir() {
-  return PROMPT_TMP_DIR;
-}

package/hub/lib/spawn-trace.mjs

@@ -1,13 +1,22 @@
 import * as childProcess from "node:child_process";
+import { createHash } from "node:crypto";
 import { EventEmitter } from "node:events";
-import { createWriteStream, mkdirSync } from "node:fs";
+import {
+  chmodSync,
+  createWriteStream,
+  mkdirSync,
+  readdirSync,
+  rmSync,
+} from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 
 const LOG_DIR = join(homedir(), ".triflux", "logs");
+const RETENTION_DAYS = 7;
 const DEDUPE_WINDOW_MS = 5_000;
 const RATE_WINDOW_MS = 1_000;
 const DEFAULT_MAX_SPAWN_PER_SEC = 100;
+const MAX_PLAIN_TRACE_VALUE = 64;
 // multi-worker headless dispatch 가 1 초 안에 ~25-30+ psmux/tmux 명령을 호출한다.
 // 2-worker dispatchBatch 가 default 30 limit 을 초과해 `rate_limit` throw 로 mac
 // 호환성 회귀 (smoke test 발견, 2026-05-15). 100 으로 상향 — 폭주 안전망은
@@ -54,7 +63,8 @@ function ensureLogStream() {
     return logStream;
   }
 
-  mkdirSync(LOG_DIR, { recursive: true });
+  mkdirSync(LOG_DIR, { recursive: true, mode: 0o700 });
+  restrictMode(LOG_DIR, 0o700);
 
   if (logStream) {
     try {
@@ -65,20 +75,115 @@ function ensureLogStream() {
   }
 
   logDay = day;
-  logStream = createWriteStream(getLogPath(day), { flags: "a" });
+  pruneOldTraceLogs(LOG_DIR, day);
+  logStream = createWriteStream(getLogPath(day), { flags: "a", mode: 0o600 });
+  restrictMode(getLogPath(day), 0o600);
   logStream.on("error", () => {
     /* ignore logging failures */
   });
   return logStream;
 }
 
+// 날짜별 파일이 끝없이 쌓이지 않게, 그날 첫 파일을 열 때 보관 기간이 지난 파일을 지운다.
+export function pruneOldTraceLogs(logDir, today) {
+  const cutoff = new Date(Date.parse(today) - RETENTION_DAYS * 86_400_000)
+    .toISOString()
+    .slice(0, 10);
+  try {
+    for (const name of readdirSync(logDir)) {
+      const day = /^spawn-trace-(\d{4}-\d{2}-\d{2})\.jsonl$/u.exec(name)?.[1];
+      if (day && day < cutoff) rmSync(join(logDir, name), { force: true });
+    }
+  } catch {
+    /* ignore */
+  }
+}
+
+// 예전 버전이 0644 로 만든 로그도 좁힌다. Windows 는 chmod 가 의미 없어 실패를 무시한다.
+function restrictMode(path, mode) {
+  try {
+    chmodSync(path, mode);
+  } catch {
+    /* ignore */
+  }
+}
+
+function redacted(value) {
+  const digest = createHash("sha256").update(value).digest("hex").slice(0, 12);
+  return `<redacted len=${value.length} sha256=${digest}>`;
+}
+
+// 프롬프트가 로그에 남지 않게, 공백이 있거나 긴 값은 길이와 해시만 남긴다.
+export function redactTraceValue(value) {
+  if (typeof value !== "string") return value;
+  if (value.length <= MAX_PLAIN_TRACE_VALUE && !/\s/u.test(value)) return value;
+  return redacted(value);
+}
+
+const PROMPT_FLAGS = new Set(["--print", "--prompt", "--message", "--seed"]);
+const SEND_KEYS_VALUE_FLAGS = new Set(["t", "N", "c"]);
+const NAMED_KEY =
+  /^(Enter|Escape|Tab|BSpace|Space|Up|Down|Left|Right|[CM]-.)$/u;
+
+// send-keys 옵션을 getopt 처럼 읽어 키 자리의 시작과 -l(문자 그대로 입력) 여부를 찾는다.
+function parseSendKeys(args, from) {
+  let literal = false;
+  let i = from;
+  while (i < args.length && /^-./u.test(String(args[i]))) {
+    const flag = String(args[i]);
+    i += 1;
+    if (flag === "--") break;
+    for (let j = 1; j < flag.length; j += 1) {
+      if (flag[j] === "l") literal = true;
+      if (SEND_KEYS_VALUE_FLAGS.has(flag[j])) {
+        if (j === flag.length - 1) i += 1;
+        break;
+      }
+    }
+  }
+  return { keysFrom: i, literal };
+}
+
+// 짧은 토큰도 키 입력과 프롬프트 자리에 오면 항상 가린다. 길이만 보면 짧은 비밀이 샌다.
+// -l 이면 Enter 같은 이름도 글자 그대로 입력되므로 가린다.
+function redactArgs(args) {
+  const sendKeysAt = args.indexOf("send-keys");
+  const { keysFrom, literal } =
+    sendKeysAt >= 0
+      ? parseSendKeys(args, sendKeysAt + 1)
+      : { keysFrom: -1, literal: false };
+  return args.map((arg, index) => {
+    if (typeof arg !== "string") return arg;
+    const promptFlag = arg.split("=")[0];
+    if (PROMPT_FLAGS.has(promptFlag) && arg.includes("=")) {
+      return `${promptFlag}=${redacted(arg.slice(promptFlag.length + 1))}`;
+    }
+    const afterPromptFlag = PROMPT_FLAGS.has(args[index - 1]);
+    const isKey =
+      keysFrom >= 0 && index >= keysFrom && (literal || !NAMED_KEY.test(arg));
+    return afterPromptFlag || isKey ? redacted(arg) : redactTraceValue(arg);
+  });
+}
+
+export function redactTraceEntry(entry) {
+  return {
+    ...entry,
+    command: redactTraceValue(entry.command),
+    args: Array.isArray(entry.args) ? redactArgs(entry.args) : entry.args,
+    // execFileSync 오류 메시지에는 명령과 인자 전체가 들어간다.
+    ...(typeof entry.error === "string"
+      ? { error: redactTraceValue(entry.error) }
+      : {}),
+  };
+}
+
 function appendTrace(data, { sync = false } = {}) {
-  const entry = {
+  const entry = redactTraceEntry({
     ts: nowIso(),
     session_id: process.env.TRIFLUX_SESSION_ID ?? null,
     parent_pid: process.pid,
     ...data,
-  };
+  });
 
   try {
     ensureLogStream().write(`${JSON.stringify(entry)}\n`);
@@ -261,6 +366,7 @@ function trackChild(child, meta) {
   child.once("error", (error) => {
     finalize("error", {
       error: error.message,
+      error_code: error.code ?? null,
     });
   });
 
@@ -532,6 +638,7 @@ export function execFileSync(file, args, options) {
         signal: error?.signal ?? null,
         duration_ms: Date.now() - startedAt,
         error: error?.message,
+        error_code: error?.code ?? null,
         sync: true,
       },
       { sync: true },

package/hub/lib/timeout-defaults.mjs

@@ -1,4 +1,5 @@
 // hub 조율 평면 타임아웃/TTL의 단일 기준값. 환경은 호출 시점에 읽는다.
+import { readMachineProfile } from "../../scripts/lib/machine-profile.mjs";
 
 export const MIN_DURATION_MS = 1_000;
 export const MAX_DURATION_MS = 86_400_000;
@@ -10,22 +11,49 @@ export const REGISTER_HEARTBEAT_GRACE_MS = 120_000;
 export const DEFAULT_STALL_INTERVENTION_SEC = 1_200;
 export const DEFAULT_HARD_CEILING_SEC = 21_600;
 
-function readEnvSeconds(env, name, fallbackSec) {
-  const value = Number(env?.[name]);
-  return Number.isFinite(value) && value > 0 ? Math.trunc(value) : fallbackSec;
+// 셸(tfx-route.sh)과 같은 우선순위: 명시 env, 그다음 machine profile, 그다음 기본값.
+function readSetting(env, name) {
+  if (env?.[name] !== undefined) return env[name];
+  return readMachineProfile({ env }).values[name];
+}
+
+function readSeconds(env, name, fallbackSec, { allowZero = false } = {}) {
+  const raw = String(readSetting(env, name) ?? "").trim();
+  // 셸의 ${VAR:-기본값} 처럼 빈 값은 기본값이다. Number("") 가 0 이 되는 것을 막는다.
+  if (!raw) return fallbackSec;
+  const value = Number(raw);
+  const min = allowZero ? 0 : 1;
+  return Number.isInteger(value) && value >= min ? value : fallbackSec;
 }
 
 export function resolveStallInterventionMs(env = process.env) {
   return (
-    readEnvSeconds(env, "TFX_STALL_THRESHOLD", DEFAULT_STALL_INTERVENTION_SEC) *
+    readSeconds(env, "TFX_STALL_THRESHOLD", DEFAULT_STALL_INTERVENTION_SEC) *
     1000
   );
 }
 
+// 0 은 셸과 같이 상한 없음이다.
 export function resolveHardCeilingMs(env = process.env) {
-  return (
-    readEnvSeconds(env, "TFX_HARD_CEILING_SEC", DEFAULT_HARD_CEILING_SEC) * 1000
+  const sec = readSeconds(
+    env,
+    "TFX_HARD_CEILING_SEC",
+    DEFAULT_HARD_CEILING_SEC,
+    {
+      allowZero: true,
+    },
   );
+  return sec === 0 ? Number.POSITIVE_INFINITY : sec * 1000;
+}
+
+// 셸 heartbeat 와 같은 값 해석. classify 는 무활동이어도 끝내지 않는다.
+export function resolveStallKill(env = process.env) {
+  const value = String(readSetting(env, "TFX_STALL_KILL") || "kill")
+    .trim()
+    .toLowerCase();
+  if (["1", "on", "kill"].includes(value)) return "kill";
+  if (["intervene", "ladder"].includes(value)) return "intervene";
+  return "classify";
 }
 
 export function resolveWorkerLeaseTtlMs(env = process.env) {

package/hub/lib/worker-lifecycle.mjs

@@ -2,6 +2,7 @@
 import {
   resolveHardCeilingMs,
   resolveStallInterventionMs,
+  resolveStallKill,
 } from "./timeout-defaults.mjs";
 
 export { resolveHardCeilingMs, resolveStallInterventionMs };
@@ -19,6 +20,7 @@ export function createActivityLifecycle({
   enabled = isActivityLifecycleEnabled(),
   interventionMs = resolveStallInterventionMs(),
   hardCeilingMs = resolveHardCeilingMs(),
+  stallKill = resolveStallKill(),
   maxInterventions = 1,
   onIntervene,
   now = Date.now,
@@ -77,6 +79,7 @@ export function createActivityLifecycle({
       }
       if (current - lastActivityAt < interventionMs || pendingIntervention)
         return "";
+      if (stallKill === "classify") return "";
       if (await intervene(context)) return "";
       timeoutReason = "inactivity";
       return timeoutReason;

package/hub/platform.mjs

@@ -1,6 +1,7 @@
 import { execFile, execFileSync, execSync } from "node:child_process";
 import os from "node:os";
 import path from "node:path";
+import { privateTmpRoot } from "./lib/private-tmp.mjs";
 
 export const IS_WINDOWS = process.platform === "win32";
 export const IS_MAC = process.platform === "darwin";
@@ -209,7 +210,8 @@ export function pipePath(name, pid = process.pid, options = {}) {
     return `\\\\.\\pipe\\${suffix}`;
   }
 
-  const baseDir = options.tempDir || TEMP_DIR;
+  // 공용 /tmp 의 소켓은 다른 사용자가 접속하거나 선점할 수 있다. 짧은 경로를 위해 /tmp 를 기준으로 둔다.
+  const baseDir = options.tempDir || privateTmpRoot({ base: TEMP_DIR });
   return path.posix.join(baseDir, `${suffix}.sock`);
 }
 

package/hub/team/agent-map.json

@@ -0,0 +1,29 @@
+{
+  "executor": "codex",
+  "build-fixer": "codex",
+  "cleanup": "codex",
+  "deslop": "codex",
+  "debugger": "codex",
+  "deep-executor": "codex",
+  "architect": "codex",
+  "planner": "codex",
+  "critic": "codex",
+  "analyst": "codex",
+  "code-reviewer": "codex",
+  "security-reviewer": "codex",
+  "quality-reviewer": "codex",
+  "scientist": "codex",
+  "scientist-deep": "codex",
+  "document-specialist": "codex",
+  "spark": "codex",
+  "designer": "antigravity",
+  "writer": "antigravity",
+  "explore": "claude",
+  "verifier": "codex",
+  "test-engineer": "codex",
+  "qa-tester": "codex",
+  "codex": "codex",
+  "antigravity": "antigravity",
+  "agy": "antigravity",
+  "claude": "claude"
+}

package/hub/team/intervention.mjs

@@ -125,10 +125,12 @@ export async function resolveCodexRolloutFile({
   return null;
 }
 
-export function buildResumeArgv({ cli, sessionId, prompt } = {}) {
+// 프롬프트는 argv 에 두면 ps 에 보여서 넣지 않는다. 실행하는 쪽이 prompt 를 stdin 으로 넘긴다.
+// claude -p 는 프롬프트 인자가 없으면, codex exec resume 은 `-` 를 받으면 stdin 을 읽는다.
+export function buildResumeArgv({ cli, sessionId } = {}) {
   if (!sessionId) return null;
-  if (cli === "claude") return ["claude", "-p", "--resume", sessionId, prompt];
-  if (cli === "codex") return ["codex", "exec", "resume", sessionId, prompt];
+  if (cli === "claude") return ["claude", "-p", "--resume", sessionId];
+  if (cli === "codex") return ["codex", "exec", "resume", sessionId, "-"];
   return null;
 }
 
@@ -474,7 +476,7 @@ export function createInterventionLadder({
         sessionId,
         prompt: reinstructPrompt,
         target,
-        argv: buildResumeArgv({ cli, sessionId, prompt: reinstructPrompt }),
+        argv: buildResumeArgv({ cli, sessionId }),
       });
       return resumed?.ok === false
         ? { ok: false, detail: "resume_dispatch_failed" }