Codex review: needs real behavior proof before merge. Reviewed June 29, 2026, 8:36 AM ET / 12:36 UTC.

Summary
The PR preserves expired suspended subagent final-delivery text in completion fallback state, adds a distinct discard reason, expands session write-lock timeout diagnostics, and updates focused agent tests.

PR surface: Source +46, Tests +15. Total +61 across 5 files.

Reproducibility: yes. at source level: current main still clears completion fallback during suspended-delivery expiry while the recovery path reads that fallback text, and linked reports include repeated live lock/lost-delivery logs. I did not run the timing-sensitive live gateway race in this read-only review.

Review metrics: 1 noteworthy metric.

• Persisted delivery state: 1 discard reason added; fallback text retained on expiry. The PR changes durable subagent recovery state, so maintainers need the rebased merge result and upgrade behavior in view before merge.

Stored data model
Persistent data-model change detected: serialized state: src/agents/session-write-lock.test.ts, serialized state: src/agents/session-write-lock.ts, unknown-data-model-change: src/agents/session-write-lock.ts. Confirm migration or upgrade compatibility proof before merge.

Root-cause cluster
Relationship: fixed_by_candidate
Canonical: #86538
Summary: This PR is the open candidate fix for the canonical session write-lock timeout plus subagent completion delivery-loss cluster; related items overlap but do not safely replace it.

Members:

• canonical: [Bug]: Session write-lock timeouts block subagent delivery lanes #86538 - The PR uses closing syntax for this open issue, and the issue remains the broader tracker for session write-lock timeout plus subagent delivery loss.
• same_root_cause: [Bug]: Subagent terminal reconciliation can expire suspended final delivery #86537 - The PR also closes this companion suspended final-delivery expiry bug, which is the durable payload-loss half of the same repair.
• partial_overlap: fix(agents): bound abort-path session lock release; force-release on unsettled retained writes #90065 - That open PR targets abort-path retained lock release in a different agent lock owner path, complementing but not superseding this PR's suspended-delivery and timeout-diagnostic changes.
• partial_overlap: [Feature/Bug]: Isolate subagent completion from parent context; return status + child session link only by default #96975 - That issue proposes metadata-only completion to reduce lock/context pressure, but it is broader product/API direction rather than this narrow durability fix.
• partial_overlap: Multi-agent orchestration is unstable: concurrent agents add/config overwrites, session-lock failures, and detached child work #43367 - The umbrella multi-agent orchestration issue includes session-lock and detached child-work symptoms, but it is broader than this PR's focused repair.

Proposal only: this assessment does not dispatch repair, suppress jobs, mutate sibling items, close, or merge anything.

Merge readiness
Overall: 🦪 silver shellfish
Proof: 🦪 silver shellfish
Patch quality: 🐚 platinum hermit
Result: blocked until real behavior proof from a real setup is added.

Overall follows the weaker of proof and patch quality, so missing proof can cap an otherwise strong patch.

Rank-up moves:

• [P1] Resolve the dirty merge state against current main and rerun focused agent tests plus required CI.
• [P1] Add redacted after-fix live gateway/session proof, runtime logs, or get an explicit maintainer proof waiver.

Proof guidance:

• [P1] Needs real behavior proof before merge: The PR has redacted before logs and focused local/Azure regression-test output, but the after-fix evidence is still test output rather than a live gateway/session replay or runtime log from the real contended requester path. After adding proof, update the PR body; ClawSweeper should re-review automatically. If it does not, the PR author or someone with repository write access can comment @clawsweeper re-review.

Mantis proof suggestion
A live transport transcript would materially help prove that stalled requester sessions still receive or can recover subagent final text after the core fix. A maintainer can ask Mantis to capture proof by posting this exact PR comment:

@openclaw-mantis telegram live proof: verify that subagent final text remains visible or recoverable after a requester session write-lock stall and suspended delivery expiry.

Risk before merge

• [P1] The branch is currently dirty/conflicting against main, and current main has newer session-lock retry/stale-handling and subagent lifecycle work that the merge result must reconcile.
• [P1] After-fix proof is focused local/Azure regression-test output rather than a live gateway/session replay or redacted runtime log from the contended requester path.
• [P1] The PR changes durable subagent completion/discard state, so a careless rebase could preserve stale or wrong child output in requester recovery state.
• [P1] Required checks currently have failures; the PR discussion says some may be unrelated, but landing still needs green checks or an explicit maintainer waiver.

