Skip to content

fix(agents): truncate tool results before overflow compaction#81190

Open
LLagoon3 wants to merge 2 commits into
openclaw:mainfrom
LLagoon3:fix/overflow-tool-result-truncation-first
Open

fix(agents): truncate tool results before overflow compaction#81190
LLagoon3 wants to merge 2 commits into
openclaw:mainfrom
LLagoon3:fix/overflow-tool-result-truncation-first

Conversation

@LLagoon3

@LLagoon3 LLagoon3 commented May 12, 2026 •
edited
Loading

Copy link
Copy Markdown
Contributor

Summary

  • Problem: tool-heavy context overflows could wait for the full LLM auto-compaction timeout before trying the existing deterministic tool-result truncation recovery.
  • Why it matters: small follow-up turns in long-lived Telegram sessions can appear hung for minutes even when tool-result truncation would be enough to recover.
  • What changed: when an overflow attempt has oversized/aggregate tool-result pressure and no preflight recovery route is active, the run loop tries tool-result truncation before explicit overflow compaction; if truncation does not help, it falls back to the existing compaction path.
  • What did NOT change (scope boundary): no config knobs, no compaction timeout changes, no changes to preflight/mid-turn recovery semantics.

AI-assisted: yes — implemented with an AI coding assistant and manually reviewed/verified locally.

Change Type (select all)

  • Bug fix
  • Feature
  • Refactor required for the fix
  • Docs
  • Security hardening
  • Chore/infra

Scope (select all touched areas)

  • Gateway / orchestration
  • Skills / tool execution
  • Auth / tokens
  • Memory / storage
  • Integrations
  • API / contracts
  • UI / DX
  • CI/CD / infra

Linked Issue/PR

Real behavior proof (required for external PRs)

  • Behavior or issue addressed: overflow recovery in a tool-heavy Telegram direct session waited for auto-compaction to time out before truncating 281 tool results.
  • Real environment tested: Docker-isolated OpenClaw runtime built from this PR checkout (OpenClaw 2026.5.12-beta.1 (7ec0b4b)) plus the original live OpenClaw Telegram direct-session before log, with private identifiers redacted in Overflow recovery should truncate tool results before waiting full auto-compaction timeout #81182. The Docker proof used a temporary OPENCLAW_HOME=/tmp/openclaw-proof-home, synthetic tool-result payloads only, and no production Telegram token, host gateway, or user data.
  • Exact steps or command run after this patch:

    • Built the package-installed Docker runtime image from this PR checkout with the repo's existing Docker E2E package pipeline.

    • Ran a Docker-isolated runtime proof harness against the packaged /app OpenClaw runtime. The harness creates a temporary transcript with an oversized tool result, runs the same sessionLikelyHasOversizedToolResults(...) + truncateOversizedToolResultsInSession(...) path used by the new overflow branch, and asserts compaction was not reached before successful truncation.

      OPENCLAW_SKIP_DOCKER_BUILD=1 \
OPENCLAW_RUNTIME_PROOF_LOG=/tmp/openclaw-pr-81190-runtime-proof.log \
scripts/proof/docker-runtime-proof.sh -- node /proof/overflow-truncation-runtime-proof.mjs
  • Evidence after fix (screenshot, recording, terminal capture, console output, redacted runtime log, linked artifact, or copied live output):

    • Redacted live runtime log from the original OpenClaw Telegram setup, showing the real failure mode this patch targets:

      2026-05-13T00:21:37+09:00 [agent/embedded] context overflow detected (attempt 1/3); attempting auto-compaction for openai-codex/gpt-5.4
2026-05-13T00:36:50+09:00 [agent/embedded] [compaction-diag] end trigger=overflow provider=openai-codex/gpt-5.4 attempt=1 outcome=failed reason=timeout durationMs=912840
2026-05-13T00:36:50+09:00 [agent/embedded] [context-overflow-recovery] Attempting tool result truncation for openai-codex/gpt-5.4 (contextWindow=272000 tokens)
2026-05-13T00:36:50+09:00 [agent/embedded] [tool-result-truncation] Truncated 281 tool result(s) in session ... aggregate=281
2026-05-13T00:36:50+09:00 [agent/embedded] [context-overflow-recovery] Truncated 281 tool result(s); retrying prompt

    • Docker-isolated patched-runtime terminal capture:

      Docker-isolated OpenClaw runtime proof for PR #81190
