@@ -369,12 +369,46 @@ export function bskInstallMessage(bskPath: string): string {
   );
 }
 
+/**
+ * Options for interpreting a finished `bsk` run.
+ *
+ * `allowNavigationTimeout`: when the CLI prints a success-shaped navigation
+ * payload with `reached: "timeout"` and then exits 4 (RenderedExit), return
+ * that payload instead of throwing. Exit 4 alone is not enough — session-busy
+ * and other failures also use 4 — so the payload must explicitly say
+ * `reached: "timeout"`.
+ */
+export interface ParseBskJsonOptions {
+  allowNavigationTimeout?: boolean;
+}
+
+/**
+ * True when stdout is a navigation/history payload whose lifecycle wait
+ * expired (`reached: "timeout"`). Used to distinguish that soft timeout from
+ * other exit-4 failures (e.g. session_busy).
+ */
+export function isNavigationLifecycleTimeoutPayload(value: unknown): value is {
+  reached: "timeout";
+  [key: string]: unknown;
+} {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    !Array.isArray(value) &&
+    (value as { reached?: unknown }).reached === "timeout"
+  );
+}
+
 /**
  * Interpret one finished run: throw `BskError` on timeout / non-zero exit
  * (parsing the CLI's JSON error envelope when present), otherwise parse and
  * return the stdout JSON payload.
  */
-export function parseBskJson(result: BskRunResult, commandLabel: string): unknown {
+export function parseBskJson(
+  result: BskRunResult,
+  commandLabel: string,
+  options: ParseBskJsonOptions = {},
+): unknown {
   if (result.timedOut) {
     throw new BskError(`bsk ${commandLabel} timed out`, { timedOut: true });
   }
@@ -385,6 +419,20 @@ export function parseBskJson(result: BskRunResult, commandLabel: string): unknow
     throw new BskError(`bsk ${commandLabel} was interrupted (process killed)`);
   }
   if (result.code !== 0) {
+    // Navigate / back / forward / reload print the success-shaped body then
+    // exit 4 on lifecycle wait expiry. Callers that opt in (combined session
+    // start-with-URL) can keep the session and surface the timeout instead of
+    // treating it as a hard failure.
+    if (options.allowNavigationTimeout === true && result.code === 4) {
+      try {
+        const payload: unknown = JSON.parse(body);
+        if (isNavigationLifecycleTimeoutPayload(payload)) {
+          return payload;
+        }
+      } catch {
+        // Fall through to the normal error path.
+      }
+    }
     let parsed: BskErrorBody | undefined;
     try {
       parsed = JSON.parse(body) as BskErrorBody;
 
@@ -25,6 +25,8 @@ import {
   type BskRunner,
   bskInstallMessage,
   isCommandNotFound,
+  isNavigationLifecycleTimeoutPayload,
+  type ParseBskJsonOptions,
   parseBskJson,
   runWithSessionBusyRetry,
 } from "./runner";
@@ -88,6 +90,7 @@ async function runBsk(
   observeSession?: string,
   runnerTimeoutMs?: number,
   initializing = false,
+  parseOptions: ParseBskJsonOptions = {},
 ): Promise<unknown> {
   const releaseForeground =
     observeSession !== undefined ? deps.observation.acquireForeground(observeSession) : undefined;
@@ -133,7 +136,7 @@ async function runBsk(
       error.name = "AbortError";
       throw error;
     }
-    return parseBskJson(result, label);
+    return parseBskJson(result, label, parseOptions);
   } catch (error) {
     actionError = error instanceof Error ? error.message.split("\n")[0] : String(error);
     throw error;
@@ -212,6 +215,8 @@ function defineBrowserOperations(deps: ToolDeps, register: DefinitionRegistrar):
             browserInstanceId: { type: "string", required: true },
             url: { type: "string" },
             device: { type: "string" },
+            reached: { type: "string" },
+            warning: { type: "string" },
           },
         },
         render: (_args, value) => [
@@ -220,7 +225,10 @@ function defineBrowserOperations(deps: ToolDeps, register: DefinitionRegistrar):
             text:
               `started browser session ${value.sessionId}` +
               (value.url !== undefined ? ` and navigated to ${value.url}` : "") +
-              (value.device !== undefined ? ` (device: ${value.device})` : ""),
+              (value.device !== undefined ? ` (device: ${value.device})` : "") +
+              (value.reached === "timeout"
+                ? " — initial navigation timed out before the requested lifecycle phase; session is usable"
+                : ""),
           },
         ],
       },