Maintainer options:

1. Rebase and prove the requester path (recommended)
   Resolve the dirty merge state, rerun focused agent tests and required CI, then add redacted after-fix live gateway/session proof or an explicit maintainer waiver before merge.
2. Accept focused proof by waiver
   Maintainers can intentionally accept the Azure before/after regression proof for this private-session failure mode, but that waiver should be explicit because it substitutes for live behavior proof.
3. Split diagnostics if current main changed too much
   If current session-lock changes make the diagnostic half stale, keep a narrower durable-delivery repair and route lock diagnostics to the active lock cluster.

Next step before merge

• [P1] The protected maintainer label, dirty merge state, live-proof waiver choice, and overlapping session-lock work require maintainer handling rather than an automated repair lane.

Security
Cleared: No concrete security or supply-chain concern found; the diff is limited to core agent session-state logic and focused tests.

ClawSweeper PR egg

🎁 Pass real behavior proof to wake the egg and unlock a hatchable treat.

Thanks for the PR. Before this can move forward, please add live proof from the affected surface, not just unit tests, mocked tests, or source inspection.

A useful proof update should include:

• the exact build/SHA tested
• the real environment used
• the command, UI flow, channel flow, provider request, or other live path exercised
• before/after symptom evidence where applicable
• the observed result after the patch
• any remaining proof gaps

Please redact secrets, tokens, phone numbers, and private message content from logs or screenshots.

Maintainer prep update for f9c6fc7de291905233e7d5ca65201f6d299e00ab.

Evidence collected

• Azure Crabbox before proof: silver-prawn / cbx_e06ef86ae274, base c4bce00727ec5f6a5b9c78e0ad34524f5dc1db54, applied the PR regression tests to the base, observed BEFORE_FIX_TEST_EXIT=1 and BEFORE_FIX_EXPECTED_REGRESSION=1.
• Azure Crabbox after proof: violet-lobster / cbx_3eda7a42d715, head f9c6fc7de291905233e7d5ca65201f6d299e00ab, ran pnpm test src/agents/subagent-registry.test.ts src/agents/session-write-lock.test.ts, observed AFTER_FIX_TEST_EXIT=0 and AFTER_FIX_REGRESSION_PASSED=1.
• Local focused proof also passed via node scripts/run-vitest.mjs src/agents/subagent-registry.test.ts src/agents/session-write-lock.test.ts.
• Autoreview was clean: no accepted/actionable findings, overall patch-correct confidence 0.84.

Review result
No blocking code findings from maintainer review. I do not see a feature drop or regression in the PR itself: the change preserves durable suspended subagent fallback text before compacting expired payloads, and the lock timeout diagnostic expansion stays scoped to owner/liveness/starttime/staleness metadata.

Current blocker
CI was rerun at https://github.com/openclaw/openclaw/actions/runs/26407542199 and still has three failed jobs: check-prod-types, check-test-types, and check-additional-extension-package-boundary. The shared failure is an unrelated type error in extensions/qa-lab/src/live-transports/whatsapp/whatsapp-live.runtime.ts:872 where rttMeasurement.source is inferred as string instead of the literal "request-to-observed-message". This PR only touches src/agents/session-write-lock* and src/agents/subagent-registry*.

I would not call this fully land-ready while required CI is red. The PR-specific code/test evidence is clean; remaining decision is whether to fix/override the unrelated qa-lab CI blocker and whether the targeted Azure before/after proof is enough versus requiring a live gateway/session replay.

Cross-posting fresh Feishu production evidence because this thread is related. Context for this thread: Open PR touching subagent delivery after lock stalls; adding production evidence for validation.

Additional production evidence from Feishu DM lane (2026-06-26)

I'm adding fresh production evidence from a Feishu direct-message session on OpenClaw 2026.6.10.

Environment

• OpenClaw app: 2026.6.10
• OS: Linux 7.0.0-22-generic x64
• Node: 24.17.0
• Channel: Feishu DM / p2p
• Session model override: kuaipao-gpt/gpt-5.5
• Workload pattern: serial sessions_spawn child runs for paper-reading tasks, with completion announcements back to the Feishu requester session
• Session state at the time: ~540 active sessions; Feishu requester session around 70k/268k context; multiple recent spawn-child sessions