runtimeVersion=packaged
sessionFile=/tmp/openclaw-runtime-proof/overflow-tool-results.jsonl
contextWindowTokens=8000 maxCharsOverride=1200
beforeToolResultChars=16179
sessionLikelyHasOversizedToolResults=true
[context-overflow-recovery] Attempting tool result truncation before compaction for openai-codex/gpt-5.5 (contextWindow=8000 tokens)
[agent/embedded] [tool-result-truncation] Truncated 1 tool result(s) in session (contextWindow=8000 maxChars=1200 aggregateBudgetChars=1200 oversized=1 aggregate=0) sessionKey=docker-runtime-proof-pr-81190
truncateOversizedToolResultsInSession={"truncated":true,"truncatedCount":1}
[context-overflow-recovery] Truncated 1 tool result(s); retrying prompt
toolResultTranscriptEntries=2
afterToolResultChars=1200
compactionAttemptedBeforeTruncation=false
RESULT: PASS - Docker runtime truncated tool results before compaction fallback

    • Targeted regression test terminal capture from the patched local checkout:

      $ CI=true node scripts/run-vitest.mjs run src/agents/pi-embedded-runner/run.overflow-compaction.loop.test.ts
Test Files 2 passed (2)
Tests 50 passed (50)
  • Observed result after fix: the patched Docker runtime detected oversized tool-result pressure, attempted tool-result truncation before compaction, reduced the transcript tool result from 16,179 chars to 1,200 chars, and did not enter the compaction fallback before successful truncation. When truncation reports no useful reduction, the existing compaction fallback still runs in the regression tests.
  • What was not tested: a patched live Telegram runtime reproducing the exact 900s timeout incident was not run, to avoid intentionally forcing a long user-visible hang/quota-consuming overflow. The after-fix proof instead uses a Docker-isolated equivalent runtime run with synthetic data.
  • Before evidence (optional but encouraged): linked issue Overflow recovery should truncate tool results before waiting full auto-compaction timeout #81182 includes the same redacted live OpenClaw runtime log showing compaction timeout durationMs=912840 followed by immediate truncation of 281 tool result(s).

Root Cause (if applicable)

  • Root cause: the explicit context-overflow recovery path attempted LLM compaction before the existing tool-result truncation fallback, even when the attempt snapshot indicated tool-result pressure.
  • Missing detection / guardrail: there was no pre-compaction guard in this overflow catch path to try the cheap deterministic truncation recovery first.
  • Contributing context (if known): preflight recovery already has truncate-only routing, but provider/assistant overflow errors can still reach the later overflow catch path.

Regression Test Plan (if applicable)

  • Coverage level that should have caught this:
    • Unit test
    • Seam / integration test
    • End-to-end test
    • Existing coverage already sufficient
  • Target test or file: src/agents/pi-embedded-runner/run.overflow-compaction.loop.test.ts
  • Scenario the test should lock in: tool-heavy overflow tries tool-result truncation before compaction, and falls back to compaction only when truncation does not help.
  • Why this is the smallest reliable guardrail: the behavior lives in the embedded run-loop overflow recovery ordering; the existing harness can assert ordering without a live model call.
  • Existing test that already covers this (if any): existing fallback truncation tests covered truncation after compaction failure, not before compaction.
  • If no new test is added, why not: N/A

User-visible / Behavior Changes

Tool-heavy overflow recovery can retry sooner by truncating tool results before waiting for LLM auto-compaction. If truncation does not help, behavior falls back to the existing compaction path.

Diagram (if applicable)

Before:
context overflow + tool-heavy transcript -> auto-compaction -> timeout/failure -> tool-result truncation -> retry

After:
context overflow + tool-heavy transcript -> tool-result truncation -> retry
                                               └─ if not helpful -> auto-compaction -> retry/error as before

Security Impact (required)

  • New permissions/capabilities? (Yes/No) No
  • Secrets/tokens handling changed? (Yes/No) No
  • New/changed network calls? (Yes/No) No
  • Command/tool execution surface changed? (Yes/No) No
  • Data access scope changed? (Yes/No) No
  • If any Yes, explain risk + mitigation: N/A

Repro + Verification

Environment

  • OS: Linux x64
  • Runtime/container: Docker-isolated package-installed OpenClaw runtime built from this PR checkout; local checkout for targeted regression tests
  • Model/provider: synthetic Docker runtime proof labels the overflow branch as openai-codex/gpt-5.5; live before evidence used openai-codex/gpt-5.4; unit tests use the mocked embedded run-loop provider
  • Integration/channel (if any): Telegram direct for before evidence; Docker synthetic transcript for patched runtime proof; unit test for fallback/guard coverage
  • Relevant config (redacted): default embedded main-agent run loop

