free-claude-code 6.3.0__tar.gz → 6.3.2__tar.gz

{free_claude_code-6.3.0 → free_claude_code-6.3.2}/.github/workflows/validate-bug-report-version.yml

@@ -37,6 +37,8 @@ jobs:
               if (doctor.length) {
                 if (doctor.length !== 1) return { valid: false };
                 let text = doctor[0].replace(/^FCC doctor output\r?\n/, "").trim();
+                const details = text.match(/^<details>\s*<summary>[^<>\r\n]*<\/summary>\s*([\s\S]*?)\s*<\/details>$/);
+                if (details) text = details[1].trim();
                 const fence = text.match(/^```(?:json)?\r?\n([\s\S]*)\r?\n```$/);
                 if (fence) text = fence[1];
                 let report;
@@ -58,7 +60,25 @@ jobs:
               const reportedVersion = versionMatches.length === 1 ? versionMatches[0][1] : undefined;
               return { valid: reportedVersion !== undefined || fieldValue === "None", reportedVersion };
             };
-            const { reportedVersion, valid } = parseReport(issue.body || "");
+            const collapseDoctorReport = (body) => {
+              const sections = body.split(/(?=^### )/m);
+              const index = sections.findIndex((section) => /^### FCC doctor output\r?\n/.test(section));
+              if (index === -1 || !parseReport(body).valid) return body;
+              const section = sections[index];
+              const text = section.replace(/^### FCC doctor output\r?\n/, "").trim();
+              if (text.startsWith("<details>")) return body;
+              const newline = section.includes("\r\n") ? "\r\n" : "\n";
+              const content = text.startsWith("```") ? text : `\`\`\`json${newline}${text}${newline}\`\`\``;
+              const wrapped = ["<details>", "<summary>FCC doctor output</summary>", "", content, "", "</details>"].join(newline);
+              const start = section.indexOf(text);
+              sections[index] = section.slice(0, start) + wrapped + section.slice(start + text.length);
+              return sections.join("");
+            };
+            const formattedBody = collapseDoctorReport(issue.body || "");
+            if (formattedBody !== (issue.body || "")) {
+              await github.rest.issues.update({ ...repo, issue_number, body: formattedBody });
+            }
+            const { reportedVersion, valid } = parseReport(formattedBody);
             const labelName = "needs-fcc-version";
             const invalidMarker = "<!-- fcc-version-validator -->";
             const outdatedMarker = "<!-- fcc-version-outdated -->";

{free_claude_code-6.3.0 → free_claude_code-6.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: free-claude-code
-Version: 6.3.0
+Version: 6.3.2
 Summary: Local proxy connecting coding agents to OpenAI-compatible AI providers
 License-Expression: AGPL-3.0-only
 License-File: LICENSE

{free_claude_code-6.3.0 → free_claude_code-6.3.2}/e2e/test_code_sessions.py

@@ -597,14 +597,18 @@ def test_settings_apply_preserves_open_creation_and_picker(
     page, admin_base_url, tmp_path, code_control
 ):
     pending = []
-    page.route("**/admin/api/config/apply", lambda route: pending.append(route))
-    page.expose_function("applyRequestIntercepted", lambda: bool(pending))
+
+    def capture_apply(route):
+        pending.append(route)
+        page.evaluate("window.applyRequestIntercepted = true")
+
+    page.route("**/admin/api/config/apply", capture_apply)
     page.goto(f"{admin_base_url}/admin")
     expect(page.locator("#messageArea")).to_have_text("")
     page.locator("#field-PORT").fill("8081")
     page.get_by_role("button", name="Apply", exact=True).click()
     expect(page.locator("#messageArea")).to_have_text("Applying…")
-    page.wait_for_function("window.applyRequestIntercepted()")
+    page.wait_for_function("window.applyRequestIntercepted === true")
     assert len(pending) == 1
     page.get_by_role("button", name="Code sessions", exact=True).click()
     page.get_by_role("button", name="New code session", exact=True).click()

{free_claude_code-6.3.0 → free_claude_code-6.3.2}/smoke/lib/e2e.py

@@ -32,6 +32,7 @@ from free_claude_code.messaging.voice import VoiceCancellationResult
 from free_claude_code.messaging.workflow import MessagingWorkflow
 from smoke.lib.child_process import run_captured_text
 from smoke.lib.config import ProviderModel, SmokeConfig, auth_headers
+from smoke.lib.http import conversation_headers
 from smoke.lib.server import RunningServer, start_server
 from smoke.lib.skips import fail_missing_env, skip_if_upstream_unavailable_events
 
@@ -88,6 +89,7 @@ class ConversationDriver:
         self.config = config
         self.messages: list[dict[str, Any]] = []
         self.turns: list[ConversationTurn] = []
+        self._session_id = str(uuid.uuid4())
 
     def ask(
         self,
@@ -120,7 +122,7 @@ class ConversationDriver:
         *,
         headers: dict[str, str] | None = None,
     ) -> ConversationTurn:
-        request_headers = headers or auth_headers()
+        request_headers = conversation_headers(headers, session_id=self._session_id)
         stream_payload = {**payload, "stream": True}
         with httpx.stream(
             "POST",
@@ -148,7 +150,7 @@ class ConversationDriver:
     ) -> dict[str, Any]:
         response = httpx.post(
             f"{self.server.base_url}/v1/messages",
-            headers=auth_headers(),
+            headers=conversation_headers(session_id=self._session_id),
             json=payload,
             timeout=self.config.timeout_s,
         )

{free_claude_code-6.3.0 → free_claude_code-6.3.2}/smoke/lib/http.py

@@ -1,5 +1,6 @@
 """HTTP helpers for live smoke requests."""
 
+import uuid
 from typing import Any
 
 import httpx
@@ -10,6 +11,16 @@ from .config import SmokeConfig, auth_headers, redacted
 from .server import RunningServer
 
 
+def conversation_headers(
+    headers: dict[str, str] | None = None, *, session_id: str | None = None
+) -> dict[str, str]:
+    """Identify a smoke conversation while preserving explicit caller headers."""
+    result = httpx.Headers(auth_headers() if headers is None else headers)
+    result.setdefault("user-agent", "fcc-smoke/1.0")
+    result.setdefault("x-opencode-session", session_id or str(uuid.uuid4()))
+    return dict(result)
+
+
 def message_payload(
     text: str,
     *,
@@ -35,7 +46,7 @@ def post_json(
     *,
     headers: dict[str, str] | None = None,
 ) -> httpx.Response:
-    request_headers = headers or auth_headers()
+    request_headers = conversation_headers(headers)
     response = httpx.post(
         f"{server.base_url}{path}",
         headers=request_headers,
@@ -52,7 +63,7 @@ def collect_message_stream(
     *,
     headers: dict[str, str] | None = None,
 ) -> list[SSEEvent]:
-    request_headers = headers or auth_headers()
+    request_headers = conversation_headers(headers)
     stream_payload = {**payload, "stream": True}
     with httpx.stream(
         "POST",

{free_claude_code-6.3.0 → free_claude_code-6.3.2}/smoke/prereq/test_provider_prereq_live.py

@@ -8,9 +8,9 @@ from free_claude_code.core.anthropic.stream_contracts import (
     text_content,
     thinking_content,
 )
-from smoke.lib.config import ProviderModel, SmokeConfig, auth_headers
+from smoke.lib.config import ProviderModel, SmokeConfig
 from smoke.lib.e2e import ProviderMatrixDriver
-from smoke.lib.http import collect_message_stream, message_payload
+from smoke.lib.http import collect_message_stream, conversation_headers, message_payload
 from smoke.lib.server import start_server
 from smoke.lib.skips import (
     skip_if_upstream_unavailable_events,
@@ -97,7 +97,7 @@ def test_client_disconnect_mid_stream_does_not_crash_server(
         with httpx.stream(
             "POST",
             f"{server.base_url}/v1/messages",
-            headers=auth_headers(),
+            headers=conversation_headers(),
             json=message_payload(smoke_config.prompt, model="fcc-smoke-default"),
             timeout=smoke_config.timeout_s,
         ) as response:

{free_claude_code-6.3.0 → free_claude_code-6.3.2}/smoke/product/test_provider_product_live.py

@@ -9,7 +9,7 @@ from free_claude_code.core.anthropic.stream_contracts import (
     SSEEvent,
     parse_sse_lines,
 )
-from smoke.lib.config import ProviderModel, SmokeConfig, auth_headers
+from smoke.lib.config import ProviderModel, SmokeConfig
 from smoke.lib.e2e import (
     ConversationDriver,
     ProviderMatrixDriver,
@@ -19,7 +19,7 @@ from smoke.lib.e2e import (
     echo_tool_schema,
     tool_use_blocks,
 )
-from smoke.lib.http import collect_message_stream
+from smoke.lib.http import collect_message_stream, conversation_headers
 from smoke.lib.skips import (
     skip_if_upstream_unavailable_events,
     skip_if_upstream_unavailable_exception,
@@ -166,7 +166,7 @@ def test_provider_error_e2e(smoke_config: SmokeConfig) -> None:
     ):
         response = client.post(
             f"{server.base_url}/v1/messages",
-            headers=auth_headers(),
+            headers=conversation_headers(),
             json={
                 "model": "fcc-smoke-default",
                 "max_tokens": 32,
@@ -605,11 +605,12 @@ def _scenario_reasoning_tool_continuation(
 def _scenario_disconnect(
     smoke_config: SmokeConfig, provider_model: ProviderModel
 ) -> None:
+    headers = conversation_headers()
     with _server_for_provider(smoke_config, provider_model, "disconnect") as server:
         with httpx.stream(
             "POST",
             f"{server.base_url}/v1/messages",
-            headers=auth_headers(),
+            headers=headers,
             json={
                 "model": "fcc-smoke-default",
                 "max_tokens": 512,
@@ -623,7 +624,7 @@ def _scenario_disconnect(
         health = httpx.get(f"{server.base_url}/health", timeout=5)
         assert health.status_code == 200
         followup = ConversationDriver(server, smoke_config).ask(
-            "Reply with one short sentence."
+            "Reply with one short sentence.", headers=headers
         )
     _assert_provider_product_stream(followup.events)
 
@@ -646,4 +647,4 @@ def _openai_auth_headers(smoke_config: SmokeConfig) -> dict[str, str]:
     token = smoke_config.settings.proxy_auth_token
     if token:
         headers["authorization"] = f"Bearer {token}"
-    return headers
+    return conversation_headers(headers)

{free_claude_code-6.3.0 → free_claude_code-6.3.2}/src/free_claude_code/cli/launchers/cline.py

@@ -1,4 +1,10 @@
-"""Installed Cline launcher with private native provider settings."""
+"""Installed Cline launcher with private native provider settings.
+
+Sessions run with an isolated Hub discovery path so a stale or user-run Cline
+Hub can never capture an fcc-cline session: the child resolves Hub state only
+inside FCC's ephemeral configuration directory, which is deleted on exit. A
+Hub started with ordinary cline keeps using its own discovery file.
+"""
 
 import re
 from collections.abc import Sequence
@@ -29,6 +35,17 @@ def _configure(
     )
     providers_path = files.write_json("settings/providers.json", config.providers)
     files.write_json("settings/models.json", config.models)
+    # Interactive Cline passes backendMode:"auto" to core, which overrides
+    # CLINE_SESSION_BACKEND_MODE and may attach to (or start) a detached Hub
+    # that resolves provider settings from the user's global store instead of
+    # FCC's ephemeral files. Redirecting Hub discovery into the ephemeral tree
+    # makes that attachment impossible without touching user-run Hub state.
+    # (Verified: shipped Cline 3.0.57 honors CLINE_HUB_DISCOVERY_PATH as the
+    # discovery-path override in its hub resolver.)
+    hub_discovery_path = files.directory / "hub" / "production.json"
+    # Pre-create the directory, not the file: the child records Hub discovery
+    # state here on startup, and the Hub itself must own the file.
+    hub_discovery_path.parent.mkdir(parents=True, mode=0o700, exist_ok=True)
     return PreparedLaunch(
         [ctx.binary_path, "--provider", CLINE_PROVIDER_ID, *args],
         client_environment(
@@ -37,6 +54,7 @@ def _configure(
             updates={
                 "CLINE_PROVIDER_SETTINGS_PATH": str(providers_path),
                 "CLINE_SESSION_BACKEND_MODE": "local",
+                "CLINE_HUB_DISCOVERY_PATH": str(hub_discovery_path),
             },
         ),
     )

{free_claude_code-6.3.0 → free_claude_code-6.3.2}/src/free_claude_code/providers/nvidia_nim/client.py

@@ -33,7 +33,6 @@ from .request_options import (
 )
 from .retry import (
     clone_body_without_chat_template,
-    clone_body_without_reasoning_budget,
     clone_body_without_reasoning_content,
 )
 from .tool_schema import (
@@ -61,10 +60,7 @@ class NvidiaNimChatBehavior(OpenAIChatBehavior):
 
     @property
     def reasoning_off_fields(self) -> tuple[tuple[str, ...], ...]:
-        return (
-            ("extra_body", "chat_template_kwargs", "thinking"),
-            ("extra_body", "chat_template_kwargs", "enable_thinking"),
-        )
+        return (("reasoning_effort",),)
 
     @property
     def normal_max_tokens(self) -> int | None:
@@ -118,17 +114,6 @@ class NvidiaNimChatBehavior(OpenAIChatBehavior):
             error_text = f"{error_text} {json.dumps(error_body, default=str)}"
         error_text = error_text.lower()
 
-        if _is_reasoning_budget_rejection(error_text) and (
-            bad_request_like or status_code == 500
-        ):
-            retry_body = clone_body_without_reasoning_budget(body)
-            if retry_body is None:
-                return None
-            logger.warning(
-                "NIM_STREAM: retrying without reasoning budget after upstream rejection"
-            )
-            return retry_body
-
         if not bad_request_like:
             return None
 
@@ -215,10 +200,3 @@ def _is_degraded_function(body: Mapping[str, Any]) -> bool:
         and function_id
         and state.strip() == _DEGRADED_FUNCTION_STATE
     )
-
-
-def _is_reasoning_budget_rejection(error_text: str) -> bool:
-    """Return whether NIM rejected optional thinking budget control."""
-    if "reasoning_budget" in error_text:
-        return True
-    return "thinking_token_budget" in error_text and "reasoning_config" in error_text

{free_claude_code-6.3.0 → free_claude_code-6.3.2}/src/free_claude_code/providers/nvidia_nim/request_options.py

@@ -6,14 +6,21 @@ from typing import Any
 from free_claude_code.config.nim import NimSettings
 from free_claude_code.core.anthropic import ReasoningReplayMode, set_if_not_none
 from free_claude_code.core.anthropic.models import MessagesRequest
-from free_claude_code.core.reasoning import ReasoningControl, ReasoningPolicy
+from free_claude_code.core.reasoning import ReasoningEffort, ReasoningPolicy
 from free_claude_code.providers.openai_chat import (
+    NamedEffortReasoning,
     OpenAIChatRequestPolicy,
     build_openai_chat_request_body,
 )
 
 from .tool_schema import sanitize_nim_tool_schemas
 
+NIM_REASONING = NamedEffortReasoning(
+    tuple((effort, effort.value) for effort in ReasoningEffort),
+    disabled_value="none",
+    enabled_value="high",
+)
+
 NIM_REQUEST_POLICY = OpenAIChatRequestPolicy(
     provider_name="NIM",
     reasoning_replay=ReasoningReplayMode.REASONING_CONTENT,
@@ -106,14 +113,7 @@ def apply_nim_request_options(
         if not request_template_kwargs:
             extra_body.pop("chat_template_kwargs", None)
 
-    if reasoning.control is ReasoningControl.OFF or reasoning.requests_reasoning:
-        chat_template_kwargs = extra_body.setdefault("chat_template_kwargs", {})
-        if isinstance(chat_template_kwargs, dict):
-            enabled = reasoning.control is not ReasoningControl.OFF
-            chat_template_kwargs["thinking"] = enabled
-            chat_template_kwargs["enable_thinking"] = enabled
-            if enabled and (budget := reasoning.numeric_budget_tokens) is not None:
-                chat_template_kwargs["reasoning_budget"] = budget
+    NIM_REASONING.encode(body, reasoning)
 
     _set_extra(extra_body, "top_k", nim.top_k, ignore_value=-1)
     _set_extra(extra_body, "min_p", nim.min_p, ignore_value=0.0)

{free_claude_code-6.3.0 → free_claude_code-6.3.2}/src/free_claude_code/providers/nvidia_nim/retry.py

@@ -7,11 +7,6 @@ from typing import Any
 from free_claude_code.core.history_replay import reasoning_context
 
 
-def clone_body_without_reasoning_budget(body: dict[str, Any]) -> dict[str, Any] | None:
-    """Clone a request body and strip only reasoning_budget fields."""
-    return _clone_strip_extra_body(body, _strip_reasoning_budget_fields)
-
-
 def clone_body_without_chat_template(body: dict[str, Any]) -> dict[str, Any] | None:
     """Clone a request body and strip NIM chat-template control fields."""
     return _clone_strip_extra_body(body, _strip_chat_template_fields)
@@ -42,17 +37,6 @@ def _clone_strip_extra_body(
     return cloned_body
 
 
-def _strip_reasoning_budget_fields(extra_body: dict[str, Any]) -> bool:
-    removed = extra_body.pop("reasoning_budget", None) is not None
-    chat_template_kwargs = extra_body.get("chat_template_kwargs")
-    if (
-        isinstance(chat_template_kwargs, dict)
-        and chat_template_kwargs.pop("reasoning_budget", None) is not None
-    ):
-        removed = True
-    return removed
-
-
 def _strip_chat_template_fields(extra_body: dict[str, Any]) -> bool:
     removed = extra_body.pop("chat_template", None) is not None
     if extra_body.pop("chat_template_kwargs", None) is not None:

{free_claude_code-6.3.0 → free_claude_code-6.3.2}/tests/cli/test_cline_launcher.py

@@ -139,6 +139,7 @@ def test_cline_native_configuration_is_available_to_child(launch_capture) -> Non
     from tests.cli.test_launcher_workflow import launch
 
     launch_ids = []
+    hub_paths = []
 
     def inspect(command, env):
         providers_path = Path(env["CLINE_PROVIDER_SETTINGS_PATH"])
@@ -152,6 +153,16 @@ def test_cline_native_configuration_is_available_to_child(launch_capture) -> Non
         assert settings["model"] in models["providers"][CLINE_PROVIDER_ID]["models"]
         assert env["CLINE_SESSION_BACKEND_MODE"] == "local"
         assert command[:3] == ["cline", "--provider", "openai-native"]
+        hub_path = Path(env["CLINE_HUB_DISCOVERY_PATH"])
+        assert hub_path.parent.name == "hub"
+        assert hub_path.name == "production.json"
+        # Hub discovery must resolve inside the same ephemeral tree as the
+        # private provider files. The hub/ directory is pre-created so the
+        # child can record discovery state; the file itself must not exist.
+        assert hub_path.parent.parent == providers_path.parent.parent
+        assert hub_path.parent.is_dir()
+        assert not hub_path.exists()
+        hub_paths.append(hub_path)
 
     launch_capture.on_start = inspect
     args = ["--model", "native-selection", "--data-dir", "native-data-dir"]
@@ -159,3 +170,32 @@ def test_cline_native_configuration_is_available_to_child(launch_capture) -> Non
     assert launch_capture.commands[0][-len(args) :] == args
     launch("cline", [])
     assert launch_ids[0] != launch_ids[1]
+    assert hub_paths[0] != hub_paths[1]
+    assert all(not hub_path.exists() for hub_path in hub_paths)
+
+
+def test_cline_hub_discovery_path_overrides_stale_inherited_value(
+    launch_capture, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    from tests.cli.test_launcher_workflow import launch
+
+    monkeypatch.setenv("CLINE_HUB_DISCOVERY_PATH", "stale-user-hub-discovery.json")
+    dir_existed_at_start = []
+
+    def inspect(command, env):
+        hub_dir = Path(env["CLINE_HUB_DISCOVERY_PATH"]).parent
+        dir_existed_at_start.append(hub_dir.is_dir())
+
+    launch_capture.on_start = inspect
+    launch("cline", [])
+    hub_path = Path(launch_capture.environments[0]["CLINE_HUB_DISCOVERY_PATH"])
+    # The stale user-level discovery file must be replaced by the isolated
+    # ephemeral path, never inherited by the fcc-cline child. The hub/
+    # directory is pre-created at launch (checked via on_start, since the
+    # ephemeral tree is cleaned up when the launcher exits); only the file
+    # itself must not be pre-created.
+    assert hub_path.name == "production.json"
+    assert hub_path.parent.name == "hub"
+    assert str(hub_path) != "stale-user-hub-discovery.json"
+    assert dir_existed_at_start == [True]
+    assert not hub_path.exists()

{free_claude_code-6.3.0 → free_claude_code-6.3.2}/tests/contracts/test_issue_form_version_validation.py

@@ -76,6 +76,21 @@ def test_bug_forms_require_description_and_post_install_diagnostics() -> None:
     "body, valid, version",
     [
         ('### FCC doctor output\n\n```json\n{"version":"1.2.3"}\n```', True, "1.2.3"),
+        (
+            '### FCC doctor output\n\n<details>\n<summary>FCC doctor output</summary>\n\n```json\n{"version":"1.2.3"}\n```\n\n</details>',
+            True,
+            "1.2.3",
+        ),
+        (
+            '### FCC doctor output\r\n\r\n<details>\r\n<summary>Diagnostics</summary>\r\n\r\n```json\r\n{"version":"1.2.3"}\r\n```\r\n\r\n</details>',
+            True,
+            "1.2.3",
+        ),
+        (
+            "### FCC doctor output\n\n<details>\n<summary>Diagnostics</summary>\n\n```json\n{invalid}\n```\n\n</details>",
+            False,
+            None,
+        ),
         (
             '### FCC doctor output\r\n\r\n```json\r\n{"version":"1.2.3"}\r\n```',
             True,
@@ -101,6 +116,12 @@ def test_bug_forms_require_description_and_post_install_diagnostics() -> None:
     ],
 )
 def test_report_parser_uses_the_correct_form_section(body, valid, version):
+    result = _parse_report(body)
+    assert result["valid"] is valid
+    assert result.get("reportedVersion") == version
+
+
+def _parse_report(body):
     patterns = "\n".join(
         f"const {name} = {json.dumps(_workflow_pattern(name))};"
         for name in ("fieldPattern", "versionPattern")
@@ -109,9 +130,71 @@ def test_report_parser_uses_the_correct_form_section(body, valid, version):
     script += (
         f"\nprocess.stdout.write(JSON.stringify(parseReport({json.dumps(body)})));"
     )
-    result = _run_javascript(script)
-    assert result["valid"] is valid
-    assert result.get("reportedVersion") == version
+    return _run_javascript(script)
+
+
+def test_plain_doctor_report_can_be_collapsed_without_changing_its_data(
+    monkeypatch, capsys
+):
+    from free_claude_code.cli import doctor
+
+    copied = []
+    report = {"version": "1.2.3", "model_routing": {"model": "provider/```</details>"}}
+    monkeypatch.setattr(doctor, "collect_report", lambda: report)
+    monkeypatch.setattr(doctor, "copy_text", copied.append)
+    doctor.main([])
+    assert json.loads(capsys.readouterr().out) == report
+    assert json.loads(copied[0]) == report
+    body = "### FCC doctor output\n\n" + copied[0]
+    collapsed = _collapse_report(body)
+    assert collapsed.startswith("### FCC doctor output\n\n<details>\n")
+    assert json.loads(collapsed.split("```json\n", 1)[1].rsplit("```", 1)[0]) == report
+    assert _parse_report(collapsed) == {"valid": True, "reportedVersion": "1.2.3"}
+
+
+def _collapse_report(body):
+    patterns = "\n".join(
+        f"const {name} = {json.dumps(_workflow_pattern(name))};"
+        for name in ("fieldPattern", "versionPattern")
+    )
+    script = (
+        patterns
+        + "\n"
+        + _javascript_function("parseReport")
+        + "\n"
+        + _javascript_function("collapseDoctorReport")
+    )
+    script += f"\nprocess.stdout.write(JSON.stringify(collapseDoctorReport({json.dumps(body)})));"
+    return _run_javascript(script)
+
+
+@pytest.mark.parametrize("newline", ["\n", "\r\n"])
+@pytest.mark.parametrize("fenced", [False, True])
+def test_collapsing_only_changes_doctor_section_and_is_idempotent(newline, fenced):
+    report = '{"version":"1.2.3","model":"$&```</details>"}'
+    content = f"```json\n{report}\n```" if fenced else report
+    before = "### Describe the issue\n\nMy description and ![image](https://example.com/image.png)\n\n### FCC doctor output\n\n"
+    after = "\n\n### Other details\n\nKeep this text exactly.\n"
+    body = (before + content + after).replace("\n", newline)
+    collapsed = _collapse_report(body)
+    assert collapsed.startswith(before.replace("\n", newline) + "<details>")
+    assert collapsed.endswith(after.replace("\n", newline))
+    assert report in collapsed
+    assert _collapse_report(collapsed) == collapsed
+    assert _parse_report(collapsed) == {"valid": True, "reportedVersion": "1.2.3"}
+
+
+@pytest.mark.parametrize(
+    "body",
+    [
+        "### Installation issue\n\nCannot install",
+        "### FCC version\n\n1.2.3",
+        "### FCC doctor output\n\n{invalid}",
+        '### FCC doctor output\n\n{"version":"1.2.3"}\n\n### FCC doctor output\n\n{"version":"1.2.3"}',
+    ],
+)
+def test_collapsing_leaves_other_or_invalid_reports_untouched(body):
+    assert _collapse_report(body) == body
 
 
 @pytest.mark.parametrize(
@@ -248,6 +331,11 @@ const github = {
         record("getIssue", args);
         return { data: liveIssue };
       },
+      update: async (args) => {
+        record("updateIssue", args);
+        liveIssue.body = args.body;
+        return { data: liveIssue };
+      },
       getLabel: async (args) => record("getLabel", args),
       createLabel: async (args) => record("createLabel", args),
       addLabels: async (args) => {
@@ -336,6 +424,7 @@ process.stdout.write(JSON.stringify({ calls, comments }));
     assert names.count("deleteComment") == 3
     assert names.count("getLatestRelease") == 4
     assert names.count("getIssue") == 6
+    assert names.count("updateIssue") == (3 if form == "doctor" else 0)
     assert names.count("getLabel") == 1
     assert names.count("addLabels") == 1
     assert names.count("removeLabel") == 2
@@ -354,7 +443,11 @@ process.stdout.write(JSON.stringify({ calls, comments }));
     )
     assert result["comments"] == []
     assert "cancel-in-progress: false" in workflow
-    assert "github.rest.issues.update({" not in workflow
+    assert all(
+        set(call["args"]) == {"owner", "repo", "issue_number", "body"}
+        for call in calls
+        if call["name"] == "updateIssue"
+    )
     assert 'state: "closed"' not in workflow