@xrkseek/harness 0.6.2 → 0.6.4

package/node_modules/@xrkseek/server-host/dist/index.js

@@ -21,7 +21,7 @@ import { createPluginLoader, composeHostPolicyEngine, wireCompositionChannels, w
 import { existsSync } from "node:fs";
 import { access } from "node:fs/promises";
 import path from "node:path";
-import { createHostAgentCache } from "./agent-cache.js";
+import { createHostAgentCache, deferBusyAgentInvalidate } from "./agent-cache.js";
 import { createHostCron } from "@xrkseek/server-cron";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { wireDrainStatus, publishDrainIdle } from "./drain-status.js";
@@ -48,7 +48,7 @@ import { resolveExecEnvironment, } from "@xrkseek/exec-environment";
 import { createSshExecutionWorldReady, resolveSshConfig, } from "@xrkseek/exec-ssh";
 /** True while an unattended cron agent turn is running — skip cron tools to avoid recursion. */
 const cronAgentDepth = new AsyncLocalStorage();
-export { createHostAgentCache, HOST_PLUGINS_KEY } from "./agent-cache.js";
+export { createHostAgentCache, deferBusyAgentInvalidate, HOST_PLUGINS_KEY } from "./agent-cache.js";
 export { createStandingToolRegistry } from "./standing-tools.js";
 export { a2aInboundSessionId, createA2aInboundPublicHandler, resolveA2aInboundEnabled, } from "./a2a-inbound-public.js";
 import { createImFaceAdmitHook } from "./im-face-admit.js";
@@ -457,11 +457,21 @@ export function createHostManager() {
             invalidateAgents = async () => {
                 await agentCache.invalidateAll({
                     skip: (sessionId) => {
-                        if (!drainActiveBox.isActive(sessionId))
+                        // Drain-active: mid-turn on the Hub bookkeeping path.
+                        // isBusy: subagent / edge cases where latch is live but drain
+                        // was not marked — disposing those was painting disposed 「已停止」.
+                        if (!drainActiveBox.isActive(sessionId) &&
+                            !agentCache.isBusy(sessionId)) {
                             return false;
+                        }
                         pendingAgentInvalidate.add(sessionId);
                         return true;
                     },
+                    // Idle parent of a busy nested worker: hold until the child drains,
+                    // else parent.dispose cascades and paints the worker 「已停止」.
+                    onHold: (sessionId) => {
+                        pendingAgentInvalidate.add(sessionId);
+                    },
                 });
                 await mcpDeferred.flush();
             };
@@ -796,15 +806,29 @@ export function createHostManager() {
                             }
                             return pathAccessModeFromSandbox(effectiveSandboxMode(readSessionEvents(store, sessionId)));
                         },
-                        readSessionPathAllowlist: () => faceBox.runtime?.pathAllowlist.list(sessionId) ?? [],
+                        readSessionPathAllowlist: () => {
+                            const rt = faceBox.runtime;
+                            if (!rt)
+                                return [];
+                            // Resident eviction forgets the in-memory map; cron/IM/drain
+                            // turns may never call session.history — refill from the log.
+                            rt.pathAllowlist.hydrate(rt.store, sessionId);
+                            return rt.pathAllowlist.list(sessionId);
+                        },
                         clearSessionPathOnce: () => {
                             faceBox.runtime?.pathAllowlist.clearOnce(sessionId);
                         },
-                        ...(faceBox.runtime
-                            ? {
-                                toolSearchState: faceBox.runtime.toolDisclosure.stateFor(sessionId),
-                            }
-                            : {}),
+                        // Always register tool_search — even while Face is still booting.
+                        // Omitting toolSearchState used to dump every deferred MCP schema
+                        // onto the wire (~100k+ tokens). Live getters attach to Face
+                        // disclosure once runtime is assigned.
+                        toolSearchState: {
+                            listExpanded: () => faceBox.runtime?.toolDisclosure.listExpanded(sessionId) ??
+                                new Set(),
+                            expand: (names) => {
+                                faceBox.runtime?.toolDisclosure.expand(sessionId, names);
+                            },
+                        },
                         routeAllowsImage: () => faceForModality.current
                             ? liveRouteAllowsImageInput(faceForModality.current, sessionId)
                             : false,
@@ -1247,14 +1271,36 @@ export function createHostManager() {
                             if (!running &&
                                 "flush" in store &&
                                 typeof store.flush === "function") {
-                                store.flush();
-                            }
-                            if (!running && pendingAgentInvalidate.has(sid)) {
-                                pendingAgentInvalidate.delete(sid);
-                                void agentCache.invalidate(sid).then(() => mcpDeferred.flush());
+                                store.flush(sid);
                             }
-                            else if (!running) {
-                                void mcpDeferred.flush();
+                            if (!running) {
+                                // Invalidate this session if it was deferred mid-turn, then flush
+                                // other pending ids that are idle (incl. parents held only to
+                                // protect a nested busy child — see agent-cache onHold).
+                                if (pendingAgentInvalidate.has(sid)) {
+                                    pendingAgentInvalidate.delete(sid);
+                                    void agentCache.invalidate(sid).then(() => mcpDeferred.flush());
+                                }
+                                for (const pending of [...pendingAgentInvalidate]) {
+                                    if (pending === sid)
+                                        continue;
+                                    if (drainActiveBox.isActive(pending) ||
+                                        agentCache.isBusy(pending)) {
+                                        continue;
+                                    }
+                                    // Idle parent held only for a nested worker: wait until that
+                                    // child is no longer protected, else parent.dispose cascades.
+                                    if (agentCache.hasProtectedNestedChild(pending, (id) => pendingAgentInvalidate.has(id) ||
+                                        drainActiveBox.isActive(id) ||
+                                        agentCache.isBusy(id))) {
+                                        continue;
+                                    }
+                                    pendingAgentInvalidate.delete(pending);
+                                    void agentCache.invalidate(pending);
+                                }
+                                if (!pendingAgentInvalidate.has(sid)) {
+                                    void mcpDeferred.flush();
+                                }
                             }
                             hostStatusBox.publish?.(sid, running);
                         });
@@ -1577,7 +1623,15 @@ export function createHostManager() {
                 ...(config.runtime.policyFile
                     ? { settingsDocumentPath: path.resolve(config.runtime.policyFile) }
                     : {}),
-                invalidateAgent: (sessionId) => agentCache.invalidate(sessionId),
+                invalidateAgent: (sessionId) => deferBusyAgentInvalidate({
+                    sessionId,
+                    drainActive: drainActiveBox.isActive(sessionId),
+                    busy: agentCache.isBusy(sessionId),
+                    defer: (id) => {
+                        pendingAgentInvalidate.add(id);
+                    },
+                    invalidate: (id) => agentCache.invalidate(id),
+                }),
                 onSessionFinalize: (sessionId) => {
                     consolidateCuratedMemoryForSession(sessionId);
                     sharedBrowser?.drop(sessionId);
@@ -1703,6 +1757,22 @@ export function createHostManager() {
                     compactionStrategyRaw === "off"
                     ? compactionStrategyRaw
                     : undefined;
+                const softBudgetTriggerPercent = typeof loop.softBudgetTriggerPercent === "number" &&
+                    Number.isFinite(loop.softBudgetTriggerPercent) &&
+                    loop.softBudgetTriggerPercent >= 50 &&
+                    loop.softBudgetTriggerPercent <= 100
+                    ? Math.floor(loop.softBudgetTriggerPercent)
+                    : undefined;
+                const compactRecentMaxTokens = typeof loop.compactRecentMaxTokens === "number" &&
+                    Number.isFinite(loop.compactRecentMaxTokens) &&
+                    loop.compactRecentMaxTokens >= 2_000
+                    ? Math.floor(loop.compactRecentMaxTokens)
+                    : undefined;
+                const softBudgetPeelAttempts = typeof loop.softBudgetPeelAttempts === "number" &&
+                    Number.isFinite(loop.softBudgetPeelAttempts) &&
+                    loop.softBudgetPeelAttempts >= 0
+                    ? Math.floor(loop.softBudgetPeelAttempts)
+                    : undefined;
                 const toolResultMaxInlineBytes = typeof loop.toolResultMaxInlineBytes === "number" &&
                     Number.isFinite(loop.toolResultMaxInlineBytes) &&
                     loop.toolResultMaxInlineBytes >= 0
@@ -2018,8 +2088,28 @@ export function createHostManager() {
                     ...(toolOrder !== undefined ? { toolOrder } : {}),
                     ...(toolSettle !== undefined ? { toolSettle } : {}),
                     ...(llmRetryMaxRetries !== undefined ? { llmRetryMaxRetries } : {}),
-                    ...(compactionStrategy !== undefined
-                        ? { compaction: { strategy: compactionStrategy } }
+                    ...(compactionStrategy !== undefined ||
+                        softBudgetTriggerPercent !== undefined ||
+                        compactRecentMaxTokens !== undefined ||
+                        softBudgetPeelAttempts !== undefined
+                        ? {
+                            compaction: {
+                                ...(compactionStrategy !== undefined
+                                    ? { strategy: compactionStrategy }
+                                    : {}),
+                                ...(softBudgetTriggerPercent !== undefined
+                                    ? {
+                                        softBudgetTriggerRatio: softBudgetTriggerPercent / 100,
+                                    }
+                                    : {}),
+                                ...(compactRecentMaxTokens !== undefined
+                                    ? { compactRecentMaxTokens }
+                                    : {}),
+                                ...(softBudgetPeelAttempts !== undefined
+                                    ? { softBudgetPeelAttempts }
+                                    : {}),
+                            },
+                        }
                         : {}),
                     ...(toolResultMaxInlineBytes !== undefined
                         ? { toolResultMaxInlineBytes }
@@ -2106,9 +2196,9 @@ export function createHostManager() {
                     }
                 }
             });
-            // Tool-delegated children nest under the parent compose scope. UI/rewind
-            // forks (`mode: "fork"`) stay root `agent:{id}` scopes — nesting them
-            // under a live parent races dispose while the child's create() awaits.
+            // Summoning session id is for identity / workspace inject only.
+            // Agent scopes stay siblings under the host root so one session's
+            // dispose cannot abort another.
             lineage.parentOf = (sessionId) => {
                 const link = faceRuntime.subagents.getByChild(sessionId);
                 if (!link || link.mode === "fork")