Steps

  1. Trigger a context overflow attempt with oversized tool-result pressure.
  2. Observe the overflow recovery ordering.
  3. Verify truncation is attempted before compaction and successful truncation retries the prompt.

Expected

  • Tool-result-heavy overflow tries tool-result truncation before explicit auto-compaction.
  • If truncation succeeds, compaction is not called.
  • If truncation does not help, compaction is still attempted.

Actual

  • Matches expected in the updated regression tests.

Evidence

Attach at least one:

  • Failing test/log before + passing after
  • Trace/log snippets
  • Screenshot/recording
  • Perf numbers (if relevant)

Human Verification (required)

What you personally verified (not just CI), and how:

  • Verified scenarios:
    • Docker-isolated runtime proof passes: OPENCLAW_SKIP_DOCKER_BUILD=1 OPENCLAW_RUNTIME_PROOF_LOG=/tmp/openclaw-pr-81190-runtime-proof.log scripts/proof/docker-runtime-proof.sh -- node /proof/overflow-truncation-runtime-proof.mjs
    • Targeted regression test passes: CI=true node scripts/run-vitest.mjs run src/agents/pi-embedded-runner/run.overflow-compaction.loop.test.ts
    • git diff --check passes.
    • pnpm exec oxfmt --write --threads=1 src/agents/pi-embedded-runner/run.ts src/agents/pi-embedded-runner/run.overflow-compaction.loop.test.ts
  • Edge cases checked:
    • successful pre-compaction truncation skips compaction
    • truncation miss falls back to compaction
    • existing preflight handled route still skips compaction
  • What you did not verify:
    • full pnpm build && pnpm check && pnpm test
    • live Telegram runtime on this patched branch; covered instead by Docker-isolated equivalent runtime proof with synthetic data

Review Conversations

  • I replied to or resolved every bot review conversation I addressed in this PR.
  • I left unresolved only the conversations that still need reviewer or maintainer judgment.

Compatibility / Migration

  • Backward compatible? (Yes/No) Yes
  • Config/env changes? (Yes/No) No
  • Migration needed? (Yes/No) No
  • If yes, exact upgrade steps: N/A

Risks and Mitigations

  • Risk: truncation might be attempted in cases where compaction would have produced a richer summary.
    • Mitigation: the new path only runs when the existing sessionLikelyHasOversizedToolResults heuristic detects tool-result pressure, and falls back to compaction when truncation does not help.

@openclaw-barnacle openclaw-barnacle Bot added agents Agent runtime and tooling size: S triage: mock-only-proof Candidate: PR proof only shows tests, mocks, snapshots, lint, typecheck, or CI. labels May 12, 2026
@clawsweeper

clawsweeper Bot commented May 12, 2026 •
edited
Loading

Copy link
Copy Markdown
Contributor

Codex review: needs maintainer review before merge. Reviewed May 28, 2026, 12:54 AM ET / 04:54 UTC.

Summary
The branch changes the embedded agent overflow recovery loop and its overflow-compaction tests so detected tool-result pressure is truncated before explicit overflow compaction, with a guard for already-persisted inbound turns.

PR surface: Source +51, Tests +56. Total +107 across 2 files.

Reproducibility: yes. Current main still attempts explicit overflow compaction before tool-result truncation, and the linked report includes runtime logs where compaction timed out for 912840ms before truncating 281 tool results.

Review metrics: 1 noteworthy metric.

  • Overflow fallback ordering: 1 ordering change. The PR changes a compatibility-sensitive recovery path by trying deterministic tool-result truncation before explicit overflow compaction when tool-result pressure is detected.

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

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

Rank-up moves:

  • [P2] Rebase or adapt the patch to the renamed src/agents/embedded-agent-runner files.
  • [P2] After rebase, rerun the focused overflow-compaction loop test and keep the Docker packaged-runtime proof current in the PR body.

Risk before merge

  • [P1] The head is currently dirty against main and targets the pre-rename src/agents/pi-embedded-runner path, so it needs a rebase/adaptation to src/agents/embedded-agent-runner before it can merge.
  • [P2] The default overflow fallback order changes for existing sessions; maintainers should explicitly accept that detected tool-result pressure favors local truncation before a richer LLM compaction summary.
  • [P1] After-fix proof is Docker packaged-runtime terminal proof rather than a patched live Telegram run; that avoids forcing a long live hang but leaves the exact channel latency path unproven.

