@triflux/core 10.49.0 → 10.50.0

package/hub/bridge.mjs

@@ -1317,7 +1317,8 @@ function daemonAttachErrorResult(error) {
     matchedCompletion: false,
     timedOut: false,
     closed: false,
-    inputSent: error?.inputSent === true,
+    inputSent: error?.inputSent ?? null,
+    status: error?.inputSent === false ? "failed" : "unknown",
     error: error?.message || String(error),
   };
 }
@@ -1388,87 +1389,323 @@ async function cmdDaemonProbe(args) {
   try {
     const payload = readBridgePayload(args);
     const { probeClaudeDaemonCandidates } = await loadDaemonControl();
-    const probe = await probeClaudeDaemonCandidates({
-      configDir: payload.configDir,
-      env: process.env,
-      short: payload.short,
-      sessionId: payload.sessionId,
-      timeoutMs: numericOption(payload.timeoutMs, 6000),
-      tmpRoot: payload.tmpRoot,
-    });
-    return emitJson(probe);
+    const { probe, recoveredFrom } = await probeDaemonTarget(
+      payload,
+      probeClaudeDaemonCandidates,
+      payload.includeContext === true,
+    );
+    return emitJson({ ...probe, ...(recoveredFrom ? { recoveredFrom } : {}) });
   } catch (error) {
     return emitJson(daemonErrorResult(error));
   }
 }
 
