fix(session): skip fork after parent size timeout

LiLan0125 · LiLan0125 · commit 36e6ece642f0 · 2026-07-08T10:17:12.000+08:00
diff --git a/src/auto-reply/reply/session-fork.test.ts b/src/auto-reply/reply/session-fork.test.ts
@@ -15,6 +15,8 @@ vi.mock("./session-fork.runtime.js", () => runtimeMocks);
 const roots: string[] = [];
 const parentTooLargeMessage =
   "Parent context is too large to fork (170000/100000 tokens); starting with isolated context instead.";
+const parentSizeTimeoutMessage =
+  "Parent context size could not be verified within 1000ms; starting with isolated context instead.";
 
 async function makeRoot(prefix: string): Promise<string> {
   // realpath first: macOS tmpdir is a /var -> /private/var symlink and the
@@ -54,7 +56,7 @@ describe("resolveParentForkDecision", () => {
     expect(runtimeMocks.resolveParentForkTokenCountRuntime).not.toHaveBeenCalled();
   });
 
-  it("continues with a fork decision when parent token probing stalls", async () => {
+  it("starts isolated when parent token probing stalls", async () => {
     vi.useFakeTimers();
     runtimeMocks.resolveParentForkTokenCountRuntime.mockReturnValue(new Promise(() => {}));
 
@@ -66,8 +68,10 @@ describe("resolveParentForkDecision", () => {
     await vi.advanceTimersByTimeAsync(1_000);
 
     await expect(decision).resolves.toEqual({
-      status: "fork",
+      status: "skip",
+      reason: "parent-size-timeout",
       maxTokens: 100_000,
+      message: parentSizeTimeoutMessage,
     });
   });
 
@@ -162,4 +166,60 @@ describe("forkSessionEntryFromParent", () => {
     expect(stored[sessionKey]?.sessionId).toBe(result.fork.sessionId);
     expect(stored[sessionKey]?.sessionFile).toBe(result.fork.sessionFile);
   });
+
+  it("does not read the parent transcript after a stalled parent size probe", async () => {
+    vi.useFakeTimers();
+    const root = await makeRoot("openclaw-session-fork-timeout-");
+    const activeStoreDir = path.join(root, "active-store");
+    await fs.mkdir(activeStoreDir, { recursive: true });
+    const storePath = path.join(activeStoreDir, "sessions.json");
+    const parentSessionKey = "agent:main:main";
+    const sessionKey = "agent:main:subagent:child";
+    await fs.writeFile(
+      storePath,
+      JSON.stringify(
+        {
+          [parentSessionKey]: {
+            sessionId: "parent-session",
+            sessionFile: path.join(activeStoreDir, "missing-parent.jsonl"),
+            updatedAt: 1,
+          },
+          [sessionKey]: { sessionId: "", updatedAt: 2 },
+        },
+        null,
+        2,
+      ),
+      "utf-8",
+    );
+    runtimeMocks.resolveParentForkTokenCountRuntime.mockReturnValue(new Promise(() => {}));
+
+    const resultPromise = forkSessionEntryFromParent({
+      agentId: "main",
+      decisionSkipPatch: () => ({
+        forkedFromParent: false,
+      }),
+      fallbackEntry: { sessionId: "", updatedAt: 2 },
+      parentSessionKey,
+      sessionKey,
+      storePath,
+    });
+
+    await vi.advanceTimersByTimeAsync(1_000);
+    const result = await resultPromise;
+
+    expect(result).toMatchObject({
+      status: "skipped",
+      reason: "decision-skip",
+      decision: {
+        status: "skip",
+        reason: "parent-size-timeout",
+        maxTokens: 100_000,
+        message: parentSizeTimeoutMessage,
+      },
+    });
+    if (result.status !== "skipped") {
+      throw new Error("expected skipped result");
+    }
+    expect(result.sessionEntry.forkedFromParent).toBe(false);
+  });
 });
diff --git a/src/auto-reply/reply/session-fork.ts b/src/auto-reply/reply/session-fork.ts
@@ -20,6 +20,10 @@ const sessionForkRuntimeLoader = createLazyImportLoader(() => import("./session-
 
 export type ParentForkDecision = SessionParentForkDecision;
 
+type ParentForkTokenCountResolution =
+  | { status: "resolved"; parentTokens?: number }
+  | { status: "timed-out" };
+
 type ParentForkDecisionParams = {
   parentEntry: SessionEntry;
   agentId?: string;
@@ -95,6 +99,17 @@ function formatParentForkTooLargeMessage(params: {
   );
 }
 
+function formatParentForkTokenProbeTimeoutMessage(): string {
+  return (
+    `Parent context size could not be verified within ${PARENT_FORK_TOKEN_COUNT_TIMEOUT_MS}ms; ` +
+    "starting with isolated context instead."
+  );
+}
+
+function formatParentForkTokenProbeUnavailableMessage(): string {
+  return "Parent context size could not be verified; starting with isolated context instead.";
+}
+
 function resolveParentForkStorePath(params: {
   agentId?: string;
   config?: OpenClawConfig;
@@ -109,12 +124,37 @@ export async function resolveParentForkDecision(
   params: ParentForkDecisionParams,
 ): Promise<ParentForkDecision> {
   const maxTokens = DEFAULT_PARENT_FORK_MAX_TOKENS;
-  const parentTokens =
-    resolveFreshSessionTotalTokens(params.parentEntry) ??
-    (await resolveParentForkTokenCountWithTimeout({
-      parentEntry: params.parentEntry,
-      storePath: resolveParentForkStorePath(params),
-    }));
+  const freshParentTokens = resolveFreshSessionTotalTokens(params.parentEntry);
+  if (typeof freshParentTokens === "number" && freshParentTokens > maxTokens) {
+    return {
+      status: "skip",
+      reason: "parent-too-large",
+      maxTokens,
+      parentTokens: freshParentTokens,
+      message: formatParentForkTooLargeMessage({ parentTokens: freshParentTokens, maxTokens }),
+    };
+  }
+  if (typeof freshParentTokens === "number") {
+    return {
+      status: "fork",
+      maxTokens,
+      parentTokens: freshParentTokens,
+    };
+  }
+
+  const tokenCountResolution = await resolveParentForkTokenCountWithTimeout({
+    parentEntry: params.parentEntry,
+    storePath: resolveParentForkStorePath(params),
+  });
+  if (tokenCountResolution.status === "timed-out") {
+    return {
+      status: "skip",
+      reason: "parent-size-timeout",
+      maxTokens,
+      message: formatParentForkTokenProbeTimeoutMessage(),
+    };
+  }
+  const parentTokens = tokenCountResolution.parentTokens;
   if (typeof parentTokens === "number" && parentTokens > maxTokens) {
     return {
       status: "skip",
@@ -124,10 +164,18 @@ export async function resolveParentForkDecision(
       message: formatParentForkTooLargeMessage({ parentTokens, maxTokens }),
     };
   }
+  if (typeof parentTokens !== "number") {
+    return {
+      status: "skip",
+      reason: "parent-size-unavailable",
+      maxTokens,
+      message: formatParentForkTokenProbeUnavailableMessage(),
+    };
+  }
   return {
     status: "fork",
     maxTokens,
-    ...(typeof parentTokens === "number" ? { parentTokens } : {}),
+    parentTokens,
   };
 }
 
@@ -209,14 +257,22 @@ async function resolveParentForkTokenCount(params: {
 async function resolveParentForkTokenCountWithTimeout(params: {
   parentEntry: SessionEntry;
   storePath: string;
-}): Promise<number | undefined> {
-  let timeoutId: number | undefined;
-  const timeout = new Promise<undefined>((resolve) => {
-    timeoutId = setTimeout(resolve, PARENT_FORK_TOKEN_COUNT_TIMEOUT_MS);
+}): Promise<ParentForkTokenCountResolution> {
+  let timeoutId: Parameters<typeof clearTimeout>[0];
+  const tokenCount = resolveParentForkTokenCount(params).then((parentTokens) =>
+    typeof parentTokens === "number"
+      ? ({ status: "resolved", parentTokens } as const)
+      : ({ status: "resolved" } as const),
+  );
+  const timeout = new Promise<ParentForkTokenCountResolution>((resolve) => {
+    timeoutId = setTimeout(
+      () => resolve({ status: "timed-out" }),
+      PARENT_FORK_TOKEN_COUNT_TIMEOUT_MS,
+    );
   });
   try {
-    // Availability wins over exact sizing when transcript probing stalls.
-    return await Promise.race([resolveParentForkTokenCount(params), timeout]);
+    // Isolated context wins when parent sizing stalls or cannot be verified.
+    return await Promise.race([tokenCount, timeout]);
   } finally {
     if (timeoutId !== undefined) {
       clearTimeout(timeoutId);
diff --git a/src/auto-reply/reply/session-parent-fork-prepare.ts b/src/auto-reply/reply/session-parent-fork-prepare.ts
@@ -29,11 +29,15 @@ export async function prepareReplySessionParentFork(params: {
     storePath: params.storePath,
   });
   if (decision.status === "skip") {
-    // The parent branch is too large to inherit usefully. Start fresh and
-    // mark as handled so the thread does not retry this decision every turn.
+    // The parent branch is not safe to inherit. Start fresh and mark as
+    // handled so the thread does not retry this decision every turn.
+    const tokenDetails =
+      decision.reason === "parent-too-large"
+        ? ` parentTokens=${decision.parentTokens} maxTokens=${decision.maxTokens}`
+        : "";
     params.warn(
-      `skipping parent fork (parent too large): parentKey=${params.parentSessionKey} → sessionKey=${params.sessionKey} ` +
-        `parentTokens=${decision.parentTokens} maxTokens=${decision.maxTokens}`,
+      `skipping parent fork (${decision.reason}): parentKey=${params.parentSessionKey} → sessionKey=${params.sessionKey}` +
+        tokenDetails,
     );
     return { ...params.sessionEntry, forkedFromParent: true };
   }
diff --git a/src/config/sessions/session-accessor.ts b/src/config/sessions/session-accessor.ts
@@ -1394,6 +1394,12 @@ export type SessionParentForkDecision =
       maxTokens: number;
       parentTokens: number;
       message: string;
+    }
+  | {
+      status: "skip";
+      reason: "parent-size-timeout" | "parent-size-unavailable";
+      maxTokens: number;
+      message: string;
     };
 
 /** Transcript identity created for a child fork. */
diff --git a/src/gateway/session-create-service.ts b/src/gateway/session-create-service.ts
@@ -437,12 +437,13 @@ export async function createGatewaySession(params: {
           storePath: parentSessionTarget.storePath,
         });
         if (forkDecision.status === "skip") {
+          const message =
+            forkDecision.reason === "parent-too-large"
+              ? `parent session is too large to fork (${forkDecision.parentTokens}/${forkDecision.maxTokens} tokens)`
+              : forkDecision.message;
           return {
             ok: false,
-            error: errorShape(
-              ErrorCodes.INVALID_REQUEST,
-              `parent session is too large to fork (${forkDecision.parentTokens}/${forkDecision.maxTokens} tokens)`,
-            ),
+            error: errorShape(ErrorCodes.INVALID_REQUEST, message),
           };
         }
         const fork = await forkSessionFromParent({