Maintainer options:

  1. Rebase and prove the current runner path (recommended)
    Adapt the patch to current src/agents/embedded-agent-runner and rerun the focused loop test plus packaged-runtime proof before merge.
  2. Accept truncation-first semantics
    Maintainers can explicitly accept that detected tool-result pressure should use deterministic truncation before LLM compaction for this overflow path.
  3. Pause for broader overflow strategy
    If maintainers want compaction, truncation, and repeated-overflow policy redesigned together, keep this PR paused and route the behavior through the broader open overflow cluster.

Next step before merge

  • [P2] Maintainer review is needed because the branch is dirty against current main and changes a compatibility-sensitive overflow fallback order; there is no discrete line-level defect for a repair worker from this review.

Security
Cleared: The diff only changes agent overflow recovery logic and tests, with no new dependencies, CI, secret handling, permissions, or external execution surface.

Review details

Best possible solution:

Rebase the focused ordering change onto src/agents/embedded-agent-runner, keep the persisted-turn guard and fallback tests, and land after targeted overflow proof plus maintainer acceptance of truncation-first recovery.

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

Yes. Current main still attempts explicit overflow compaction before tool-result truncation, and the linked report includes runtime logs where compaction timed out for 912840ms before truncating 281 tool results.

Is this the best way to solve the issue?

Yes, with rebase work. Reusing the existing truncation heuristic before LLM compaction is a narrow fix, but the current branch is not merge-ready until it is adapted to the renamed runner path and maintainers accept the fallback-order change.

AGENTS.md: found and applied where relevant.

Codex review notes: model gpt-5.5, reasoning high; reviewed against f7c32fc8befd.

Label changes

Label changes:

  • add P1: The PR targets a user-visible agent/channel stall where tool-heavy sessions can wait around 15 minutes for compaction before a fast deterministic recovery.
  • add merge-risk: 🚨 compatibility: The PR changes existing fallback ordering for upgraded sessions rather than adding an opt-in path.
  • add merge-risk: 🚨 session-state: The changed branch mutates transcript tool results and controls whether a persisted inbound turn is replayed or resumed from the transcript.
  • add proof: sufficient: Contributor real behavior proof is sufficient. The PR body includes redacted before logs plus Docker packaged-runtime terminal output showing truncation before compaction and a passing targeted regression run.
  • add rating: 🐚 platinum hermit: Overall readiness is 🐚 platinum hermit; proof is 🦞 diamond lobster and patch quality is 🐚 platinum hermit.
  • add status: 👀 ready for maintainer look: ClawSweeper has no concrete contributor-facing blocker left for this PR. Sufficient (terminal): The PR body includes redacted before logs plus Docker packaged-runtime terminal output showing truncation before compaction and a passing targeted regression run.
  • remove rating: 🌊 off-meta tidepool: Current PR rating is rating: 🐚 platinum hermit, so this older rating label is no longer current.

Label justifications:

  • P1: The PR targets a user-visible agent/channel stall where tool-heavy sessions can wait around 15 minutes for compaction before a fast deterministic recovery.
  • merge-risk: 🚨 compatibility: The PR changes existing fallback ordering for upgraded sessions rather than adding an opt-in path.
  • merge-risk: 🚨 session-state: The changed branch mutates transcript tool results and controls whether a persisted inbound turn is replayed or resumed from the transcript.
  • rating: 🐚 platinum hermit: Overall readiness is 🐚 platinum hermit; proof is 🦞 diamond lobster and patch quality is 🐚 platinum hermit.
  • status: 👀 ready for maintainer look: ClawSweeper has no concrete contributor-facing blocker left for this PR. Sufficient (terminal): The PR body includes redacted before logs plus Docker packaged-runtime terminal output showing truncation before compaction and a passing targeted regression run.
  • proof: sufficient: Contributor real behavior proof is sufficient. The PR body includes redacted before logs plus Docker packaged-runtime terminal output showing truncation before compaction and a passing targeted regression run.
Evidence reviewed

PR surface:

Source +51, Tests +56. Total +107 across 2 files.

View PR surface stats
Area Files Added Removed Net
Source 1 51 0 +51
Tests 1 71 15 +56
Docs 0 0 0 0
Config 0 0 0 0
Generated 0 0 0 0
Other 0 0 0 0
Total 2 122 15 +107