@@ -264,28 +272,77 @@ function defineBrowserOperations(deps: ToolDeps, register: DefinitionRegistrar):
               true,
             );
           }
+          let navigationTimeout:
+            | {
+                reached: "timeout";
+                url?: string;
+                final_url?: string;
+                error_text?: string;
+              }
+            | undefined;
           if (args.url !== undefined) {
-            await runBsk(
+            // Combined start-with-URL: a lifecycle wait timeout (exit 4 +
+            // reached:"timeout") must not cancel the session that was already
+            // created — the page may still be usable. Genuine navigate failures
+            // still fall through to starts.fail below.
+            const navigateReply = await runBsk(
               deps,
               exec,
               ["navigate", "--session", reply.session_id, args.url],
               "navigate",
               reply.session_id,
               undefined,
               true,
+              { allowNavigationTimeout: true },
             );
+            if (isNavigationLifecycleTimeoutPayload(navigateReply)) {
+              navigationTimeout = {
+                reached: "timeout",
+                url: typeof navigateReply.url === "string" ? navigateReply.url : undefined,
+                final_url:
+                  typeof navigateReply.final_url === "string" ? navigateReply.final_url : undefined,
+                error_text:
+                  typeof navigateReply.error_text === "string"
+                    ? navigateReply.error_text
+                    : undefined,
+              };
+              deps.observation.setUrl(
+                reply.session_id,
+                navigationTimeout.final_url ?? navigationTimeout.url ?? args.url,
+              );
+            } else {
+              const okReply = navigateReply as {
+                url?: string;
+                final_url?: string;
+              };
+              deps.observation.setUrl(
+                reply.session_id,
+                okReply.final_url ?? okReply.url ?? args.url,
+              );
+            }
           }
           await starts.claim(record, exec.signal);
+          return {
+            sessionId: reply.session_id,
+            browserInstanceId: reply.browser_instance_id,
+            ...(args.url !== undefined ? { url: args.url } : {}),
+            ...(args.device !== undefined ? { device: args.device } : {}),
+            ...(navigationTimeout !== undefined
+              ? {
+                  reached: "timeout" as const,
+                  warning:
+                    "Initial navigation timed out waiting for the page lifecycle; " +
+                    "the session remains open — observe the page and decide how to proceed." +
+                    (navigationTimeout.error_text !== undefined
+                      ? ` (${navigationTimeout.error_text})`
+                      : ""),
+                }
+              : {}),
+          };
         } catch (error) {
           await starts.fail(record).catch(() => {});
           throw error;
         }