Summary

The Feishu lane repeatedly became unable to reliably receive normal user messages or subagent completion announcements while a long-running/compacting requester session was active. The failures were not isolated to one child run; they formed a cascade:

1. Feishu DM dispatch enters an active/queued state.
2. Child/subagent completion tries to announce back to the requester session.
3. The requester session is busy or its prompt lock is released/reacquired during compaction/model work.
4. Delivery fails via either SessionWriteLockTimeoutError, EmbeddedAttemptSessionTakeoverError, or gateway request timeout.
5. Subagent completion retries eventually give up, so the user sees the workflow as "stalled" even though child output may already be written to disk.
6. Feishu per-chat queue eventually hits the 300000ms cap and evicts work so later same-key messages can proceed.

Counts from today's Feishu-related gateway logs

From journalctl --user -u openclaw-gateway --since '2026-06-26 00:00:00', filtered for Feishu/session-lock/subagent/compaction terms:

• SessionWriteLockTimeoutError: 12
• Embedded agent failed before reply: 12
• EmbeddedAttemptSessionTakeoverError: 13
• Subagent completion direct announce failed: 38
• Subagent announce give up: 8
• Active requester session could not be woken: 24
• Compaction timed out: 12
• Full summarization failed: 9
• per-chat task exceeded 300000ms cap: 5
• lane wait exceeded: 45
• long-running session: 2

Some early entries are provider/rate-limit failures, but the afternoon cluster below is specifically session lock / takeover / completion delivery related.

Representative timeline excerpt, redacted

2026-06-26T13:48:30+08:00 [diagnostic] lane task error: lane=main durationMs=60167 error="SessionWriteLockTimeoutError: session file locked (timeout 60000ms): pid=<gateway-pid> alive=true ageMs=124708 <session>.jsonl.lock"
2026-06-26T13:48:30+08:00 [diagnostic] lane task error: lane=session:agent:main:feishu:direct:<open-id> durationMs=60169 error="SessionWriteLockTimeoutError: session file locked (timeout 60000ms): pid=<gateway-pid> alive=true ageMs=124708 <session>.jsonl.lock"
2026-06-26T13:48:30+08:00 Embedded agent failed before reply: session file locked (timeout 60000ms): pid=<gateway-pid> alive=true ageMs=124708 <session>.jsonl.lock
2026-06-26T13:49:22+08:00 [agents/cli-compaction] CLI transcript compaction failed for kuaipao-gpt/gpt-5.5: Compaction timed out
2026-06-26T13:51:18+08:00 [diagnostic] lane task error: lane=main durationMs=168013 error="EmbeddedAttemptSessionTakeoverError: session file changed while embedded prompt lock was released: <session>.jsonl"
2026-06-26T13:52:04+08:00 [warn] Subagent completion direct announce failed for run <run-id>: gateway request timeout for agent
2026-06-26T13:52:06+08:00 [warn] Subagent completion direct announce failed for run <run-id>: EmbeddedAttemptSessionTakeoverError: session file changed while embedded prompt lock was released: <session>.jsonl
2026-06-26T13:52:08+08:00 [warn] Subagent announce give up (retry-limit) run=<run-id> child=agent:main:subagent:<child-id> requester=agent:main:feishu:direct:<open-id> retries=3 endedAgo=245s deliveryError="EmbeddedAttemptSessionTakeoverError..."

2026-06-26T14:15:04+08:00 [diagnostic] lane task error: lane=main durationMs=60138 error="SessionWriteLockTimeoutError: session file locked (timeout 60000ms): pid=<gateway-pid> alive=true ageMs=86720 <session>.jsonl.lock"
2026-06-26T14:16:19+08:00 [diagnostic] lane task error: lane=main durationMs=60139 error="SessionWriteLockTimeoutError: session file locked (timeout 60000ms): pid=<gateway-pid> alive=true ageMs=161689 <session>.jsonl.lock"
2026-06-26T14:16:34+08:00 [agents/cli-compaction] CLI transcript compaction failed for kuaipao-gpt/gpt-5.5: Compaction timed out
2026-06-26T14:21:02+08:00 [agents/cli-compaction] CLI transcript compaction failed for kuaipao-gpt/gpt-5.5: Compaction timed out

