fix(agent): make stuck recovery phase-safe by mushuiyu886 · Pull Request #93655 · openclaw/openclaw

mushuiyu886 · 2026-06-16T14:09:16Z

What Problem This Solves

Fixes an issue where users with configured model fallbacks could still receive an aborted reply when the diagnostic watchdog recovered a stuck model call. Recovery also needs to preserve the safety boundary that keeps potentially side-effecting tools and unknown phases out of automatic replay, while keeping queued turns serialized behind the recovering reply.

Why This Change Was Made

Diagnostic recovery now distinguishes cancelling the currently attached embedded attempt from cancelling the whole reply. Previously the shared caller signal was already aborted before runWithModelFallback() could start its next candidate. A running embedded backend now receives stuck_recovery exactly once while the reply caller signal stays live; when the attempt drains, the next fallback backend can attach to the same operation. The watchdog also re-checks combined embedded/reply ownership before resetting the session command lane, so queued turns cannot run concurrently with fallback. Active model calls become idle timeouts, potentially side-effecting tool calls remain tool-execution timeouts, compaction stalls remain compaction timeouts, and unknown phases remain external aborts.

The recovery window is bounded and does not weaken real cancellation. User and restart aborts still terminate the whole reply, queued/non-embedded recovery remains terminal, and a backend owner that does not drain within the diagnostic 15-second settle window is force-cleared after the whole reply is terminated; the registry terminal-settle timer remains a longer backstop.

This is the downstream generic recovery fix for the core in-tree embedded attempt path, independent of whichever provider or transport caused progress to stall. Alternate plugin-owned agent harnesses, including Codex and Copilot, retain their owner-specific cancellation semantics and are outside this PR. It does not change provider contracts, model routing, fallback selection policy, public configuration, schemas, persistence, channels, or ordinary no_activity expiry behavior.

User Impact

Stuck sessions can recover without losing the safety distinction between model work and tool work:

active model calls can enter the existing idle-timeout retry/fallback path;
active potentially side-effecting tools remain non-replayable;
compaction stalls remain non-replayable and cannot enter model fallback;
successful model fallback completes the original reply instead of inheriting an already-aborted caller signal;
queued turns remain behind the active reply until fallback completes;
real user/restart cancellation still stops the entire fallback chain;
one recovery cancellation owner prevents duplicate abort delivery, with bounded cleanup if the owner hangs.

Evidence

The evidence below covers the production-module behavior proof, focused regression suites, and static verification.

Current-head refresh

Merged current main at 71c5005d2c57988b045b2c6671489f75d3a35dc8 without rewriting the PR history.
Resolved the run-state.ts conflict by retaining main's supportsQueueMessageImages capability and this PR's typed stuck_recovery abort semantics.
Moved the stuck-recovery abort-propagation case into a focused test file after the current-main max-lines check flagged the monolithic registry suite; the assertion coverage is unchanged.
Preserved the PR behavior across main's tool-tracker cleanup and test-support refactors.
Added compaction-stall classification coverage so model calls owned by compaction remain outside retry/fallback.
git diff --check, final diff review, and the daily-fix pre-submit guard passed locally. Repository trust policy prevents executing fork test scripts locally; exact-head CI will run after this branch update.

Real behavior proof

Behavior or issue addressed: A reply-owned active model attempt recovered by the diagnostic watchdog must receive one stuck_recovery cancellation, drain successfully, keep the whole-reply caller signal and session command lane live, and start the next configured fallback candidate; a queued turn must wait until fallback completes, while tool and unknown phases remain non-replayable.

Real environment tested: Linux with supported Node 24.15.0. The production-module probe ran on hosted behavior head 24f776d6f7e1263b3bf3166deb26a2ea66ce3a89; the final CI-only tail was validated on committed HEAD e580471dd073ba3b7744fc00272cc351c9d2e9ea. The probe loaded the production diagnostic recovery, embedded-run registry, reply registry, attempt abort classifier, and model fallback modules; the embedded backend handle and active phase ports were controlled in-process fixtures.

