create-windy 0.8.0 → 0.8.2

package/dist/cli.js

@@ -2022,7 +2022,14 @@ var nativeSymbols = {
 };
 var directoryFlags = constants2.O_RDONLY | constants2.O_DIRECTORY | constants2.O_NOFOLLOW;
 var removeDirectoryFlag = process.platform === "darwin" ? 128 : 512;
-var getLibc = createLazyLibcLoader((candidate) => dlopen2(candidate, nativeSymbols), "\u5F53\u524D\u5E73\u53F0\u65E0\u6CD5\u52A0\u8F7D\u5B89\u5168\u76EE\u5F55\u53E5\u67C4 API");
+var getLibc = createLazyLibcLoader((candidate) => {
+  const libc = dlopen2(candidate, nativeSymbols);
+  const errnoSymbol = process.platform === "darwin" ? libc.symbols.__error : libc.symbols.__errno_location;
+  const errnoPointer = errnoSymbol();
+  if (!errnoPointer)
+    throw new Error("\u65E0\u6CD5\u8BFB\u53D6\u539F\u751F\u9519\u8BEF\u7801\uFF0C\u4E8B\u52A1\u5B89\u5168\u5173\u95ED");
+  return { symbols: libc.symbols, errnoPointer };
+}, "\u5F53\u524D\u5E73\u53F0\u65E0\u6CD5\u52A0\u8F7D\u5B89\u5168\u76EE\u5F55\u53E5\u67C4 API");
 function resolveSafeTarget(root, path) {
   if (!path || isAbsolute(path) || path.includes("\x00") || path.split(/[\\/]/).includes("..")) {
     throw new Error(`\u66F4\u65B0\u8BA1\u5212\u5305\u542B\u4E0D\u5B89\u5168\u8DEF\u5F84\uFF1A${path}`);
@@ -2196,12 +2203,7 @@ function nativeUnlinkAt(directoryFd, name, flags) {
 }
 function nativeError(syscall, path) {
   const libc = getLibc();
-  const errnoSymbol = process.platform === "darwin" ? libc.symbols.__error : libc.symbols.__errno_location;
-  const errnoPointer = errnoSymbol();
-  if (!errnoPointer) {
-    throw new Error(`\u65E0\u6CD5\u8BFB\u53D6 ${syscall} \u7684\u539F\u751F\u9519\u8BEF\u7801\uFF0C\u4E8B\u52A1\u5B89\u5168\u5173\u95ED`);
-  }
-  const errno = read.i32(errnoPointer, 0);
+  const errno = read.i32(libc.errnoPointer, 0);
   return Object.assign(new Error(`${syscall} ${path} \u5931\u8D25`), {
     code: errnoCode(errno),
     errno: -errno,
@@ -4107,6 +4109,8 @@ var templateDocumentationFiles = [
   "docs/architecture/mcp-business-capabilities.md",
   "docs/architecture/migration-bundle.md",
   "docs/architecture/module-host.md",
+  "docs/architecture/log-governance-plan.md",
+  "docs/architecture/log-governance-implementation.md",
   "docs/architecture/module-manifest-composition.md",
   "docs/architecture/module-secret-resolution.md",
   "docs/architecture/object-storage.md",
@@ -8524,7 +8528,9 @@ var recipes = [
     id: "starter-0.7.0-to-0.8.0",
     from: "0.7.0",
     to: "0.8.0"
-  }
+  },
+  { id: "starter-0.8.0-to-0.8.1", from: "0.8.0", to: "0.8.1" },
+  { id: "starter-0.8.1-to-0.8.2", from: "0.8.1", to: "0.8.2" }
 ];
 function resolveRecipeChain(sourceVersion, targetVersion) {
   if (compareVersions2(sourceVersion, minimumSupportedUpdateVersion) < 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-windy",
-  "version": "0.8.0",
+  "version": "0.8.2",
   "description": "创建单组织、单租户、私有部署优先的 Windy 企业 Dashboard Starter",
   "type": "module",
   "bin": {

package/template/.windy-template.json

@@ -1,7 +1,7 @@
 {
   "schemaVersion": 1,
-  "templateCommit": "20ddeda7267de315fb8fe115d64ad6b8c892ccb8",
-  "generatorVersion": "0.8.0",
+  "templateCommit": "7c00e145cc8fef9f4c6ec621e8740e3c01f7cc2d",
+  "generatorVersion": "0.8.2",
   "modules": [
     {
       "name": "system",

package/template/apps/agent-server/Dockerfile

@@ -24,4 +24,4 @@ RUN mkdir -p /app/data/agent \
 USER windy
 HEALTHCHECK --interval=15s --timeout=5s --start-period=10s --retries=4 \
   CMD ["python", "-c", "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/ready', timeout=3)"]
-CMD ["uvicorn", "southwind_agent_server.app:app", "--host", "0.0.0.0", "--port", "8080"]
+CMD ["uvicorn", "southwind_agent_server.asgi:app", "--host", "0.0.0.0", "--port", "8080"]

package/template/apps/agent-server/README.md

@@ -43,7 +43,7 @@ export AI_PROVIDER_INPUT_MODALITIES='text'
 export AGENT_RUN_STORE_PATH='.data/agent-runs.sqlite3'
 export AI_PROVIDER_AUDIT_STORE_PATH='.data/provider-audit.sqlite3'
 export AI_PROVIDER_AUDIT_RETENTION_DAYS='90'
-uv run uvicorn southwind_agent_server.app:app
+uv run uvicorn southwind_agent_server.asgi:app
 ```
 
 公网 URL 必须使用 HTTPS 且 Host 精确命中 allowlist；本机、容器服务名和内网地址允许

package/template/apps/agent-server/src/southwind_agent_server/asgi.py

@@ -0,0 +1,8 @@
+"""Production ASGI entrypoint with operational logging installed."""
+
+from .app import app
+from .structured_logging import configure_agent_logging
+
+configure_agent_logging()
+
+__all__ = ["app"]

package/template/apps/agent-server/src/southwind_agent_server/attempt_context.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from dataclasses import dataclass
+from dataclasses import dataclass, replace
 
 from .attempt_context_projection import (
     AttemptContextPreparation,
@@ -15,6 +15,7 @@ from .contracts import JsonValue, LongSessionContext
 from .engine import EngineRunRequest, PreparedArtifact
 from .openai_provider import OpenAiCompatibleProvider
 from .provider_governance import GovernedAttempt, ProviderRequestGovernance
+from .provider_output_guidance import tool_output_messages
 
 
 @dataclass(frozen=True)
@@ -64,6 +65,13 @@ async def govern_provider_attempt(
                 )
             ),
         )
+        if governed.tools:
+            governed = replace(
+                governed,
+                messages=tool_output_messages(
+                    governed.messages, governed.output_schema
+                ),
+            )
         provider_request = provider.request_body(
             governed.messages,
             governed.tools,

package/template/apps/agent-server/src/southwind_agent_server/openai_provider.py

@@ -14,6 +14,7 @@ from .config import (
 from .contracts import AgentErrorCode, JsonValue, RuntimeToolDefinition
 from .engine import SafeEngineError
 from .multimodal import response_format
+from .provider_output_guidance import tool_output_messages
 from .report_types import UsageFacts
 from .vision_probe import probe_vision
 
@@ -97,6 +98,9 @@ class OpenAiCompatibleProvider:
         output_schema: dict[str, JsonValue] | None = None,
         max_output_tokens: int | None = None,
     ) -> bytes:
+        structured = response_format(output_schema_key, output_schema)
+        if tools:
+            messages = tool_output_messages(messages, output_schema)
         payload: dict[str, JsonValue] = {
             "model": self.config.model,
             "messages": cast(JsonValue, messages),
@@ -105,8 +109,7 @@ class OpenAiCompatibleProvider:
         }
         if tools:
             payload["tools"] = [tool_schema(tool) for tool in tools]
-        structured = response_format(output_schema_key, output_schema)
-        if structured is not None:
+        if structured is not None and not tools:
             payload["response_format"] = structured
         if max_output_tokens is not None:
             payload["max_tokens"] = max_output_tokens

package/template/apps/agent-server/src/southwind_agent_server/provider_output_guidance.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+import json
+
+from .contracts import JsonValue
+from .engine import SafeEngineError
+
+
+def tool_output_messages(
+    messages: list[dict[str, JsonValue]],
+    output_schema: dict[str, JsonValue] | None,
+) -> list[dict[str, JsonValue]]:
+    """Merge already-governed schema guidance without moving Context source ordinals."""
+    if output_schema is None:
+        return messages
+    if not messages or messages[0].get("role") != "system":
+        raise SafeEngineError(
+            "INVALID_INPUT", "工具结构化输出缺少系统指令", retryable=False
+        )
+    instructions = messages[0].get("content")
+    if not isinstance(instructions, str):
+        raise SafeEngineError(
+            "INVALID_INPUT", "工具结构化输出指令无效", retryable=False
+        )
+    guidance = (
+        "\n\n需要工具时，只通过 API 的 function calling 调用已提供的工具，"
+        "不要在正文中模拟工具调用。工具处理完成后的最终回复必须是符合以下 "
+        "JSON Schema 的单个 JSON 值，不含 Markdown 围栏或额外说明；"
+        "工具调用阶段不受最终 JSON 格式限制。\n"
+        + json.dumps(output_schema, ensure_ascii=False, separators=(",", ":"))
+    )
+    if instructions.endswith(guidance):
+        return messages
+    return [{**messages[0], "content": instructions + guidance}, *messages[1:]]

package/template/apps/agent-server/src/southwind_agent_server/runtime_logging.py

@@ -0,0 +1,57 @@
+"""Safe attempt diagnostics, separate from the canonical Run store and audit."""
+
+from __future__ import annotations
+
+import logging
+import time
+
+from .store import RunRecord
+
+logger = logging.getLogger(__name__)
+
+
+class AgentOperationalAttempt:
+    def __init__(self, record: RunRecord) -> None:
+        self._run_id = record.run_id
+        self._trace_id = record.trace_id
+        self._started_at: float | None = None
+        self._finished = False
+
+    def start(self) -> None:
+        if self._started_at is not None:
+            return
+        self._started_at = time.monotonic()
+        self._emit("agent.run.attempt.started")
+
+    def finish(self, status: str) -> None:
+        if self._started_at is None or self._finished:
+            return
+        self._finished = True
+        self._emit(
+            "agent.run.attempt.completed",
+            operational_status=status,
+            operational_duration_ms=round(
+                (time.monotonic() - self._started_at) * 1_000, 3
+            ),
+        )
+
+    def _emit(self, event: str, **fields: str | float) -> None:
+        try:
+            emit = (
+                logger.warning
+                if event == "agent.run.attempt.completed"
+                and fields.get("operational_status") != "completed"
+                else logger.info
+            )
+            emit(
+                "Agent 执行阶段",
+                extra={
+                    "operational_event": event,
+                    "run_id": self._run_id,
+                    "trace_id": self._trace_id,
+                    **fields,
+                },
+            )
+        except Exception:
+            # 日志出口失败不能改变 Run 或租约的业务结果。
+            return

package/template/apps/agent-server/src/southwind_agent_server/structured_logging.py

@@ -0,0 +1,145 @@
+"""Agent runtime adapter for the Windy operational log contract."""
+
+from __future__ import annotations
+
+import json
+import logging
+import math
+import re
+import sys
+from datetime import UTC, datetime
+from typing import TextIO
+
+MAX_LOG_BYTES = 2048
+_CORRELATION = re.compile(r"^[A-Za-z0-9._-]{1,128}$")
+_STABLE = re.compile(r"^[a-z][a-z0-9]*(?:[._-][a-z0-9]+)*$")
+_EVENTS = {
+    "Agent Run 恢复轮询失败，将继续重试": (
+        "agent.run.recovery.failed",
+        "AGENT_RUN_RECOVERY_FAILED",
+    ),
+    "Agent Runtime 报表写入失败": (
+        "agent.report.write.failed",
+        "AGENT_REPORT_WRITE_FAILED",
+    ),
+}
+_ATTEMPT_EVENTS = frozenset(
+    {
+        "agent.run.attempt.started",
+        "agent.run.attempt.completed",
+    }
+)
+_ATTEMPT_ERRORS = {
+    "failed": "AGENT_RUN_FAILED",
+    "cancelled": "AGENT_RUN_CANCELLED",
+    "interrupted": "AGENT_RUN_INTERRUPTED",
+}
+
+
+def agent_log_record(record: logging.LogRecord) -> dict[str, str | bool | float]:
+    """Map known runtime failures without serializing messages, errors or extras."""
+    event, error_code = _EVENTS.get(
+        record.msg if isinstance(record.msg, str) else "",
+        ("agent.runtime.failed", "AGENT_RUNTIME_FAILED"),
+    )
+    attempt_event = getattr(record, "operational_event", None)
+    is_attempt = isinstance(attempt_event, str) and attempt_event in _ATTEMPT_EVENTS
+    result: dict[str, str | bool | float] = {
+        "timestamp": datetime.now(UTC)
+        .isoformat(timespec="milliseconds")
+        .replace("+00:00", "Z"),
+        "level": "error"
+        if record.levelno >= logging.ERROR
+        else ("warn" if record.levelno >= logging.WARNING else "info"),
+        "component": "agent-server",
+        "event": attempt_event
+        if isinstance(attempt_event, str) and is_attempt
+        else event,
+        "retentionClass": "operational",
+    }
+    if not is_attempt:
+        result.update(outcome="failure", errorCode=error_code)
+    elif attempt_event == "agent.run.attempt.completed":
+        status = getattr(record, "operational_status", "interrupted")
+        if status not in {"completed", "failed", "cancelled"}:
+            status = "interrupted"
+        result["stageKey"] = status
+        result["outcome"] = "success" if status == "completed" else "failure"
+        if status != "completed":
+            result["errorCode"] = _ATTEMPT_ERRORS[status]
+        duration = getattr(record, "operational_duration_ms", None)
+        if (
+            isinstance(duration, (int, float))
+            and not isinstance(duration, bool)
+            and math.isfinite(duration)
+            and 0 <= duration <= 3_600_000
+        ):
+            result["durationMs"] = duration
+    for source, target in (
+        ("request_id", "requestId"),
+        ("run_id", "runId"),
+        ("job_id", "jobId"),
+        ("trace_id", "traceId"),
+    ):
+        value = getattr(record, source, None)
+        if isinstance(value, str) and _CORRELATION.fullmatch(value):
+            result[target] = value
+    stage = getattr(record, "report_stage", None)
+    if isinstance(stage, str) and len(stage) <= 64 and _STABLE.fullmatch(stage):
+        result["stageKey"] = stage
+    for key in ("stageKey", "traceId", "jobId", "runId", "requestId"):
+        if len(json.dumps(result, ensure_ascii=False).encode("utf-8")) <= MAX_LOG_BYTES:
+            break
+        result.pop(key, None)
+        result["truncated"] = True
+    return result
+
+
+class AgentStructuredLogHandler(logging.Handler):
+    def __init__(self, stream: TextIO | None = None) -> None:
+        super().__init__(level=logging.INFO)
+        self.stream = stream or sys.stdout
+
+    def emit(self, record: logging.LogRecord) -> None:
+        try:
+            if (
+                record.levelno < logging.WARNING
+                and getattr(record, "operational_event", None) not in _ATTEMPT_EVENTS
+            ):
+                return
+            line = json.dumps(
+                agent_log_record(record), ensure_ascii=False, separators=(",", ":")
+            )
+            self.stream.write(f"{line}\n")
+            self.flush()
+        except Exception:
+            # 运行日志旁路失败时不能改变 Run 与报表写入的业务结果。
+            return
+
+    def flush(self) -> None:
+        try:
+            self.stream.flush()
+        except Exception:
+            return
+
+
+def configure_agent_logging() -> None:
+    """Use one package sink without closing handlers shared with Uvicorn."""
+    logger = logging.getLogger("southwind_agent_server")
+    structured = next(
+        (
+            handler
+            for handler in logger.handlers
+            if isinstance(handler, AgentStructuredLogHandler)
+        ),
+        None,
+    )
+    if structured is None:
+        structured = AgentStructuredLogHandler()
+    for handler in logger.handlers[:]:
+        if handler is not structured:
+            logger.removeHandler(handler)
+    if structured not in logger.handlers:
+        logger.addHandler(structured)
+    logger.setLevel(logging.INFO)
+    logger.propagate = False

package/template/apps/agent-server/src/southwind_agent_server/telemetry.py

@@ -17,6 +17,7 @@ from opentelemetry.trace import (
     TraceFlags,
 )
 
+from .runtime_logging import AgentOperationalAttempt
 from .store import RunRecord
 
 _configured = False
@@ -50,11 +51,14 @@ class AgentRunTrace:
             },
         )
         self._token: Token[Context] | None = None
+        self._operational = AgentOperationalAttempt(record)
 
     def start(self) -> None:
         self._token = context.attach(trace.set_span_in_context(self._span))
+        self._operational.start()
 
     def finish(self, status: str) -> None:
+        self._operational.finish(status)
         self._span.set_attribute("agent.run.status", status)
         if self._token is not None:
             context.detach(self._token)

package/template/apps/agent-server/tests/test_run_operational_logging.py

@@ -0,0 +1,114 @@
+from __future__ import annotations
+
+import asyncio
+import io
+import json
+import logging
+from collections.abc import Iterator
+from typing import TextIO, cast
+
+import httpx
+import pytest
+
+from southwind_agent_server.app import create_app
+from southwind_agent_server.deterministic import DeterministicEngineAdapter
+from southwind_agent_server.runtime_logging import AgentOperationalAttempt, logger
+from southwind_agent_server.service import AgentRunService
+from southwind_agent_server.store import RunRecord
+from southwind_agent_server.structured_logging import AgentStructuredLogHandler
+
+
+@pytest.fixture(autouse=True)
+def operational_log_level() -> Iterator[None]:
+    previous = logger.level
+    logger.setLevel(logging.INFO)
+    try:
+        yield
+    finally:
+        logger.setLevel(previous)
+
+
+@pytest.mark.parametrize("broken_sink", [False, True])
+async def test_real_run_completion_and_replay_with_operational_logs(
+    monkeypatch: pytest.MonkeyPatch,
+    broken_sink: bool,
+) -> None:
+    class Stream(io.StringIO):
+        def write(self, value: str) -> int:
+            written = super().write(value)
+            if broken_sink:
+                raise OSError("sink-secret")
+            return written
+
+    stream = Stream()
+    monkeypatch.setattr(logger, "handlers", [AgentStructuredLogHandler(stream)])
+    monkeypatch.setattr(logger, "propagate", False)
+    app = create_app(DeterministicEngineAdapter(), heartbeat_seconds=0.01)
+    service = cast(AgentRunService, app.state.run_service)
+    async with httpx.AsyncClient(
+        transport=httpx.ASGITransport(app=app),
+        base_url="http://agent.test",
+    ) as client:
+
+        async def start() -> httpx.Response:
+            return await client.post(
+                "/api/agent/runs",
+                headers={"Idempotency-Key": "operational-replay"},
+                json={
+                    "operationKey": "test.echo",
+                    "input": {"text": "input-secret"},
+                    "traceId": "1" * 32,
+                },
+            )
+
+        response = await start()
+        assert response.status_code == 200
+        run_id = str(response.json()["runId"])
+        await asyncio.gather(*service._tasks)
+        replay = await start()
+        assert replay.json()["runId"] == run_id
+        events = await client.get(f"/api/agent/runs/{run_id}/events")
+        result = await client.get(f"/api/agent/runs/{run_id}/result")
+    assert result.json()["status"] == "completed"
+    assert result.json()["output"] == {"text": "input-secret"}
+    assert "run.failed" not in events.text
+    records = [json.loads(line) for line in stream.getvalue().splitlines()]
+    assert [record["event"] for record in records] == [
+        "agent.run.attempt.started",
+        "agent.run.attempt.completed",
+    ]
+    assert all(record["runId"] == run_id for record in records)
+    assert all(record["traceId"] == "1" * 32 for record in records)
+    assert records[-1]["outcome"] == "success"
+    assert records[-1]["durationMs"] >= 0
+    assert "input-secret" not in stream.getvalue()
+    assert "sink-secret" not in stream.getvalue()
+
+
+@pytest.mark.parametrize("status", ["failed", "cancelled", "running"])
+def test_attempt_terminal_mapping_and_duplicate_finish_are_safe(
+    monkeypatch: pytest.MonkeyPatch,
+    status: str,
+) -> None:
+    stream = io.StringIO()
+    monkeypatch.setattr(logger, "handlers", [AgentStructuredLogHandler(stream)])
+    monkeypatch.setattr(logger, "propagate", False)
+    record = RunRecord("run-1", "test.echo", {"secret": "input"}, "key", "digest")
+    attempt = AgentOperationalAttempt(record)
+    attempt.start()
+    attempt.start()
+    attempt.finish(status)
+    attempt.finish(status)
+    records = [json.loads(line) for line in stream.getvalue().splitlines()]
+    assert len(records) == 2
+    assert records[-1]["outcome"] == "failure"
+    expected = status if status in {"failed", "cancelled"} else "interrupted"
+    assert records[-1]["errorCode"] == f"AGENT_RUN_{expected.upper()}"
+    assert "secret" not in stream.getvalue()
+
+
+def test_unknown_info_message_does_not_expand_log_content() -> None:
+    stream = io.StringIO()
+    handler = AgentStructuredLogHandler(cast(TextIO, stream))
+    handler.emit(logging.makeLogRecord({"levelno": logging.INFO, "msg": "secret"}))
+    assert stream.getvalue() == ""

package/template/apps/agent-server/tests/test_structured_logging.py

@@ -0,0 +1,142 @@
+import io
+import json
+import logging
+from importlib import import_module
+from typing import TextIO, cast
+
+import pytest
+
+from southwind_agent_server.structured_logging import (
+    MAX_LOG_BYTES,
+    AgentStructuredLogHandler,
+    agent_log_record,
+    configure_agent_logging,
+)
+
+
+def test_agent_report_failure_keeps_only_safe_correlation() -> None:
+    stream = io.StringIO()
+    handler = AgentStructuredLogHandler(stream)
+    logger = logging.getLogger("southwind_agent_server.test_structured_logging")
+    logger.addHandler(handler)
+    logger.setLevel(logging.WARNING)
+    logger.propagate = False
+    try:
+        try:
+            raise ValueError("secret-error")
+        except ValueError:
+            logger.exception(
+                "Agent Runtime 报表写入失败",
+                extra={
+                    "run_id": "run-1",
+                    "report_stage": "run_terminal",
+                    "request_id": "bad\nrequest-secret",
+                    "body": "secret-body",
+                    "authorization": "Bearer secret-token",
+                },
+            )
+    finally:
+        logger.removeHandler(handler)
+    line = stream.getvalue().strip()
+    parsed = json.loads(line)
+    assert parsed["event"] == "agent.report.write.failed"
+    assert parsed["errorCode"] == "AGENT_REPORT_WRITE_FAILED"
+    assert parsed["runId"] == "run-1"
+    assert parsed["stageKey"] == "run_terminal"
+    assert parsed["retentionClass"] == "operational"
+    assert len(line.encode("utf-8")) <= MAX_LOG_BYTES
+    assert all(
+        secret not in line
+        for secret in (
+            "request-secret",
+            "secret-body",
+            "secret-token",
+            "secret-error",
+        )
+    )
+
+
+def test_unknown_message_and_long_fields_are_bounded() -> None:
+    record = logging.makeLogRecord(
+        {
+            "name": "southwind_agent_server.service",
+            "levelno": logging.ERROR,
+            "msg": "secret-message",
+            "run_id": "x" * 500,
+            "report_stage": "payload secret",
+        }
+    )
+    safe = agent_log_record(record)
+    assert safe["event"] == "agent.runtime.failed"
+    assert "runId" not in safe
+    assert "stageKey" not in safe
+    assert "secret-message" not in json.dumps(safe)
+    assert len(json.dumps(safe).encode("utf-8")) <= MAX_LOG_BYTES
+
+
+def test_asgi_entrypoint_installs_handler_without_changing_app() -> None:
+    from southwind_agent_server.app import app
+
+    asgi = import_module("southwind_agent_server.asgi")
+    configure_agent_logging()
+    handlers = [
+        handler
+        for handler in logging.getLogger("southwind_agent_server").handlers
+        if isinstance(handler, AgentStructuredLogHandler)
+    ]
+    assert asgi.app is app
+    assert len(handlers) == 1
+
+
+def test_stdout_failure_does_not_interrupt_runtime() -> None:
+    class BrokenStream:
+        def write(self, _value: str) -> None:
+            raise OSError("stdout unavailable")
+
+        def flush(self) -> None:
+            raise OSError("stdout unavailable")
+
+    handler = AgentStructuredLogHandler(cast(TextIO, BrokenStream()))
+    record = logging.makeLogRecord(
+        {
+            "name": "southwind_agent_server.service",
+            "levelno": logging.ERROR,
+            "msg": "Agent Run 恢复轮询失败，将继续重试",
+        }
+    )
+    handler.emit(record)
+
+
+def test_bootstrap_removes_borrowed_sink_without_closing_uvicorn(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    stream = io.StringIO()
+    legacy_stream = io.StringIO()
+    legacy = logging.StreamHandler(legacy_stream)
+    structured = AgentStructuredLogHandler(stream)
+    logger = logging.getLogger("southwind_agent_server")
+    uvicorn = logging.getLogger("uvicorn")
+    monkeypatch.setattr(logger, "handlers", [legacy, structured])
+    monkeypatch.setattr(logger, "level", logging.INFO)
+    monkeypatch.setattr(logger, "propagate", False)
+    monkeypatch.setattr(uvicorn, "handlers", [legacy])
+    monkeypatch.setattr(uvicorn, "level", logging.INFO)
+    monkeypatch.setattr(uvicorn, "propagate", False)
+    closed: list[bool] = []
+    monkeypatch.setattr(legacy, "close", lambda: closed.append(True))
+
+    configure_agent_logging()
+    configure_agent_logging()
+    assert logger.handlers == [structured]
+    assert uvicorn.handlers == [legacy]
+    assert not closed
+    try:
+        raise ValueError("secret-exception")
+    except ValueError:
+        logger.exception("Agent Run 恢复轮询失败，将继续重试")
+    assert len(stream.getvalue().splitlines()) == 1
+    assert json.loads(stream.getvalue())["errorCode"] == "AGENT_RUN_RECOVERY_FAILED"
+    assert legacy_stream.getvalue() == ""
+    assert "secret-exception" not in stream.getvalue()
+    uvicorn.warning("independent-server-warning")
+    assert "independent-server-warning" in legacy_stream.getvalue()