Skip to content

openai-chatgpt-responses native replay sends encrypted reasoning and breaks next turn with invalid_encrypted_content #90093

Closed

Description

@richardmqq

Summary

On OpenClaw 2026.6.1, a native/OpenClaw-runtime openai-chatgpt-responses session can succeed on the first turn and then fail on the next turn with a provider-side 400 invalid_encrypted_content before any model output.

The user-visible error is sanitized to:

LLM request failed: provider rejected the request schema or tool payload.

The raw trajectory error is:

Codex error: {"type":"error","error":{"type":"invalid_request_error","code":"invalid_encrypted_content","message":"The encrypted content gAAA... could not be verified. Reason: Encrypted content could not be decrypted or parsed."},"status":400}

Environment

  • OpenClaw: 2026.6.1 (2e08f0f)
  • macOS: 26.4.1 arm64
  • Node: 25.9.0
  • Runtime / harness: OpenClaw native (agentRuntime.id = "openclaw")
  • Provider/model shape:
{
  "provider": "openai",
  "model": "gpt-5.5",
  "api": "openai-chatgpt-responses",
  "baseUrl": "https://chatgpt.com/backend-api/codex",
  "agentRuntime": { "id": "openclaw" },
  "params": { "thinking": "xhigh", "transport": "sse" }
}

Reproduction observed

  1. Start a fresh session using openai/gpt-5.5 with api=openai-chatgpt-responses and native runtime.
  2. Send a first turn that causes a normal model response and tool use. This succeeds.
  3. The successful assistant turn stores a thinking block with thinkingSignature containing a serialized Responses reasoning item with encrypted_content.
  4. Send a second turn in the same session.
  5. OpenClaw replays the prior assistant reasoning item in the submitted history.
  6. The ChatGPT/Codex backend rejects the request before model output with 400 invalid_encrypted_content.

This explains why the previous turn succeeds but the next turn fails.

What I found in dist

openai-chatgpt-responses requests encrypted reasoning:

// openai-chatgpt-responses-*.js
include: ["reasoning.encrypted_content"]

sanitizeSessionHistory only drops reasoning history when the provider replay policy says so:

const droppedReasoning = policy.dropReasoningFromHistory
  ? dropReasoningFromHistory(validatedThinkingSignatures)
  : validatedThinkingSignatures;

But buildOpenAIReplayPolicy(ctx) currently treats openai-chatgpt-responses as a Responses-family API with synthetic tool results, and does not set dropReasoningFromHistory for this API.

Local mitigation that fixed it

Adding this to buildOpenAIReplayPolicy(ctx) fixed the same session immediately:

...ctx.modelApi === "openai-chatgpt-responses" ? { dropReasoningFromHistory: true } : {},

After restarting the gateway, the same session and same message completed successfully. The submitted history no longer contained thinkingSignature; only the old failed assistant turn's plain-text errorMessage still contained the string invalid_encrypted_content, which is harmless.

Expected behavior

For openai-chatgpt-responses against the ChatGPT/Codex backend, OpenClaw should not replay stale/unverifiable encrypted reasoning content, or should retry safely without it before surfacing an error.

Actual behavior

The next turn replays encrypted reasoning content and the backend rejects the whole request with 400 invalid_encrypted_content, resulting in an empty/non-deliverable assistant turn.

Related

