oasis_test_v2 2.2.103 → 2.2.105

package/dist/index.js

@@ -1118,12 +1118,12 @@ function sanitizeRuntimeQuotas(value2, now = Date.now()) {
   }
   return result;
 }
-var RUNTIME_QUOTA_POLL_MS, RUNTIME_QUOTA_STALE_MS, RUNTIME_QUOTA_REFRESH_MIN_GAP_MS, statuses;
+var RUNTIME_QUOTA_REUSE_MS, RUNTIME_QUOTA_STALE_MS, RUNTIME_QUOTA_REFRESH_MIN_GAP_MS, statuses;
 var init_runtime_quota = __esm({
   "../contract/src/runtime-quota.ts"() {
     "use strict";
-    RUNTIME_QUOTA_POLL_MS = 5 * 6e4;
-    RUNTIME_QUOTA_STALE_MS = 2 * RUNTIME_QUOTA_POLL_MS;
+    RUNTIME_QUOTA_REUSE_MS = 10 * 6e4;
+    RUNTIME_QUOTA_STALE_MS = 60 * 6e4;
     RUNTIME_QUOTA_REFRESH_MIN_GAP_MS = 3e4;
     statuses = /* @__PURE__ */ new Set(["ok", "unavailable", "unauthenticated", "unsupported", "error", "rate_limited"]);
   }
@@ -142037,6 +142037,21 @@ var init_store_postgres = __esm({
           createdAt: iso(r.createdAt)
         }));
       }
+      async listLiveNodeAssignees(workorderId) {
+        const res = await this.pool.query(
+          `SELECT n.assignee_actor_id AS "assigneeActorId",
+              n.continuation_budget AS "continuationBudget"
+         FROM ${quoteIdent(this.schema)}.workflow_nodes n
+         JOIN ${quoteIdent(this.schema)}.workorders w ON w.id = n.workorder_id
+        WHERE n.workorder_id = $1 AND w.lifecycle = 'active'
+          AND n.cancelled_at IS NULL AND n.assignee_actor_id IS NOT NULL`,
+          [workorderId]
+        );
+        return res.rows.map((r) => ({
+          assigneeActorId: r.assigneeActorId,
+          continuationBudget: r.continuationBudget ?? null
+        }));
+      }
       /* ── intervention 草案卡（见 store.ts 的接口注释）。与上面两口钟同类：直连 pool 的窄读写，
             标识符位一律经 quoteIdent——带连字符的公司 schema 裸拼会 syntax error。 ── */
       async listInterventionDrafts() {
@@ -144386,7 +144401,7 @@ function emptySnapshotPlaceholder(record10) {
     reviews: []
   };
 }