What I checked:

  • Current main still compacts before truncation: Current main enters explicit overflow compaction before the existing tool-result truncation fallback, so the central behavior this PR targets is still present on main. (src/agents/embedded-agent-runner/run.ts:1998, f7c32fc8befd)
  • Existing fallback runs only after compaction path: The current truncation fallback is below the compaction attempt and logs the older post-compaction recovery wording. (src/agents/embedded-agent-runner/run.ts:2169, f7c32fc8befd)
  • PR adds the pre-compaction truncation branch: The first PR commit inserts a has-oversized-tool-results check before explicit overflow compaction and falls back to compaction when truncation does not help. (src/agents/pi-embedded-runner/run.ts:1736, 90749d75b476)
  • PR preserves persisted-turn retry semantics: The second PR commit adds the continuation/suppress-next-user-append guard when truncation succeeds after the inbound message was already persisted. (src/agents/pi-embedded-runner/run.ts:1769, 7ec0b4b52877)
  • Regression coverage is targeted: The PR updates the loop harness expectations so successful truncation skips compaction, failed truncation falls back to compaction, and persisted inbound turns resume from transcript. (src/agents/pi-embedded-runner/run.overflow-compaction.loop.test.ts:239, 7ec0b4b52877)
  • Current main path drift blocks direct merge: The provided live GitHub context reports mergeableState=dirty, and current main has the runner files under src/agents/embedded-agent-runner while the PR commits still touch src/agents/pi-embedded-runner. (f7c32fc8befd)

