@triflux/remote 10.31.0 → 10.32.0

package/hub/server.mjs

@@ -56,6 +56,7 @@ import { createStoreAdapter } from "./store-adapter.mjs";
 import { createGitPreflight } from "./team/git-preflight.mjs";
 import { nativeProxy } from "./team/nativeProxy.mjs";
 import { createSwarmLocks } from "./team/swarm-locks.mjs";
+import { createCtoAutoCollector } from "./team/cto-auto-collect.mjs";
 import {
   createSynapseRegistry,
   projectPeer,
@@ -69,6 +70,21 @@ registerTeamBridge(nativeProxy);
 const hubLog = createModuleLogger("hub");
 const brokerDiagnosticsAttached = new WeakSet();
 
+async function runCtoCollect(args, opts) {
+  try {
+    const mod = await import("triflux/cto/collect.mjs");
+    if (typeof mod?.runCollect === "function") {
+      return await mod.runCollect(args, opts);
+    }
+  } catch (error) {
+    hubLog.warn(
+      { err: String(error?.message || error) },
+      "cto.auto_collect.remote_collect_unavailable",
+    );
+  }
+  return null;
+}
+
 const MAX_BODY_SIZE = 1024 * 1024;
 const PUBLIC_PATHS = new Set(["/", "/status", "/health", "/healthz"]);
 const RATE_LIMIT_MAX = 100; // requests per window
@@ -1009,10 +1025,16 @@ export async function startHub({
     registry: synapseRegistry,
     locks: swarmLocks,
   });
+  const ctoAutoCollector = createCtoAutoCollector({
+    registry: synapseRegistry,
+    runCollect: runCtoCollect,
+    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");

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,
+  });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@triflux/remote",
-  "version": "10.31.0",
+  "version": "10.32.0",
   "description": "triflux remote — team mode, psmux, MCP workers, SQLite store.",
   "type": "module",
   "main": "hub/index.mjs",