oasis_test_v2 2.2.73 → 2.2.74

package/dist/index.js

@@ -846,10 +846,22 @@ var init_runtime = __esm({
 });
 
 // ../contract/src/runtime-allocation.ts
-var RUNTIME_FAULT_PROBE_MAX_INTERVAL_MS, RUNTIME_FAULT_PROBE_MAX_TOTAL_MS, RUNTIME_QUOTA_DERATE_THRESHOLD_PERCENT, RUNTIME_ALLOCATION_MAX_ATTEMPTS;
+var RUNTIME_FAULT_RECOVERY, RUNTIME_FAULT_PROBE_INITIAL_MS, RUNTIME_FAULT_PROBE_MAX_INTERVAL_MS, RUNTIME_FAULT_PROBE_MAX_TOTAL_MS, RUNTIME_QUOTA_DERATE_THRESHOLD_PERCENT, RUNTIME_ALLOCATION_MAX_ATTEMPTS;
 var init_runtime_allocation = __esm({
   "../contract/src/runtime-allocation.ts"() {
     "use strict";
+    RUNTIME_FAULT_RECOVERY = {
+      "quota-exhausted": "readonly-probe",
+      // 登录失效直接走人工：恢复需要人在那台机器上重新登录，放一条真会话过去试只是又坏一件活。
+      unauthenticated: "manual",
+      "node-offline": "connection",
+      "runtime-missing": "connection",
+      "startup-failed": "half-open",
+      crashed: "half-open",
+      timeout: "half-open",
+      "node-error": "half-open"
+    };
+    RUNTIME_FAULT_PROBE_INITIAL_MS = 6e4;
     RUNTIME_FAULT_PROBE_MAX_INTERVAL_MS = 30 * 6e4;
     RUNTIME_FAULT_PROBE_MAX_TOTAL_MS = 6 * 60 * 6e4;
     RUNTIME_QUOTA_DERATE_THRESHOLD_PERCENT = 60;
@@ -202049,11 +202061,18 @@ var init_service3 = __esm({
         const actors = await this.options.resolveActors(companyId);
         const bindings = await actors.listBindings();
         const reachability = async (actorId) => {
-          const binding = bindings.find((b2) => b2.actorId === actorId && b2.status === "active");
-          if (!binding) return { ok: false, reason: "\u6CA1\u6709\u63A5\u8FD0\u884C\u65F6" };
-          if (!this.options.probeRuntime) return { ok: true };
-          const probed = await this.options.probeRuntime({ actorId, nodeId: binding.nodeId, runtimeKind: binding.runtimeKind }).catch(() => ({ reachable: true }));
-          return probed.reachable ? { ok: true } : { ok: false, ...probed.reason ? { reason: probed.reason } : {} };
+          const primaryReason = await (async () => {
+            const binding = bindings.find((b2) => b2.actorId === actorId && b2.status === "active");
+            if (!binding) return "\u6CA1\u6709\u63A5\u8FD0\u884C\u65F6";
+            if (!this.options.probeRuntime) return null;
+            const probed = await this.options.probeRuntime({ actorId, nodeId: binding.nodeId, runtimeKind: binding.runtimeKind }).catch(() => ({ reachable: true }));
+            return probed.reachable ? null : probed.reason ?? "\u8FD0\u884C\u65F6\u4E0D\u53EF\u8FBE";
+          })();
+          if (primaryReason === null) return { ok: true };
+          if (!this.options.probeAllocation) return { ok: false, reason: primaryReason };
+          const alt = await this.options.probeAllocation({ actorId, ...companyId ? { companyId } : {} }).catch(() => ({ reachable: true }));
+          if (alt.reachable) return { ok: true };
+          return { ok: false, reason: alt.reason ? `${alt.reason}\uFF08\u4E3B\u8FD0\u884C\u65F6\uFF1A${primaryReason}\uFF09` : primaryReason };
         };
         if (target.startsWith("actor:")) {
           const actor = await actors.getActor(target);
@@ -204016,6 +204035,7 @@ function assembleDelegationsDomain(deps) {
       ...input.binaryFiles ? { binaryFiles: input.binaryFiles } : {}
     }),
     ...deps.probeRuntime ? { probeRuntime: deps.probeRuntime } : {},
+    ...deps.probeAllocation ? { probeAllocation: deps.probeAllocation } : {},
     // 轮次账本 = 「这一次派发到底有没有发生过」的权威答案（见 service 的 resolveChatTurns 注释）。
     ...deps.resolveChatTurns ? { resolveChatTurns: deps.resolveChatTurns } : {},
     ...deps.enabled ? { enabled: deps.enabled } : {},
@@ -210375,6 +210395,7 @@ async function startOasisServer(opts) {
       // 按公司解析；单租户装配退回那唯一一个。两者都没有 → 域层自动关掉租约回收。
       resolveChatTurns: async (companyId) => (opts.resolveChatTurns ? await opts.resolveChatTurns(companyId) : void 0) ?? opts.chatTurns,
       ...opts.delegationProbeRuntime ? { probeRuntime: opts.delegationProbeRuntime } : {},
+      ...opts.delegationProbeAllocation ? { probeAllocation: opts.delegationProbeAllocation } : {},
       ...opts.chatDelegationEnabled ? { enabled: opts.chatDelegationEnabled } : {},
       ...opts.delegationWorkdir ? { workdir: opts.delegationWorkdir } : {},
       ...opts.delegationMetrics ? { metrics: opts.delegationMetrics } : {}
@@ -242470,6 +242491,59 @@ var init_sender = __esm({
   }
 });
 
+// ../server/src/domains/runtime-allocation/faults.ts
+function faultReasonOfExit(reason, errorMessage2) {
+  if (reason === "server-unreachable") return "node-error";
+  if (reason === "auth-error") return "node-error";
+  if (reason === "rate-limit") return "quota-exhausted";
+  if (reason === "error" && errorMessage2?.startsWith("\u8FD9\u4E00\u8F6E\u6CA1\u80FD\u5728\u8282\u70B9\u4E0A\u542F\u52A8\uFF1A")) return "startup-failed";
+  return null;
+}
+function probeIntervalMs(attempt) {
+  const raw = RUNTIME_FAULT_PROBE_INITIAL_MS * 2 ** Math.max(0, attempt - 1);
+  return Math.min(raw, RUNTIME_FAULT_PROBE_MAX_INTERVAL_MS);
+}
+function faultAfterFailure(previous3, input, now) {
+  const nowIso = new Date(now).toISOString();
+  const markedAt = previous3?.markedAt ?? nowIso;
+  const attempts = (previous3?.attempts ?? 0) + 1;
+  const base = {
+    nodeId: input.nodeId,
+    runtimeKind: input.runtimeKind,
+    reason: input.reason,
+    ...input.detail ? { detail: input.detail.slice(0, 500) } : {},
+    markedAt,
+    attempts,
+    awaitingManual: false
+  };
+  if (RUNTIME_FAULT_RECOVERY[input.reason] === "manual") {
+    return { ...base, awaitingManual: true };
+  }
+  const elapsed = now - Date.parse(markedAt);
+  if (Number.isFinite(elapsed) && elapsed >= RUNTIME_FAULT_PROBE_MAX_TOTAL_MS) {
+    return { ...base, awaitingManual: true };
+  }
+  return { ...base, nextProbeAt: new Date(now + probeIntervalMs(attempts)).toISOString() };
+}
+function quotaClearsFault(fault, quotaStatus) {
+  if (RUNTIME_FAULT_RECOVERY[fault.reason] !== "readonly-probe" && fault.reason !== "unauthenticated") return false;
+  return quotaStatus === "ok";
+}
+function describeFault(fault, now) {
+  const head = `${fault.nodeId} \xB7 ${fault.runtimeKind} \u6545\u969C\uFF08${fault.reason}${fault.detail ? `\uFF1A${fault.detail}` : ""}\uFF09`;
+  if (fault.awaitingManual) return `${head}\uFF0C\u5DF2\u8BD5 ${fault.attempts} \u6B21\u4ECD\u672A\u6062\u590D\uFF0C\u7B49\u4EBA\u5DE5\u6062\u590D`;
+  if (!fault.nextProbeAt) return `${head}\uFF0C\u7B49\u8FDE\u63A5\u6062\u590D`;
+  const waitMs = Date.parse(fault.nextProbeAt) - now;
+  const mins = Math.max(0, Math.round(waitMs / 6e4));
+  return `${head}\uFF0C\u5DF2\u8BD5 ${fault.attempts} \u6B21\uFF0C${mins} \u5206\u949F\u540E\u653E\u4E00\u6761\u65B0\u4F1A\u8BDD\u8FC7\u53BB\u8BD5`;
+}
+var init_faults = __esm({
+  "../server/src/domains/runtime-allocation/faults.ts"() {
+    "use strict";
+    init_src();
+  }
+});
+
 // ../server/src/domains/nodes/runtime-status.ts
 function runtimeConnectionStatus(nodeId, connected) {
   return connected.has(nodeId) ? "online" : "offline";
@@ -243170,6 +243244,21 @@ async function resolveRuntimeModels(deps, runtimeId) {
 }
 function nodesDomain(deps) {
   const quotaByNode = /* @__PURE__ */ new Map();
+  const faultByTarget = /* @__PURE__ */ new Map();
+  const faultKey = (nodeId, runtimeKind) => `${nodeId}::${runtimeKind}`;
+  const refreshFaults = async () => {
+    const rows = await deps.nodeStore.listRuntimeFaults();
+    faultByTarget.clear();
+    for (const f2 of rows) faultByTarget.set(faultKey(f2.nodeId, f2.runtimeKind), f2);
+  };
+  void refreshFaults().catch((err) => console.warn(`[nodes] \u6545\u969C\u6807\u8BB0\u6C34\u5408\u5931\u8D25\uFF08\u9875\u9762\u4E0A\u6682\u65F6\u770B\u4E0D\u5230\u6545\u969C\u6761\uFF09\uFF1A${err instanceof Error ? err.message : String(err)}`));
+  let faultsReadAtMs = 0;
+  const FAULT_CACHE_TTL_MS = 1e4;
+  const refreshFaultsIfStale = async () => {
+    if (Date.now() - faultsReadAtMs < FAULT_CACHE_TTL_MS) return;
+    faultsReadAtMs = Date.now();
+    await refreshFaults().catch((err) => console.warn(`[nodes] \u6545\u969C\u6807\u8BB0\u91CD\u8BFB\u5931\u8D25\uFF08\u672C\u8F6E\u6CBF\u7528\u4E0A\u6B21\u7ED3\u679C\uFF09\uFF1A${err instanceof Error ? err.message : String(err)}`));
+  };
   void deps.nodeStore.listRuntimeQuotas().then((rows) => {
     for (const row of rows) {
       if (row.runtimeKind !== "codex" && row.runtimeKind !== "claude-code") continue;
@@ -243183,10 +243272,12 @@ function nodesDomain(deps) {
   const nodeUpdates = /* @__PURE__ */ new Map();
   function runtimeInfoOf(r) {
     const quota = quotaByNode.get(r.nodeId)?.find((q2) => q2.kind === r.kind);
+    const fault = faultByTarget.get(faultKey(r.nodeId, r.kind));
     const activeRunCount = deps.activeRunCountOf?.(r.nodeId, r.kind) ?? 0;
     const activeRuns = deps.activeRunsOf?.(r.nodeId, r.kind);
     return {
       ...quota ? { quota: { status: quota.status, checkedAt: quota.checkedAt, windows: quota.windows, ...quota.retryAt ? { retryAt: quota.retryAt } : {} } } : {},
+      ...fault ? { fault } : {},
       id: r.id,
       nodeId: r.nodeId,
       hostname: r.hostname,
@@ -243282,6 +243373,15 @@ function nodesDomain(deps) {
       const quotas = sanitizeRuntimeQuotas(msg.quotas).filter((q2) => daemon.meta.adapters.includes(q2.kind));
       quotaByNode.set(daemonId, quotas);
       void nodeStore.saveRuntimeQuotas(daemonId, quotas.map((q2) => ({ ...q2, nodeId: daemonId, runtimeKind: q2.kind }))).catch((err) => console.warn(`[nodes] \u989D\u5EA6\u843D\u5E93\u5931\u8D25(node=${daemonId})\uFF1A${err instanceof Error ? err.message : String(err)}`));
+      void (async () => {
+        for (const q2 of quotas) {
+          const existing = faultByTarget.get(faultKey(daemonId, q2.kind));
+          if (!existing || !quotaClearsFault(existing, q2.status)) continue;
+          await nodeStore.clearRuntimeFault(daemonId, q2.kind);
+          faultByTarget.delete(faultKey(daemonId, q2.kind));
+          console.log(`[nodes] \u53EA\u8BFB\u91C7\u96C6\u56DE ok\uFF0C\u81EA\u52A8\u89E3\u9664\u6545\u969C\uFF1A${daemonId} \xB7 ${q2.kind}\uFF08\u539F\u56E0 ${existing.reason}\uFF09`);
+        }
+      })().catch((err) => console.warn(`[nodes] \u6545\u969C\u81EA\u52A8\u89E3\u9664\u5931\u8D25(node=${daemonId})\uFF1A${err instanceof Error ? err.message : String(err)}`));
     });
     hub.addMessageListener(async (daemonId, msg) => {
       if (msg.type !== "hello") return;
@@ -243385,6 +243485,7 @@ function nodesDomain(deps) {
       await deps.nodeStore.setNodeRuntimesOnline(daemonId, true);
     }
     router.get("/api/nodes", async (req) => {
+      await refreshFaultsIfStale();
       const hub = deps.getHub();
       if (hub) wireHub(hub);
       const daemonVersionById = new Map((hub?.connectedDaemons() ?? []).map((d) => [d.daemonId, d.meta.daemonVersion]));
@@ -243654,6 +243755,20 @@ function nodesDomain(deps) {
       deps.onStatusChange?.();
       return { status: 200, body: { ok: true, maxConcurrent: limit } };
     });
+    router.post("/api/nodes/:nodeId/runtimes/:runtimeKind/recover", async (req) => {
+      const nodeId = req.params["nodeId"];
+      const runtimeKind = req.params["runtimeKind"];
+      if (!nodeId || !runtimeKind) return { status: 400, body: { error: "missing nodeId/runtimeKind" } };
+      const forbidden = await forbidUnlessOrgManager(req, "\u624B\u52A8\u6062\u590D\u8FD0\u884C\u65F6");
+      if (forbidden) return forbidden;
+      const scope2 = req.auth.companyId !== void 0 ? { companyId: req.auth.companyId } : void 0;
+      const node2 = (await deps.nodeStore.listNodes(scope2)).find((n) => n.id === nodeId);
+      if (!node2) return { status: 404, body: { error: "NODE_NOT_FOUND", message: "\u8282\u70B9\u4E0D\u5B58\u5728\u6216\u4E0D\u5C5E\u4E8E\u5F53\u524D\u7EC4\u7EC7" } };
+      const cleared = await deps.nodeStore.clearRuntimeFault(nodeId, runtimeKind);
+      faultByTarget.delete(faultKey(nodeId, runtimeKind));
+      deps.onStatusChange?.();
+      return { status: 200, body: { ok: true, cleared } };
+    });
     router.delete("/api/nodes/:nodeId", async (req) => {
       const nodeId = req.params["nodeId"];
       if (!nodeId) return { status: 400, body: { error: "missing nodeId" } };
@@ -243832,6 +243947,7 @@ var init_routes7 = __esm({
   "../server/src/domains/nodes/routes.ts"() {
     "use strict";
     init_src();
+    init_faults();
     init_runtime_status();
     import_node_crypto61 = require("node:crypto");
     import_node_fs17 = require("node:fs");
@@ -244203,6 +244319,52 @@ function createRuntimeAllocator(ports) {
     noteSettled(unitOfWork) {
       units.delete(unitOfWork);
     },
+    /**
+     * 一次失败的**完整处置**（ADR 0616 D8）：记进这件活的失败链（下一次换候选）**并**给这个目标
+     * 落一条故障行（跨会话生效——别的活也别再往这台机器上派）。
+     *
+     * 两件事必须同一处做：只记失败链的话，这台机器的坏只对「这一件活」成立，下一件活照样一头撞上去；
+     * 只落故障行的话，这一件活的重试计数没人管，撞满上限也不会停。
+     *
+     * 故障落库失败只告警、不抛：失败链已经记上了，换候选照常。
+     */
+    async recordFailure(input) {
+      const now = input.now ?? Date.now();
+      const chained = this.noteFailure(input);
+      const target = input.target ?? units.get(input.unitOfWork)?.lastAssigned;
+      const reason = faultReasonOfExit(input.reason, input.errorMessage);
+      if (!target || !reason || !ports.saveFault) return { chained, fault: null };
+      try {
+        const previous3 = await ports.getFault?.(target) ?? null;
+        const fault = faultAfterFailure(previous3, {
+          ...target,
+          reason,
+          ...input.errorMessage?.trim() ? { detail: input.errorMessage.trim() } : {}
+        }, now);
+        await ports.saveFault(fault);
+        log3(`[runtime-alloc] ${describeFault(fault, now)}`);
+        return { chained, fault };
+      } catch (err) {
+        log3(`[runtime-alloc] \u6545\u969C\u843D\u5E93\u5931\u8D25\uFF08\u6362\u5019\u9009\u7167\u5E38\uFF09${target.nodeId}\xB7${target.runtimeKind}\uFF1A${String(err)}`);
+        return { chained, fault: null };
+      }
+    },
+    /**
+     * 这件活这一轮**不是因为 runtime/节点**结束的 → 丢掉失败链，并把上次那个目标的故障行解除掉。
+     *
+     * 「跑成了」就是半开试探要的那个答案：到点放一条新会话过去试、它成了 → 解除。这条路与只读采集
+     * 那条（额度/登录回 ok 自动解除）并列，覆盖的正是**采集看不出来**的那一类。
+     */
+    async recordSettled(unitOfWork, target) {
+      const resolved = target ?? units.get(unitOfWork)?.lastAssigned;
+      this.noteSettled(unitOfWork);
+      if (!resolved || !ports.clearFault) return;
+      try {
+        await ports.clearFault(resolved);
+      } catch (err) {
+        log3(`[runtime-alloc] \u6545\u969C\u89E3\u9664\u5931\u8D25 ${resolved.nodeId}\xB7${resolved.runtimeKind}\uFF1A${String(err)}`);
+      }
+    },
     /** 只给测试与诊断用：这件活当前失败链的账。 */
     inspect(unitOfWork) {
       const s2 = units.get(unitOfWork);
@@ -244217,6 +244379,7 @@ var init_service7 = __esm({
     "use strict";
     init_src();
     init_allocate();
+    init_faults();
     init_errors6();
     UNIT_STATE_TTL_MS = 2 * 60 * 6e4;
   }
@@ -278738,7 +278901,13 @@ function refreshConnectorSkillsInBackground(dataDir, apply) {
 }
 var CONNECTOR_SKILL_REFRESH_MS = 24 * 60 * 6e4;
 var SESSION_TOKEN_GRACE_MS = 15 * 6e4;
-function makeResumeRetryProxy(first, spawnFallback) {
+function allocatedTurnOf(req) {
+  return Boolean(req.delegatedChildTurn) || req.executionProfile === "knowledge-single-turn" || req.executionProfile === "discussion-background";
+}
+function allocationUnitOfWorkOf(req) {
+  return `chat-session:${req.chatSessionId ?? req.dispatchId ?? req.actorId}`;
+}
+function makeResumeRetryProxy(first, spawnFallback, runtimeRetry) {
   const relay = () => {
     const cbs = [];
     const buf = [];
@@ -278787,8 +278956,11 @@ function makeResumeRetryProxy(first, spawnFallback) {
     return chatExit?.reason === "session-not-found";
   };
   const done = first.done.catch(async (err) => {
-    if (sawOutput || !isSessionNotFound2(err)) throw err;
-    const second = await spawnFallback();
+    if (sawOutput) throw err;
+    const exit3 = err instanceof Error ? err.chatExit ?? {} : {};
+    const spawnSecond = isSessionNotFound2(err) && spawnFallback ? spawnFallback : runtimeRetry?.shouldRetry({ ...exit3.reason ? { reason: exit3.reason } : {}, ...exit3.detail ?? exit3.summary ? { detail: exit3.detail ?? exit3.summary } : {} }) ? () => runtimeRetry.spawn({ ...exit3.reason ? { reason: exit3.reason } : {}, ...exit3.detail ?? exit3.summary ? { detail: exit3.detail ?? exit3.summary } : {} }) : null;
+    if (!spawnSecond) throw err;
+    const second = await spawnSecond();
     active = second;
     wire(second);
     await second.done;
@@ -281138,6 +281310,13 @@ async function startServe(opts) {
       },
       faults: () => nodeStore.listRuntimeFaults({ companyId }),
       quotas: () => nodeStore.listRuntimeQuotas({ companyId }),
+      // 故障的读 / 写 / 解除（ADR 0616 D8）：三个一起接，缺一个就会出现「标了但下次算不出间隔」
+      // 或者「跑成了也不解除」这种半拉子状态。
+      getFault: async (t) => (await nodeStore.listRuntimeFaults({ nodeId: t.nodeId })).find((f2) => f2.runtimeKind === t.runtimeKind) ?? null,
+      saveFault: (fault) => nodeStore.upsertRuntimeFault(fault),
+      clearFault: async (t) => {
+        await nodeStore.clearRuntimeFault(t.nodeId, t.runtimeKind);
+      },
       actorName: async (actorId) => (await (await actors.resolveCtx(companyId)).service.getActor(actorId).catch(() => null))?.name ?? null
     });
     runtimeAllocators.set(companyId, allocator);
@@ -281851,6 +282030,25 @@ async function startServe(opts) {
       }
       return { reachable: true };
     },
+    /**
+     * ★ ADR 0616：上面那道只问主绑定那台机器。候选 runtime 上线之后「主的机器离线」不再等于
+     * 「这位专家派不出去」——这一问把**运行时分配**接进委派的第一道闸。
+     *
+     * 不接的后果 2026-09-23 在 v2 didi 上实测过：主绑定改到离线节点、候选配在在线节点，
+     * `oasis delegate` 仍当场回 `EXPERT_UNREACHABLE`「绑定节点 … 当前不在线」，分配那一段
+     * **一行都没跑到**。
+     *
+     * 用 `tryAllocate`（不抛、不消耗重试次数）：这里只是问「挑不挑得出来」，真正的分配在
+     * 那一轮派发时再跑一次——两次之间机器状态可能变，以派发那一次为准。
+     */
+    delegationProbeAllocation: async ({ actorId, companyId }) => {
+      const result = await runtimeAllocatorFor(companyId ?? defaultCompanyId).tryAllocate({
+        actorId,
+        unitOfWork: `delegation-preflight:${actorId}`
+      });
+      if (result.ok) return { reachable: true };
+      return { reachable: false, reason: describeRejections(result.rejections) || "\u6CA1\u6709\u53EF\u7528\u7684\u8FD0\u884C\u65F6\u76EE\u6807" };
+    },
     // ADR 会话投递 D4：/api/chat 与渠道入站据它占同一个会话槽（自动化侧经 automations 域接同一实例）。
     chatTurns: chatTurnStore,
     // ADR 0176 第二步（缺陷 B）：按当前公司解析轮次账本——turn 必须与它的会话同 schema，
@@ -282363,6 +282561,16 @@ async function startServe(opts) {
         const isolatedKnowledgeTurn = executionProfile === "knowledge-single-turn";
         const discussionBackground = executionProfile === "discussion-background";
         const isolatedBackground = isolatedKnowledgeTurn || discussionBackground;
+        const allocatedTurn = allocatedTurnOf({
+          ...delegatedChildTurn ? { delegatedChildTurn } : {},
+          ...executionProfile ? { executionProfile } : {}
+        });
+        const allocationWhat = delegatedChildTurn ? "\u59D4\u6D3E\u5B50\u4F1A\u8BDD" : isolatedKnowledgeTurn ? "\u77E5\u8BC6\u5E93\u5355\u8F6E" : "\u540E\u53F0\u6574\u7406";
+        const allocationUnitOfWork = allocationUnitOfWorkOf({
+          ...chatSessionId ? { chatSessionId } : {},
+          ...requestDispatchId ? { dispatchId: requestDispatchId } : {},
+          actorId
+        });
         const runCompanyId = companyId ?? defaultCompanyId;
         const actorCtxForCompany = await actors.resolveCtx(runCompanyId);
         const actorService = actorCtxForCompany.service;
@@ -282420,25 +282628,25 @@ async function startServe(opts) {
             });
           } catch (e) {
             if (e instanceof SessionRuntimeOverrideError) {
-              if (!delegatedChildTurn) throw new ApiError(e.status, e.code, e.message);
-              console.log(`[runtime-alloc] \u59D4\u6D3E\u5B50\u4F1A\u8BDD\u9489\u4F4F\u7684\u76EE\u6807\u4E0D\u53EF\u7528\uFF08${e.code}\uFF09\uFF0C\u4EA4\u7ED9\u5206\u914D\u6311\u5019\u9009`);
+              if (!allocatedTurn) throw new ApiError(e.status, e.code, e.message);
+              console.log(`[runtime-alloc] ${allocationWhat}\u9489\u4F4F\u7684\u76EE\u6807\u4E0D\u53EF\u7528\uFF08${e.code}\uFF09\uFF0C\u4EA4\u7ED9\u5206\u914D\u6311\u5019\u9009`);
               resolved = null;
             } else throw e;
           }
-          if (!resolved && !delegatedChildTurn) {
+          if (!resolved && !allocatedTurn) {
             throw new ApiError(409, "ACTOR_BINDING_MISSING", `\u8FD9\u4F4D Agent \u8FD8\u6CA1\u6709\u7ED1\u5B9A\u8FD0\u884C\u65F6\uFF0C\u8BF7${chatRebindHint("\u7ED1\u5B9A\u4E00\u4E2A\u53EF\u7528\u7684\u8FD0\u884C\u65F6")}\u540E\u518D\u53D1`);
           }
           binding = resolved?.binding ?? { actorId, nodeId: "", runtimeKind: "", status: "active" };
           runtimeTargetSource = resolved?.source ?? "actor_binding";
-          if (delegatedChildTurn) {
+          if (allocatedTurn) {
             const pinned = sessionRuntimeOverride(priorChatSession);
             const primary = resolved ? { nodeId: resolved.binding.nodeId, runtimeKind: resolved.binding.runtimeKind } : pinned ? { nodeId: pinned.nodeId, runtimeKind: pinned.runtimeKind } : null;
             try {
               const allocated = await runtimeAllocatorFor(runCompanyId).allocateFor({
                 actorId,
                 // 「同一件活」= 这条子会话。重试上限算在它头上，不与同一位专家的别条委派互相扣次数。
-                unitOfWork: `chat-session:${chatSessionId ?? artifactId}`,
-                what: "\u59D4\u6D3E\u5B50\u4F1A\u8BDD",
+                unitOfWork: allocationUnitOfWork,
+                what: allocationWhat,
                 primary
               });
               if (allocated.binding.nodeId !== binding.nodeId || allocated.binding.runtimeKind !== binding.runtimeKind) {
@@ -282448,7 +282656,7 @@ async function startServe(opts) {
               }
             } catch (e) {
               if (e instanceof RuntimeAllocationError) throw new ApiError(e.status === 503 ? 503 : 409, e.code, e.message);
-              console.warn(`[runtime-alloc] \u59D4\u6D3E\u5B50\u4F1A\u8BDD\u5206\u914D\u5931\u8D25\uFF1A${String(e)}`);
+              console.warn(`[runtime-alloc] ${allocationWhat}\u5206\u914D\u5931\u8D25\uFF1A${String(e)}`);
               if (!resolved) throw e;
             }
           }
@@ -282883,23 +283091,16 @@ async function startServe(opts) {
         const done = new Promise((resolve11, reject) => {
           handle.onExit((info) => {
             chatLiveSessions.delete(chatJobKey);
-            if (delegatedChildTurn) {
-              try {
-                const unitOfWork = `chat-session:${chatSessionId ?? artifactId}`;
-                const allocator = runtimeAllocatorFor(runCompanyId);
-                if (isRuntimeClassFailure(info.reason, info.errorMessage)) {
-                  allocator.noteFailure({
-                    unitOfWork,
-                    target: { nodeId: binding.nodeId, runtimeKind: binding.runtimeKind },
-                    ...info.reason ? { reason: info.reason } : {},
-                    ...info.errorMessage ? { errorMessage: info.errorMessage } : {}
-                  });
-                } else {
-                  allocator.noteSettled(unitOfWork);
-                }
-              } catch (err) {
-                console.warn(`[runtime-alloc] \u59D4\u6D3E\u5B50\u4F1A\u8BDD\u5931\u8D25\u56DE\u62A5\u51FA\u9519\uFF08\u4E0D\u5F71\u54CD\u6536\u5C3E\uFF09\uFF1A${String(err)}`);
-              }
+            if (allocatedTurn) {
+              const unitOfWork = allocationUnitOfWork;
+              const allocator = runtimeAllocatorFor(runCompanyId);
+              const target = { nodeId: binding.nodeId, runtimeKind: binding.runtimeKind };
+              void (isRuntimeClassFailure(info.reason, info.errorMessage) ? allocator.recordFailure({
+                unitOfWork,
+                target,
+                ...info.reason ? { reason: info.reason } : {},
+                ...info.errorMessage ? { errorMessage: info.errorMessage } : {}
+              }) : allocator.recordSettled(unitOfWork, target)).catch((err) => console.warn(`[runtime-alloc] \u4F1A\u8BDD\u5931\u8D25\u5904\u7F6E\u51FA\u9519\uFF08\u4E0D\u5F71\u54CD\u6536\u5C3E\uFF09\uFF1A${String(err)}`));
             }
             setTimeout(() => {
               chatRunByDispatch.delete(handle.id);
@@ -283010,8 +283211,37 @@ async function startServe(opts) {
         firstPromise = dispatchChatImpl(chatReq);
       }
       const first = await firstPromise;
-      if (!chatReq.sessionId) return first;
-      if (chatReq.executionProfile === "knowledge-single-turn" || chatReq.executionProfile === "discussion-background") return first;
+      const runtimeRetry = allocatedTurnOf({
+        ...chatReq.delegatedChildTurn ? { delegatedChildTurn: chatReq.delegatedChildTurn } : {},
+        ...chatReq.executionProfile ? { executionProfile: chatReq.executionProfile } : {}
+      }) ? (() => {
+        const unitOfWork = allocationUnitOfWorkOf({
+          ...chatReq.chatSessionId ? { chatSessionId: chatReq.chatSessionId } : {},
+          ...chatReq.dispatchId ? { dispatchId: chatReq.dispatchId } : {},
+          actorId: chatReq.actorId
+        });
+        const allocator = runtimeAllocatorFor(chatReq.companyId ?? defaultCompanyId);
+        return {
+          shouldRetry: (exit3) => isRuntimeClassFailure(exit3.reason, exit3.detail) && canRetryAllocation(allocator.inspect(unitOfWork)?.failures ?? 0),
+          spawn: async (exit3) => {
+            const last = allocator.inspect(unitOfWork)?.lastAssigned;
+            if (last) {
+              allocator.noteFailure({
+                unitOfWork,
+                target: last,
+                ...exit3.reason ? { reason: exit3.reason } : {},
+                ...exit3.detail ? { errorMessage: exit3.detail } : {}
+              });
+            }
+            console.log(`[runtime-alloc] ${unitOfWork} \u56E0 ${exit3.reason ?? "runtime \u6545\u969C"} \u5931\u8D25\u4E14\u672A\u4EA7\u51FA\u4EFB\u4F55\u8F93\u51FA \u2192 \u6362\u5019\u9009\u91CD\u8D77\u8FD9\u4E00\u8F6E`);
+            return dispatchChatImpl(chatReq);
+          }
+        };
+      })() : void 0;
+      if (!chatReq.sessionId) return runtimeRetry ? makeResumeRetryProxy(first, null, runtimeRetry) : first;
+      if (chatReq.executionProfile === "knowledge-single-turn" || chatReq.executionProfile === "discussion-background") {
+        return runtimeRetry ? makeResumeRetryProxy(first, null, runtimeRetry) : first;
+      }
       return makeResumeRetryProxy(first, async () => {
         const message = chatReq.fallbackMessage ?? await buildResumeFallbackMessage(chatReq) ?? chatReq.message;
         const { admitDispatch: _alreadyAdmitted, ...fallbackReq } = chatReq;
@@ -283022,7 +283252,7 @@ async function startServe(opts) {
           message,
           ...chatReq.dispatchId && isHumanSubmitDispatchId(chatReq.dispatchId) ? { dispatchId: resumeFallbackDispatchId(chatReq.dispatchId) } : {}
         });
-      });
+      }, runtimeRetry);
     },
     trajectoryFeed: {
       subscribe(sessionId, listener) {
@@ -283349,15 +283579,12 @@ async function startServe(opts) {
               if (mapping && exitBus) {
                 if (mapping.artifactId && mapping.companyId) {
                   const allocator = runtimeAllocatorFor(mapping.companyId);
-                  if (isRuntimeClassFailure(msg.info.reason, msg.info.errorMessage)) {
-                    allocator.noteFailure({
-                      unitOfWork: mapping.artifactId,
-                      ...msg.info.reason ? { reason: msg.info.reason } : {},
-                      ...msg.info.errorMessage ? { errorMessage: msg.info.errorMessage } : {}
-                    });
-                  } else {
-                    allocator.noteSettled(mapping.artifactId);
-                  }
+                  const unitOfWork = mapping.artifactId;
+                  void (isRuntimeClassFailure(msg.info.reason, msg.info.errorMessage) ? allocator.recordFailure({
+                    unitOfWork,
+                    ...msg.info.reason ? { reason: msg.info.reason } : {},
+                    ...msg.info.errorMessage ? { errorMessage: msg.info.errorMessage } : {}
+                  }) : allocator.recordSettled(unitOfWork)).catch((err) => console.warn(`[runtime-alloc] \u5DE5\u5355\u6D3E\u53D1\u5931\u8D25\u5904\u7F6E\u51FA\u9519\uFF08\u4E0D\u5F71\u54CD\u6536\u53E3\uFF09\uFF1A${String(err)}`));
                 }
                 await exitBus.submit({
                   companyId: "",
@@ -290753,7 +290980,7 @@ async function waitForCommandAuthorization(base, headers, draftId, fallback) {
     }
   }
 }
-var CLI_VERSION = "2.2.73" ? "2.2.73" : "dev";
+var CLI_VERSION = "2.2.74" ? "2.2.74" : "dev";
 function apiHeaders(token, company) {
   const headers = {
     authorization: `Bearer ${token}`,
@@ -294559,7 +294786,7 @@ function shimScript() {
 }
 
 // src/index.ts
-var PKG_VERSION = true ? "2.2.73" : "dev";
+var PKG_VERSION = true ? "2.2.74" : "dev";
 var LOCAL_BIN = localBin();
 var NPM_PREFIX = npmPrefix();
 var INSTANCE = DEFAULT_INSTANCE;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oasis_test_v2",
-  "version": "2.2.73",
+  "version": "2.2.74",
   "description": "Oasis node daemon + CLI — background daemon, auto-start, full server CLI",
   "bin": {
     "oasis": "./dist/index.js"
@@ -26,6 +26,6 @@
     "node": ">=20"
   },
   "oasisRelease": {
-    "sourceHead": "e848985111fca586021ed25e5b1cb3e7339a61cb"
+    "sourceHead": "c5a1a29b8950671d6033bab4a5c1bf9f3b2ff51a"
   }
 }