Exact steps or command run for the behavior patch: Ran node --import tsx canonical-reply-owned-stuck-recovery-probe.mjs on hosted head 24f776d. The probe registers a reply-owned active embedded model attempt inside a real session command lane, queues a second turn behind it, invokes the production diagnostic watchdog, routes its timeout result through the production model fallback loop, and records lane ownership before the configured fallback succeeds. The final e580471d tail only removes two unused type exports, applies two const lint fixes in the integration fixture, and gives the existing setImmediate promise executor a block body; the logging owner-config runtime/integration files were rerun on that final tail (2 files, 33 tests passed).

Evidence after fix:

[diagnostic] reply run stale recovery: cancelled active attempt reason=stuck_recovery phase=running
[diagnostic] stuck session recovery outcome: status=aborted aborted=true drained=true forceCleared=false released=0 queuedCount=1
[model-fallback/decision] candidate_failed candidate=probe/primary reason=timeout next=probe/fallback
[model-fallback/decision] candidate_succeeded candidate=probe/fallback
replyDuringRecovery=result:null signalAborted:false active:true
laneBeforeRecovery=active:1 queued:1 generation:0
laneDuringFallback=active:1 queued:1 generation:0
laneEvents=["fallback-started","fallback-completed","queued-turn-started"]
queuedStartedBeforeFallbackCompleted=false
attemptedCandidates=["probe/primary","probe/fallback"]
fallbackOutcome=completed fallbackResult="fallback ok"
finalReplyResult=completed
backendCancelReasons=["stuck_recovery"]
directHandleAbortReasons=[]
activeModelCall=model_idle_timeout
activePotentialSideEffectTool=tool_execution_timeout
unknownPhase=external_abort

Observed result after fix: Recovery returned aborted=true, drained=true, forceCleared=false, and released=0. During recovery the reply remained active with result=null and an un-aborted caller signal. The command lane stayed at one active reply plus one queued turn throughout fallback, and the queued turn started only after fallback-completed. The production fallback loop attempted the primary and fallback candidates, completed with fallback ok, and the original reply completed normally. The first and only backend cancellation was stuck_recovery; model, side-effecting-tool, and unknown phases classified as model_idle_timeout, tool_execution_timeout, and external_abort.

What was not tested: No live OpenCode/provider stream, external channel delivery, real model stream, or real tool invocation was exercised. The continuous recovery-to-fallback path used production modules with controlled model candidates, backend handle, and phase ports. This patch does not change or claim a provider/channel boundary.

Regression and static verification

Embedded attempt/run coverage: 4 files, 79 tests passed.
Model fallback coverage: 129 tests passed, including recovery handoff and user cancellation after fallback starts.
Stuck-recovery classifier: 4 tests passed.
Tool lifecycle and side-effect counter coverage: 123 tests passed.
Reply-run registry: 54 tests passed.
Diagnostic recovery runtime and real-lane integration coverage: 33 tests passed.
Core production and core test tsgo checks passed.
Formatting passed for the 4 files changed by the final CI-only tail; the prior behavior head had already passed formatting across all 25 affected files.
git diff --check passed against the synchronized base.
Final-head CI round 2 equivalents passed for targeted oxlint and deadcode unused-export checks (Knip baseline matched all 626 entries).

Risk boundary

The behavior change is restricted to cancellation reason propagation, reply ownership, and command-lane release after diagnostic recovery has already decided a running embedded attempt is stale. Ordinary stale expiry continues to use superseded; CLI/non-embedded recovery remains terminal; user/restart cancellation still terminates the whole reply; public configuration, provider contracts, schemas, persistence, and fallback selection policy are unchanged.

clawsweeper · 2026-06-16T14:30:53Z

Codex review: needs maintainer review before merge. Reviewed July 16, 2026, 11:45 PM ET / July 17, 2026, 03:45 UTC.

Summary
Propagates a typed stuck-recovery cancellation through embedded attempts and reply operations, classifies replay safety by execution phase, and retains command-lane ownership while a safe model fallback completes.