-        return {
-          sessionId: reply.session_id,
-          browserInstanceId: reply.browser_instance_id,
-          ...(args.url !== undefined ? { url: args.url } : {}),
-          ...(args.device !== undefined ? { device: args.device } : {}),
-        };
       },
       presentCall: (args) => ({
         card: "terminal",
 
@@ -9,6 +9,7 @@ import {
   type BskRunResult,
   createBskRunner,
   isCommandNotFound,
+  isNavigationLifecycleTimeoutPayload,
   isSessionBusyResult,
   parseBskJson,
   runWithSessionBusyRetry,
@@ -535,6 +536,41 @@ describe("parseBskJson", () => {
       /did not produce JSON/,
     );
   });
+
+  it("returns navigation lifecycle timeout payloads when opted in", () => {
+    const payload = {
+      tab_id: 1,
+      url: "https://slow.example/",
+      final_url: "https://slow.example/",
+      reached: "timeout",
+      error_text: "timed out waiting for load",
+    };
+    const result = parseBskJson({ ...base, code: 4, stdout: JSON.stringify(payload) }, "navigate", {
+      allowNavigationTimeout: true,
+    });
+    expect(result).toEqual(payload);
+    expect(isNavigationLifecycleTimeoutPayload(result)).toBe(true);
+  });
+
+  it("still throws exit 4 without reached: timeout even when opted in", () => {
+    const busy = {
+      code: "timeout",
+      message: "session already has an unfinished command",
+      data: { reason: "session_busy" },
+    };
+    expect(() =>
+      parseBskJson({ ...base, code: 4, stdout: JSON.stringify(busy) }, "navigate", {
+        allowNavigationTimeout: true,
+      }),
+    ).toThrow(/session already has an unfinished command/);
+  });
+
+  it("throws navigation timeout payloads by default (no opt-in)", () => {
+    const payload = { tab_id: 1, url: "https://x/", reached: "timeout" };
+    expect(() =>
+      parseBskJson({ ...base, code: 4, stdout: JSON.stringify(payload) }, "navigate"),
+    ).toThrow(/failed/);
+  });
 });
 
 describe("isCommandNotFound", () => {
 
@@ -82,6 +82,15 @@ function fakeRunner(responses: Record<string, unknown>) {
               typeof response === "object" && response !== null && "__seq" in response
                 ? (response as { __seq: unknown[] }).__seq.shift()
                 : response;
+            // Allow tests to return a full BskRunResult (custom exit code / body).
+            if (
+              typeof reply === "object" &&
+              reply !== null &&
+              "__result" in reply &&
+              typeof (reply as { __result: unknown }).__result === "object"
+            ) {
+              return (reply as { __result: BskRunResult }).__result;
+            }
             return {
               code: 0,
               stdout: JSON.stringify(reply),
@@ -404,6 +413,89 @@ describe("session.start", () => {
     expect(registry.current()).toBeUndefined();
   });
 
+  it("keeps the session when combined start-with-URL hits a navigation lifecycle timeout", async () => {
+    // CLI exit 4 + reached:"timeout" must not cancel the newly created session
+    // (review on #442): the agent should get sessionId + an explicit warning and
+    // be able to observe afterwards. Exit 4 alone is not treated as success.
+    const { tools, calls, registry } = setup({
+      "session start": START_REPLY("s1"),
+      navigate: {
+        __result: {
+          code: 4,
+          stdout: JSON.stringify({
+            tab_id: 7,
+            url: "https://slow.example/",
+            final_url: "https://slow.example/",
+            reached: "timeout",
+            error_text: "timed out waiting for load",
+          }),
+          stderr: "",
+          timedOut: false,
+          aborted: false,
+        },
+      },
+      observe: {
+        text: '- heading "Partial" [ref=@e1]',
+        ref_count: 1,
+        tab_id: 7,
+        truncated: false,
+      },
+    });
+    const start = tools.get("session.start");
+    const value = (await start?.execute({ url: "https://slow.example/" }, makeExec())) as {
+      sessionId: string;
+      reached?: string;
+      warning?: string;
+      url?: string;
+    };
+    expect(value).toMatchObject({
+      sessionId: "s1",
+      url: "https://slow.example/",
+      reached: "timeout",
+    });
+    expect(value.warning).toMatch(/timed out/i);
+    expect(value.warning).toMatch(/remains open|usable|observe/i);
+    // Claimed and active — no cancel/cleanup issued.
+    expect(registry.current()).toBe("s1");
+    expect(calls.some((c) => c.args[1] === "request" && c.args.includes("--cancel"))).toBe(false);
+    expect(calls.some((c) => c.args.join(" ").startsWith("session stop"))).toBe(false);
+
+    const observe = tools.get("inspect.observe");
+    const observed = (await observe?.execute({}, makeExec())) as {
+      session: string;
+      refCount: number;
+    };
+    expect(observed).toMatchObject({ session: "s1", refCount: 1 });
+    expect(calls.some((c) => c.args[0] === "observe" && c.args.includes("s1"))).toBe(true);
+  });
+
+  it("still cleans up when exit 4 lacks reached: timeout on combined start", async () => {
+    // Exit 4 is also used for session_busy / other errors — must not keep the session.
+    const { tools, calls, registry } = setup({
+      "session start": START_REPLY("s1"),
+      "session stop": {},
+      navigate: {
+        __result: {
+          code: 4,
+          stdout: JSON.stringify({
+            code: "timeout",
+            message: "session already has an unfinished command",
+            data: { reason: "session_busy" },
+          }),
+          stderr: "",
+          timedOut: false,
+          aborted: false,
+        },
+      },
+    });
+    const tool = tools.get("session.start");
+    await expect(tool?.execute({ url: "https://example.com" }, makeExec())).rejects.toThrow(
+      /navigate/,
+    );
+    expect(calls.some((c) => c.args[1] === "request" && c.args.includes("--cancel"))).toBe(true);
+    expect(registry.current()).toBeUndefined();
+  });
+
   it("returns the session when bsk exits but something still holds its stdio pipes", async () => {
     // Issue #180: `bsk session start` printed its JSON and exited, but the daemon
     // it auto-spawned kept the stdio pipes open, so the child's `close` never