2026-06-26T14:32:44+08:00 [diagnostic] lane task error: lane=main durationMs=60146 error="SessionWriteLockTimeoutError: session file locked (timeout 60000ms): pid=<gateway-pid> alive=true ageMs=122137 <session>.jsonl.lock"
2026-06-26T14:33:28+08:00 [agents/cli-compaction] CLI transcript compaction failed for kuaipao-gpt/gpt-5.5: Compaction timed out
2026-06-26T14:35:16+08:00 [diagnostic] lane task error: lane=main durationMs=127727 error="EmbeddedAttemptSessionTakeoverError: session file changed while embedded prompt lock was released: <session>.jsonl"
2026-06-26T14:37:08+08:00 [warn] Subagent completion direct announce failed for run <run-id>: gateway request timeout for agent
2026-06-26T14:37:12+08:00 [warn] Subagent announce give up (retry-limit) run=<run-id> child=agent:main:subagent:<child-id> requester=agent:main:feishu:direct:<open-id> retries=3 endedAgo=246s deliveryError="EmbeddedAttemptSessionTakeoverError..."

2026-06-26T14:43:34+08:00 [diagnostic] lane task error: lane=main durationMs=60197 error="SessionWriteLockTimeoutError: session file locked (timeout 60000ms): pid=<gateway-pid> alive=true ageMs=125037 <session>.jsonl.lock"
2026-06-26T14:44:26+08:00 [agents/cli-compaction] CLI transcript compaction failed for kuaipao-gpt/gpt-5.5: Compaction timed out
2026-06-26T14:46:19+08:00 [diagnostic] lane task error: lane=main durationMs=111864 error="EmbeddedAttemptSessionTakeoverError: session file changed while embedded prompt lock was released: <session>.jsonl"
2026-06-26T14:46:21+08:00 [warn] Active requester session could not be woken for subagent completion; falling back to requester-agent handoff: active requester session could not be woken: queue_message_failed reason=source_reply_delivery_mode_mismatch sessionId=<session-id> gatewayHealth=live
2026-06-26T14:51:55+08:00 [diagnostic] long-running session: sessionId=<session-id> sessionKey=agent:main:feishu:direct:<open-id> state=processing age=130s queueDepth=1 reason=queued_behind_active_work classification=long_running activeWorkKind=model_call lastProgress=model_call:started lastProgressAge=67s recovery=none
2026-06-26T14:54:43+08:00 [feishu] feishu[default]: per-chat task exceeded 300000ms cap (key=feishu:default:<chat-id>); evicting from queue so later same-key messages can proceed (#70133)

Lock file state observed during the incident

The active Feishu requester session lock was owned by the live Gateway process, not an orphaned PID:

{
  "pid": <gateway-pid>,
  "createdAt": "2026-06-26T06:52:28.443Z",
  "maxHoldMs": 300000,
  "starttime": 131306136
}

The important mismatch remained: callers were failing after timeout 60000ms while the live lock could remain valid much longer (maxHoldMs: 300000 in this release; previously observed as 1020000 in older releases).

User-visible impact

The workflow was a serial paper-reading chain (P01..P20) where each child writes a note file and the parent should announce completion and spawn the next child. During the incident:

• note files were written successfully through at least read_p11.md, so some child work completed;
• the Feishu requester session still missed or delayed completion events;
• several child completion announcements retried and gave up;
• the human saw the workflow as stalled and had to repeatedly send manual nudges such as "child agent stopped again" / "why can't it continue automatically";
• progress tracking lagged behind actual child output because the completion-to-parent handoff was unreliable.

Why this seems relevant here

This looks like the same family as the session write-lock / long-turn / subagent delivery lane issues, but today's evidence adds two details:

1. On 2026.6.10, the lock maxHoldMs is now 300000, yet callers still fail at 60000ms, so the timeout mismatch still creates user-visible failures.
2. Compaction timeouts and EmbeddedAttemptSessionTakeoverError appear to amplify the problem: once the requester session is busy/compacting, subagent completion delivery can fail repeatedly and eventually give up even though the child output exists.

If useful, I can provide a fuller redacted log bundle, but I avoided pasting full paths, Feishu IDs, or local project contents here.

Linking #96975 as related design context for this PR: preserving subagent delivery after lock stalls would be more robust if completion delivery is metadata-only by default rather than carrying large child payloads.