PR surface: Source +227, Tests +804. Total +1031 across 26 files.

Reproducibility: yes. at source level. Current main accepts reason: "stuck_recovery" at the diagnostic layer but does not forward it through abortEmbeddedAgentRun, and the canonical issue provides deterministic registry and terminal-settle reproduction steps; this review did not independently execute them. (github.com)

Review metrics: none identified.

Root-cause cluster
Relationship: fixed_by_candidate
Canonical: #103697
Summary: This PR is the direct candidate fix for the canonical generic phase-safe stuck-recovery issue; the stalled-interruption PR and provider-specific stream fixes address adjacent, distinct failure boundaries.

Members:

canonical: [Bug]: Generic stuck-session recovery loses phase-safe abort semantics #103697 - It defines the exact typed-reason, phase-classification, reply-abortability, and terminal-settlement contract implemented by this PR.
adjacent_distinct: fix: surface stalled-session interruptions #103990 - It surfaces stalled interruptions and stops waiting on non-cooperative tools, but does not implement phase-safe model fallback ownership.
adjacent_distinct: fix(opencode-go): streaming completes when provider ends responses #93965 - It fixed an opencode-go provider-stream stall at the provider boundary, while this PR handles provider-agnostic downstream diagnostic recovery.

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

Merge readiness
Overall: 🦞 diamond lobster
Proof: 🦞 diamond lobster
Patch quality: 🦞 diamond lobster
Result: ready for maintainer review.

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

Risk before merge

[P2] A phase-detection regression could either replay a potentially side-effecting tool or deny fallback to a safely replayable model call.
[P1] Reply-operation, embedded-run, and command-lane ownership must remain synchronized; a mistake could start queued work concurrently or retain stale registry state.
[P1] The PR head is cleanly mergeable but behind current main, and these central recovery files are active areas, so the actual refreshed merge result still needs exact-head review.

Maintainer options:

Refresh and verify the merged lifecycle (recommended)
Refresh the branch onto current main and re-review fallback ownership, queued-lane serialization, and bounded cleanup on the exact head before merge.
Retain terminal-only recovery
Pause or close the PR if maintainers do not want diagnostic model-call recovery to start another fallback candidate on the same reply.

Next step before merge

No automated repair is indicated; refresh the branch and have the recovery-policy owner review the exact merged session-ownership and availability lifecycle before landing.

Maintainer decision needed

Question: After refreshing this branch onto current main, should OpenClaw adopt phase-safe fallback for watchdog-recovered model calls while keeping side-effecting tools, compaction, and unknown phases terminal?
Rationale: The implementation follows the requested design and has no identified correctness defect, but it deliberately changes core cancellation, retry, reply ownership, and forced-cleanup behavior that requires human acceptance.
Likely owner: vincentkoc — They supplied the controlling phase-safety review requirement and are the clearest owner for accepting the resulting lifecycle tradeoff.
Options:
- Refresh and land phase-safe recovery (recommended): Refresh onto current main, recheck the exact merged lifecycle and gates, then merge if ownership and replay-safety coverage remains green.
- Keep all watchdog recovery terminal: Decline automatic fallback after diagnostic recovery and narrow or close the PR if maintainers prefer every stuck recovery to terminate the reply.

Security
Cleared: No dependency, workflow, secret, permission, publishing, or supply-chain change is present; the patch strengthens the tool side-effect replay boundary rather than weakening it.

Review details

Best possible solution:

Land one canonical generic recovery path that preserves stuck_recovery, classifies replay eligibility at the active attempt, keeps tool/compaction/unknown phases terminal, and holds reply/lane ownership until fallback or bounded cleanup finishes.

Do we have a high-confidence way to reproduce the issue?

Yes, at source level. Current main accepts reason: "stuck_recovery" at the diagnostic layer but does not forward it through abortEmbeddedAgentRun, and the canonical issue provides deterministic registry and terminal-settle reproduction steps; this review did not independently execute them. (github.com)

