@triflux/remote 10.31.0 → 10.33.0

package/hub/server.mjs

@@ -15,35 +15,45 @@ import { homedir } from "node:os";
 import { extname, join, resolve, sep } from "node:path";
 import { performance } from "node:perf_hooks";
 import { fileURLToPath } from "node:url";
-
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import {
   CallToolRequestSchema,
   ListToolsRequestSchema,
 } from "@modelcontextprotocol/sdk/types.js";
+import { runCollect } from "../cto/collect.mjs";
+import { runStatus as runCtoStatus } from "../cto/status.mjs";
 import { createModuleLogger } from "../scripts/lib/logger.mjs";
-import { broker as brokerInstance, reloadBroker } from "@triflux/core/hub/account-broker.mjs";
-import { createAdaptiveEngine } from "@triflux/core/hub/adaptive.mjs";
-import { createAssignCallbackServer } from "@triflux/core/hub/assign-callbacks.mjs";
-import { DelegatorService } from "@triflux/core/hub/delegator/index.mjs";
-import { createHitlManager } from "@triflux/core/hub/hitl.mjs";
+import {
+  inspectRegistry,
+  inspectRegistryStatus,
+} from "../scripts/lib/mcp-guard-engine.mjs";
+import { broker as brokerInstance, reloadBroker } from "./account-broker.mjs";
+import { createAdaptiveEngine } from "./adaptive.mjs";
+import { createAssignCallbackServer } from "./assign-callbacks.mjs";
+import { DelegatorService } from "./delegator/index.mjs";
+import { createHitlManager } from "./hitl.mjs";
 import {
   cleanupOrphanNodeProcesses,
   cleanupOrphanRuntimeProcesses,
   cleanupStaleFsmonitorDaemons,
-} from "@triflux/core/hub/lib/process-utils.mjs";
-import * as spawnTrace from "@triflux/core/hub/lib/spawn-trace.mjs";
+} from "./lib/process-utils.mjs";
+import {
+  reapExistingHubProcesses,
+  resolveHubPortForContext,
+} from "./hub-lifecycle.mjs";
+import * as spawnTrace from "./lib/spawn-trace.mjs";
 import {
   recordRequest,
   recordWorker,
   snapshot as traceSnapshot,
-} from "@triflux/core/hub/lib/trace-recorder.mjs";
-import { logQuotaRefreshFailures } from "@triflux/core/hub/middleware/quota-middleware.mjs";
-import { wrapRequestHandler } from "@triflux/core/hub/middleware/request-logger.mjs";
+} from "./lib/trace-recorder.mjs";
+import { focusSessionOnMac } from "./mac-focus.mjs";
+import { logQuotaRefreshFailures } from "./middleware/quota-middleware.mjs";
+import { wrapRequestHandler } from "./middleware/request-logger.mjs";
 import { createPipeServer } from "./pipe.mjs";
-import { createRouter } from "@triflux/core/hub/router.mjs";
-import { createAdaptiveFingerprintService } from "@triflux/core/hub/session-fingerprint.mjs";
+import { createRouter } from "./router.mjs";
+import { createAdaptiveFingerprintService } from "./session-fingerprint.mjs";
 import {
   acquireLock,
   getVersionHash,
@@ -51,8 +61,9 @@ import {
   readState,
   releaseLock,
   writeState,
-} from "@triflux/core/hub/state.mjs";
+} from "./state.mjs";
 import { createStoreAdapter } from "./store-adapter.mjs";
+import { createCtoAutoCollector } from "./team/cto-auto-collect.mjs";
 import { createGitPreflight } from "./team/git-preflight.mjs";
 import { nativeProxy } from "./team/nativeProxy.mjs";
 import { createSwarmLocks } from "./team/swarm-locks.mjs";
@@ -60,8 +71,11 @@ import {
   createSynapseRegistry,
   projectPeer,
 } from "./team/synapse-registry.mjs";
-import { registerTeamBridge } from "@triflux/core/hub/team-bridge.mjs";
+import { registerTeamBridge } from "./team-bridge.mjs";
 import { createTools } from "./tools.mjs";
+import { spawnTrayForHub } from "./tray-lifecycle.mjs";
+import { getRuntimeStatus } from "./tray-runtime.mjs";
+import { buildTrayStatePayload } from "./tray-state.mjs";
 import { createDelegatorMcpWorker } from "./workers/delegator-mcp.mjs";
 
 registerTeamBridge(nativeProxy);
