fix(coding-agent): prefer persisted header depth for legacy rehydration entries

The legacy-entry rehydration fallback (entry.rlmDepth ?? 1) is passed as
config, which outranks the opened transcript header in AgentSession — so a
nested legacy child whose header carried a deeper persisted depth woke at
depth 1, weakening the host recursion gate. Registry depth stays
authoritative when present; otherwise the validated header depth wins and 1
remains the last-resort default for fully legacy children.

origin: PR #584 fallback restored in round-1 triage; surfaced by post-rebase
bot review of PR #589.

Author: snimu

packages/coding-agent/src/modes/daemon/daemon-mode.ts

@@ -2619,9 +2619,14 @@ export class AgentDaemon {
 							},
 						},
 						rlmSessionDir: entry.sessionDir,
-						rlmDepth: existsSync(entry.sessionFile)
-							? resolveSessionRlmDepth(sessionManager.getHeader() ?? {}, entry.sessionFile)
-							: (entry.rlmDepth ?? 1),
+						// Registry depth is authoritative (written at spawn); for legacy entries
+						// without it, the shared accessor resolves persisted header depth or the
+						// session file's sub- path before the depth-1 default.
+						rlmDepth:
+							entry.rlmDepth ??
+							(existsSync(entry.sessionFile)
+								? resolveSessionRlmDepth(sessionManager.getHeader() ?? {}, entry.sessionFile)
+								: 1),
 						rlmMaxDepth: entry.rlmMaxDepth,
 						rlmParentNodeId: entry.rlmParentNodeId ?? entry.childId,
 					},

packages/coding-agent/test/daemon-mode.test.ts

@@ -4664,6 +4664,44 @@ describe("daemon mode helpers", () => {
 		}
 	});
 
+	it("prefers the persisted header depth when a legacy registry entry lacks one", async () => {
+		const tempDir = mkdtempSync(join(tmpdir(), "prime-agent-daemon-legacy-header-depth-"));
+		try {
+			const fixture = makePersistedRlmDaemonFixture(tempDir);
+			const childLines = readFileSync(fixture.childSessionFile, "utf8").split("\n");
+			const childHeader = JSON.parse(childLines[0] ?? "{}") as Record<string, unknown>;
+			childHeader.rlmDepth = 2;
+			childLines[0] = JSON.stringify(childHeader);
+			writeFileSync(fixture.childSessionFile, childLines.join("\n"));
+
+			const registryPath = join(fixture.parentArtifactDir, "rlm-subagents.jsonl");
+			const registryEntry = JSON.parse(readFileSync(registryPath, "utf8").trim()) as Record<string, unknown>;
+			delete registryEntry.rlmDepth;
+			writeFileSync(registryPath, `${JSON.stringify(registryEntry)}\n`);
+
+			const internals = fixture.daemon as unknown as {
+				createRuntime(command: Extract<DaemonCommand, { type: "create" }>): Promise<ActiveSessionState>;
+				createAgentMessageController(
+					getCurrentState: () => ActiveSessionState | undefined,
+				): AgentSessionMessageController;
+			};
+			const parentState = await internals.createRuntime({
+				type: "create",
+				sessionPath: fixture.parentSessionFile,
+			});
+
+			await internals
+				.createAgentMessageController(() => parentState)
+				.sendAgentMessage({ target: "renamed-worker", message: "report progress" });
+
+			// The nested header depth must win over the legacy depth-1 default so the
+			// woken child does not come up shallower than persisted.
+			expect(fixture.createRuntime.mock.calls[1]?.[0].sessionOptions?.rlmDepth).toBe(2);
+		} finally {
+			rmSync(tempDir, { recursive: true, force: true });
+		}
+	});
+
 	it("hydrates only the ancestor chain when a nested passive child is messaged", async () => {
 		const tempDir = mkdtempSync(join(tmpdir(), "prime-agent-daemon-lazy-nested-message-"));
 		try {