@triflux/core 10.41.1 → 10.43.0

package/hub/team/intervention.mjs

@@ -0,0 +1,530 @@
+// 무활동 감지는 호출자 소유다. 이 모듈은 개입 사다리만 집행한다.
+// ① interrupt+재지시 → ② graceful+resume → ③ SIGTERM → ④ SIGKILL
+import { execFile } from "node:child_process";
+import { statSync } from "node:fs";
+import { readdir, readlink } from "node:fs/promises";
+import { promisify } from "node:util";
+import { isPidAlive } from "../lib/process-utils.mjs";
+import { killProcess } from "../platform.mjs";
+import {
+  resolveHardCeilingMs,
+  resolveStallInterventionMs as resolveStallThresholdMs,
+} from "../lib/timeout-defaults.mjs";
+
+export { resolveHardCeilingMs, resolveStallThresholdMs };
+
+export const CHANNELS = Object.freeze({
+  CLAUDE_DAEMON: "claude-daemon",
+  TMUX_PANE: "tmux-pane",
+  CODEX_APP_SERVER: "codex-app-server",
+  PROCESS: "process",
+});
+
+export const STEPS = Object.freeze({
+  REINSTRUCT: "reinstruct",
+  RESUME: "resume",
+  SIGTERM: "sigterm",
+  SIGKILL: "sigkill",
+});
+
+export const INTERVENTION_DEFAULTS = Object.freeze({
+  interruptSettleMs: 3_000,
+  reinstructInjectTimeoutMs: 8_000,
+  reinstructWaitMs: 300_000,
+  resumeDispatchTimeoutMs: 60_000,
+  resumeWaitMs: 300_000,
+  activityPollMs: 5_000,
+  sigtermGraceMs: 5_000,
+});
+
+export const DEFAULT_REINSTRUCT_PROMPT =
+  "[triflux intervention] 무활동이 감지되어 인터럽트했다. 직전 작업을 이어가라: " +
+  "1) 마지막으로 완료한 단계를 한 줄로 요약하고, 2) 남은 단계를 계속 진행하라. " +
+  "장시간 침묵하는 단일 도구 호출 대신 진행 상황을 주기적으로 출력하라.";
+
+const ROLLOUT_UUID_RE =
+  /rollout-.*-([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})\.jsonl$/u;
+const execFileAsync = promisify(execFile);
+const resumeCapabilityCache = new Map();
+
+function positiveSeconds(env, key) {
+  const value = Number.parseInt(String(env?.[key] ?? ""), 10);
+  return Number.isFinite(value) && value > 0 ? value * 1_000 : undefined;
+}
+
+function sleepFor(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+export function detectChannel(target = {}) {
+  if (Object.values(CHANNELS).includes(target.channel)) return target.channel;
+  if (target.appServer?.client && target.appServer?.threadId)
+    return CHANNELS.CODEX_APP_SERVER;
+  if (
+    target.daemon?.controlSock &&
+    (target.daemon.short || target.daemon.sessionId)
+  )
+    return CHANNELS.CLAUDE_DAEMON;
+  if (typeof target.paneId === "string" && target.paneId)
+    return CHANNELS.TMUX_PANE;
+  if (Number.isInteger(target.pid) && target.pid > 0) return CHANNELS.PROCESS;
+  return null;
+}
+
+export function extractCodexSessionIdFromRolloutPath(rolloutPath) {
+  const match = ROLLOUT_UUID_RE.exec(String(rolloutPath || ""));
+  return match ? match[1].toLowerCase() : null;
+}
+
+function isRolloutPath(value, codexHome) {
+  const file = String(value || "").replaceAll("\\", "/");
+  const home = String(codexHome || "")
+    .replaceAll("\\", "/")
+    .replace(/\/$/u, "");
+  return (
+    /\/sessions\/.*\/rollout-[^/]+\.jsonl$/u.test(file) &&
+    (!home || file.startsWith(`${home}/sessions/`))
+  );
+}
+
+/** Best-effort only: neither failure nor a missing open rollout is exceptional. */
+export async function resolveCodexRolloutFile({
+  pid,
+  codexHome,
+  deps = {},
+} = {}) {
+  const numericPid = Number(pid);
+  if (!Number.isInteger(numericPid) || numericPid <= 0) return null;
+  const run = deps.execFileAsync || execFileAsync;
+  const candidates = [];
+
+  try {
+    const result = await run("lsof", ["-Fn", "-p", String(numericPid)], {
+      timeout: 5_000,
+    });
+    const output = typeof result === "string" ? result : result?.stdout;
+    for (const line of String(output || "").split(/\r?\n/u)) {
+      if (line.startsWith("n") && isRolloutPath(line.slice(1), codexHome))
+        candidates.push(line.slice(1));
+    }
+  } catch {
+    // Linux /proc fallback below; macOS simply returns null if lsof is unavailable.
+  }
+
+  if (candidates.length) return candidates[0];
+  const list = deps.readdir || readdir;
+  const link = deps.readlink || readlink;
+  try {
+    for (const fd of await list(`/proc/${numericPid}/fd`)) {
+      const candidate = await link(`/proc/${numericPid}/fd/${fd}`);
+      if (isRolloutPath(candidate, codexHome)) return candidate;
+    }
+  } catch {
+    // /proc is intentionally optional (macOS/Windows do not expose it).
+  }
+  return null;
+}
+
+export function buildResumeArgv({ cli, sessionId, prompt } = {}) {
+  if (!sessionId) return null;
+  if (cli === "claude") return ["claude", "-p", "--resume", sessionId, prompt];
+  if (cli === "codex") return ["codex", "exec", "resume", sessionId, prompt];
+  return null;
+}
+
+export async function probeResumeCapability(
+  cli,
+  { execFileAsync: run = execFileAsync, cache = resumeCapabilityCache } = {},
+) {
+  if (cache.has(cli)) return cache.get(cli);
+  let supported = false;
+  try {
+    if (cli === "claude") supported = true;
+    else if (cli === "codex") {
+      await run("codex", ["exec", "resume", "--help"], { timeout: 8_000 });
+      supported = true;
+    }
+  } catch {
+    supported = false;
+  }
+  cache.set(cli, supported);
+  return supported;
+}
+
+export function createFileActivitySource({
+  files = [],
+  rolloutFile = null,
+  deps = {},
+} = {}) {
+  const stat = deps.statSync || statSync;
+  const targets = [...files, ...(rolloutFile ? [rolloutFile] : [])].filter(
+    Boolean,
+  );
+  return () =>
+    targets
+      .map((file) => {
+        try {
+          const current = stat(file);
+          return `${current.size}:${Math.floor(current.mtimeMs)}`;
+        } catch {
+          return "-";
+        }
+      })
+      .join("|");
+}
+
+function defaultCli(channel, target) {
+  if (target.cli) return target.cli;
+  if (channel === CHANNELS.CLAUDE_DAEMON) return "claude";
+  if (channel === CHANNELS.CODEX_APP_SERVER) return "codex";
+  return null;
+}
+
+function processPid(target) {
+  const pid = Number(target.pid || target.appServer?.pid);
+  return Number.isInteger(pid) && pid > 0 ? pid : null;
+}
+
+export function createInterventionLadder({
+  target = {},
+  reinstructPrompt = DEFAULT_REINSTRUCT_PROMPT,
+  readActivitySignature,
+  config = {},
+  log = () => {},
+  deps = {},
+} = {}) {
+  if (typeof readActivitySignature !== "function")
+    throw new Error(
+      "createInterventionLadder requires readActivitySignature()",
+    );
+
+  const cfg = {
+    ...INTERVENTION_DEFAULTS,
+    ...(positiveSeconds(process.env, "TFX_INTERVENTION_REINSTRUCT_WAIT_SEC")
+      ? {
+          reinstructWaitMs: positiveSeconds(
+            process.env,
+            "TFX_INTERVENTION_REINSTRUCT_WAIT_SEC",
+          ),
+        }
+      : {}),
+    ...(positiveSeconds(process.env, "TFX_INTERVENTION_RESUME_WAIT_SEC")
+      ? {
+          resumeWaitMs: positiveSeconds(
+            process.env,
+            "TFX_INTERVENTION_RESUME_WAIT_SEC",
+          ),
+        }
+      : {}),
+    ...config,
+  };
+  const sleep = deps.sleep || sleepFor;
+  const alive = deps.isPidAlive || isPidAlive;
+  const kill = deps.killProcess || killProcess;
+  const state = { step: null, attempts: [] };
+  let emit = () => {};
+
+  const loadDaemonControl = async () =>
+    deps.daemonControl || (await import("./claude-daemon-control.mjs"));
+  const loadPane = async () => {
+    if (deps.psmuxExec && deps.injectPrompt)
+      return { psmuxExec: deps.psmuxExec, injectPrompt: deps.injectPrompt };
+    const [{ psmuxExec }, { injectPrompt }] = await Promise.all([
+      import("./psmux.mjs"),
+      import("./pane.mjs"),
+    ]);
+    return { psmuxExec, injectPrompt };
+  };
+  const loadPsmux = async () => {
+    if (deps.psmuxExec) return deps.psmuxExec;
+    return (await import("./psmux.mjs")).psmuxExec;
+  };
+
+  async function signature() {
+    return await readActivitySignature();
+  }
+
+  async function waitForActivity(baseline, waitMs) {
+    const deadline = Date.now() + waitMs;
+    do {
+      if ((await signature()) !== baseline) return true;
+      if (Date.now() >= deadline) break;
+      await sleep(
+        Math.min(cfg.activityPollMs, Math.max(0, deadline - Date.now())),
+      );
+    } while (Date.now() < deadline);
+    return (await signature()) !== baseline;
+  }
+
+  async function record(step, action) {
+    const startedAt = Date.now();
+    emit({ step, phase: "start" });
+    let result;
+    try {
+      result = await action();
+    } catch {
+      result = { ok: false, detail: "operation_failed" };
+    }
+    const attempt = {
+      step,
+      ok: result?.ok === true,
+      detail: result?.detail || (result?.ok ? "ok" : "operation_failed"),
+      startedAt,
+      endedAt: Date.now(),
+    };
+    state.attempts.push(attempt);
+    emit({ step, phase: "end", ok: attempt.ok, detail: attempt.detail });
+    return attempt;
+  }
+
+  async function tryReinstruct(channel) {
+    return await record(STEPS.REINSTRUCT, async () => {
+      if (channel === CHANNELS.CLAUDE_DAEMON) {
+        const daemon = target.daemon || {};
+        let control;
+        try {
+          control = await loadDaemonControl();
+        } catch {
+          return { ok: false, detail: "channel_unavailable" };
+        }
+        const auth =
+          (await control.buildDaemonControlAuth?.(daemon.configDir)) || {};
+        const interrupted = await control.interruptClaudeDaemonSession({
+          controlSock: daemon.controlSock,
+          short: daemon.short,
+          ...auth,
+        });
+        if (interrupted?.inputSent !== true)
+          return { ok: false, detail: "interrupt_not_delivered" };
+        await sleep(cfg.interruptSettleMs);
+        const attached = await control.attachClaudeDaemonSession({
+          controlSock: daemon.controlSock,
+          short: daemon.short,
+          input: reinstructPrompt,
+          ...auth,
+          timeoutMs: cfg.reinstructInjectTimeoutMs,
+          completionQuiescenceMs: 0,
+        });
+        return attached?.inputSent === true
+          ? { ok: true, detail: "injected" }
+          : { ok: false, detail: "inject_failed" };
+      }
+      if (channel === CHANNELS.TMUX_PANE) {
+        if (target.interactive !== true)
+          return { ok: false, detail: "headless_pane_no_input_channel" };
+        let pane;
+        try {
+          pane = await loadPane();
+        } catch {
+          return { ok: false, detail: "channel_unavailable" };
+        }
+        await pane.psmuxExec([
+          "send-keys",
+          "-t",
+          target.paneId,
+          target.cli === "claude" ? "Escape" : "C-c",
+        ]);
+        await sleep(cfg.interruptSettleMs);
+        await pane.injectPrompt(target.paneId, reinstructPrompt, {
+          cli: target.cli || null,
+        });
+        return { ok: true, detail: "injected" };
+      }
+      if (channel === CHANNELS.CODEX_APP_SERVER) {
+        const { client, threadId } = target.appServer || {};
+        await client.request("turn/interrupt", { threadId }, 10_000);
+        await client.request(
+          "turn/start",
+          { threadId, input: [{ type: "text", text: reinstructPrompt }] },
+          30_000,
+        );
+        return { ok: true, detail: "injected" };
+      }
+      return { ok: false, detail: "channel_unsupported" };
+    });
+  }
+
+  async function resolveSessionId(channel, cli) {
+    if (target.sessionId) return target.sessionId;
+    if (target.daemon?.sessionId) return target.daemon.sessionId;
+    if (channel === CHANNELS.CODEX_APP_SERVER)
+      return target.appServer?.threadId || null;
+    const direct = extractCodexSessionIdFromRolloutPath(target.rolloutFile);
+    if (direct) return direct;
+    if (cli !== "codex") return null;
+    const resolveRollout =
+      deps.resolveCodexRolloutFile || resolveCodexRolloutFile;
+    const rolloutFile = await resolveRollout({
+      pid: processPid(target),
+      codexHome: target.codexHome,
+      deps,
+    });
+    return extractCodexSessionIdFromRolloutPath(rolloutFile);
+  }
+
+  async function terminate(
+    channel,
+    { force = false, recordAttempt = true } = {},
+  ) {
+    const step = force ? STEPS.SIGKILL : STEPS.SIGTERM;
+    const signal = force ? "SIGKILL" : "SIGTERM";
+    const action = async () => {
+      if (channel === CHANNELS.CLAUDE_DAEMON) {
+        const daemon = target.daemon || {};
+        let control;
+        try {
+          control = await loadDaemonControl();
+        } catch {
+          return { ok: false, detail: "channel_unavailable" };
+        }
+        const auth =
+          (await control.buildDaemonControlAuth?.(daemon.configDir)) || {};
+        const sessionId = target.sessionId || daemon.sessionId;
+        const result = sessionId
+          ? await control.sendKillBySessionId({
+              daemonPaths: {
+                controlSock: daemon.controlSock,
+                configDir: daemon.configDir,
+              },
+              sessionId,
+              ...auth,
+            })
+          : await control.killDaemonJob?.(
+              daemon.controlSock,
+              daemon.short,
+              auth,
+            );
+        return result?.ok === true
+          ? { ok: true, detail: "daemon_killed" }
+          : { ok: false, detail: "daemon_kill_failed" };
+      }
+
+      if (channel === CHANNELS.TMUX_PANE) {
+        let psmuxExec;
+        try {
+          psmuxExec = await loadPsmux();
+        } catch {
+          return { ok: false, detail: "channel_unavailable" };
+        }
+        const output = await psmuxExec([
+          "list-panes",
+          "-t",
+          target.paneId,
+          "-F",
+          "#{pane_pid}",
+        ]);
+        const panePid = Number(
+          String(output || "")
+            .trim()
+            .split(/\s+/u)[0],
+        );
+        if (!Number.isInteger(panePid) || panePid <= 0) {
+          if (!force) return { ok: false, detail: "pane_pid_unavailable" };
+          await psmuxExec(["kill-pane", "-t", target.paneId]);
+          return { ok: true, detail: "pane_killed" };
+        }
+        const sent = kill(panePid, {
+          signal,
+          tree: true,
+          ...(force ? { force: true } : {}),
+        });
+        if (!sent) return { ok: false, detail: "signal_failed" };
+        await sleep(
+          force ? Math.min(cfg.sigtermGraceMs, 250) : cfg.sigtermGraceMs,
+        );
+        if (!alive(panePid)) return { ok: true, detail: "terminated" };
+        if (force) await psmuxExec(["kill-pane", "-t", target.paneId]);
+        return { ok: false, detail: "still_alive" };
+      }
+
+      const pid = processPid(target);
+      if (!pid) return { ok: false, detail: "pid_unavailable" };
+      const sent = kill(pid, {
+        signal,
+        tree: true,
+        ...(force ? { force: true } : {}),
+      });
+      if (!sent) return { ok: false, detail: "signal_failed" };
+      await sleep(
+        force ? Math.min(cfg.sigtermGraceMs, 250) : cfg.sigtermGraceMs,
+      );
+      return !alive(pid)
+        ? { ok: true, detail: "terminated" }
+        : { ok: false, detail: "still_alive" };
+    };
+    return recordAttempt ? await record(step, action) : await action();
+  }
+
+  async function tryResume(channel) {
+    return await record(STEPS.RESUME, async () => {
+      const cli = defaultCli(channel, target);
+      const probe = deps.probeResumeCapability || probeResumeCapability;
+      const supported = await probe(cli, { execFileAsync: deps.execFileAsync });
+      if (!supported) return { ok: false, detail: "capability_unsupported" };
+      const sessionId = await resolveSessionId(channel, cli);
+      if (!sessionId) return { ok: false, detail: "session_id_unavailable" };
+      if (typeof deps.resumeHandler !== "function")
+        return { ok: false, detail: "no_resume_handler" };
+
+      // A resume handler owns relaunching; only stop after all prerequisites exist.
+      const stopped = await terminate(channel, { recordAttempt: false });
+      if (!stopped.ok) return { ok: false, detail: "graceful_stop_failed" };
+      const resumed = await deps.resumeHandler({
+        cli,
+        sessionId,
+        prompt: reinstructPrompt,
+        target,
+        argv: buildResumeArgv({ cli, sessionId, prompt: reinstructPrompt }),
+      });
+      return resumed?.ok === false
+        ? { ok: false, detail: "resume_dispatch_failed" }
+        : { ok: true, detail: "resume_dispatched" };
+    });
+  }
+
+  async function intervene() {
+    state.step = null;
+    state.attempts.length = 0;
+    const channel = detectChannel(target);
+    emit = (event) => {
+      try {
+        log({ ts: Date.now(), channel, ...event });
+      } catch {
+        // Logging must never change recovery behaviour.
+      }
+    };
+
+    const finish = (outcome, step) => {
+      state.step = step;
+      return {
+        ok: outcome !== "failed",
+        outcome,
+        step,
+        channel,
+        attempts: [...state.attempts],
+      };
+    };
+
+    if (channel && channel !== CHANNELS.PROCESS) {
+      const baseline = await signature();
+      const attempt = await tryReinstruct(channel);
+      if (attempt.ok && (await waitForActivity(baseline, cfg.reinstructWaitMs)))
+        return finish("reactivated", STEPS.REINSTRUCT);
+    }
+
+    const resumeBaseline = await signature();
+    const resumed = await tryResume(channel);
+    if (resumed.ok && (await waitForActivity(resumeBaseline, cfg.resumeWaitMs)))
+      return finish("resumed", STEPS.RESUME);
+
+    const terminated = await terminate(channel);
+    if (terminated.ok) return finish("terminated", STEPS.SIGTERM);
+    const killed = await terminate(channel, { force: true });
+    return finish(killed.ok ? "killed" : "failed", STEPS.SIGKILL);
+  }
+
+  return Object.freeze({
+    intervene,
+    getState: () => ({ step: state.step, attempts: [...state.attempts] }),
+  });
+}

package/hub/team/retry-state-machine.mjs

@@ -41,10 +41,14 @@ export const MODES = Object.freeze({
 const ESCALATION_CHAIN_CONFIG_PATH = ".triflux/config/escalation-chain.json";
 
 // Escalation chain (2026-05-27 정책):
-//   1. codex gpt-5.5   — 코드/추론/비용에서 mini/5.3-codex 중간 단계를 대체
+//   1. codex gpt-5.6-sol — 기존 최상위 Codex escalation 단계
 //   2. claude opus-4-8 — 최종 수단
 const DEFAULT_ESCALATION_CHAIN = Object.freeze([
-  Object.freeze({ cli: "codex", model: "gpt-5.5" }),
+  Object.freeze({
+    cli: "codex",
+    model: "gpt-5.6-sol",
+    profile: "gpt56_sol_xhigh",
+  }),
   Object.freeze({ cli: "claude", model: "opus-4-8" }),
 ]);
 

package/hud/constants.mjs

@@ -50,6 +50,13 @@ export const CONTEXT_MONITOR_CACHE_PATH = join(
   "tfx-hub",
   "context-monitor.json",
 );
+export const HUB_REQUEST_MONITOR_CACHE_PATH = join(
+  homedir(),
+  ".claude",
+  "cache",
+  "tfx-hub",
+  "hub-request-context-monitor.json",
+);
 export const CONTEXT_MONITOR_LEGACY_PATH = join(
   homedir(),
   ".omc",
@@ -122,6 +129,20 @@ export const ONE_DAY_MS = 24 * 60 * 60 * 1000;
 export const DEFAULT_OAUTH_CLIENT_ID = "9d1c250a-e61b-44d9-88ed-5944d1962f5e";
 
 export const CODEX_AUTH_PATH = join(homedir(), ".codex", "auth.json");
+export const CODEX_PROBE_STATE_PATH = join(
+  homedir(),
+  ".claude",
+  "cache",
+  "codex-probe-state.json",
+);
+export const CODEX_BROKER_AUTH_CACHE_DIR = join(
+  homedir(),
+  ".claude",
+  "cache",
+  "tfx-hub",
+);
+export const CODEX_PROBE_TTL_MS = 5 * 60 * 1000;
+export const CODEX_PROBE_TIMEOUT_MS = 10_000;
 export const CODEX_QUOTA_CACHE_PATH = join(
   homedir(),
   ".claude",

package/hud/context-monitor.mjs

@@ -283,26 +283,23 @@ export function deriveContextLimit(stdin) {
 
 export function buildContextUsageView(stdin, snapshot = null) {
   const stdinUsage = getStdinContextUsage(stdin);
-  const monitor = snapshot || readContextMonitorSnapshot();
-  const modelId = stdin?.model?.id ?? stdin?.model;
-  const modelHintLimit = resolveModelLimit(modelId);
-  const monitorLimit = Number(monitor?.limitTokens || 0);
-  const stdinLimit = stdinUsage?.limitTokens;
-  // When a model id is known it is the authoritative per-model ceiling: the
-  // monitor's cached limitTokens is just a default-derived accumulator (now 1M
-  // by default) and must not override a known model's real window in either
-  // direction — it would inflate a 200K model (Sonnet 4.5 / Haiku) up to 1M.
-  // The model hint already upgrades a stale-low monitor on its own (#88).
-  const limitTokens =
-    stdinLimit != null && stdinLimit > 0
-      ? Math.max(1, stdinLimit)
-      : modelId
-        ? Math.max(1, modelHintLimit)
-        : Math.max(1, monitorLimit || modelHintLimit);
+  if (!stdinUsage) {
+    return {
+      usedTokens: 0,
+      limitTokens: 0,
+      percent: 0,
+      display: "--",
+      warningLevel: "ok",
+      warningMessage: "",
+      warningTag: "",
+      source: "none",
+    };
+  }
 
-  const usedTokens = stdinUsage?.usedTokens ?? Number(monitor?.usedTokens || 0);
-  const percent =
-    limitTokens > 0 ? clampPercent((usedTokens / limitTokens) * 100) : 0;
+  const modelId = stdin?.model?.id ?? stdin?.model;
+  const limitTokens = Math.max(1, stdinUsage.limitTokens);
+  const usedTokens = stdinUsage.usedTokens;
+  const percent = clampPercent((usedTokens / limitTokens) * 100);
 
   const warning = classifyContextThreshold(percent);
   const showInfoOnlyStatus = !(
@@ -324,12 +321,12 @@ export function buildContextUsageView(stdin, snapshot = null) {
           : warning.level === "info"
             ? "ℹ 절반 이상 사용"
             : "",
-    source: stdinUsage?.source || (monitor ? "monitor" : "none"),
+    source: stdinUsage.source,
   };
 }
 
 export function createContextMonitor(options = {}) {
-  // Default to a 1M context window (Opus 4.x [1M] / Codex gpt-5.5 both run on
+  // Default to a 1M context window (Opus 4.x [1M] / Codex GPT-5.6 family runs on
   // a 1M window) when no explicit limit is supplied, so the cached percent the
   // Stop hook reads is not inflated against a 200K assumption — assuming 200K
   // there false-positives at ~15% real usage and blocks legitimate stops.

package/hud/hud-qos-status.mjs

@@ -97,7 +97,7 @@ async function main() {
   }
 
   if (process.argv.includes(CODEX_REFRESH_FLAG)) {
-    refreshCodexRateLimitsCache();
+    await refreshCodexRateLimitsCache();
     return;
   }