Likely related people:

  • steipete: Authored the current-main runner move/large touch that now owns the affected run loop and tests, and committed the April fallback restoration. (role: recent area contributor; confidence: high; commits: 1f1cdd84ea24, 09b7c00daba4; files: src/agents/embedded-agent-runner/run.ts, src/agents/embedded-agent-runner/run.overflow-compaction.loop.test.ts)
  • Takhoffman: Authored the April commit that restored readable tool-result overflow fallback coverage across the run loop, harness, tests, and truncation helper. (role: feature-history owner; confidence: high; commits: 09b7c00daba4; files: src/agents/pi-embedded-runner/run.ts, src/agents/pi-embedded-runner/run.overflow-compaction.loop.test.ts, src/agents/pi-embedded-runner/tool-result-truncation.ts)
  • tyler6204: Authored the original oversized tool-result context-overflow recovery feature and tests that this PR reorders in the overflow path. (role: introduced behavior; confidence: high; commits: 0deb8b0da187; files: src/agents/pi-embedded-runner/run.ts, src/agents/pi-embedded-runner/tool-result-truncation.ts, src/agents/pi-embedded-runner/tool-result-truncation.test.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.

@openclaw-barnacle openclaw-barnacle Bot added proof: supplied External PR includes structured after-fix real behavior proof. and removed triage: mock-only-proof Candidate: PR proof only shows tests, mocks, snapshots, lint, typecheck, or CI. labels May 12, 2026
@LLagoon3

LLagoon3 commented May 12, 2026 •
edited by clawsweeper Bot
Loading

Copy link
Copy Markdown
Contributor Author

Thanks, ClawSweeper. I addressed the P2 persisted-turn retry guard in 7ec0b4b: successful pre-compaction tool-result truncation now uses the same transcript-continuation + suppress-next-user-append guard as the compaction-success path when the inbound message was already persisted. I also added a regression test for that exact case.\n\nValidation:\n\ntext\nCI=true node scripts/run-vitest.mjs run src/agents/pi-embedded-runner/run.overflow-compaction.loop.test.ts\nTest Files 2 passed (2)\nTests 50 passed (50)\n

Re-review progress:

@LLagoon3

LLagoon3 commented May 13, 2026 •
edited by clawsweeper Bot
Loading

Copy link
Copy Markdown
Contributor Author

Added Docker-isolated patched-runtime proof to the PR body. The proof image is built from this PR checkout, runs with a temporary OPENCLAW_HOME and synthetic tool-result transcript only, and shows the runtime truncation path executing before compaction fallback:\n\ntext\nbeforeToolResultChars=16179\nsessionLikelyHasOversizedToolResults=true\n[context-overflow-recovery] Attempting tool result truncation before compaction for openai-codex/gpt-5.5 (contextWindow=8000 tokens)\n[agent/embedded] [tool-result-truncation] Truncated 1 tool result(s) in session ... sessionKey=docker-runtime-proof-pr-81190\n[context-overflow-recovery] Truncated 1 tool result(s); retrying prompt\nafterToolResultChars=1200\ncompactionAttemptedBeforeTruncation=false\nRESULT: PASS - Docker runtime truncated tool results before compaction fallback\n\n\n@clawsweeper re-review

Re-review progress:

@LLagoon3

LLagoon3 commented May 13, 2026

Copy link
Copy Markdown
Contributor Author

@clawsweeper re-review

Added Docker-isolated patched-runtime proof to the PR body. The Real behavior proof check is now green, and the proof shows the packaged OpenClaw runtime truncating tool results before compaction fallback with synthetic data and no production credentials.

@clawsweeper

clawsweeper Bot commented May 13, 2026 •
edited
Loading

Copy link
Copy Markdown
Contributor

🦞🧹
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:

@clawsweeper clawsweeper Bot added the proof: sufficient ClawSweeper judged the real behavior proof convincing. label May 13, 2026
This was referenced May 15, 2026
Closed
Open
Open
Open
Open
Open
@openclaw-barnacle

openclaw-barnacle Bot commented May 27, 2026

Copy link
Copy Markdown

This pull request has been automatically marked as stale due to inactivity.
Please add updates or it will be closed.

@openclaw-barnacle openclaw-barnacle Bot added the stale Marked as stale due to inactivity label May 27, 2026
@clawsweeper clawsweeper Bot added rating: 🌊 off-meta tidepool PR readiness rating does not apply to this item. and removed proof: sufficient ClawSweeper judged the real behavior proof convincing. labels May 27, 2026
@clawsweeper

clawsweeper Bot commented May 27, 2026 •
edited
Loading

Copy link
Copy Markdown
Contributor

ClawSweeper PR egg: ✨ hatched 🥚 common Cosmic Diff Drake. Rarity: 🥚 common. Trait: collects tiny proofs.

Details

Share on X: post this hatch
Copy: My PR egg hatched a 🥚 common Cosmic Diff Drake in ClawSweeper.
Hatchability:

  • Merged PRs are hatchable.
  • Open PRs are hatchable when they are status: 👀 ready for maintainer look, status: 🚀 automerge armed, or labeled clawsweeper:automerge.
  • Closed unmerged PRs are hatchable only when one of those hatchable labels is still present in the durable record.

About:

  • Eggs appear after real-behavior proof passes. They are collectible flavor only.
  • Review momentum changes the shell state: follow-up work warms it, re-review makes it wobble, and a clean final review lets it hatch.
  • The hatch is seeded from this repository and PR number, so the same PR keeps the same creature; the reviewed head SHA can only change safe visual details.
  • Rarity is just collectible sparkle: 🥚 common, 🌱 uncommon, 💎 rare, ✨ glimmer, and 🌈 legendary.

@openclaw-barnacle openclaw-barnacle Bot removed the stale Marked as stale due to inactivity label May 28, 2026
@clawsweeper clawsweeper Bot added proof: sufficient ClawSweeper judged the real behavior proof convincing. rating: 🐚 platinum hermit Good normal PR readiness with ordinary maintainer review expected. status: 👀 ready for maintainer look ClawSweeper has no concrete contributor-facing blocker left for this PR. P1 High-priority user-facing bug, regression, or broken workflow. and removed rating: 🌊 off-meta tidepool PR readiness rating does not apply to this item. labels May 28, 2026
@clawsweeper clawsweeper Bot added merge-risk: 🚨 compatibility 🚨 May break existing users, config, migrations, defaults, or upgrade paths. merge-risk: 🚨 session-state 🚨 May lose, corrupt, stale, or mis-associate session, agent, or context state. labels May 28, 2026
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Reviewers

No reviews

Assignees

No one assigned

Labels

agents Agent runtime and tooling merge-risk: 🚨 compatibility 🚨 May break existing users, config, migrations, defaults, or upgrade paths. merge-risk: 🚨 session-state 🚨 May lose, corrupt, stale, or mis-associate session, agent, or context state. P1 High-priority user-facing bug, regression, or broken workflow. proof: sufficient ClawSweeper judged the real behavior proof convincing. proof: supplied External PR includes structured after-fix real behavior proof. rating: 🐚 platinum hermit Good normal PR readiness with ordinary maintainer review expected. size: S status: 👀 ready for maintainer look ClawSweeper has no concrete contributor-facing blocker left for this PR.

Projects

None yet

Milestone

No milestone

Development

Successfully merging this pull request may close these issues.

Overflow recovery should truncate tool results before waiting full auto-compaction timeout

1 participant

@LLagoon3