Is this the best way to solve the issue?

Yes. Classifying at the active attempt is the narrowest maintainable fix because it preserves the existing fallback policy while keeping side-effecting tools, compaction, and unknown phases outside automatic replay; provider-specific stream work does not solve this generic downstream path.

AGENTS.md: found and applied where relevant.

Codex review notes: model internal, reasoning high; reviewed against 225638788572.

Label changes

Label justifications:

P1: The bug can turn a recoverable stuck model call into an aborted reply despite configured fallback, affecting active agent workflows.
merge-risk: 🚨 session-state: The patch changes reply-operation ownership, embedded-run attachment, terminal settlement, and queued command-lane release.
merge-risk: 🚨 availability: The patch changes watchdog cancellation, fallback continuation, drain timeouts, and forced cleanup for stuck runs.
rating: 🦞 diamond lobster: Overall readiness is 🦞 diamond lobster; proof is 🦞 diamond lobster and patch quality is 🦞 diamond lobster.
status: 👀 ready for maintainer look: ClawSweeper has no concrete contributor-facing blocker left for this PR. Sufficient (live_output): The supplied Linux Node 24 production-module probe demonstrates the improved recovery-to-fallback lifecycle, distinct phase classifications, single cancellation delivery, and queued-lane ordering; tests and CI supplement that proof.
proof: sufficient: Contributor real behavior proof is sufficient. The supplied Linux Node 24 production-module probe demonstrates the improved recovery-to-fallback lifecycle, distinct phase classifications, single cancellation delivery, and queued-lane ordering; tests and CI supplement that proof.

Evidence reviewed

PR surface:

Source +227, Tests +804. Total +1031 across 26 files.

View PR surface stats

Area	Files	Added	Removed	Net
Source	13	278	51	+227
Tests	13	866	62	+804
Docs	0	0	0	0
Config	0	0	0	0
Generated	0	0	0	0
Other	0	0	0	0
Total	26	1144	113	+1031

What I checked:

Current-main behavior remains unfixed: Current main's abort-and-drain path accepts a diagnostic reason but still invokes abortEmbeddedAgentRun(sessionId) without forwarding it, so the canonical problem remains necessary. (github.com) (src/agents/embedded-agent-runner/runs.ts, 225638788572)
Canonical issue contract: The linked canonical issue requires typed stuck_recovery propagation, model/tool/unknown-phase classification, existing reply abortability, bounded terminal settlement, and focused regression coverage; the PR addresses that exact contract. (github.com)
Replay-safe phase classifier: The branch adds an explicit four-way classifier: side-effecting tool timeout takes precedence, compaction stays non-replayable, an active model call may use idle-timeout fallback, and unknown phases remain external aborts. (src/agents/embedded-agent-runner/run/stuck-recovery-abort.ts:8, 8c5ed1a5a9bf)
Reply ownership and cleanup: The branch adds a dedicated reply-operation stuck-recovery path with backend ownership tracking and terminal-settle cleanup instead of aborting the whole caller signal immediately. (src/auto-reply/reply/reply-run-registry.ts:551, 8c5ed1a5a9bf)
Command-lane serialization: Diagnostic recovery rechecks combined embedded/reply ownership before resetting the session lane, preserving queued-turn serialization while fallback owns the reply. (src/logging/diagnostic-stuck-session-recovery.runtime.ts:158, 8c5ed1a5a9bf)
Regression and behavior proof: The PR supplies production-module output showing one stuck_recovery cancellation, an un-aborted reply caller signal, fallback completion before the queued turn starts, and distinct model/tool/unknown classifications; exact-head CI includes successful agent-runtime, session-diagnostics, security, build, lint, type, and real-behavior-proof gates. (src/logging/diagnostic-stuck-session-recovery.integration.test.ts:321, 8c5ed1a5a9bf)

Likely related people:

vincentkoc: Assigned the PR and established the decisive replay-safety requirement that the revised implementation follows; this makes them the strongest routing candidate for final lifecycle acceptance. (role: reviewer and likely follow-up owner; confidence: high; files: src/agents/embedded-agent-runner/run/attempt-abort.ts, src/auto-reply/reply/reply-run-registry.ts, src/logging/diagnostic-stuck-session-recovery.runtime.ts)
steipete: Authored the earlier experimental stuck-session abort work spanning diagnostic recovery and active-run cleanup, providing relevant history for the recovery policy and ownership boundary. (role: adjacent recovery design contributor; confidence: medium; commits: de4e1940fd38; files: src/logging/diagnostic-stuck-session-recovery.runtime.ts, src/agents/embedded-agent-runner/runs.ts)

What the crustacean ranks mean

🦀 challenger crab: rare, exceptional readiness with strong proof, clean implementation, and convincing validation.
🦞 diamond lobster: very strong readiness with only minor maintainer review expected.
🐚 platinum hermit: good normal PR, likely mergeable with ordinary maintainer review.
🦐 gold shrimp: useful signal, but proof or patch confidence is still limited.
🦪 silver shellfish: thin signal; proof, validation, or implementation needs work.
🧂 unranked krab: not merge-ready because proof is missing/unusable or there are serious correctness or safety concerns.
🌊 off-meta tidepool: rating does not apply to this item.

Shiny media proof means a screenshot, video, or linked artifact directly shows the changed behavior. Runtime, network, CSP, and security claims still need visible diagnostics.

How this review workflow works

ClawSweeper keeps one durable marker-backed review comment per issue or PR.
Re-runs edit this comment so the latest verdict, findings, and automation markers stay together instead of adding duplicate bot comments.
A fresh review can be triggered by eligible @clawsweeper re-review comments, exact-item GitHub events, scheduled/background review runs, or manual workflow dispatch.
PR/issue authors and users with repository write access can comment @clawsweeper re-review or @clawsweeper re-run on an open PR or issue to request a fresh review only.
Maintainers can also comment @clawsweeper review to request a fresh review only.
Fresh-review commands do not start repair, autofix, rebase, CI repair, or automerge.
Maintainer-only repair and merge flows require explicit commands such as @clawsweeper autofix, @clawsweeper automerge, @clawsweeper fix ci, or @clawsweeper address review.
Maintainers can comment @clawsweeper explain to ask for more context, or @clawsweeper stop to stop active automation.

Review history (19 earlier review cycles; latest 8 shown)

reviewed 2026-07-12T05:46:27.257Z sha 2148a4c :: needs maintainer review before merge. :: none
reviewed 2026-07-12T06:51:13.189Z sha 81dcd1d :: needs changes before merge. :: [P3] Format the changed attempt runner
reviewed 2026-07-12T07:34:48.920Z sha 664cdd7 :: needs maintainer review before merge. :: none
reviewed 2026-07-12T08:56:07.933Z sha ea6a80a :: needs maintainer review before merge. :: none
reviewed 2026-07-12T10:00:01.969Z sha 9df68ab :: needs maintainer review before merge. :: none
reviewed 2026-07-16T02:18:26.735Z sha aa85888 :: needs maintainer review before merge. :: none
reviewed 2026-07-16T08:23:23.909Z sha 3c818f5 :: needs maintainer review before merge. :: none
reviewed 2026-07-17T03:04:41.039Z sha 8c5ed1a :: needs maintainer review before merge. :: none

ForceConstant · 2026-06-16T15:26:43Z

@clawsweeper re-run

vincentkoc · 2026-06-16T15:46:17Z

Holding this one rather than landing it as-is. Mapping every stuck-run recovery to an idle timeout loses the distinction between a stalled model call and a stalled tool call, and retrying the latter can replay side effects.

The best fix must classify the stuck phase first and only retry states whose replay semantics are safe, with regression proof for model-call and side-effecting tool-call stalls.

mushuiyu886 · 2026-06-16T17:07:08Z

Updated this PR to address the replay-safety concern.

What changed:

