@triflux/remote 10.49.0 → 10.50.1

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

@@ -13,6 +13,10 @@ import {
   removeClaudeSessionProjection,
   writeClaudeSessionProjection,
 } from "./claude-session-projection.mjs";
+import {
+  findClaudeTranscript,
+  readClaudeTranscript,
+} from "./claude-transcript.mjs";
 
 export function resolveClaudeConfigDir(env = process.env) {
   if (env.CLAUDE_CONFIG_DIR) return path.resolve(env.CLAUDE_CONFIG_DIR);
@@ -223,6 +227,21 @@ function sessionsFromDaemonList(listResponse) {
   return extractClaudeAgentSessions(listResponse);
 }
 
+async function addSessionContexts(sessions, candidate) {
+  return await Promise.all(
+    sessions.map(async (session) => {
+      const transcript = await findClaudeTranscript({
+        configDir: candidate.configDir,
+        sourceConfigDir: candidate.sourceConfigDir,
+        sessionId: session.sessionId,
+        cwd: session.cwd,
+      });
+      const snapshot = await readClaudeTranscript(transcript).catch(() => null);
+      return { ...session, context: snapshot?.context ?? null };
+    }),
+  );
+}
+
 function errorMessage(error) {
   return error?.message || String(error);
 }
@@ -322,12 +341,21 @@ export async function probeClaudeDaemonCandidates({
   sessionId,
   timeoutMs = 6000,
   tmpRoot = "/tmp",
+  includeContext = false,
+  candidateSourceConfigDir,
 } = {}) {
-  const candidates = await buildClaudeDaemonDiscoveryCandidates({
+  const discovered = await buildClaudeDaemonDiscoveryCandidates({
     configDir,
     env,
     tmpRoot,
   });
+  const candidates = candidateSourceConfigDir
+    ? discovered.filter(
+        (candidate) =>
+          (candidate.sourceConfigDir ?? candidate.configDir) ===
+          candidateSourceConfigDir,
+      )
+    : discovered;
   const callerProvenance = detectCallerProvenance(env);
   const targetRequested = Boolean(short || sessionId);
   const results = [];
@@ -339,7 +367,10 @@ export async function probeClaudeDaemonCandidates({
         { proto: 1, op: "list" },
         { timeoutMs },
       );
-      const sessions = sessionsFromDaemonList(list);
+      const normalized = sessionsFromDaemonList(list);
+      const sessions = includeContext
+        ? await addSessionContexts(normalized, candidate)
+        : normalized;
       const ok = list?.ok !== false;
       results.push({
         ok,
@@ -1038,10 +1069,10 @@ function defaultClaudeAttachCompletionMatched(
   );
 }
 
-function writeClaudeAttachInput(socket, input) {
+function writeClaudeAttachInput(socket, input, onSubmitted) {
   socket.write("\x15");
   socket.write(`\x1b[200~${String(input)}\x1b[201~`);
-  socket.write("\r");
+  socket.write("\r", onSubmitted);
 }
 
 function requiresPostInputTransition(handshake) {
@@ -1066,6 +1097,7 @@ export function attachClaudeDaemonSession({
   timeoutMs = 30_000,
   completionQuiescenceMs = DEFAULT_ATTACH_COMPLETION_QUIESCENCE_MS,
   completionMatched = defaultClaudeAttachCompletionMatched,
+  noWait = false,
 } = {}) {
   if (!controlSock) throw new Error("controlSock is required");
   return new Promise((resolve, reject) => {
@@ -1198,8 +1230,24 @@ export function attachClaudeDaemonSession({
               { cols },
             );
             responseStartOffset = stream.length;
-            writeClaudeAttachInput(socket, input);
-            inputSent = true;
+            inputSent = noWait ? null : true;
+            writeClaudeAttachInput(
+              socket,
+              input,
+              noWait
+                ? (error) => {
+                    if (error) fail(error);
+                    else {
+                      inputSent = true;
+                      finish({
+                        timedOut: false,
+                        matchedCompletion: false,
+                        closed: false,
+                      });
+                    }
+                  }
+                : undefined,
+            );
           }, initialDrainMs);
         }
       } else {

package/hub/team/claude-transcript.mjs

@@ -0,0 +1,240 @@
+import { createReadStream } from "node:fs";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { StringDecoder } from "node:string_decoder";
+import { modelContext } from "./session-context.mjs";
+
+const transcriptCache = new Map();
+
+export async function findClaudeTranscript({
+  configDir,
+  sourceConfigDir,
+  sessionId,
+  cwd,
+}) {
+  if (!configDir || !sessionId || /[/\\]/u.test(sessionId)) return null;
+  for (const dir of new Set([configDir, sourceConfigDir].filter(Boolean))) {
+    const projectsDir = path.join(dir, "projects");
+    const preferred = cwd
+      ? path.resolve(cwd).replace(/[^a-zA-Z0-9]/g, "-")
+      : null;
+    const projects = [
+      ...(preferred ? [preferred] : []),
+      ...(await fs.readdir(projectsDir).catch(() => [])).filter(
+        (project) => project !== preferred,
+      ),
+    ];
+    for (const project of projects) {
+      const candidate = path.join(projectsDir, project, `${sessionId}.jsonl`);
+      try {
+        await fs.access(candidate);
+        return candidate;
+      } catch {
+        // Continue looking for this session.
+      }
+    }
+  }
+  return null;
+}
+
+function messageText(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content
+    .filter((part) => part?.type === "text" && typeof part.text === "string")
+    .map((part) => part.text)
+    .join("\n");
+}
+
+function beginTurn(state) {
+  state.userSeen = true;
+  state.queued = false;
+  state.response = "";
+  state.error = null;
+  state.turnEnded = false;
+  state.sectionClosed = false;
+}
+
+function acceptEntry(state, entry, marker) {
+  if (entry?.isSidechain) return;
+  const message = entry?.message;
+  if (entry?.type === "system" && entry.subtype === "compact_boundary") {
+    state.compactCount += 1;
+    state.compact = {
+      preTokens: entry.compactMetadata?.preTokens ?? null,
+      postTokens: entry.compactMetadata?.postTokens ?? null,
+    };
+    state.estimatedContextTokens = state.compact.postTokens;
+    state.measuredAt = entry.timestamp || null;
+  }
+  if (entry?.type === "assistant") {
+    if (entry.isApiErrorMessage === true || message?.model === "<synthetic>") {
+      if (state.userSeen && !state.sectionClosed && entry.isApiErrorMessage) {
+        state.error = messageText(message?.content) || "Claude API error";
+        state.turnEnded = true;
+      }
+      return;
+    }
+    const usage = message?.usage;
+    if (usage) {
+      state.estimatedContextTokens =
+        (usage.input_tokens || 0) +
+        (usage.cache_read_input_tokens || 0) +
+        (usage.cache_creation_input_tokens || 0);
+      state.model = message.model || state.model;
+      state.measuredAt = entry.timestamp || state.measuredAt;
+    }
+    if (state.userSeen && !state.sectionClosed) {
+      const text = messageText(message?.content);
+      if (text) state.response = text;
+      if (message?.stop_reason === "end_turn") state.turnEnded = true;
+    }
+    return;
+  }
+  if (entry?.type === "user") {
+    const content = message?.content;
+    // Tool results are not a new human turn.
+    const humanText =
+      typeof content === "string" ||
+      (Array.isArray(content) && content.some((part) => part?.type === "text"))
+        ? messageText(content)
+        : "";
+    const marked =
+      marker &&
+      (humanText.includes(marker) ||
+        JSON.stringify(
+          entry.attachments ?? message?.attachments ?? [],
+        ).includes(marker));
+    if (humanText || marked) {
+      if (!marker || marked) beginTurn(state);
+      else if (state.userSeen) state.sectionClosed = true;
+    }
+    return;
+  }
+  if (
+    entry?.type === "attachment" &&
+    entry.attachment?.type === "queued_command" &&
+    marker &&
+    JSON.stringify(entry.attachment).includes(marker)
+  ) {
+    beginTurn(state);
+    return;
+  }
+  if (entry?.type === "queue-operation") {
+    const marked =
+      marker &&
+      typeof entry.content === "string" &&
+      entry.content.includes(marker);
+    if (marked && entry.operation === "enqueue") {
+      state.queued = true;
+      state.queuedContent = entry.content;
+    } else if (
+      state.queued &&
+      (marked || entry.content === state.queuedContent)
+    ) {
+      if (entry.operation === "remove") beginTurn(state);
+    } else if (marked && entry.operation === "remove") {
+      beginTurn(state);
+    }
+    return;
+  }
+  if (
+    state.userSeen &&
+    !state.sectionClosed &&
+    entry?.type === "system" &&
+    entry.subtype === "turn_duration"
+  ) {
+    state.turnEnded = true;
+  }
+}
+
+function acceptLine(state, line, marker) {
+  try {
+    acceptEntry(state, JSON.parse(line), marker);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function readClaudeTranscript(transcriptPath, { requestId } = {}) {
+  if (!transcriptPath) return null;
+  const marker = requestId ? `[tfx-live req=${requestId}]` : null;
+  const key = `${transcriptPath}\0${requestId || ""}`;
+  let stat;
+  try {
+    stat = await fs.stat(transcriptPath);
+  } catch (error) {
+    if (error?.code === "ENOENT") return null;
+    throw error;
+  }
+  let state = transcriptCache.get(key);
+  if (
+    !state ||
+    state.ino !== stat.ino ||
+    stat.size < state.offset ||
+    (stat.size === state.offset && stat.mtimeMs !== state.mtimeMs)
+  ) {
+    state = {
+      ino: stat.ino,
+      offset: 0,
+      pending: "",
+      decoder: new StringDecoder("utf8"),
+      userSeen: false,
+      queued: false,
+      queuedContent: null,
+      response: "",
+      error: null,
+      turnEnded: false,
+      sectionClosed: false,
+      estimatedContextTokens: null,
+      model: null,
+      measuredAt: null,
+      compactCount: 0,
+      compact: null,
+    };
+  }
+  try {
+    if (stat.size > state.offset) {
+      const stream = createReadStream(transcriptPath, {
+        start: state.offset,
+        end: stat.size - 1,
+      });
+      for await (const chunk of stream) {
+        const lines = (state.pending + state.decoder.write(chunk)).split("\n");
+        state.pending = lines.pop();
+        for (const line of lines) acceptLine(state, line, marker);
+      }
+      if (state.pending && acceptLine(state, state.pending, marker))
+        state.pending = "";
+    }
+  } catch (error) {
+    transcriptCache.delete(key);
+    if (error?.code === "ENOENT") return null;
+    throw error;
+  }
+  state.offset = stat.size;
+  state.mtimeMs = stat.mtimeMs;
+  transcriptCache.set(key, state);
+  return {
+    context:
+      state.estimatedContextTokens === null && state.model === null
+        ? null
+        : {
+            ...modelContext(
+              "claude",
+              state.model,
+              state.estimatedContextTokens,
+            ),
+            model: state.model,
+            measuredAt: state.measuredAt,
+          },
+    userSeen: state.userSeen,
+    response: state.response,
+    error: state.error,
+    turnEnded: state.turnEnded,
+    sectionClosed: state.sectionClosed,
+    compactCount: state.compactCount,
+    compact: state.compact,
+  };
+}

package/hub/team/cli/commands/start/index.mjs

@@ -72,9 +72,19 @@ function renderTmuxInstallHelp() {
 
 export { parseTeamArgs };
 
+export function resolveTeamWorkers({ agents, task, assigns = [] }) {
+  if (assigns.length > 0) {
+    return {
+      agents: assigns.map((assign) => assign.cli),
+      subtasks: assigns.map((assign) => assign.prompt),
+    };
+  }
+  return { agents, subtasks: decomposeTask(task, agents.length) };
+}
+
 export async function teamStart(args = []) {
   const {
-    agents,
+    agents: requestedAgents,
     lead,
     layout,
     teammateMode,
@@ -100,11 +110,16 @@ export async function teamStart(args = []) {
     rawTask ||
     (assigns.length > 0 ? assigns.map((a) => a.prompt).join(" + ") : "");
   if (!task) return printStartUsage();
+  const { agents, subtasks } = resolveTeamWorkers({
+    agents: requestedAgents,
+    task,
+    assigns,
+  });
 
   console.log(`\n  ${AMBER}${BOLD}⬡ tfx multi${RESET}\n`);
 
   // P1b: 워커 수 계산 — 단일 워커 headless에는 Hub 불필요
-  const workerCount = assigns.length > 0 ? assigns.length : agents.length;
+  const workerCount = agents.length;
   const needsHub = workerCount >= 2 || teammateMode !== "headless";
 
   let hub = null;
@@ -126,7 +141,6 @@ export async function teamStart(args = []) {
   }
 
   const sessionId = `tfx-multi-${Date.now().toString(36).slice(-4)}${Math.random().toString(36).slice(2, 6)}`;
-  const subtasks = decomposeTask(task, agents.length);
   const hubUrl = hub?.url || getDefaultHubUrl();
   const { mode: effectiveMode, warnings: modeWarnings } =
     resolveEffectiveMode(teammateMode);

package/hub/team/cli/commands/start/parse-args.mjs

@@ -25,6 +25,7 @@ const KNOWN_ROLES = new Set([
   "test-engineer",
   "designer",
   "writer",
+  "researcher",
   "scientist",
 ]);
 

package/hub/team/session-context.mjs

@@ -0,0 +1,203 @@
+import { createReadStream } from "node:fs";
+import fs from "node:fs/promises";
+import { homedir } from "node:os";
+import path from "node:path";
+import { StringDecoder } from "node:string_decoder";
+
+// https://platform.claude.com/docs/en/build-with-claude/context-windows 2026-10-08
+// https://developers.openai.com/api/docs/models 2026-10-08
+const MODEL_CONTEXT = [
+  {
+    cli: "claude",
+    model: /^(?:claude-)?(?:fable-5[.-]1|opus-5[.-]5|sonnet-5[.-]5)(?:$|[-[])/i,
+    tokens: 1_000_000,
+    source:
+      "https://platform.claude.com/docs/en/build-with-claude/context-windows",
+  },
+  {
+    cli: "codex",
+    model: /^gpt-6(?:\.\d+)?(?:$|[-_])/i,
+    tokens: 1_050_000,
+    source: "https://developers.openai.com/api/docs/models",
+  },
+];
+
+export const CONTEXT_THRESHOLDS = {
+  claude: { warnContextPct: 60, maxContextPct: 90 },
+  codex: { warnContextPct: 15, maxContextPct: 22 },
+};
+
+const rolloutCache = new Map();
+
+export function modelContext(cli, model, estimatedContextTokens = null) {
+  const entry = MODEL_CONTEXT.find(
+    (item) => item.cli === cli && item.model.test(model || ""),
+  );
+  const contextLimitTokens = entry?.tokens ?? null;
+  const executionContextLimitTokens =
+    cli === "claude" && process.env.CLAUDE_CODE_DISABLE_1M_CONTEXT === "1"
+      ? 200_000
+      : null;
+  const effectiveLimit = Math.min(
+    contextLimitTokens ?? Infinity,
+    executionContextLimitTokens ?? Infinity,
+  );
+  return {
+    estimatedContextTokens,
+    contextLimitTokens,
+    contextLimitSource: entry?.source ?? null,
+    ...(executionContextLimitTokens ? { executionContextLimitTokens } : {}),
+    contextPct:
+      contextLimitTokens && Number.isFinite(estimatedContextTokens)
+        ? (estimatedContextTokens / effectiveLimit) * 100
+        : null,
+  };
+}
+
+export function contextGuard(
+  cli,
+  context,
+  { warnContextPct, maxContextPct } = {},
+) {
+  const defaults = CONTEXT_THRESHOLDS[cli];
+  const warn = warnContextPct ?? defaults?.warnContextPct ?? 0;
+  const max = maxContextPct ?? defaults?.maxContextPct ?? 0;
+  const fields = {
+    estimatedContextTokens: context?.estimatedContextTokens ?? null,
+    contextLimitTokens: context?.contextLimitTokens ?? null,
+    contextLimitSource: context?.contextLimitSource ?? null,
+    executionContextLimitTokens: context?.executionContextLimitTokens ?? null,
+    contextPct: context?.contextPct ?? null,
+  };
+  if (fields.contextPct === null) {
+    return warn > 0
+      ? {
+          contextWarning: {
+            ...fields,
+            reason:
+              fields.contextLimitTokens === null
+                ? "unknown-model"
+                : "usage-unavailable",
+          },
+        }
+      : {};
+  }
+  if (max > 0 && fields.contextPct >= max) {
+    return {
+      ok: false,
+      errorCode: "context-limit",
+      inputSent: false,
+      hint: "세션을 승계한 뒤 새 세션에 요청하라.",
+      ...fields,
+    };
+  }
+  return warn > 0 && fields.contextPct >= warn
+    ? { contextWarning: { ...fields, thresholdPct: warn } }
+    : {};
+}
+
+async function findCodexRollout(threadId) {
+  if (!/^[a-zA-Z0-9-]+$/u.test(threadId || "")) return null;
+  const root = path.join(
+    process.env.CODEX_HOME || path.join(homedir(), ".codex"),
+    "sessions",
+  );
+  for (const year of (await fs.readdir(root).catch(() => []))
+    .sort()
+    .reverse()) {
+    if (!/^\d{4}$/u.test(year)) continue;
+    for (const month of (
+      await fs.readdir(path.join(root, year)).catch(() => [])
+    )
+      .sort()
+      .reverse()) {
+      if (!/^\d{2}$/u.test(month)) continue;
+      for (const day of (
+        await fs.readdir(path.join(root, year, month)).catch(() => [])
+      )
+        .sort()
+        .reverse()) {
+        if (!/^\d{2}$/u.test(day)) continue;
+        const dir = path.join(root, year, month, day);
+        const file = (await fs.readdir(dir).catch(() => [])).find((name) =>
+          name.endsWith(`-${threadId}.jsonl`),
+        );
+        if (file) return path.join(dir, file);
+      }
+    }
+  }
+  return null;
+}
+
+function acceptCodexLine(state, line) {
+  let entry;
+  try {
+    entry = JSON.parse(line);
+  } catch {
+    return false;
+  }
+  if (entry?.type === "turn_context")
+    state.model = entry.payload?.model || state.model;
+  if (entry?.type === "event_msg" && entry.payload?.type === "token_count") {
+    const info = entry.payload.info;
+    if (Number.isFinite(info?.last_token_usage?.total_tokens))
+      state.tokens = info.last_token_usage.total_tokens;
+    if (Number.isFinite(info?.model_context_window))
+      state.executionContextLimitTokens = info.model_context_window;
+  }
+  return true;
+}
+
+export async function readCodexContext(rolloutPath, threadId) {
+  rolloutPath ||= await findCodexRollout(threadId);
+  if (!rolloutPath) return { ...modelContext("codex", null), model: null };
+  let stat;
+  try {
+    stat = await fs.stat(rolloutPath);
+  } catch {
+    return { ...modelContext("codex", null), model: null };
+  }
+  let state = rolloutCache.get(rolloutPath);
+  if (
+    !state ||
+    state.ino !== stat.ino ||
+    stat.size < state.offset ||
+    (stat.size === state.offset && stat.mtimeMs !== state.mtimeMs)
+  ) {
+    state = {
+      ino: stat.ino,
+      offset: 0,
+      pending: "",
+      decoder: new StringDecoder("utf8"),
+      model: null,
+      tokens: null,
+      executionContextLimitTokens: null,
+    };
+  }
+  try {
+    if (stat.size > state.offset) {
+      const stream = createReadStream(rolloutPath, {
+        start: state.offset,
+        end: stat.size - 1,
+      });
+      for await (const chunk of stream) {
+        const lines = (state.pending + state.decoder.write(chunk)).split("\n");
+        state.pending = lines.pop();
+        for (const line of lines) acceptCodexLine(state, line);
+      }
+      if (state.pending && acceptCodexLine(state, state.pending))
+        state.pending = "";
+    }
+  } catch {
+    rolloutCache.delete(rolloutPath);
+    return { ...modelContext("codex", null), model: null };
+  }
+  state.offset = stat.size;
+  state.mtimeMs = stat.mtimeMs;
+  rolloutCache.set(rolloutPath, state);
+  return {
+    ...modelContext("codex", state.model, state.tokens),
+    model: state.model,
+    executionContextLimitTokens: state.executionContextLimitTokens,
+  };
+}