@@ -104,7 +118,7 @@ const SYNAPSE_VALID_OPS = new Set([
   "stash-pop",
   "worktree-remove",
 ]);
-const HUB_IDLE_TIMEOUT_DEFAULT_MS = 0; // 0 = 영구 실행 (idle shutdown 비활성). TFX_HUB_IDLE_TIMEOUT_MS 환경변수로 오버라이드 가능
+const HUB_IDLE_TIMEOUT_DEFAULT_MS = 30 * 60 * 1000;
 const HUB_IDLE_SWEEP_DEFAULT_MS = 60 * 1000;
 const STATIC_CONTENT_TYPES = Object.freeze({
   ".html": "text/html",
@@ -256,10 +270,11 @@ function readHubPidFile(
 }
 
 export function resolveHubPort(env = process.env, opts = {}) {
-  void opts;
-  const envPort = parseHubPort(env?.TFX_HUB_PORT);
-  if (envPort) return envPort;
-  return HUB_DEFAULT_PORT;
+  return resolveHubPortForContext({
+    env,
+    cwd: opts.cwd ?? process.cwd(),
+    defaultPort: HUB_DEFAULT_PORT,
+  });
 }
 
 export function detectLivePeer(
@@ -482,6 +497,7 @@ function isPublicPath(path) {
   return (
     PUBLIC_PATHS.has(path) ||
     path === "/dashboard" ||
+    path === "/tray.html" ||
     path === "/api/qos-stats" ||
     path.startsWith("/public/")
   );
@@ -638,6 +654,68 @@ function parsePositiveInt(value, fallback) {
   return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
 }
 
+export function resolveHubIdleTimeoutMs({
+  port,
+  env = process.env,
+  defaultPort = HUB_DEFAULT_PORT,
+} = {}) {
+  const parsed = Number.parseInt(String(env?.TFX_HUB_IDLE_TIMEOUT_MS ?? ""), 10);
+  if (Number.isFinite(parsed) && parsed >= 0) return parsed;
+  return Number(port) === defaultPort ? 0 : HUB_IDLE_TIMEOUT_DEFAULT_MS;
+}
+
+export function cleanupOwnedPidFile({
+  pidFilePath = PID_FILE,
+  currentPid = process.pid,
+  readFile = readFileSync,
+  unlink = unlinkSync,
+} = {}) {
+  try {
+    const info = JSON.parse(readFile(pidFilePath, "utf8"));
+    if (Number(info?.pid) !== Number(currentPid)) return false;
+    unlink(pidFilePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function cleanupOwnedTokenFile({
+  tokenFilePath = TOKEN_FILE,
+  token,
+  port = HUB_DEFAULT_PORT,
+  readFile = readFileSync,
+  unlink = unlinkSync,
+  defaultPort = HUB_DEFAULT_PORT,
+} = {}) {
+  if (Number(port) !== Number(defaultPort)) return false;
+  const normalizedToken = String(token ?? "").trim();
+  if (!normalizedToken) return false;
+  try {
+    if (String(readFile(tokenFilePath, "utf8")).trim() !== normalizedToken) {
+      return false;
+    }
+    unlink(tokenFilePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function writeOwnedTokenFile({
+  tokenFilePath = TOKEN_FILE,
+  tokenDir = join(homedir(), ".claude"),
+  token,
+  mkdir = mkdirSync,
+  writeFile = writeFileSync,
+} = {}) {
+  const normalizedToken = String(token ?? "").trim();
+  if (!normalizedToken) return false;
+  mkdir(tokenDir, { recursive: true });
+  writeFile(tokenFilePath, normalizedToken, { mode: 0o600 });
+  return true;
+}
+
 function readRecentAimdEvents(now = Date.now()) {
   try {
     if (!existsSync(BATCH_EVENTS_PATH)) return [];
@@ -779,10 +857,41 @@ function getBrokerPublicSnapshot(currentBroker = brokerInstance) {
   return currentBroker.publicSnapshot();
 }
 
+async function getTrayCtoStatus() {
+  try {
+    return await runCtoStatus(["--json"], {
+      rootDir: PROJECT_ROOT,
+      stdout: { write() {} },
+    });
+  } catch (error) {
+    return { error: error?.message || String(error) };
+  }
+}
+
+function getTrayMcpStatus() {
+  const registryState = inspectRegistry();
+  if (!registryState.exists || !registryState.valid) {
+    return {
+      registry_path: registryState.path,
+      server_count: 0,
+      rows: [],
+      error: registryState.errors?.join("; ") || "MCP registry unavailable",
+    };
+  }
+  const status = inspectRegistryStatus(registryState.registry);
+  return {
+    registry_path: registryState.path,
+    server_count: Object.keys(registryState.registry?.servers || {}).length,
+    rows: status.rows,
+  };
+}
+
 function resolvePublicFilePath(path) {
   let relativePath = null;
   if (path === "/dashboard") {
     relativePath = "dashboard.html";
+  } else if (path === "/tray.html") {
+    relativePath = "tray.html";
   } else if (path.startsWith("/public/")) {
     relativePath = path.slice("/public/".length);
   }
@@ -878,10 +987,7 @@ export async function startHub({
   attachBrokerDiagnostics(brokerInstance);
   syncBrokerAuthCache(brokerInstance);
 
-  const hubIdleTimeoutMs = parsePositiveInt(
-    process.env.TFX_HUB_IDLE_TIMEOUT_MS,
-    HUB_IDLE_TIMEOUT_DEFAULT_MS,
-  );
+  const hubIdleTimeoutMs = resolveHubIdleTimeoutMs({ port, env: process.env });
   const hubIdleSweepMs = parsePositiveInt(
     process.env.TFX_HUB_IDLE_SWEEP_MS,
     Math.min(HUB_IDLE_SWEEP_DEFAULT_MS, hubIdleTimeoutMs),
@@ -926,12 +1032,9 @@ export async function startHub({
 
   const HUB_TOKEN = process.env.TFX_HUB_TOKEN?.trim() || null;
   if (HUB_TOKEN) {
-    mkdirSync(join(homedir(), ".claude"), { recursive: true });
-    writeFileSync(TOKEN_FILE, HUB_TOKEN, { mode: 0o600 });
+    writeOwnedTokenFile({ token: HUB_TOKEN, port });
   } else {
-    try {
-      unlinkSync(TOKEN_FILE);
-    } catch {}
+    cleanupOwnedTokenFile({ token: HUB_TOKEN, port });
   }
 
   const store = await createStoreAdapter(dbPath);
@@ -970,7 +1073,7 @@ export async function startHub({
 
   // adaptive rule confidence decay (7일 이상 미관측 규칙 -0.1 감소)
   try {
-    const { decayRules } = await import("@triflux/core/hub/reflexion.mjs");
+    const { decayRules } = await import("./reflexion.mjs");
     const decay = decayRules(
       store,
       adaptiveEngine.sessionCount?.() || 1,
@@ -1009,10 +1112,16 @@ export async function startHub({
     registry: synapseRegistry,
     locks: swarmLocks,
   });
+  const ctoAutoCollector = createCtoAutoCollector({
+    registry: synapseRegistry,
+    runCollect,
+    logger: hubLog,
+  });
 
   // Synapse Layer 5: emitter subscribers — bridge events to hub logging
-  synapseEmitter.on("synapse.session.started", ({ sessionId }) => {
+  synapseEmitter.on("synapse.session.started", ({ sessionId, session }) => {
     hubLog.info({ sessionId }, "synapse.session.started");
+    ctoAutoCollector.handleSessionStarted({ sessionId, session });
   });
   synapseEmitter.on("synapse.session.heartbeat", ({ sessionId }) => {
     hubLog.debug({ sessionId }, "synapse.session.heartbeat");
@@ -1323,6 +1432,66 @@ export async function startHub({
         });
       }
 
+      if (path === "/api/tray-state" && req.method === "GET") {
+        if (!isLoopbackRemoteAddress(req.socket.remoteAddress)) {
+          return writeJson(res, 403, { ok: false, error: "Loopback only" });
+        }
+
+        const qos = getQosStatsPayload();
+        const synapseSnapshot = synapseRegistry.snapshot();
+        const broker = getBrokerPublicSnapshot(brokerInstance);
+        const runtimeStatus = getRuntimeStatus({
+          projectRoots: [PROJECT_ROOT],
+        });
+        const [ctoStatus, mcpStatus] = await Promise.all([
+          getTrayCtoStatus(),
+          Promise.resolve(getTrayMcpStatus()),
+        ]);
+
+        return writeJson(
+          res,
+          200,
+          buildTrayStatePayload({
+            hub: {
+              id: String(sessionId),
+              pid: process.pid,
+              port,
+              url: buildHubUrl(host, port),
+              projectRoot: PROJECT_ROOT,
+            },
+            qos,
+            synapseSnapshot,
+            broker,
+            ctoStatus,
+            mcpStatus,
+            runtimeStatus,
+          }),
+        );
+      }
+
+      if (path === "/api/focus-session" && req.method === "POST") {
+        if (!isLoopbackRemoteAddress(req.socket.remoteAddress)) {
+          return writeJson(res, 403, { ok: false, error: "Loopback only" });
+        }
+        let body;
+        try {
+          body = await parseBody(req);
+        } catch (_e) {
+          return writeJson(res, 400, {
+            error: "Invalid JSON or Body too large",
+          });
+        }
+
+        const { sessionId, udsId } = body || {};
+        const result = await focusSessionOnMac({
+          sessionId,
+          udsId,
+          pid: body?.pid,
+          agentId: body?.agentId ?? body?.agent_id,
+        });
+        return writeJson(res, 200, { ok: result.ok !== false, focus: result });
+      }
+
       // Redacted peer-discovery surface. Returns co-located live peers (same
       // cwd / worktree) with raw cwd/pid stripped — only label/hash + booleans.
       if (path === "/synapse/peers" && req.method === "GET") {
@@ -2145,9 +2314,7 @@ export async function startHub({
       store.close();
     } catch {}
     if (!preserveTokenFile) {
-      try {
-        unlinkSync(TOKEN_FILE);
-      } catch {}
+      cleanupOwnedTokenFile({ token: HUB_TOKEN, port });
     }
     releaseStartupLock();
   };
@@ -2271,6 +2438,22 @@ export async function startHub({
             },
             "hub.started",
           );
+          if (port === HUB_DEFAULT_PORT) {
+            void reapExistingHubProcesses({ currentPid: process.pid }).then(
+              ({ reaped }) => {
+                if (reaped.length > 0) {
+                  hubLog.info(
+                    {
+                      killed: reaped.length,
+                      processes: reaped,
+                      caller: "startup",
+                    },
+                    "hub.startup_reaper",
+                  );
+                }
+              },
+            );
+          }
           hubLog.debug(
             {
               publicDir: PUBLIC_DIR,
@@ -2315,12 +2498,8 @@ export async function startHub({
                 synapseRegistry.destroy();
               } catch {}
               store.close();
-              try {
-                unlinkSync(PID_FILE);
-              } catch {}
-              try {
-                unlinkSync(TOKEN_FILE);
-              } catch {}
+              cleanupOwnedPidFile();
+              cleanupOwnedTokenFile({ token: HUB_TOKEN, port });
               httpServer.closeAllConnections();
               await new Promise((resolveClose) =>
                 httpServer.close(resolveClose),
@@ -2730,13 +2909,14 @@ refresh();setInterval(refresh,10000);
 
 const selfRun = process.argv[1]?.replace(/\\/g, "/").endsWith("hub/server.mjs");
 if (selfRun) {
-  const port = resolveHubPort(process.env);
+  const port = resolveHubPortForContext({
+    env: process.env,
+    cwd: process.cwd(),
+  });
   const dbPath = process.env.TFX_HUB_DB || undefined;
 
   const cleanupPidFile = () => {
-    try {
-      unlinkSync(PID_FILE);
-    } catch {}
+    cleanupOwnedPidFile();
   };
 
   process.on("unhandledRejection", (err) => {
@@ -2760,6 +2940,15 @@ if (selfRun) {
         process.exit(0);
         return;
       }
+      try {
+        const trayPath = fileURLToPath(new URL("./tray.mjs", import.meta.url));
+        const tray = spawnTrayForHub({ trayPath });
+        if (tray.status === "started") {
+          hubLog.info({ pid: tray.pid }, "tray.auto_started");
+        }
+      } catch (error) {
+        hubLog.warn({ err: error }, "tray.auto_start_failed");
+      }
       const shutdown = async (signal) => {
         hubLog.info({ signal }, "hub.stopping");
         try {

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

@@ -10,52 +10,6 @@ import {
   writeClaudeSessionProjection,
 } from "./claude-session-projection.mjs";
 
-export function buildClaudePromptDispatchPayload({
-  short = crypto.randomBytes(4).toString("hex"),
-  sessionId,
-  cwd = process.cwd(),
-  prompt,
-  name = "tfx uds claude prompt",
-  createdAt = Date.now(),
-  cols = 120,
-  rows = 40,
-} = {}) {
-  if (!prompt) throw new Error("prompt is required");
-  const uuid = crypto.randomUUID();
-  const resolvedSessionId = sessionId || `${short}${uuid.slice(8)}`;
-  return {
-    proto: 1,
-    short,
-    sessionId: resolvedSessionId,
-    createdAt,
-    source: "shell",
-    cwd,
-    agent: "claude",
-    launch: {
-      mode: "prompt",
-      args: [
-        "--session-id",
-        resolvedSessionId,
-        "--agent",
-        "claude",
-        "--permission-mode",
-        "auto",
-        "--",
-        prompt,
-      ],
-    },
-    env: {},
-    isolation: "none",
-    respawnFlags: [],
-    seed: {
-      intent: "[redacted uds orchestration prompt]",
-      name,
-    },
-    cols,
-    rows,
-  };
-}
-
 export function resolveClaudeConfigDir(env = process.env) {
   if (env.CLAUDE_CONFIG_DIR) return path.resolve(env.CLAUDE_CONFIG_DIR);
   return path.join(os.homedir(), ".claude");
@@ -1054,6 +1008,52 @@ export function buildDaemonExecDispatchPayload({
   };
 }
 
+export function buildClaudePromptDispatchPayload({
+  short = crypto.randomBytes(4).toString("hex"),
+  sessionId,
+  cwd = process.cwd(),
+  prompt,
+  name = "tfx uds claude prompt",
+  createdAt = Date.now(),
+  cols = 120,
+  rows = 40,
+} = {}) {
+  if (!prompt) throw new Error("prompt is required");
+  const uuid = crypto.randomUUID();
+  const resolvedSessionId = sessionId || `${short}${uuid.slice(8)}`;
+  return {
+    proto: 1,
+    short,
+    sessionId: resolvedSessionId,
+    createdAt,
+    source: "shell",
+    cwd,
+    agent: "claude",
+    launch: {
+      mode: "prompt",
+      args: [
+        "--session-id",
+        resolvedSessionId,
+        "--agent",
+        "claude",
+        "--permission-mode",
+        "auto",
+        "--",
+        prompt,
+      ],
+    },
+    env: {},
+    isolation: "none",
+    respawnFlags: [],
+    seed: {
+      intent: "[redacted uds orchestration prompt]",
+      name,
+    },
+    cols,
+    rows,
+  };
+}
+
 export function findDaemonJobByShort(listResponse, short) {
   if (!Array.isArray(listResponse?.jobs)) return null;
   return listResponse.jobs.find((job) => job?.short === short) || null;

package/hub/team/conductor.mjs

@@ -39,6 +39,7 @@ import {
   ensureConductorRegistry,
   getConductorRegistry,
 } from "./conductor-registry.mjs";
+import { readCtoSnapshot } from "./cto-pull.mjs";
 import { createEventLog } from "./event-log.mjs";
 import { buildSpawnSpecForMode, MODES } from "./execution-mode.mjs";
 import { extractCompletionPayload } from "./extract-completion-payload.mjs";
@@ -219,6 +220,22 @@ export function createConductor(opts = {}) {
   // 공유 event log (모든 세션 이벤트를 하나의 JSONL에)
   const eventLog = createEventLog(join(logsDir, "conductor-events.jsonl"));
 
+  function logCtoContext(sessionId) {
+    const snapshot = readCtoSnapshot({ lakeRoot: opts.ctoLakeRoot });
+    if (!snapshot) return;
+    eventLog.append("cto_context", {
+      session: sessionId,
+      snapshot: {
+        schema_version: snapshot.schema_version,
+        repo: snapshot.repo,
+        sources: snapshot.sources,
+        ledger_tail: snapshot.ledger_tail,
+        live_sessions: snapshot.live_sessions,
+        active_shards: snapshot.active_shards,
+      },
+    });
+  }
+
   /**
    * 세션 상태 전이.
    * @param {object} session
@@ -1172,6 +1189,7 @@ export function createConductor(opts = {}) {
 
     sessions.set(resolvedConfig.id, session);
     getConductorRegistry()?.register?.(resolvedConfig.id, publicApi);
+    logCtoContext(resolvedConfig.id);
 
     if (resolvedConfig.remote) {
       startRemoteSession(session);

package/hub/team/cto-auto-collect.mjs

@@ -0,0 +1,109 @@
+import { existsSync, statSync } from "node:fs";
+import { join } from "node:path";
+
+const DEFAULT_DEBOUNCE_MS = 120_000;
+const OFF_VALUES = new Set(["0", "false", "off", "no"]);
+
+export function isCtoAutoCollectDisabled(env = process.env) {
+  return OFF_VALUES.has(
+    String(env?.TFX_CTO_AUTO_COLLECT ?? "")
+      .trim()
+      .toLowerCase(),
+  );
+}
+
+function freshCurrentMd(projectRoot, now, debounceMs) {
+  try {
+    const currentMd = join(projectRoot, ".triflux", "lake", "current.md");
+    if (!existsSync(currentMd)) return false;
+    return now - statSync(currentMd).mtimeMs < debounceMs;
+  } catch {
+    return false;
+  }
+}
+
+export function createCtoAutoCollector(opts = {}) {
+  const registry = opts.registry;
+  const runCollect = opts.runCollect;
+  const logger = opts.logger || null;
+  const debounceMs = Number(opts.debounceMs || DEFAULT_DEBOUNCE_MS);
+  const now = opts.now || (() => Date.now());
+  const env = opts.env || process.env;
+  const lastCollectMs = opts.lastCollectMs || new Map();
+  const inFlight = new Set();
+
+  function handleSessionStarted({ sessionId, session } = {}) {
+    if (isCtoAutoCollectDisabled(env))
+      return { triggered: false, reason: "disabled" };
+    if (!registry || typeof registry.querySessions !== "function") {
+      return { triggered: false, reason: "missing-registry" };
+    }
+    if (typeof runCollect !== "function") {
+      return { triggered: false, reason: "missing-runCollect" };
+    }
+
+    const cwd = typeof session?.cwd === "string" ? session.cwd : "";
+    const worktree =
+      typeof session?.worktreePath === "string" ? session.worktreePath : "";
+    const projectRoot = worktree || cwd;
+    if (!projectRoot)
+      return { triggered: false, reason: "missing-project-root" };
+
+    let peers = [];
+    try {
+      peers = registry.querySessions({
+        cwd,
+        worktree,
+        excludeSessionId: sessionId,
+      });
+    } catch (error) {
+      logger?.warn?.(
+        { sessionId, err: String(error?.message || error) },
+        "cto.auto_collect.query_failed",
+      );
+      return { triggered: false, reason: "query-failed" };
+    }
+    if (!Array.isArray(peers) || peers.length < 1) {
+      return { triggered: false, reason: "no-peers" };
+    }
+
+    const currentTime = now();
+    const last = lastCollectMs.get(projectRoot) || 0;
+    if (currentTime - last < debounceMs) {
+      return { triggered: false, reason: "debounced" };
+    }
+    if (freshCurrentMd(projectRoot, currentTime, debounceMs)) {
+      lastCollectMs.set(projectRoot, currentTime);
+      return { triggered: false, reason: "fresh-lake" };
+    }
+
+    lastCollectMs.set(projectRoot, currentTime);
+    const promise = Promise.resolve()
+      .then(() => runCollect([], { rootDir: projectRoot }))
+      .catch((error) => {
+        logger?.warn?.(
+          { projectRoot, err: String(error?.message || error) },
+          "cto.auto_collect.failed",
+        );
+      })
+      .finally(() => {
+        inFlight.delete(promise);
+      });
+    inFlight.add(promise);
+    return {
+      triggered: true,
+      reason: "triggered",
+      projectRoot,
+      peerCount: peers.length,
+    };
+  }
+
+  async function drain() {
+    await Promise.allSettled([...inFlight]);
+  }
+
+  return Object.freeze({
+    handleSessionStarted,
+    drain,
+  });
+}