+function staleCandidate(probe) {
+  return probe?.candidateResults?.find((candidate) =>
+    ["daemon-dir-missing", "stale-control-socket"].includes(
+      candidate.errorCode,
+    ),
+  );
+}
+
+function daemonProbeOptions(payload, includeContext = false) {
+  return {
+    configDir: payload.configDir,
+    env: process.env,
+    short: payload.short,
+    sessionId: payload.sessionId,
+    timeoutMs: numericOption(payload.timeoutMs, 6000),
+    tmpRoot: payload.tmpRoot,
+    includeContext,
+  };
+}
+
+async function probeDaemonTarget(
+  payload,
+  probeCandidates,
+  includeContext = false,
+) {
+  const options = daemonProbeOptions(payload, includeContext);
+  const probe = await probeCandidates(options);
+  const stale = staleCandidate(probe);
+  if (probe.ok || !(payload.short || payload.sessionId) || !stale) {
+    return { probe, recoveredFrom: null };
+  }
+  const retry = await probeCandidates({
+    ...options,
+    candidateSourceConfigDir: stale.sourceConfigDir ?? stale.configDir,
+  });
+  return {
+    probe: retry,
+    recoveredFrom: retry.ok ? stale : null,
+  };
+}
+
 async function cmdDaemonAttach(args) {
   try {
     const payload = readBridgePayload(args);
     if (!payload.prompt) throw new Error("prompt is required");
-
     const {
       attachClaudeDaemonSession,
       buildDaemonControlAuth,
       probeClaudeDaemonCandidates,
     } = await loadDaemonControl();
-    const probe = await probeClaudeDaemonCandidates({
-      configDir: payload.configDir,
-      env: process.env,
-      short: payload.short,
-      sessionId: payload.sessionId,
-      timeoutMs: numericOption(payload.timeoutMs, 6000),
-      tmpRoot: payload.tmpRoot,
-    });
+    let { probe, recoveredFrom } = await probeDaemonTarget(
+      payload,
+      probeClaudeDaemonCandidates,
+      false,
+    );
     if (!probe.ok) return emitJson(daemonAttachProbeFailureResult(probe));
-    const short = payload.short ?? probe.target?.short;
-    if (!short) {
-      return emitJson(
-        daemonAttachProbeFailureResult({
-          ...probe,
-          ok: false,
-          reason: "target-not-found",
-          error: "short or resolvable sessionId is required",
-        }),
-      );
-    }
-    const controlAuth = await buildDaemonControlAuth(
-      probe.daemon?.configDir ?? payload.configDir,
+    const { findClaudeTranscript, readClaudeTranscript } = await import(
+      "./team/claude-transcript.mjs"
+    );
+    const { contextGuard, modelContext } = await import(
+      "./team/session-context.mjs"
     );
-
     let result;
-    try {
-      result = await attachClaudeDaemonSession({
-        controlSock: probe.controlSock,
-        short,
-        input: payload.prompt,
-        ...controlAuth,
-        cols: numericOption(payload.cols, undefined),
-        rows: numericOption(payload.rows, undefined),
-        timeoutMs: numericOption(payload.timeoutMs, 30_000),
+    let context = modelContext("claude", null);
+    let guard = {};
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+      const short = payload.short ?? probe.target?.short;
+      if (!short) {
+        return emitJson(
+          daemonAttachProbeFailureResult({
+            ...probe,
+            reason: "target-not-found",
+            error: "short or resolvable sessionId is required",
+          }),
+        );
+      }
+      const transcript = await findClaudeTranscript({
+        configDir: probe.daemon?.configDir,
+        sourceConfigDir: probe.daemon?.sourceConfigDir,
+        sessionId: probe.target?.sessionId,
+        cwd: probe.target?.cwd,
       });
-    } catch (error) {
-      return emitJson({
-        ...daemonAttachErrorResult(error),
-        ...daemonProbeMetadata(probe),
+      context =
+        (await readClaudeTranscript(transcript).catch(() => null))?.context ??
+        modelContext("claude", null);
+      guard = contextGuard("claude", context, {
+        warnContextPct: payload.warnContextPct,
+        maxContextPct: payload.maxContextPct,
       });
+      if (guard.ok === false) {
+        return emitJson({
+          ...guard,
+          ...(recoveredFrom ? { recoveredFrom } : {}),
+          ...daemonProbeMetadata(probe),
+        });
+      }
+      const controlAuth = await buildDaemonControlAuth(
+        probe.daemon?.configDir ?? payload.configDir,
+      );
+      try {
+        result = await attachClaudeDaemonSession({
+          controlSock: probe.controlSock,
+          short,
+          input: payload.prompt,
+          ...controlAuth,
+          cols: numericOption(payload.cols, undefined),
+          rows: numericOption(payload.rows, undefined),
+          timeoutMs: numericOption(payload.timeoutMs, 30_000),
+          noWait: payload.noWait === true,
+        });
+        break;
+      } catch (error) {
+        if (
+          attempt === 1 ||
+          error?.code !== "ENOENT" ||
+          error?.inputSent !== false
+        ) {
+          return emitJson({
+            ...daemonAttachErrorResult(error),
+            ...(recoveredFrom ? { recoveredFrom } : {}),
+            ...daemonProbeMetadata(probe),
+          });
+        }
+        const stale = probe.daemon;
+        const recovered = await probeClaudeDaemonCandidates({
+          ...daemonProbeOptions(payload),
+          candidateSourceConfigDir: stale.sourceConfigDir ?? stale.configDir,
+        });
+        if (!recovered.ok) {
+          return emitJson({
+            ...daemonAttachErrorResult(error),
+            ...daemonProbeMetadata(recovered),
+          });
+        }
+        probe = recovered;
+        recoveredFrom = stale;
+      }
     }
 
     return emitJson({
-      ok: result.matchedCompletion === true,
+      ok:
+        payload.noWait === true
+          ? result.inputSent === true
+          : result.matchedCompletion === true,
+      ...(payload.noWait === true
+        ? {
+            status:
+              result.inputSent === true
+                ? "submitted"
+                : result.inputSent === false
+                  ? "failed"
+                  : "unknown",
+            done: false,
+            ...(result.inputSent === true
+              ? { submittedAt: new Date().toISOString() }
+              : {}),
+            target: probe.target,
+          }
+        : {}),
       text: result.text,
       raw: result.streamText,
       responseRaw: result.responseStreamText,
       matchedCompletion: result.matchedCompletion === true,
-      timedOut: result.timedOut === true,
+      ...(payload.noWait === true
+        ? {}
+        : { timedOut: result.timedOut === true }),
       closed: result.closed === true,
-      inputSent: result.inputSent === true,
+      inputSent: result.inputSent ?? null,
       error:
         result.handshake?.ok === false ? result.handshake?.error : undefined,
+      ...context,
+      ...guard,
+      ...(recoveredFrom ? { recoveredFrom } : {}),
       ...daemonProbeMetadata(probe),
     });
   } catch (error) {
-    return emitJson(daemonAttachErrorResult(error));
+    return emitJson(
+      daemonAttachErrorResult({
+        inputSent: false,
+        message: error?.message || String(error),
+      }),
+    );
+  }
+}
+
+async function cmdDaemonWait(args) {
+  let requestId = null;
+  const emptyContext = {
+    estimatedContextTokens: null,
+    contextLimitTokens: null,
+    contextLimitSource: null,
+    contextPct: null,
+  };
+  try {
+    const payload = readBridgePayload(args);
+    requestId = payload.requestId ?? null;
+    if (!payload.short && !payload.sessionId)
+      throw new Error("short or sessionId is required");
+    const { probeClaudeDaemonCandidates } = await loadDaemonControl();
+    const { findClaudeTranscript, readClaudeTranscript } = await import(
+      "./team/claude-transcript.mjs"
+    );
+    const timeoutMs = numericOption(payload.timeoutMs, 30_000);
+    const pollIntervalMs = Math.max(
+      10,
+      numericOption(payload.pollIntervalMs, 500),
+    );
+    const deadline = Date.now() + timeoutMs;
+    let last = null;
+    do {
+      const probe = await probeClaudeDaemonCandidates({
+        configDir: payload.configDir,
+        env: process.env,
+        short: payload.short,
+        sessionId: payload.sessionId,
+        timeoutMs: Math.max(1, Math.min(6000, deadline - Date.now())),
+        tmpRoot: payload.tmpRoot,
+        includeContext: false,
+      });
+      if (!probe.ok) {
+        if (Date.now() >= deadline) {
+          return emitJson({
+            ...(last ?? emptyContext),
+            ok: true,
+            status: "working",
+            done: false,
+            timedOut: true,
+            requestId,
+          });
+        }
+        return emitJson({
+          ok: false,
+          status: "unknown",
+          done: false,
+          timedOut: false,
+          ...emptyContext,
+          requestId,
+          ...daemonProbeMetadata(probe),
+          error: probe.error || probe.reason,
+        });
+      }
+      const transcriptPath = await findClaudeTranscript({
+        configDir: probe.daemon?.configDir,
+        sourceConfigDir: probe.daemon?.sourceConfigDir,
+        sessionId: probe.target?.sessionId,
+        cwd: probe.target?.cwd,
+      });
+      const transcript = await readClaudeTranscript(transcriptPath, {
+        requestId: payload.requestId,
+      });
+      const context = transcript?.context ?? emptyContext;
+      const idle = [
+        probe.target?.state,
+        probe.target?.status,
+        probe.target?.tempo,
+      ].some((value) =>
+        ["idle", "done", "ready"].includes(String(value || "").toLowerCase()),
+      );
+      last = {
+        ok: true,
+        status: transcript?.userSeen ? "working" : "submitted",
+        done: false,
+        timedOut: false,
+        response: transcript?.response || "",
+        ...context,
+        requestId,
+        target: probe.target,
+        ...daemonProbeMetadata(probe),
+      };
+      if (transcript?.error) {
+        return emitJson({
+          ...last,
+          ok: false,
+          status: "failed",
+          error: transcript.error,
+        });
+      }
+      if (
+        (idle || transcript?.sectionClosed) &&
+        transcript?.userSeen &&
+        transcript.turnEnded
+      ) {
+        if (!transcript.response.trim())
+          return emitJson({
+            ...last,
+            ok: false,
+            status: "failed",
+            error: "turn ended without assistant text",
+          });
+        return emitJson({ ...last, status: "completed", done: true });
+      }
+      if (Date.now() >= deadline) break;
+      await new Promise((resolve) =>
+        setTimeout(resolve, Math.min(pollIntervalMs, deadline - Date.now())),
+      );
+    } while (Date.now() < deadline);
+    return emitJson({ ...last, status: "working", timedOut: true });
+  } catch (error) {
+    return emitJson({
+      ...daemonErrorResult(error),
+      status: "unknown",
+      done: false,
+      timedOut: false,
+      ...emptyContext,
+      requestId,
+    });
   }
 }
 
@@ -1807,6 +2044,8 @@ export async function main(argv = process.argv.slice(2)) {
       return await cmdDaemonProbe(args);
     case "daemon-attach":
       return await cmdDaemonAttach(args);
+    case "daemon-wait":
+      return await cmdDaemonWait(args);
     case "daemon-interrupt":
       return await cmdDaemonInterrupt(args);
     case "retry-run":
@@ -1817,7 +2056,7 @@ export async function main(argv = process.argv.slice(2)) {
       return await cmdInterveneRun(args);
     default:
       console.error(
-        "사용법: bridge.mjs <register|heartbeat|result|control|handoff|publish|takeover-role|send-input|context|deregister|assign-async|assign-result|assign-status|assign-retry|team-info|team-task-list|team-task-update|team-send-message|pipeline-state|pipeline-advance|pipeline-init|pipeline-list|ping|delegator-delegate|delegator-reply|delegator-status|hitl-request|hitl-submit|hitl-pending|daemon-probe|daemon-attach|daemon-interrupt|retry-run|retry-status|intervene-run> [--옵션]",
+        "사용법: bridge.mjs <register|heartbeat|result|control|handoff|publish|takeover-role|send-input|context|deregister|assign-async|assign-result|assign-status|assign-retry|team-info|team-task-list|team-task-update|team-send-message|pipeline-state|pipeline-advance|pipeline-init|pipeline-list|ping|delegator-delegate|delegator-reply|delegator-status|hitl-request|hitl-submit|hitl-pending|daemon-probe|daemon-attach|daemon-wait|daemon-interrupt|retry-run|retry-status|intervene-run> [--옵션]",
       );
       process.exit(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 {