stuck_recovery is no longer mapped directly to an idle timeout.
The active attempt now classifies the recovery phase first:
- model call started + no active potential-side-effect tool execution => model idle timeout, so the existing rotate/fallback path remains available;
- active potential-side-effect tool execution => tool-execution timeout, so it stays out of automatic retry/fallback and avoids replaying side effects;
- pre-model/unknown recovery => external-abort-like path, not a replay path.
The tool execution tracker now records whether an active tool call is a potential side effect using the existing replay-safety summary.
Both diagnostic stuck-session recovery paths preserve abortReason: "stuck_recovery" before the attempt-local classification runs.

Regression proof added/updated:

stuck-recovery-abort.test.ts covers model-call, side-effecting tool-call, and pre-model classifications.
embedded-agent-subscribe.handlers.tools.test.ts covers active side-effecting vs replay-safe tool counters.
diagnostic-stuck-session-recovery.runtime.test.ts covers both recovery paths preserving stuck_recovery.
Existing failover-policy.test.ts continues to prove idle timeouts can fallback while tool-execution timeouts do not.

Fresh local verification on the current PR head 74eb3d5564772110a7d59c2a2151f7ad9086333e:

targeted Vitest shards: 125 tests passed;
pnpm tsgo:core passed;
pnpm tsgo:test:src passed;
git diff --check HEAD~1..HEAD produced no output.

I did not run a live opencode-go/deepseek-v4-flash stream or live cron job; the PR body now calls out that boundary explicitly.

mushuiyu886 · 2026-06-16T17:09:26Z

@vincentkoc I updated this PR to address your replay-safety feedback. stuck_recovery now classifies the active phase before setting abort semantics: model-call stalls can use the existing idle-timeout fallback path, active potential-side-effect tool stalls become tool-execution timeouts and stay out of retry/fallback, and pre-model/unknown recovery remains external-abort-like. The PR body includes the current-head verification and the live opencode-go proof boundary.

mushuiyu886 · 2026-07-10T14:47:01Z

@clawsweeper re-review

clawsweeper · 2026-07-10T14:47:04Z

🦞🧹
ClawSweeper re-review requested.

I asked ClawSweeper to review this item again.
Action: item re-review queued (workflow sweep.yml, event repository_dispatch).
Result: the existing ClawSweeper review comment will be edited in place when the review finishes.

Re-review progress:

State: Complete
Detail: The targeted re-review finished, the durable review comment was updated, and the synced verdict was routed.
Run: https://github.com/openclaw/clawsweeper/actions/runs/29101861784
Updated: 2026-07-10T15:08:07.773Z

mushuiyu886 · 2026-07-11T02:59:21Z

@clawsweeper re-review

clawsweeper · 2026-07-11T02:59:24Z

🦞🧹
ClawSweeper re-review requested.

I asked ClawSweeper to review this item again.
Action: item re-review queued (workflow sweep.yml, event repository_dispatch).
Result: the existing ClawSweeper review comment will be edited in place when the review finishes.

Re-review progress:

State: Complete
Detail: The targeted re-review published an exact durable review comment and queued an executing target-wide serialized router scan.
Run: https://github.com/openclaw/clawsweeper/actions/runs/29137551978
Updated: 2026-07-11T03:17:37.573Z

openclaw-barnacle · 2026-07-14T04:31:19Z

This assigned pull request has been automatically marked as stale after being open for 27 days.
Please add updates or it will be closed.

…borts

openclaw-barnacle · 2026-07-15T04:30:03Z

This assigned pull request has been automatically marked as stale after being open for 27 days.
Please add updates or it will be closed.

openclaw-barnacle · 2026-07-17T04:35:09Z

This assigned pull request has been automatically marked as stale after being open for 27 days.
Please add updates or it will be closed.

openclaw-barnacle Bot added agents Agent runtime and tooling proof: supplied External PR includes structured after-fix real behavior proof. size: S labels Jun 16, 2026

vincentkoc self-assigned this Jun 16, 2026