-var SYSTEM_ACTOR, NOOP_IO, SYSTEM_CLOCK, HandlerRegistry, DEFAULT_STUCK_APPLIED_RECOVERY_MS, SETTLE_FOREIGN_PROGRESS_FALLBACK_MS, EVENT_RETRY_DELAY_MS, EngineBus, ApplyFailure, sleep3;
+var SYSTEM_ACTOR, POLICY_MISSING, SCAN_POLICY_ATTEMPTS, NOOP_IO, SYSTEM_CLOCK, HandlerRegistry, DEFAULT_STUCK_APPLIED_RECOVERY_MS, SETTLE_FOREIGN_PROGRESS_FALLBACK_MS, EVENT_RETRY_DELAY_MS, EngineBus, ApplyFailure, sleep3;
 var init_bus = __esm({
   "../engine/src/bus.ts"() {
     "use strict";
@@ -144400,6 +144415,8 @@ var init_bus = __esm({
     init_protocol_recovery();
     init_continuation();
     SYSTEM_ACTOR = "actor:system:engine";
+    POLICY_MISSING = Symbol("continuation-policy-missing");
+    SCAN_POLICY_ATTEMPTS = 3;
     NOOP_IO = {
       async dispatchWork() {
       },
@@ -145086,6 +145103,38 @@ var init_bus = __esm({
        * ★ 只在调度器（run）内调用，其他代码不得调。
        */
       async scan(workorderId) {
+        for (let attempt = 1; ; attempt++) {
+          const policies = await this.prefetchContinuationPolicies(workorderId);
+          const result = await this.scanOnce(workorderId, policies);
+          if (result !== POLICY_MISSING) return result;
+          if (attempt >= SCAN_POLICY_ATTEMPTS) {
+            console.warn(`[bus] scan ${workorderId}: \u8FDE\u7EED ${attempt} \u6B21\u9501\u5185\u51FA\u73B0\u672A\u9884\u8BFB\u8BBE\u7F6E\u7684\u8D1F\u8D23\u4EBA\uFF0C\u672C\u8F6E\u4E0D\u5224\u65AD`);
+            return { emitted: 0, terminated: false };
+          }
+        }
+      }
+      /**
+       * 事务外预读员工分批执行设置（v2 连接池耗尽，工单 fa17f92a）。
+       *
+       * 读设置要经 `io.continuationPolicy` 向**同一个池**借连接；放在 scan 持锁事务里读，事务那条连接
+       * 一直空等，多家公司同时全扫就全卡在「拿着一条、等第二条」上，直到借连接超时，网页请求一起 503。
+       * 所以先不持任何连接读完、放回池子，再进事务。设置的时效与原来相同——原来那次读本就走另一条
+       * 连接、不在事务快照里。
+       *
+       * 预读范围是锁内跳过条件的超集：额度已冻结（待审/已拒）的节点锁内也不读，这里同样跳过；
+       * 额度是否用完要看 works，窄读拿不到，统统预读。锁内判断仍以锁内读到的状态为准。
+       */
+      async prefetchContinuationPolicies(workorderId) {
+        const policies = /* @__PURE__ */ new Map();
+        if (!this.io.continuationPolicy) return policies;
+        for (const node2 of await this.store.listLiveNodeAssignees(workorderId)) {
+          const decision = node2.continuationBudget?.request?.decision;
+          if (decision === "pending" || decision === "denied" || policies.has(node2.assigneeActorId)) continue;
+          policies.set(node2.assigneeActorId, await this.io.continuationPolicy(node2.assigneeActorId));
+        }
+        return policies;
+      }
+      async scanOnce(workorderId, prefetched) {
         let wrote = false;
         let settledAt = null;
         const result = await this.store.transaction(async (tx) => {
@@ -145102,7 +145151,11 @@ var init_bus = __esm({
               const budget = node2.continuationBudget;
               if (budget && (!continuationExhausted(state, node2) || budget.request?.decision === "pending" || budget.request?.decision === "denied")) continue;
               if (node2.assigneeActorId && !continuationPolicies.has(node2.assigneeActorId)) {
-                const policy = await this.io.continuationPolicy(node2.assigneeActorId);
+                if (!prefetched.has(node2.assigneeActorId)) {
+                  settledAt = null;
+                  return POLICY_MISSING;
+                }
+                const policy = prefetched.get(node2.assigneeActorId) ?? null;
                 if (policy && (!Number.isSafeInteger(policy.maxRounds) || policy.maxRounds < 1 || policy.maxRounds > 100)) {
                   throw new Error(`invalid continuation round limit for ${node2.assigneeActorId}`);
                 }
@@ -145131,6 +145184,7 @@ var init_bus = __esm({
           wrote = state.mutations.length > 0 || allEvents.length > 0;
           return { emitted: allEvents.length, terminated };
         });
+        if (result === POLICY_MISSING) return result;
         if (settledAt !== null) {
           const prev = this.scanProgress.get(workorderId);
           this.scanProgress.set(workorderId, {
@@ -213246,6 +213300,11 @@ async function startOasisServer(opts) {
           return;
         }
         const url = new URL(req.url ?? "/", "http://localhost");
+        if (url.pathname === "/healthz" && url.searchParams.get("deep") === "1") {
+          const db = opts.deepHealth ? await opts.deepHealth() : { ok: true, db: "none" };
+          res.writeHead(db.ok ? 200 : 503, { "content-type": "application/json" }).end(JSON.stringify({ ok: db.ok, ...getBuildInfo(), db }));
+          return;
+        }
         if (url.pathname === "/healthz") {
           res.writeHead(200, { "content-type": "application/json" }).end(JSON.stringify({ ok: true, ...getBuildInfo() }));
           return;
@@ -246611,9 +246670,15 @@ function faultAfterFailure(previous3, input, now) {
   }
   return { ...base, nextProbeAt: new Date(now + probeIntervalMs(attempts)).toISOString() };
 }
-function quotaClearsFault(fault, quotaStatus) {
+function quotaClearsFault(fault, quota, now = Date.now()) {
   if (RUNTIME_FAULT_RECOVERY[fault.reason] !== "readonly-probe") return false;
-  return quotaStatus === "ok";
+  if (quota?.status !== "ok") return false;
+  const exhaustedUntilFuture = quota.windows.some((w2) => {
+    if (w2.usedPercent < 100 || !w2.resetsAt) return false;
+    const resetsAt = Date.parse(w2.resetsAt);
+    return Number.isFinite(resetsAt) && resetsAt > now;
+  });
+  return exhaustedUntilFuture || fault.awaitingManual;
 }
 function describeFault(fault, now) {
   const head = `${fault.nodeId} \xB7 ${fault.runtimeKind} \u6545\u969C\uFF08${fault.reason}${fault.detail ? `\uFF1A${fault.detail}` : ""}\uFF09`;
@@ -247645,7 +247710,7 @@ function nodesDomain(deps) {
       void (async () => {
         for (const q2 of quotas) {
           const existing = faultByTarget.get(faultKey(daemonId, q2.kind));
-          if (!existing || !quotaClearsFault(existing, q2.status)) continue;
+          if (!existing || !quotaClearsFault(existing, q2)) 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`);
@@ -248405,13 +248470,20 @@ function atCapacity(node2) {
   if (limit === null || limit === void 0) return false;
   return node2.activeRunCount >= limit;
 }
-function quotaDerateFactor(quota) {
-  if (!quota || quota.status !== "ok" || quota.windows.length === 0) return { factor: 1 };
-  const worst = Math.max(...quota.windows.map((w2) => w2.usedPercent));
+function quotaDerateFactor(quota, now = Date.now()) {
+  if (!quota || quota.status !== "ok") return { factor: 1 };
+  const windows = quota.windows.filter((w2) => windowStillCurrent(w2, now));
+  if (windows.length === 0) return { factor: 1 };
+  const worst = Math.max(...windows.map((w2) => w2.usedPercent));
   if (worst <= RUNTIME_QUOTA_DERATE_THRESHOLD_PERCENT) return { factor: 1, worstUsedPercent: worst };
   const remaining = Math.max(0, 100 - worst);
   return { factor: remaining / (100 - RUNTIME_QUOTA_DERATE_THRESHOLD_PERCENT), worstUsedPercent: worst };
 }
+function windowStillCurrent(window3, now) {
+  if (!window3.resetsAt) return true;
+  const resetsAt = Date.parse(window3.resetsAt);
+  return !Number.isFinite(resetsAt) || resetsAt > now;
+}
 function faultFromQuota(target, quota, now) {
   if (!quota) return null;
   const base = { nodeId: target.nodeId, runtimeKind: target.runtimeKind, markedAt: quota.checkedAt, attempts: 0 };
@@ -248419,7 +248491,7 @@ function faultFromQuota(target, quota, now) {
     return { ...base, reason: "unauthenticated", awaitingManual: true, detail: "\u8FD0\u884C\u65F6\u767B\u5F55\u5DF2\u5931\u6548\uFF0C\u9700\u8981\u5728\u8BE5\u673A\u5668\u4E0A\u91CD\u65B0\u767B\u5F55" };
   }
   if (quota.status !== "ok") return null;
-  const exhausted = quota.windows.filter((w2) => w2.usedPercent >= 100);
+  const exhausted = quota.windows.filter((w2) => w2.usedPercent >= 100 && windowStillCurrent(w2, now));
   if (exhausted.length === 0) return null;
   const resets = exhausted.map((w2) => w2.resetsAt).filter((v2) => Boolean(v2)).sort();
   const latest = resets.at(-1);
@@ -248503,7 +248575,7 @@ function allocateRuntime(input, now = Date.now()) {
   const rank = (candidate) => {
     const node2 = input.nodes.get(candidate.nodeId);
     const idleness = idlenessOf(node2);
-    const { factor, worstUsedPercent } = quotaDerateFactor(input.quotas?.get(runtimeTargetKey(candidate)));
+    const { factor, worstUsedPercent } = quotaDerateFactor(input.quotas?.get(runtimeTargetKey(candidate)), now);
     return {
       candidate,
       nodeName: node2.displayName?.trim() || candidate.nodeId,
@@ -248748,6 +248820,7 @@ function createRuntimeAllocator(ports) {
         }, now);
         await ports.saveFault(fault);
         log3(`[runtime-alloc] ${describeFault(fault, now)}`);
+        if (reason === "quota-exhausted" && !previous3) ports.onQuotaExhausted?.(target);
         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)}`);
@@ -263845,6 +263918,32 @@ function createPgPool(dsn, opts) {
     connectionTimeoutMillis: opts?.connectionTimeoutMillis ?? 5e3
   });
 }
+async function probePgPool(pool, timeoutMs = 2e3) {
+  const startedAt = Date.now();
+  const stats = () => ({ max: pool.options.max, total: pool.totalCount, idle: pool.idleCount, waiting: pool.waitingCount });
+  const attempt = (async () => {
+    const client = await pool.connect();
+    try {
+      await client.query("SELECT 1");
+    } finally {
+      client.release();
+    }
+  })();
+  let timer;
+  const timeout = new Promise((_2, reject) => {
+    timer = setTimeout(() => reject(new Error(`\u501F\u8FDE\u63A5\u8D85\u8FC7 ${timeoutMs}ms`)), timeoutMs);
+  });
+  try {
+    await Promise.race([attempt, timeout]);
+    return { ok: true, ms: Date.now() - startedAt, pool: stats() };
+  } catch (err) {
+    attempt.catch(() => {
+    });
+    return { ok: false, ms: Date.now() - startedAt, error: err instanceof Error ? err.message : String(err), pool: stats() };
+  } finally {
+    clearTimeout(timer);
+  }
+}
 async function dropSchemaIfExists(dsn, schema) {
   const pool = createPgPool(dsn, { max: 1 });
   try {
@@ -279789,6 +279888,7 @@ __export(src_exports, {
   payloadChecksum: () => payloadChecksum,
   pinChatSessionsToAgentDefault: () => pinChatSessionsToAgentDefault,
   planSessionOrd: () => planSessionOrd,
+  probePgPool: () => probePgPool,
   provisionCompanyDataPlaneSchema: () => provisionCompanyDataPlaneSchema,
   provisionNewCompanyDataPlane: () => provisionNewCompanyDataPlane,
   quoteIdent: () => quoteIdent2,
@@ -287849,6 +287949,13 @@ async function startServe(opts) {
       clearFault: async (t) => {
         await nodeStore.clearRuntimeFault(t.nodeId, t.runtimeKind);
       },
+      /* ADR 0633：撞限流 → 叫那台机器现去问一遍额度。只发给自报能重采的节点；结果帧没人等，
+         serve 那边按不认识的 requestId 丢掉，新数据照旧走 runtime_quotas 落库；用满了才解除落库故障、改按重置时刻挡。 */
+      onQuotaExhausted: (t) => {
+        const daemon = hub?.connectedDaemons().find((d) => d.daemonId === t.nodeId);
+        if (!daemon?.meta.supportsQuotaRefresh) return;
+        hub?.dispatch(t.nodeId, { type: "refresh_quotas", requestId: (0, import_node_crypto91.randomUUID)() });
+      },
       actorName: async (actorId) => (await (await actors.resolveCtx(companyId)).service.getActor(actorId).catch(() => null))?.name ?? null
     });
     runtimeAllocators.set(companyId, allocator);
@@ -288067,6 +288174,7 @@ async function startServe(opts) {
     blobs: engine.blobs,
     // 自动化 webhook 公开入口（ADR 0156 D4）：token 即凭证，归属从触发器行反推。
     automationWebhook: (token2, rawBody, headers) => automations.webhook.handle(token2, rawBody, headers),
+    ...pgPool ? { deepHealth: () => probePgPool(pgPool) } : {},
     ...engine.assets ? { assets: engine.assets } : {},
     // ★ 新引擎 store：blob GC 从 work_artifacts 扫根（事实源=实体表，oplog 已退役）。
     engineStore: engine.kernel.getStore?.(),
@@ -293857,49 +293965,71 @@ function fileQuotaCache(dir, env = process.env) {
         (0, import_node_fs25.renameSync)(tmp, target);
       } catch {
       }
+    },
+    claim(kind, ttlMs) {
+      const lock = `${file(kind)}.lock`;
+      for (let attempt = 0; attempt < 2; attempt++) {
+        try {
+          (0, import_node_fs25.mkdirSync)(dir, { recursive: true, mode: 448 });
+          (0, import_node_fs25.writeFileSync)(lock, String(process.pid), { flag: "wx", mode: 384 });
+          return true;
+        } catch (err) {
+          if (err.code !== "EEXIST") return true;
+          try {
+            if (Date.now() - (0, import_node_fs25.statSync)(lock).mtimeMs < ttlMs) return false;
+            (0, import_node_fs25.unlinkSync)(lock);
+          } catch {
+          }
+        }
+      }
+      return false;
+    },
+    release(kind) {
+      try {
+        (0, import_node_fs25.unlinkSync)(`${file(kind)}.lock`);
+      } catch {
+      }
     }
   };
 }
 
 // ../cli/src/daemon/quota/monitor.ts
+var CLAIM_TTL_MS = 3e4;
+var PEER_POLL_MS = 500;
 var read2 = (runtime, signal) => runtime.kind === "codex" ? readCodexQuota(runtime.binary ?? "codex", signal) : readClaudeQuota(runtime.binary ?? "claude", signal, { version: runtime.version });
 var RuntimeQuotaMonitor = class _RuntimeQuotaMonitor {
-  constructor(runtimes, send, reader = read2, intervalMs = RUNTIME_QUOTA_POLL_MS, minGapMs = RUNTIME_QUOTA_REFRESH_MIN_GAP_MS, shared = null) {
+  constructor(runtimes, send, reader = read2, reuseMs = RUNTIME_QUOTA_REUSE_MS, minGapMs = RUNTIME_QUOTA_REFRESH_MIN_GAP_MS, shared = null) {
     this.runtimes = runtimes;
     this.send = send;
     this.reader = reader;
-    this.intervalMs = intervalMs;
+    this.reuseMs = reuseMs;
     this.minGapMs = minGapMs;
     this.shared = shared;
   }
   cache = [];
   collectedAt;
   pending;
-  timer;
   abort = new AbortController();
   stopped = false;
   /** daemon 用的那一份：同机同账号的其它 daemon 刚采过就直接用它的结果（见 shared-cache.ts）。 */
   static forNode(runtimes, send, sharedDir) {
-    return new _RuntimeQuotaMonitor(runtimes, send, read2, RUNTIME_QUOTA_POLL_MS, RUNTIME_QUOTA_REFRESH_MIN_GAP_MS, sharedDir ? fileQuotaCache(sharedDir) : null);
+    return new _RuntimeQuotaMonitor(runtimes, send, read2, RUNTIME_QUOTA_REUSE_MS, RUNTIME_QUOTA_REFRESH_MIN_GAP_MS, sharedDir ? fileQuotaCache(sharedDir) : null);
   }
   connected() {
     if (this.stopped) return;
     if (this.cache.length) this.send(this.cache);
-    if (!this.timer) this.timer = setInterval(() => {
-      void this.refresh();
-    }, this.intervalMs);
     void this.refresh();
   }
   stop() {
     this.stopped = true;
-    if (this.timer) clearInterval(this.timer);
     this.abort.abort();
   }
+  /** 连接时那一次：复用期内采过（自己或同账号的别的 daemon）就不再问上游。 */
   refresh() {
     if (this.stopped) return Promise.resolve();
     if (this.pending) return this.pending;
-    if (this.collectedAt !== void 0 && Date.now() - this.collectedAt < this.intervalMs) return Promise.resolve();
-    this.pending = this.collect(this.intervalMs).finally(() => {
+    if (this.collectedAt !== void 0 && Date.now() - this.collectedAt < this.reuseMs) return Promise.resolve();
+    this.pending = this.collect(this.reuseMs).finally(() => {
       this.pending = void 0;
     });
     return this.pending;
@@ -293907,7 +294037,7 @@ var RuntimeQuotaMonitor = class _RuntimeQuotaMonitor {
   /**
    * 人点了页面上的「刷新」（服务端下发 `refresh_quotas`，ADR 0620）：**现在就去问上游**。
    *
-   * 与 {@link refresh} 的唯一区别就是**不看那 5 分钟**——那条节流是背景轮询的节奏，
+   * 与 {@link refresh} 的唯一区别就是**不看那 10 分钟复用期**——那条是连接时防重复的闸，
    * 对一个正盯着页面等结果的人没有任何意义。换上的是一条窄得多的闸：
    * {@link RUNTIME_QUOTA_REFRESH_MIN_GAP_MS}（30 秒）。连点被它挡下，且挡下时**如实说**
    * 「刚在 N 秒前采过」，不假装采了一次（发起人方申的定则：会静默降级的动作必须回报走了哪条路）。
@@ -293939,6 +294069,16 @@ var RuntimeQuotaMonitor = class _RuntimeQuotaMonitor {
     for (const r of this.runtimes) if (r.kind === "codex" || r.kind === "claude-code") kinds.push(r.kind);
     return kinds;
   }
+  /** 等持锁的那个 daemon 把结果写进共享缓存；等不到（它挂了 / 采失败不外传）就回 undefined，自己去问。 */
+  async awaitPeer(kind) {
+    const since = Date.now();
+    while (!this.stopped && Date.now() - since < CLAIM_TTL_MS) {
+      await new Promise((r) => setTimeout(r, PEER_POLL_MS));
+      const peer = this.shared?.get(kind);
+      if (peer && Date.parse(peer.checkedAt) >= since - PEER_POLL_MS) return peer;
+    }
+    return void 0;
+  }
   /** `maxAgeMs`：同机其它 daemon 采到的结果在这个时长内就直接用，不再去问上游。 */
   async collect(maxAgeMs) {
     const result = [];
@@ -293956,6 +294096,15 @@ var RuntimeQuotaMonitor = class _RuntimeQuotaMonitor {
         result.push({ ...peer, kind });
         continue;
       }
+      const held = this.shared?.claim ? this.shared.claim(kind, CLAIM_TTL_MS) : false;
+      if (this.shared?.claim && !held) {
+        const theirs = await this.awaitPeer(kind);
+        if (this.stopped) return;
+        if (theirs) {
+          result.push({ ...theirs, kind });
+          continue;
+        }
+      }
       let quota;
       try {
         quota = await this.reader(runtime, this.abort.signal);
@@ -293963,6 +294112,7 @@ var RuntimeQuotaMonitor = class _RuntimeQuotaMonitor {
         quota = { status: "error", windows: [], checkedAt: (/* @__PURE__ */ new Date()).toISOString() };
       }
       if (quota.status === "ok" || quota.status === "rate_limited") this.shared?.put(kind, quota);
+      if (held) this.shared?.release?.(kind);
       result.push({ ...quota, kind });
     }
     if (this.stopped) return;
@@ -297914,7 +298064,7 @@ async function waitForCommandAuthorization(base, headers, draftId, fallback) {
     }
   }
 }
-var CLI_VERSION = "2.2.103" ? "2.2.103" : "dev";
+var CLI_VERSION = "2.2.105" ? "2.2.105" : "dev";
 function apiHeaders(token2, company) {
   const headers = {
     authorization: `Bearer ${token2}`,
@@ -301950,7 +302100,7 @@ function shimScript() {
 }
 
 // src/index.ts
-var PKG_VERSION = true ? "2.2.103" : "dev";
+var PKG_VERSION = true ? "2.2.105" : "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.103",
+  "version": "2.2.105",
   "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": "be78091fa39438c497835a6207b5df1d519afcc9"
+    "sourceHead": "962f486e9d39e2c8299be8337837771b2c87fdf0"
   }
 }