Activity

  1. clawsweeper commented on Jun 4, 2026

    @clawsweeper
    Contributor

    Codex review: keeping this open for maintainer follow-up; there is still a little grit to resolve. Reviewed June 3, 2026, 9:16 PM ET / 01:16 UTC.

    Summary
    Keep open: current main still has a source-backed path where openai-chatgpt-responses can persist encrypted reasoning, preserve it when replay provenance matches, and send it on the next OpenClaw-runtime turn. The issue is valid, but several open PRs already touch this same Responses reasoning replay surface, so this should be coordinated rather than closed or duplicated.

    Reproducibility: yes. with source-level confidence rather than a live run: the issue's v2026.6.1 steps match current code that persists encrypted reasoning, preserves it when replay metadata matches, and sends it on the next openai-chatgpt-responses OpenClaw-runtime request.

    Next step
    The bug is narrow and valid, but adjacent open PRs already target the same encrypted Responses replay surface, so a maintainer should choose or extend the canonical fix path before queuing another repair PR.

    Review details

    Best possible solution:

    Fold this into one canonical Responses replay fix: native ChatGPT/Codex OpenClaw-runtime requests should drop or safely retry unverifiable encrypted reasoning while preserving custom/proxy replay contracts, with focused regression coverage.

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

    Yes, with source-level confidence rather than a live run: the issue's v2026.6.1 steps match current code that persists encrypted reasoning, preserves it when replay metadata matches, and sends it on the next openai-chatgpt-responses OpenClaw-runtime request.

    Is this the best way to solve the issue?

    The local mitigation is plausible but probably too broad if applied only at generic transcript policy; the best fix should target the native ChatGPT/Codex request/retry path while preserving custom Responses backends that intentionally support encrypted replay.

    AGENTS.md: found and applied where relevant.

    Remaining risk / open question:

    • No live current-main OpenAI/Codex turn was run in this read-only review; the keep-open decision is source-backed and supported by the reporter's release reproduction.
    • Multiple open PRs already modify Responses reasoning replay recovery, so maintainers should avoid landing overlapping partial fixes without choosing one canonical path.

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

    Label changes

    Label changes:

    • add P1: The report describes a released multi-turn OpenAI/Codex agent workflow failing before any model output on the next turn.
    • add impact:message-loss: The failed second turn produces no deliverable assistant output after the provider rejects the replay payload.
    • add impact:session-state: The break depends on replaying persisted prior assistant reasoning from the same session.
    • add impact:auth-provider: The failure is specific to the OpenAI ChatGPT/Codex Responses provider route and its encrypted reasoning contract.
    • add issue-rating: 🦞 diamond lobster: Current issue advisory state selects this label.
    • add clawsweeper:source-repro: Current issue advisory state selects this label.
    • add clawsweeper:no-new-fix-pr: Current issue advisory state selects this label.
    • add clawsweeper:fix-shape-clear: Current issue advisory state selects this label.
    • add clawsweeper:needs-maintainer-review: Current issue advisory state selects this label.

    Label justifications:

    • P1: The report describes a released multi-turn OpenAI/Codex agent workflow failing before any model output on the next turn.
    • impact:message-loss: The failed second turn produces no deliverable assistant output after the provider rejects the replay payload.
    • impact:session-state: The break depends on replaying persisted prior assistant reasoning from the same session.
    • impact:auth-provider: The failure is specific to the OpenAI ChatGPT/Codex Responses provider route and its encrypted reasoning contract.
    Evidence reviewed

    Acceptance criteria:

    • node scripts/run-vitest.mjs run src/agents/openai-transport-stream.test.ts -t "encrypted reasoning"
    • node scripts/run-vitest.mjs run src/agents/embedded-agent-runner.sanitize-session-history.test.ts -t "reasoning"

    What I checked:

    • Current source stores encrypted reasoning replay metadata: Responses output handling persists the full reasoning item as thinkingSignature and attaches replay metadata when encrypted_content is present, which matches the reporter's stored-history observation. (src/agents/openai-transport-stream.ts:1601, 179ff9b4230c)
    • Current source preserves encrypted content when provenance matches: prepareOpenAIResponsesReasoningItemForReplay strips encrypted_content only when replay metadata does not match; matching metadata returns the reasoning item intact. (src/agents/openai-transport-stream.ts:936, 179ff9b4230c)
    • Native ChatGPT/Codex request builder still replays reasoning items: buildOpenAIResponsesParams calls convertResponsesMessages with replayReasoningItems: true; native ChatGPT/Codex handling disables item id replay but does not disable reasoning item replay. (src/agents/openai-transport-stream.ts:2212, 179ff9b4230c)
    • Native ChatGPT/Codex sanitizer does not strip encrypted reasoning: The native ChatGPT/Codex sanitizer removes unsupported top-level request params and text fields, but its unsupported-param list does not remove encrypted_content from replayed reasoning input. (src/agents/openai-transport-stream.ts:2097, 179ff9b4230c)
    • Transcript policy does not drop Responses-family reasoning by default: Session history drops reasoning only when policy.dropReasoningFromHistory is true, and the OpenAI-compatible replay helper only sets that flag for openai-completions, not openai-chatgpt-responses. (src/agents/embedded-agent-runner/replay-history.ts:744, 179ff9b4230c)
    • Existing tests show the intended surface is split: Current tests strip unproven native encrypted reasoning, but separately preserve matching embedded replay provenance for compatible backends; there is no test proving matching native ChatGPT/Codex provenance is stripped before dispatch. (src/agents/openai-transport-stream.test.ts:3193, 179ff9b4230c)

    Likely related people:

    • steipete: Authored recent OpenAI reasoning replay and provider identity changes, including commit cf315dd that made reasoning replay metadata preservation explicit. (role: recent area contributor; confidence: high; commits: cf315ddef69f, 5259fa4495ac, 4c33aaa86c16; files: src/agents/openai-transport-stream.ts, src/plugins/provider-replay-helpers.ts, src/agents/embedded-agent-runner/replay-history.ts)
    • zhanghang02: Authored the merged Responses store=false item-id replay fix in the same request-building path, which is closely related to this encrypted reasoning replay failure mode. (role: adjacent owner; confidence: medium; commits: 03dec8bb3a00; files: src/agents/openai-transport-stream.ts, src/agents/openai-transport-stream.test.ts)
    • joshavant: Authored the merged provenance-bound Codex reasoning replay PR that established the replay metadata behavior this issue now hits in the native ChatGPT/Codex route. (role: feature history owner; confidence: medium; commits: a54c73687f58; files: src/agents/openai-transport-stream.ts, src/agents/openai-transport-stream.test.ts)
    • vincentkoc: Recently touched the provider transport runtime selection in src/agents/openai-transport-stream.ts; less central to encrypted replay, but adjacent to the issue's native transport route. (role: recent adjacent contributor; confidence: low; commits: d07ba5f2656d; files: src/agents/openai-transport-stream.ts)
    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.
  2. toruvieI commented on Jun 4, 2026

    @toruvieI
    Contributor

    I dug through the current 2026.6.1 source path and I think the narrower bug is not runtime selection. The Pi/OpenClaw-native route is being used; the failure is in how the native ChatGPT subscription / openai-chatgpt-responses request body reconstructs prior Responses reasoning items.

    Findings:

    • src/llm/providers/openai-chatgpt-responses.ts builds the ChatGPT/Codex request with:

      const messages = convertResponsesMessages(model, context, CODEX_TOOL_CALL_PROVIDERS, {
        includeSystemPrompt: false,
        replayResponsesItemIds: false,
      });
    • The same request body uses stateless Responses mode and asks the backend to return encrypted reasoning:

      store: false,
      include: ["reasoning.encrypted_content"],
      input: messages,
    • In src/agents/openai-transport-stream.ts, convertResponsesMessages() calls prepareOpenAIResponsesReasoningItemForReplay(...). When replay provenance matches, that helper intentionally preserves the reasoning item's encrypted_content.

    • Immediately after that, the generic replayResponsesItemIds: false policy deletes the replay item id:

      if (!shouldReplayResponsesItemIds) {
        delete replayableReasoningItem.id;
      }

    So the next-turn payload can contain a malformed replay item like:

    {
      "type": "reasoning",
      "encrypted_content": "...",
      "summary": []
    }

    instead of the full prior Responses output reasoning item containing both id: "rs_..." and encrypted_content.

    That is the poisoned middle state: OpenClaw preserves reasoning.encrypted_content, but strips the associated Responses reasoning item id on the native openai-chatgpt-responses / ChatGPT subscription path. This matches the observed second-turn invalid_encrypted_content failure better than a runtime-selection issue.

    There is also a source-level smoking-gun test in src/llm/providers/openai-chatgpt-responses.test.ts named does not replay Responses item ids for store-disabled ChatGPT requests; it currently expects a reasoning replay item with encrypted_content and no id. That expectation looks wrong for encrypted reasoning replay.

    Likely fix shape:

    • preserve id for type: "reasoning" items that retain encrypted_content; or
    • if the native ChatGPT backend cannot accept that replay shape in some cases, drop the reasoning item / strip both id and encrypted_content together rather than sending encrypted_content without its item id;
    • keep the existing store=false no-id behavior for ordinary message/function-call replay items.

    We will open a PR shortly with focused regression coverage for this path.

  3. toruvieI commented on Jun 4, 2026

    @toruvieI
    Contributor

    Opened PR #90425 with the focused fix and regression coverage: #90425

  4. toruvieI commented on Jun 4, 2026

    @toruvieI
    Contributor

    Update: I retracted PR #90425.

    The proposed direction there — preserving rs_* reasoning item ids with encrypted_content — was wrong for this route.

    Live validation showed that preserving the reasoning item id under store:false causes the backend to reject the retry with:

    404 Item with id 'rs_...' not found. Items are not persisted when `store` is set to false. Try again with `store` set to true, or remove this item from your input.
    

    So that payload shape requires a stored Responses lineage (store:true), which is a no-go for openai-chatgpt-responses: the old pre-#88451 openai-codex-responses path already used store:false with include: ["reasoning.encrypted_content"], and the source noted ChatGPT Codex Responses rejects store:true / requires store to remain false.

    Conclusion: #90425 does not solve this issue, and I closed it. The real fix needs to stay on the store:false stateless encrypted-reasoning path rather than preserving persisted item ids.

  5. toruvieI commented on Jun 4, 2026

    @toruvieI
    Contributor

    Additional analysis after retracting #90425:

    1. Why the current state is still bad

    Current 2026.6.1 behavior on openai-chatgpt-responses is not usually a hard failure because OpenClaw catches invalid_encrypted_content, logs:

    [responses] retrying without encrypted reasoning content provider=openai api=openai-chatgpt-responses model=gpt-5.5
    

    and then retries with the encrypted reasoning content stripped.

    That fallback is useful, but if it happens routinely it is still bad operational behavior:

    • every affected turn pays for two Responses requests instead of one;
    • the first request uploads a larger payload containing stale/unusable reasoning.encrypted_content;
    • latency increases by the failed round trip plus retry setup;
    • OpenAI/ChatGPT backend capacity and client quota are wasted on requests that are expected to fail;
    • logs get noisy enough to hide real provider/runtime errors.

    So even if the user-visible turn eventually succeeds, this is a real efficiency/regression problem, not just cosmetic logging.

    1. What happened in OpenClaw 2026.5.x

    I do not have reliable local runtime logs proving whether these warnings fired in my 2026.5.x sessions. Source-wise, though, the retry mechanism already existed in v2026.5.27:

    • src/agents/openai-transport-stream.ts had isInvalidEncryptedContentError(...);
    • it had stripResponsesRequestEncryptedContent(...);
    • it logged the same [responses] retrying without encrypted reasoning content ... warning;
    • native Codex Responses used replayResponsesItemIds: !isNativeCodexResponses, so for openai-codex-responses item ids were already stripped;
    • reasoning requests used include: ["reasoning.encrypted_content"] when reasoning was enabled.

    The architecture was different, though: 2026.5.x still had the openai-codex-responses route/provider identity, while post-#88451 the native ChatGPT/Codex route is unified/renamed toward openai-chatgpt-responses. That means the fallback warning existing in 2026.5.x does not prove the current frequency/trigger pattern was present then; it only proves the safety net was already in the code.

    This is why I would phrase this as: possible regression in behavior/frequency after the provider identity refactor, but not yet proven by historical logs.

    1. How upstream openai/codex does this

    Current upstream openai/codex appears to follow the same high-level direction that OpenClaw should preserve for the ChatGPT/Codex route:

    • for non-Azure Responses it sends store: false (store: provider.is_azure_responses_endpoint());
    • when reasoning is enabled it sends include: ["reasoning.encrypted_content"];
    • its protocol model keeps reasoning summary and encrypted_content serializable;
    • importantly, ResponseItem::Reasoning.id is marked #[serde(default, skip_serializing)], so Codex may keep the rs_* id internally but does not serialize that id back into the next request payload.

    That is why preserving rs_* ids, as attempted in #90425, was the wrong fix for this route. With store:false, those ids are not persisted server-side; live validation returned:

    404 Item with id 'rs_...' not found. Items are not persisted when `store` is set to false.
    

    So the likely correct family of fixes must keep the store:false stateless encrypted-reasoning path, keep include: ["reasoning.encrypted_content"], keep reasoning summaries, and avoid relying on persisted rs_* item ids. The remaining question is why OpenClaw is producing encrypted-content replay that the backend rejects often enough to trigger the retry path.

  6. toruvieI commented on Jun 4, 2026

    @toruvieI
    Contributor

    Additional cross-PR/release note as of Thu 2026-06-04 21:26 GMT+2:

    I checked the adjacent encrypted Responses replay PRs that ClawSweeper alluded to.

    Release status relative to v2026.6.1:

    My current read is that #84904/#85277 are important prevention/payload-policy fixes, but they do not by themselves fully explain or close this specific 2026.6.1 warning path, because they were not in that release and the warning is specifically about native encrypted reasoning replay being rejected and then retried without encrypted content.

    The PR that most directly matches this issue seems to be #87151, because it targets the native ChatGPT/Codex Responses path by omitting encrypted reasoning replay before the first request rather than relying on the invalid_encrypted_content retry fallback. If maintainers accept that tradeoff, #90093 should probably be closed by #87151.

    The other open PRs look more like adjacent recovery/fallback layers:

    So my suggested closure mapping is: #90093 → probably #87151, with #84267/#88917/#85362 remaining as recovery/session-state follow-ups depending on which layering maintainers choose.

  7. toruvieI commented on Jun 4, 2026

    @toruvieI
    Contributor

    @clawsweeper re-review

  8. clthuang commented on Jun 5, 2026

    @clthuang

    Adding a complementary finding from a 2026.6.1 reproduction yesterday — same user-visible symptom (invalid_encrypted_content on a multi-turn openai/openai-chatgpt-responses Telegram session) but a different root cause than the replay-reconstruction path discussed above.

    We sandbox-bisected the failure by extracting the persisted reasoning items from the affected session JSONL and replaying each one in isolation against https://chatgpt.com/backend-api/codex/responses. Result: of 33 reasoning items persisted across the conversation, exactly 2 returned 400 invalid_encrypted_content. The other 31 — including older ones, newer ones, and items adjacent to the failures — decrypted fine. So in our case the server is not categorically rejecting replay; it's rejecting two specific blobs whose ciphertext bytes are corrupted.

    The corruption pattern:

    …XzzZqcAfo3unbAY-ku84xgsvB0fpLkbDvSh3WS5qzfSCmcgw…vK2RyV2GQ4ohzcfYwhRwTvY76TvR7Tvr_…  (poisoned encrypted_content)
    

    E2 80 A6 (U+2026 HORIZONTAL ELLIPSIS) in the middle of a base64url Fernet blob. The byte pattern is byte-identical to redact-*.js maskToken() output:

    firstNchars.slice(0, 6) + "…" + matchedToken.slice(-4)

    Tracing back: transcript-*.js:494 runs redactTranscriptMessage(message, params.config) on every assistant message before persisting it. redactTranscriptStructuredValue recurses into every string leaf of the message — including the JSON-stringified thinkingSignature field, which embeds encrypted_content. Once inside the ciphertext, redactSensitiveText({mode:"tools"}) runs the 31 DEFAULT_REDACT_PATTERNS (redact-*.js:359-391). The low-specificity patterns (\b\d{6,}:…\b-shape, JWT-shape, etc.) can match incidental substrings of any sufficiently long random base64url string, and maskToken then substitutes … into the matched window.

    The poisoned session JSONL is then written. Every subsequent turn rebuilds the request from disk, ships the corrupted encrypted_content to the backend, and the strip-retry middleware fires (createResponsesStreamWithEncryptedContentRetry in openai-transport-stream-*.js:1705-1714) — which masks the underlying defect exactly as @toruvieI described, but burns 21 retry rounds over 5 minutes before the embedded run's timeoutMs=300000 finally surfaces the error to the user.

    Evidence this is independent of the replay-policy path discussed above:

    • Only 2/33 reasoning items in the same session fail. If the replay reconstruction were the issue, all 33 would fail or all 33 would succeed.
    • The failing items contain … in their encrypted_content (verified via grep -c $'\xe2\x80\xa6' on the JSONL).
    • Clean reasoning items extracted from the same JSONL, posted with the same headers/account/token to the same endpoint, return 200 OK.
    • Re-running redactSensitiveText on the poisoned data is idempotent (… doesn't match any further patterns), so the corruption is exactly 1 redaction pass deep.

    We've shipped a local sentinel-guarded dist patch that adds an opaque-field exemption at the top of the walker:

    function redactTranscriptStructuredValue(value, cfg, fieldKey, seen = new WeakSet()) {
      if (
        fieldKey === "encrypted_content" ||
        fieldKey === "thinkingSignature" ||
        fieldKey === "thoughtSignature"
      ) {
        return value;
      }
      // ... existing body unchanged
    }

    Multi-turn smoke (3 turns × tool round-trip × reasoning enabled) passes with this patch; the new session JSONL contains 0 U+2026 bytes; old poisoned sessions remain unrecoverable on disk (we deleted the 2 corrupted thinking blocks from one such session by hand).

    Worth considering whether the fix path here should be both:

    1. Drop reasoning from history for openai-chatgpt-responses (the path @toruvieI is exploring — addresses the "encrypted_content is fragile across turns" surface, AND incidentally avoids replaying the redactor-corrupted blobs).
    2. Stop the transcript redactor from descending into opaque crypto fields (addresses the corruption regardless of whether replay is attempted, and prevents the same bug from reappearing on any future opaque-blob field — Anthropic's redacted_thinking.data has the same shape).

    Tightening DEFAULT_REDACT_PATTERNS (line 390 \b\d{6,}:…\b, line 382 JWT-shape) to require contextual anchors so they cannot match incidental substrings would be a third layer, useful even outside the encrypted-reasoning context.

    Logging the strip-retry decision at INFO instead of only when it terminates a run would also have caught this earlier — the 21 retry lines were only visible after the 300s timeout fired and the user noticed.

    Full RCA with reproduction scripts, 7 hypotheses (4 rejected with evidence), and causal DAG is at the project I reproduced this on; happy to extract anything that would help.

  9. fanyangCS commented on Jun 6, 2026

    @fanyangCS
    Contributor

    Additional repro from OpenClaw 2026.6.1 on a Discord channel session, likely the same encrypted-reasoning replay failure class.

    Environment:

    • OpenClaw: 2026.6.1 (2e08f0f)
    • Channel: Discord guild thread/channel
    • Agent/model: main embedded agent, github-copilot/gpt-5.5
    • Runtime symptom: Discord mention was received and reacted to, but the agent failed before producing/sending a reply.

    Gateway log excerpt (sanitized):

    embedded_run_agent_end
    isError=true
    error="LLM request failed."
    model="gpt-5.5"
    provider="github-copilot"
    rawErrorPreview="OpenAI API error (400): 400 The encrypted content /LUJ...kISb could not be verified. Reason: Encrypted content could not be decrypted or parsed."
    rawErrorHash="sha256:16784127d063"
    providerRuntimeFailureKind="unclassified"
    

    This happened twice in the same Discord discussion window:

    • 2026-06-06T09:27:39.874Z
    • 2026-06-06T09:56:19.616Z

    User-visible impact: the bot visibly acknowledged the mention (reaction), but no answer was generated/delivered because the provider rejected the replayed encrypted content before model output.

    This looks related to the recovery direction in #84267 / #88917: classify this as stale/invalid encrypted Responses reasoning replay and retry once after stripping the replayed encrypted reasoning items, instead of surfacing it as a terminal generic LLM request failure.

  10. self-assigned this
    on Jun 14, 2026
  11. added a commit that references this issue on Jun 14, 2026
    66880a5
  12. added a commit that references this issue on Jun 14, 2026
    34b4f5c
  13. added a commit that references this issue on Jun 16, 2026
    c35f666
  14. added a commit that references this issue on Jun 17, 2026
    48f30b3
  15. locked as resolved and limited conversation to collaborators on Jun 25, 2026
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Metadata

Metadata

Assignees

Labels

No labels
No labels

Type

No type

Fields

Priority

None yet

Projects

No projects

    Milestone

    No milestone

    Relationships

    None yet

    Development

    No branches or pull requests

    Issue actions