openclaw-barnacle Bot added size: M and removed size: S labels Jun 16, 2026

zhangguiping-xydt mentioned this pull request Jun 17, 2026

fix(opencode-go): streaming completes when provider ends responses #93965

Merged

This was referenced Jun 19, 2026

fix(agents): surface user-visible error when embedded session is stuck or overflows context (#84536) #84602

Closed

fix: add stream stall guard for lost stream termination signal (opencode-go) #93640

Closed

mushuiyu886 force-pushed the fix/issue-93610-stuck-recovery-failover branch from 74eb3d5 to 5d36d5c Compare June 20, 2026 02:20

clawsweeper Bot added rating: 🦐 gold shrimp Decent PR readiness signal, but merge confidence is limited. and removed rating: 🐚 platinum hermit Good normal PR readiness with ordinary maintainer review expected. labels Jun 21, 2026

joshavant mentioned this pull request Jul 14, 2026

fix: surface stalled-session interruptions #103990

Closed

mushuiyu886 added 15 commits July 14, 2026 23:56

fix(agent): classify stuck recovery as idle timeout

15dea03

fix(agent): make stuck recovery phase-safe

1b49b64

fix(agent): use active model calls for stuck recovery

c8a46e0

fix(testing): satisfy openai tools cancellation lint

dcf995d

fix(agent): preserve stuck recovery through reply-run fallback

af445d2

fix(agent): preserve reply-run abortability for stuck recovery

8ba1142

fix(test): preserve OpenAI chat tools timeout errors

a57f6ff

fix(test): align direct runtime reply operation mock

37c8a99

test: restore unrelated mainline fixtures

9ffabf4

fix(reply-run): schedule terminal settle for running stuck-recovery a…

1cdd27f

…borts

fix(agent): preserve stuck recovery on reply expiry

73fc111

fix(agent): preserve phase-safe stuck recovery

0497566

fix(agent): preserve phase-safe stuck recovery

df9c648

fix(agent): keep fallback reply lane owned

24f776d

fix(ci): satisfy lint and deadcode checks

e580471

mushuiyu886 added 7 commits July 15, 2026 13:17

Merge branch 'main' into fix/issue-93610-stuck-recovery-failover

aa85888

Merge upstream/main into fix/issue-93610-stuck-recovery-failover

e0b9f1a

fix(agent): keep compaction recovery out of fallback

df32619

fix(agent): expose compaction timeout state to stream recovery

3f5e420

style(agent): format stuck recovery timeout ports

3c818f5

Merge upstream/main into fix/issue-93610-stuck-recovery-failover

9c3a131

test(agent): split stuck recovery registry coverage

8c5ed1a

Uh oh!

Uh oh!

Conversation

mushuiyu886 commented Jun 16, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

What Problem This Solves

Why This Change Was Made

User Impact

Evidence

Current-head refresh

Real behavior proof

Regression and static verification

Risk boundary

Uh oh!

clawsweeper Bot commented Jun 16, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

ForceConstant commented Jun 16, 2026

Uh oh!

vincentkoc commented Jun 16, 2026

Uh oh!

mushuiyu886 commented Jun 16, 2026

Uh oh!

mushuiyu886 commented Jun 16, 2026

Uh oh!

mushuiyu886 commented Jul 10, 2026

Uh oh!

clawsweeper Bot commented Jul 10, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

mushuiyu886 commented Jul 11, 2026

Uh oh!

clawsweeper Bot commented Jul 11, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

openclaw-barnacle Bot commented Jul 14, 2026

Uh oh!

openclaw-barnacle Bot commented Jul 15, 2026

Uh oh!

openclaw-barnacle Bot commented Jul 17, 2026

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

4 participants

mushuiyu886 commented Jun 16, 2026 •

edited

Loading

clawsweeper Bot commented Jun 16, 2026 •

edited

Loading

clawsweeper Bot commented Jul 10, 2026 •

edited

Loading

clawsweeper Bot commented Jul 11, 2026 •

edited

Loading