oasis_test 0.1.124 → 0.1.125

package/dist/index.js

@@ -174511,6 +174511,16 @@ var init_daemon_hub = __esm({
        * （2026-08-25 真机实测：chat 会话刚连上就收到 evict(unknown)，用户看到「对话已中断」）。
        */
       sessionClaimCheckers = [];
+      /**
+       * 持久层认领（异步）。只在同步认领全 `unknown` 时才问——内存里没有，不代表系统里没有。
+       * 与同步那圈同样是**多个**：chat 道与 dispatch 道各查各的账（对账键都不一样），汇总规则也同口径。
+       */
+      sessionClaimResolvers = [];
+      /** 本 hub（≈本 serve 进程）起于何时——冷启动宽限的基准。 */
+      startedAt = Date.now();
+      coldStartGraceMs;
+      /** 冷启动宽限期内被挂起、待重判的会话（键=dispatchId）。连接断开或重判跑完即清。 */
+      sessionJudgeTimers = /* @__PURE__ */ new Map();
       resolveDataplane;
       /** 每个 daemon 最近一次收到任何帧的时间戳（含它自发的心跳 pong）——liveness 判定的依据。 */
       lastSeen = /* @__PURE__ */ new Map();
@@ -174558,6 +174568,7 @@ var init_daemon_hub = __esm({
         this.resolveNode = resolveNode;
         this.getNodeStatus = opts.getNodeStatus;
         this.resolveDataplane = opts.resolveDataplane;
+        this.coldStartGraceMs = opts.coldStartGraceMs ?? 9e4;
         this.onHandshakeRejected = opts.onHandshakeRejected;
         this.throttle = new HandshakeThrottle(opts.throttle);
         this.wss = new import_websocket_server.default({
@@ -174718,9 +174729,14 @@ var init_daemon_hub = __esm({
             if (!registered) {
               registered = true;
               this.sessionSockets.set(dispatchId, ws);
-              this.sessionMeta.set(dispatchId, { nodeId, sessionId: msg.sessionId, connectedAt: Date.now() });
+              this.sessionMeta.set(dispatchId, {
+                nodeId,
+                sessionId: msg.sessionId,
+                connectedAt: Date.now(),
+                ...msg.jobArtifactId ? { jobArtifactId: msg.jobArtifactId } : {}
+              });
               for (const l of this.sessionConnectListeners) l({ dispatchId, sessionId: msg.sessionId, nodeId });
-              this.judgeSession(dispatchId);
+              void this.judgeSession(dispatchId, ws);
             }
             return;
           }
@@ -174738,6 +174754,7 @@ var init_daemon_hub = __esm({
           if (this.sessionSockets.get(dispatchId) !== ws) return;
           this.sessionSockets.delete(dispatchId);
           this.sessionMeta.delete(dispatchId);
+          this.clearJudgeTimer(dispatchId);
           for (const l of this.sessionDisconnectListeners) l({ dispatchId, nodeId });
         });
         ws.on("error", (err) => console.error(`[hub] session ${dispatchId} error:`, err.message));
@@ -174751,18 +174768,96 @@ var init_daemon_hub = __esm({
       registerSessionClaimCheck(fn) {
         this.sessionClaimCheckers.push(fn);
       }
-      /** 会话连上来时问一圈：没人说 live、且有人说 settled，才 evict。全 unknown = 没人认领，也 evict。 */
-      judgeSession(dispatchId) {
-        if (this.sessionClaimCheckers.length === 0) return;
+      /**
+       * 注册**持久层**认领（异步，唯一）。只在同步认领全 `unknown` 时才被问到。
+       *
+       * 存在的理由：同步那圈问的是 adapter 的内存在途表，serve 一重启就全空，于是所有活着的会话
+       * 重连上来都是 unknown。会话自己已经把身份报全了（`session_hello`），缺的是服务端拿这份身份
+       * 去查一次**持久事实**（运行账本 / 在跑的 chat 行）。查到在跑的，就该认领它、重新接上，
+       * 而不是当野进程杀掉。
+       */
+      registerSessionClaimResolver(fn) {
+        this.sessionClaimResolvers.push(fn);
+      }
+      /** 会话自报的身份（`session_hello` 已校验过与 token 一致）。连接已不在则返回 null。 */
+      sessionIdentity(dispatchId) {
+        const meta = this.sessionMeta.get(dispatchId);
+        if (!meta) return null;
+        return {
+          dispatchId,
+          sessionId: meta.sessionId,
+          nodeId: meta.nodeId,
+          ...meta.jobArtifactId ? { jobArtifactId: meta.jobArtifactId } : {}
+        };
+      }
+      clearJudgeTimer(dispatchId) {
+        const t = this.sessionJudgeTimers.get(dispatchId);
+        if (t) {
+          clearTimeout(t);
+          this.sessionJudgeTimers.delete(dispatchId);
+        }
+      }
+      /**
+       * 会话连上来时判它该不该活。三级，从便宜到贵、从「我记得」到「我不知道」：
+       *
+       *  ① 同步问各 adapter 的内存在途表：有人说 live → 放行；有人说 settled（我明确收过它）→ evict。
+       *  ② 全 unknown：**内存里没有 ≠ 系统里没有**。拿会话自报的身份去查持久层（运行账本 / chat 行），
+       *     查到还在跑的就认领——这一格正是 serve 重启后所有活会话会落进来的地方。
+       *  ③ 持久层也说不知道：若还在冷启动宽限内，解读为「我还没恢复完」，挂起、到点重判一次；
+       *     宽限外（或重判后仍无人认领）才 evict。
+       *
+       * 传 `ws` 是因为 ② 要 await：期间同一 dispatch 可能已重连、旧连接已被顶掉，此时这轮判定的
+       * 结论对新连接无效，必须整段作废（与 close 里那道 `sessionSockets.get(...) !== ws` 同源）。
+       */
+      async judgeSession(dispatchId, ws, deferred = false) {
+        if (this.sessionClaimCheckers.length === 0 && this.sessionClaimResolvers.length === 0) return;
+        const identity = this.sessionIdentity(dispatchId);
+        if (!identity) return;
         const verdicts = this.sessionClaimCheckers.map((f2) => {
           try {
-            return f2(dispatchId);
+            return f2(identity);
           } catch {
             return "unknown";
           }
         });
         if (verdicts.includes("live")) return;
-        this.evictSession(dispatchId, verdicts.includes("settled") ? "reaped" : "unknown");
+        if (verdicts.includes("settled")) {
+          this.evictSession(dispatchId, "reaped");
+          return;
+        }
+        if (this.sessionClaimResolvers.length > 0) {
+          const resolved = await Promise.all(
+            this.sessionClaimResolvers.map(async (f2) => {
+              try {
+                return await f2(identity);
+              } catch (err) {
+                console.warn(`[hub] \u4F1A\u8BDD\u8BA4\u9886\u67E5\u8BE2\u5931\u8D25 dispatch=${dispatchId}: ${String(err)}`);
+                return "unknown";
+              }
+            })
+          );
+          if (this.sessionSockets.get(dispatchId) !== ws) return;
+          if (resolved.includes("live")) return;
+          if (resolved.includes("settled")) {
+            this.evictSession(dispatchId, "reaped");
+            return;
+          }
+        }
+        const graceLeft = deferred ? 0 : this.coldStartGraceMs - (Date.now() - this.startedAt);
+        if (graceLeft > 0) {
+          if (this.sessionJudgeTimers.has(dispatchId)) return;
+          console.warn(
+            `[hub] \u4F1A\u8BDD dispatch=${dispatchId} \u6682\u65E0\u4EBA\u8BA4\u9886\uFF0C\u51B7\u542F\u52A8\u5BBD\u9650\u5185\u6302\u8D77 ${graceLeft}ms \u540E\u91CD\u5224\uFF08serve \u53EF\u80FD\u8FD8\u6CA1\u6062\u590D\u5B8C\uFF09`
+          );
+          const timer = setTimeout(() => {
+            this.sessionJudgeTimers.delete(dispatchId);
+            if (this.sessionSockets.get(dispatchId) === ws) void this.judgeSession(dispatchId, ws, true);
+          }, graceLeft);
+          timer.unref?.();
+          this.sessionJudgeTimers.set(dispatchId, timer);
+          return;
+        }
+        this.evictSession(dispatchId, "unknown");
       }
       /** 会话连接建立（`session_hello` 通过校验）时触发——2b 的收割判据挂在这上面。 */
       addSessionConnectListener(l) {
@@ -174887,6 +174982,8 @@ var init_daemon_hub = __esm({
         }
         for (const ws of this.sockets.values()) ws.close();
         for (const ws of this.sessionSockets.values()) ws.close();
+        for (const t of this.sessionJudgeTimers.values()) clearTimeout(t);
+        this.sessionJudgeTimers.clear();
         this.daemons.clear();
         this.sockets.clear();
         this.sessionSockets.clear();
@@ -190156,7 +190253,7 @@ var init_daemon_adapter = __esm({
         hub.addDisconnectListener((daemonId) => this.onNodeDown(daemonId));
         hub.addConnectListener((daemon) => this.onNodeUp(daemon));
         hub.addSessionConnectListener?.((i) => this.onSessionUp(i.dispatchId));
-        hub.registerSessionClaimCheck?.((dispatchId) => {
+        hub.registerSessionClaimCheck?.(({ dispatchId }) => {
           const e = this.pending.get(dispatchId);
           if (e) return e.exited ? "settled" : "live";
           return this.settledDispatchIds.has(dispatchId) ? "settled" : "unknown";
@@ -201589,6 +201686,21 @@ async function startServe(opts) {
           console.log(`[chat-recovery] \u91CD\u6302 chat \u8F6E\uFF1Asession=${plan.chatSessionId} run=${plan.runId} node=${daemonId}`);
         }
       };
+      hub.registerSessionClaimResolver?.(async (id) => {
+        if (!id.jobArtifactId || !chatRemoteAdapter) return "unknown";
+        const jobKey = `chat::${id.jobArtifactId}`;
+        if (chatLiveSessions.has(jobKey)) return "live";
+        await new Promise((resolve10) => {
+          chatRecoveryChain = chatRecoveryChain.then(() => recoverChatTurns(id.nodeId, [
+            { dispatchId: id.dispatchId, sessionId: id.sessionId, jobArtifactId: id.jobArtifactId }
+          ])).catch((err) => {
+            console.error(`[chat-recovery] session_hello \u8BA4\u9886\u5931\u8D25: ${String(err)}`);
+          }).then(() => {
+            resolve10();
+          });
+        });
+        return chatLiveSessions.has(jobKey) ? "live" : "unknown";
+      });
       hub.addMessageListener((daemonId, msg) => {
         if (msg.type !== "gc_query_artifacts") return;
         void (async () => {
@@ -202434,7 +202546,8 @@ async function startServe(opts) {
       }
     }
     const recoverActiveSessions = async (daemonId, activeSessions) => {
-      if (!dispatchRemoteAdapter) return;
+      if (!dispatchRemoteAdapter) return 0;
+      let restoredCount = 0;
       const { plans, zombies } = await planSessionRecoveryWithZombies(activeSessions, (id) => traceStore.getRun(id));
       for (const z of zombies) {
         console.warn(
@@ -202493,14 +202606,28 @@ async function startServe(opts) {
             reason: "server-restart"
           });
           console.log(`[dispatch:${companyId}] recovered ${plan.jobKey} from node ${daemonId} session=${plan.sessionId ?? plan.dispatchId}`);
+          restoredCount += 1;
         }
       }
+      return restoredCount;
     };
     hub.addMessageListener((daemonId, msg) => {
       if (msg.type === "hello" && msg.meta.activeSessions?.length) {
         void recoverActiveSessions(daemonId, msg.meta.activeSessions);
       }
     });
+    hub.registerSessionClaimResolver?.(async (id) => {
+      if (!dispatchRemoteAdapter) return "unknown";
+      const run = await traceStore.getRun(id.dispatchId).catch(() => null);
+      if (!run) return "unknown";
+      const restored = await recoverActiveSessions(id.nodeId, [{
+        dispatchId: id.dispatchId,
+        sessionId: id.sessionId,
+        ...id.jobArtifactId ? { jobArtifactId: id.jobArtifactId } : {}
+      }]);
+      if (restored > 0) return "live";
+      return run.status === "running" ? "unknown" : "settled";
+    });
     for (const daemon of hub.connectedDaemons()) {
       if (daemon.meta.activeSessions?.length) void recoverActiveSessions(daemon.daemonId, daemon.meta.activeSessions);
     }
@@ -203509,7 +203636,10 @@ var SessionProcessState = class {
         sessionId: this.handle?.id ?? this.spec.dispatchId,
         dispatchId: this.spec.dispatchId,
         nodeId: this.spec.nodeId,
-        daemonVersion: this.spec.daemonVersion
+        daemonVersion: this.spec.daemonVersion,
+        // 自报身份要够服务端对上账：chat 道的对账键是 artifactId（run.id=chat-run:* ≠ dispatchId），
+        // 只报 dispatchId 的话 serve 重启后它认不出这是条活会话，会当成野进程 evict 掉。
+        ...this.spec.job.artifactId ? { jobArtifactId: this.spec.job.artifactId } : {}
       });
       for (const m2 of this.outbox) this.rawSend(m2);
     });
@@ -209724,7 +209854,7 @@ function shimScript() {
 }
 
 // src/index.ts
-var PKG_VERSION = true ? "0.1.124" : "dev";
+var PKG_VERSION = true ? "0.1.125" : "dev";
 var LOCAL_BIN = localBin();
 var NPM_PREFIX = npmPrefix();
 var INSTANCE = DEFAULT_INSTANCE;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oasis_test",
-  "version": "0.1.124",
+  "version": "0.1.125",
   "description": "Oasis node daemon + CLI — background daemon, auto-start, full server CLI",
   "bin": {
     "oasis": "./dist/index.js"